@@ -3716,10 +3716,13 @@ distribution is produced. One validated index serves `<Syntax names={…}>`, `xm
 #678's release reference, so three surfaces cannot describe one component three
 ways. It joins by name *and* owning package: a repository `Elicit.md` has a
 repository origin, which names no package, so the built-in's prose is never
-attached to it. A heading naming something the package does not supply, one
-appearing twice, and one that is not a component name each refuse the whole
-index rather than producing a partial one; a component with no section is
-ordinary and renders the sentence saying so.
+attached to it. A first-party component with no
+section, a heading naming something the package does not supply, one appearing
+twice, and one that is not a component name each refuse the whole index rather
+than producing a partial one — a reference with a hole in it cannot be told from
+one whose components have nothing to say. The no-documentation sentence is for a
+**custom** component instead, which no package governs and which takes its prose
+from its own document's body when it has any.
 
 **It says so in the catalog.** A protected component reports its own origin
 kind, `protected`, rather than borrowing `registered` with `reserved: true`. The
 
@@ -500,17 +500,23 @@ describe("Tier SX — the command line", { sanitizeOps: false, sanitizeResources
     // profile's contributions while a document's own named form fell back to a
     // core-only index, so one product answered the same question two ways.
     const command = yield* runCli(["syntax", "Prompt", "--include", "."], { cwd: "." }).expect();
-    expect(command.stdout).toContain("### `<Prompt>`");
-    expect(command.stdout).toContain("Sends a prompt and renders the reply");
-
     const document = yield* runCli(
       ["run", "-e", '<Syntax names={["Prompt"]} />', "--include", "."],
       { cwd: "." },
     ).expect();
-    expect(document.stdout).toContain("Sends a prompt and renders the reply");
-    expect(document.stdout).not.toContain(
-      "No long-form documentation is available for this component.",
-    );
+
+    // The whole rendered result, not a phrase from it. Both surfaces render the
+    // same text through the same renderer; they differ only in the trailing
+    // newline a rendered document ends with, which is the presentation boundary
+    // rather than the answer. Comparing substrings would pass just as happily
+    // if one surface silently dropped the documentation and kept the heading.
+    expect(document.stdout.trimEnd()).toBe(command.stdout.trimEnd());
+
+    // And it is a real answer rather than two matching empties.
+    expect(command.stdout).toContain("### `<Prompt>`");
+    expect(command.stdout).toContain("Sends a prompt and renders the reply");
+    expect(command.stdout).toContain("**Available in this evaluation:** yes");
+    expect(command.stdout.length).toBeGreaterThan(400);
   });
 
   it("SX10: writes markdown by default and version-2 JSON with --json", function* () {
 
@@ -23,18 +23,23 @@
  * component whose section they are in, so a component's own documentation can
  * have structure without ending its section.
  *
- * Three things refuse the whole index rather than producing a partial one:
+ * Four things refuse the whole index rather than producing a partial one:
  *
+ * - a **missing** section — a component the package supplies and does not
+ *   document. A reader cannot tell "nobody has written this yet" from "this
+ *   component has nothing to say", so a first-party package with a hole in its
+ *   reference is not a valid build;
  * - a **duplicate** heading, in one file or across two, because then a component
  *   has two documentations and nothing says which is current;
  * - an **unknown** heading, because it is documentation for something this
  *   boundary does not register — a rename that updated one side, usually;
  * - a heading that is **not a component name at all**, which is a file that has
  *   drifted from this format into ordinary prose.
  *
- * A component with *no* section is not a failure. It renders the sentence
- * `<Syntax>` states for one, and stays usable while its documentation is still
- * being written.
+ * The no-documentation sentence `<Syntax>` renders is therefore *not* for a
+ * first-party component. It is for a **custom** component — a repository file, a
+ * bundle member, a host's declared Markdown — which no package governs and which
+ * takes its documentation from its own document's body when it has any.
  *
  * ## The join is name *and* origin
  *
 
@@ -70,6 +70,22 @@ export interface CatalogObservation {
    * author needs or imply an authority they do not have.
    */
   document(names: readonly string[]): Operation<string>;
+  /**
+   * The observation for a subtree that may execute less than this site.
+   *
+   * The narrowing seam, and it belongs here rather than in the evaluator
+   * because everything it needs is already here. A canonical evaluation
+   * boundary that has admitted a vocabulary hands it over; what comes back
+   * reports that vocabulary from `observe()` and keeps *this* observation's
+   * authoring catalog and documentation index for `document()`.
+   *
+   * Deriving it any other way would mean the evaluator recovering the raw
+   * contributions and rebuilding an index — which is both a hole (that list is
+   * execution-private for a reason) and a way for the two indexes to drift.
+   * Narrowing what may run is not narrowing what may be read about, and the
+   * observation is the thing that already knows both.
+   */
+  narrow(executable: SyntaxCatalog): CatalogObservation;
 }
 
 /**
@@ -121,17 +137,48 @@ export function rootCatalogObservation(
   function* current(): Operation<SyntaxCatalog> {
     return contribution === undefined ? yield* derived(inputs) : yield* contribution();
   }
+  // Snapshotted once, here, so the contributions an observation reads are the
+  // ones the installation boundary captured rather than whatever the caller's
+  // objects hold by the time a document asks.
+  const captured = snapshotContributions(documentation);
+  return observing(current, current, captured);
+}
+
+/**
+ * One observation over an authoring catalog and an executable one.
+ *
+ * `reference` is what named lookup reads and `executable` is what may run. At a
+ * root they are the same operation; a narrowed observation keeps the reference
+ * and replaces the executable, which is the whole of the seam.
+ */
+function observing(
+  reference: () => Operation<SyntaxCatalog>,
+  executable: () => Operation<SyntaxCatalog>,
+  documentation: readonly DocumentationContribution[],
+): CatalogObservation {
   return {
     *observe(): Operation<string> {
-      return renderSyntaxMarkdown(yield* current());
+      return renderSyntaxMarkdown(yield* executable());
     },
     *document(names: readonly string[]): Operation<string> {
-      // At the root the two inputs are one catalog: nothing has narrowed what
-      // may execute, so what an author may read about and what they may run are
-      // the same set, and every selected entry is available.
-      const catalog = yield* current();
+      const authoring = yield* reference();
+      const runnable = yield* executable();
       const index = yield* documentationIndexFor(documentation);
-      return renderSelectedDocumentation(select(catalog, catalog, names, index));
+      return renderSelectedDocumentation(select(authoring, runnable, names, index));
+    },
+    narrow(admitted: SyntaxCatalog): CatalogObservation {
+      // The enclosing reference and the enclosing index, unchanged. Only what
+      // may execute is replaced, so a nested author keeps the documentation
+      // they had and every entry reports its availability against the
+      // admission.
+      // deno-lint-ignore require-yield
+      return observing(
+        reference,
+        function* () {
+          return admitted;
+        },
+        documentation,
+      );
     },
   };
 }
@@ -241,6 +288,33 @@ function* derived(inputs: CapturedCatalogInputs): Operation<SyntaxCatalog> {
  * adds nothing: the catalog handed here is the admission's, so an entry that is
  * not in the admission cannot be in the observation.
  */
+/**
+ * A defensive copy of what a caller handed the installation boundary.
+ *
+ * Field by field, and the name set materialized into one this module owns. A
+ * contribution is a caller's object: the array can be reordered, the source
+ * replaced, the `Set` added to after capture, and an iterable can answer
+ * differently the second time it is walked. Retaining any of those would make
+ * what a document is told about the product depend on what its host did
+ * afterwards.
+ */
+export function snapshotContributions(
+  contributions: readonly DocumentationContribution[],
+): readonly DocumentationContribution[] {
+  return Object.freeze(
+    [...contributions].map((one) =>
+      Object.freeze({
+        source: Object.freeze({
+          owner: String(one.source.owner),
+          asset: String(one.source.asset),
+          text: String(one.source.text),
+        }),
+        supplies: new Set([...one.supplies].map((name) => String(name))),
+      }),
+    ),
+  );
+}
+
 export function fixedCatalogObservation(
   catalog: SyntaxCatalog,
   /**
@@ -268,15 +342,16 @@ export function fixedCatalogObservation(
    */
   documentation: readonly DocumentationContribution[] = [],
 ): CatalogObservation {
-  const rendered = renderSyntaxMarkdown(catalog);
-  return {
+  const captured = snapshotContributions(documentation);
+  return observing(
     // deno-lint-ignore require-yield
-    *observe(): Operation<string> {
-      return rendered;
+    function* () {
+      return reference;
     },
-    *document(names: readonly string[]): Operation<string> {
-      const index = yield* documentationIndexFor(documentation);
-      return renderSelectedDocumentation(select(reference, catalog, names, index));
+    // deno-lint-ignore require-yield
+    function* () {
+      return catalog;
     },
-  };
+    captured,
+  );
 }
@@ -49,7 +49,9 @@ import { selectComponent } from "../src/components/select.ts";
 import { installedBundle } from "../src/components/bundle.ts";
 import { retainedSource } from "../src/root-source.ts";
 import { renderSyntaxMarkdown } from "../src/syntax-markdown.ts";
-import { fixedCatalogObservation } from "../src/syntax-observation.ts";
+import { fixedCatalogObservation, rootCatalogObservation } from "../src/syntax-observation.ts";
+import type { CatalogObservation } from "../src/syntax-observation.ts";
+import type { DocumentationContribution } from "../src/component-documentation.ts";
 import { SYNTAX_COMPONENT } from "../src/components/Syntax.ts";
 import type { ImportedDefinition } from "../src/components/import-authority.ts";
 import type { ComponentOrigin, FunctionComponent, SyntaxCatalog } from "../mod.ts";
@@ -187,6 +189,48 @@ function* tampered(
   return partial;
 }
 
+/** A catalog holding one component entry of exactly this identity. */
+function catalogNamed(name: string, origin: NamedOrigin): SyntaxCatalog {
+  return {
+    version: 2,
+    categories: [
+      { kind: "structural", entries: [] },
+      {
+        kind: "built-in",
+        entries: [
+          {
+            kind: "component" as const,
+            name,
+            origin,
+            sourceKind: "registered" as const,
+            inspectability: "complete" as const,
+            forms: ["self-closing" as const],
+            props: { type: "object", properties: {}, additionalProperties: false },
+            captures: [],
+            returnMode: "text" as const,
+            returns: { type: "string" },
+          },
+        ],
+      },
+      { kind: "user-provided", entries: [] },
+    ],
+  };
+}
+
+/**
+ * The observation an ordinary root carries.
+ *
+ * Built the way an execution builds it — from captured selection inputs, with
+ * no host contribution — so a case about narrowing is about the object the
+ * product actually hands to expansion.
+ */
+function rootObservation(): CatalogObservation {
+  return rootCatalogObservation(
+    { includes: [], registry: new Map(), components: [], declarations: [] },
+    undefined,
+  );
+}
+
 /** A working directory of this case's own, torn down on the way out. */
 function useWorkingDirectory<T>(body: (dir: string) => Operation<T>): Operation<T> {
   return scoped(function* () {
@@ -372,8 +416,13 @@ describe("Tier SYN — the named form", () => {
     // could be written in.
     const suspending: ExecutionInstallation = {
       *catalog(): Operation<SyntaxCatalog> {
+        // Entered *inside* the named documentation operation: the component has
+        // claimed its occurrence and opened its durable operation by the time
+        // this runs, so a cancellation that arrives now is one that landed in
+        // the work rather than before it.
+        torn.push("entered");
         yield* ensure(() => {
-          torn.push("observation");
+          torn.push("torn down");
         });
         yield* suspend();
         return catalogOf("Unreachable");
@@ -389,12 +438,16 @@ describe("Tier SYN — the named form", () => {
       yield* task.halt();
     });
 
-    // Teardown ran, so the observation's own cleanup completed rather than
-    // being abandoned mid-flight.
-    expect(torn).toEqual(["observation"]);
-    // And nothing successful was retained: a continuation has no catalog to
-    // restore, which is the honest state for work that never finished.
-    expect(retained(yield* stream.readAll())).toHaveLength(0);
+    const events = yield* stream.readAll();
+    // Reached the work, then tore it down — in that order. Cancelling before
+    // the observation was entered would leave `entered` absent, which is the
+    // vacuous pass this ordering rules out.
+    expect(torn).toEqual(["entered", "torn down"]);
+    // Nothing was committed at all: a durable operation records its event when
+    // it completes, and this one never did. So there is no record for a
+    // continuation to restore, successful or otherwise.
+    expect(observations(events)).toHaveLength(0);
+    expect(retained(events)).toHaveLength(0);
   });
 
   it("SYN39: retains the named text, and a continuation restores it whole", function* () {
@@ -1214,6 +1267,64 @@ describe("Tier SYN — observation is never authority", () => {
     ).toContain("**Available in this evaluation:** yes");
   });
 
+  it("SYN25e: a narrowed observation is derived from the enclosing one", function* () {
+    // The seam as an evaluator actually meets it: it holds the enclosing
+    // observation and an admitted catalog, and nothing else. No raw
+    // contribution list, no second index — which is the point, because that
+    // list is execution-private and rebuilding an index from it is how two
+    // indexes drift apart.
+    const enclosing = rootObservation();
+    const admitted = catalogOf("Admitted");
+    const narrowed = enclosing.narrow(admitted);
+
+    // What may run is the admission.
+    const executable = yield* narrowed.observe();
+    expect(executable).toContain("### `<Admitted>`");
+    expect(executable).not.toContain("### `<Elicit>`");
+
+    // What may be read about is still the enclosing site's, with the enclosing
+    // index behind it — so a real component's real documentation survives.
+    const documented = yield* narrowed.document(["Elicit"]);
+    expect(documented).toContain("### `<Elicit>`");
+    expect(documented).toContain("Asks a person a structured question");
+    expect(documented).toContain("**Available in this evaluation:** no");
+
+    // And the enclosing observation is unchanged by having been narrowed.
+    expect(yield* enclosing.observe()).toContain("### `<Elicit>`");
+    expect(yield* enclosing.document(["Elicit"])).toContain(
+      "**Available in this evaluation:** yes",
+    );
+  });
+
+  it("SYN25f: contributions are captured, not held by reference", function* () {
+    const supplies = new Set(["Alpha"]);
+    const source = {
+      owner: "@executablemd/mutable",
+      asset: "packages/mutable/src/components.md",
+      text: "## Alpha\n\nThe captured documentation.\n",
+    };
+    const contribution = { source, supplies };
+    const observation = fixedCatalogObservation(
+      catalogNamed("Alpha", {
+        kind: "registered",
+        origin: "@executablemd/mutable",
+        reserved: false,
+      }),
+      undefined,
+      [contribution],
+    );
+
+    // Everything a caller still holds, changed after capture.
+    source.text = "## Alpha\n\nSUBSTITUTED AFTER CAPTURE.\n";
+    source.owner = "@executablemd/other";
+    supplies.add("Beta");
+    supplies.delete("Alpha");
+
+    const rendered = yield* observation.document(["Alpha"]);
+    expect(rendered).toContain("The captured documentation.");
+    expect(rendered).not.toContain("SUBSTITUTED AFTER CAPTURE");
+  });
+
   it("SYN25: an execution that carries no observation refuses rather than inventing one", function* () {
     // `execute()` driven directly still carries one, so the case that has none
     // is an expansion driven outside an execution — which is what a component
Original file line number	Diff line number	Diff line change
`@@ -23,18 +23,23 @@`
`23`	`23`	`* component whose section they are in, so a component's own documentation can`
`24`	`24`	`* have structure without ending its section.`
`25`	`25`	`*`
`26`		`- * Three things refuse the whole index rather than producing a partial one:`
	`26`	`+ * Four things refuse the whole index rather than producing a partial one:`
`27`	`27`	`*`
	`28`	`+ * - a missing section — a component the package supplies and does not`
	`29`	`+ * document. A reader cannot tell "nobody has written this yet" from "this`
	`30`	`+ * component has nothing to say", so a first-party package with a hole in its`
	`31`	`+ * reference is not a valid build;`
`28`	`32`	`* - a duplicate heading, in one file or across two, because then a component`
`29`	`33`	`* has two documentations and nothing says which is current;`
`30`	`34`	`* - an unknown heading, because it is documentation for something this`
`31`	`35`	`* boundary does not register — a rename that updated one side, usually;`
`32`	`36`	`* - a heading that is not a component name at all, which is a file that has`
`33`	`37`	`* drifted from this format into ordinary prose.`
`34`	`38`	`*`
`35`		`- * A component with no section is not a failure. It renders the sentence`
`36`		- * `<Syntax>` states for one, and stays usable while its documentation is still
`37`		`- * being written.`
	`39`	+ * The no-documentation sentence `<Syntax>` renders is therefore not for a
	`40`	`+ * first-party component. It is for a custom component — a repository file, a`
	`41`	`+ * bundle member, a host's declared Markdown — which no package governs and which`
	`42`	`+ * takes its documentation from its own document's body when it has any.`
`38`	`43`	`*`
`39`	`44`	`* ## The join is name and origin`
`40`	`45`	`*`