@c4a/context 0.7.4 → 0.7.8

package/index.js

@@ -892,14 +892,14 @@ var require_foldFlowLines = __commonJS((exports) => {
   var FOLD_FLOW = "flow";
   var FOLD_BLOCK = "block";
   var FOLD_QUOTED = "quoted";
-  function foldFlowLines(text, indent, mode = "flow", { indentAtStart, lineWidth = 80, minContentWidth = 20, onFold, onOverflow } = {}) {
+  function foldFlowLines(text2, indent, mode = "flow", { indentAtStart, lineWidth = 80, minContentWidth = 20, onFold, onOverflow } = {}) {
     if (!lineWidth || lineWidth < 0)
-      return text;
+      return text2;
     if (lineWidth < minContentWidth)
       minContentWidth = 0;
     const endStep = Math.max(1 + minContentWidth, 1 + lineWidth - indent.length);
-    if (text.length <= endStep)
-      return text;
+    if (text2.length <= endStep)
+      return text2;
     const folds = [];
     const escapedFolds = {};
     let end = lineWidth - indent.length;
@@ -916,14 +916,14 @@ var require_foldFlowLines = __commonJS((exports) => {
     let escStart = -1;
     let escEnd = -1;
     if (mode === FOLD_BLOCK) {
-      i = consumeMoreIndentedLines(text, i, indent.length);
+      i = consumeMoreIndentedLines(text2, i, indent.length);
       if (i !== -1)
         end = i + endStep;
     }
-    for (let ch;ch = text[i += 1]; ) {
+    for (let ch;ch = text2[i += 1]; ) {
       if (mode === FOLD_QUOTED && ch === "\\") {
         escStart = i;
-        switch (text[i + 1]) {
+        switch (text2[i + 1]) {
           case "x":
             i += 3;
             break;
@@ -941,13 +941,13 @@ var require_foldFlowLines = __commonJS((exports) => {
       if (ch === `
 `) {
         if (mode === FOLD_BLOCK)
-          i = consumeMoreIndentedLines(text, i, indent.length);
+          i = consumeMoreIndentedLines(text2, i, indent.length);
         end = i + indent.length + endStep;
         split = undefined;
       } else {
         if (ch === " " && prev && prev !== " " && prev !== `
 ` && prev !== "\t") {
-          const next = text[i + 1];
+          const next = text2[i + 1];
           if (next && next !== " " && next !== `
 ` && next !== "\t")
             split = i;
@@ -960,12 +960,12 @@ var require_foldFlowLines = __commonJS((exports) => {
           } else if (mode === FOLD_QUOTED) {
             while (prev === " " || prev === "\t") {
               prev = ch;
-              ch = text[i += 1];
+              ch = text2[i += 1];
               overflow = true;
             }
             const j = i > escEnd + 1 ? i - 2 : escStart - 1;
             if (escapedFolds[j])
-              return text;
+              return text2;
             folds.push(j);
             escapedFolds[j] = true;
             end = j + endStep;
@@ -980,40 +980,40 @@ var require_foldFlowLines = __commonJS((exports) => {
     if (overflow && onOverflow)
       onOverflow();
     if (folds.length === 0)
-      return text;
+      return text2;
     if (onFold)
       onFold();
-    let res = text.slice(0, folds[0]);
+    let res = text2.slice(0, folds[0]);
     for (let i2 = 0;i2 < folds.length; ++i2) {
       const fold = folds[i2];
-      const end2 = folds[i2 + 1] || text.length;
+      const end2 = folds[i2 + 1] || text2.length;
       if (fold === 0)
         res = `
-${indent}${text.slice(0, end2)}`;
+${indent}${text2.slice(0, end2)}`;
       else {
         if (mode === FOLD_QUOTED && escapedFolds[fold])
-          res += `${text[fold]}\\`;
+          res += `${text2[fold]}\\`;
         res += `
-${indent}${text.slice(fold + 1, end2)}`;
+${indent}${text2.slice(fold + 1, end2)}`;
       }
     }
     return res;
   }
-  function consumeMoreIndentedLines(text, i, indent) {
+  function consumeMoreIndentedLines(text2, i, indent) {
     let end = i;
     let start = i + 1;
-    let ch = text[start];
+    let ch = text2[start];
     while (ch === " " || ch === "\t") {
       if (i < start + indent) {
-        ch = text[++i];
+        ch = text2[++i];
       } else {
         do {
-          ch = text[++i];
+          ch = text2[++i];
         } while (ch && ch !== `
 `);
         end = i;
         start = i + 1;
-        ch = text[start];
+        ch = text2[start];
       }
     }
     return end;
@@ -10994,7 +10994,7 @@ var indexerIdSchema = exports_external.string().regex(/^[a-z0-9][a-z0-9._/-]*$/u
 var indexerSnakeCaseIdSchema = exports_external.string().regex(/^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$/u);
 var indexerSemverSchema = exports_external.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/u);
 var indexerProtocolIdSchema = exports_external.string().regex(/^[a-z][a-z0-9.-]*(?:\.[a-z][a-z0-9.-]*)*\/v[1-9]\d*$/u);
-var indexerCanonicalRefSchema = exports_external.string().regex(/^[a-z][a-z0-9.-]*:[A-Za-z0-9][A-Za-z0-9._~:/#@+-]*$/u);
+var indexerCanonicalRefSchema = exports_external.string().regex(/^[a-z][a-z0-9.-]*:[\p{L}\p{N}][\p{L}\p{N}._~:/#@+-]*$/u);
 var indexerProviderLayerRefSchema = indexerCanonicalRefSchema.refine((value) => !value.includes("#composer:"), "Provider layer ref cannot contain a composer suffix");
 var indexerComposerRefSchema = indexerCanonicalRefSchema.refine((value) => /#composer:[a-z0-9][a-z0-9._/-]*$/u.test(value), "composer ref must end with #composer:<id>");
 function isPortableIndexerPath(value) {
@@ -11052,6 +11052,278 @@ function addDuplicateIssues(values, context, field) {
     seen.add(value);
   });
 }
+// src/indexerPublicContractFacts.ts
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function propsName(value) {
+  if (typeof value.propsType === "string" && /^[A-Za-z_$][\w$]*$/u.test(value.propsType))
+    return value.propsType;
+  return typeof value.typeAnnotation === "string" ? /^(?:React\.)?(?:FC|FunctionComponent)\s*<\s*([A-Za-z_$][\w$]*)\s*>$/u.exec(value.typeAnnotation)?.[1] : undefined;
+}
+function publicContractSupport(selected, available) {
+  const refs = new Set(selected.map((fact) => fact.fact_ref));
+  return available.filter((fact) => {
+    if (refs.has(fact.fact_ref))
+      return false;
+    const value = record(fact.value);
+    if (value?.kind !== "component" || value.visibility !== "exported" || !Array.isArray(value.members) || !value.members.length)
+      return false;
+    const name = propsName(value);
+    if (!name)
+      return false;
+    return typeof value.file === "string" && selected.filter((target) => {
+      const type = record(target.value);
+      return type?.name === name && type.file === value.file && type.visibility === "exported" && (type.kind === "type" || type.kind === "interface") && Array.isArray(type.members) && target.subject_key.namespace === fact.subject_key.namespace && target.subject_key.kind === fact.subject_key.kind && target.subject_key.local_key === fact.subject_key.local_key;
+    }).length === 1;
+  }).sort((left, right) => compareIndexerCanonicalText(left.fact_ref, right.fact_ref));
+}
+function reconcilePublicContractFacts(facts) {
+  const owners = new Map;
+  const types2 = new Map;
+  for (const component of facts) {
+    const value = record(component.value);
+    if (value?.kind !== "component" || value.visibility !== "exported" || !Array.isArray(value.members) || !value.members.length)
+      continue;
+    const name = propsName(value);
+    if (!name || typeof value.file !== "string")
+      continue;
+    const matches = facts.filter((fact) => {
+      const type2 = record(fact.value);
+      return type2?.name === name && type2.file === value.file && type2.visibility === "exported" && (type2.kind === "type" || type2.kind === "interface") && Array.isArray(type2.members) && fact.subject_key.namespace === component.subject_key.namespace && fact.subject_key.kind === component.subject_key.kind && fact.subject_key.local_key === component.subject_key.local_key;
+    });
+    if (matches.length !== 1)
+      continue;
+    const type = matches[0];
+    types2.set(component.fact_ref, type);
+    owners.set(type.fact_ref, [...owners.get(type.fact_ref) ?? [], component]);
+  }
+  return facts.flatMap((fact) => {
+    if (owners.has(fact.fact_ref))
+      return [];
+    const value = record(fact.value);
+    const typeFact = types2.get(fact.fact_ref);
+    if (!value || !typeFact)
+      return [fact];
+    const type = record(typeFact.value);
+    const implementations = new Map(value.members.flatMap((item) => {
+      const member = record(item);
+      return typeof member?.name === "string" ? [[member.name, member]] : [];
+    }));
+    const members = type.members.map((item) => {
+      const declaration = record(item);
+      if (!declaration || typeof declaration.name !== "string")
+        return item;
+      const member = implementations.get(declaration.name);
+      implementations.delete(declaration.name);
+      if (!member)
+        return item;
+      const conflict = declaration.defaultValue !== undefined && member.defaultValue !== undefined && declaration.defaultValue !== member.defaultValue;
+      return {
+        ...member,
+        ...declaration,
+        ...member.defaultValue === undefined ? {} : { defaultValue: member.defaultValue },
+        doc: [
+          declaration.doc || member.doc,
+          conflict ? `Default for ${String(value.name)}; declaration documents ${String(declaration.defaultValue)}.` : ""
+        ].filter(Boolean).join(" ")
+      };
+    });
+    members.push(...implementations.values());
+    const name = owners.get(typeFact.fact_ref).length === 1 ? String(type.name) : `${String(type.name)} (${String(value.name)})`;
+    return [
+      { ...fact, value: { ...value, members: [], params: [] } },
+      { ...typeFact, fact_ref: fact.fact_ref, value: { ...type, name, members } }
+    ];
+  });
+}
+
+// src/indexerContractDeclaration.ts
+function compactContractDeclaration(raw, rows) {
+  const normalize = (text) => text.replace(/\s+/gu, " ").trim();
+  const notes = rows.map((row) => row[5] ?? "");
+  let declaration = "";
+  let plain = "";
+  const flush = () => {
+    declaration += plain.replace(/[ \t]*(?:\r?\n[ \t]*)+/gu, (space) => (space.includes(`\r
+`) ? `\r
+` : `
+`) + (/[ \t]*$/u.exec(space)?.[0] ?? ""));
+    plain = "";
+  };
+  for (let i = 0;i < raw.length; ) {
+    const quote = raw[i];
+    if (quote === '"' || quote === "'" || quote === "`") {
+      const start = i++;
+      while (i < raw.length) {
+        if (raw[i] === "\\") {
+          i += 2;
+          continue;
+        }
+        if (raw[i++] === quote)
+          break;
+      }
+      flush();
+      declaration += raw.slice(start, i);
+    } else if (raw.startsWith("//", i)) {
+      const end = raw.indexOf(`
+`, i);
+      const next = end < 0 ? raw.length : end;
+      flush();
+      declaration += raw.slice(i, next);
+      i = next;
+    } else if (raw.startsWith("/*", i)) {
+      const end = raw.indexOf("*/", i + 2);
+      if (end < 0) {
+        flush();
+        declaration += raw.slice(i);
+        break;
+      }
+      const comment = raw.slice(i, end + 2);
+      const body = comment.slice(2, -2).replace(/^\s*\* ?/gmu, "").trim();
+      const prose = normalize(body.split(/@\w/u)[0] ?? "");
+      const tags = [...body.matchAll(/@(\w+)/gu)].map((match) => match[1]);
+      const duplicate = prose.length > 0 && notes.some((note) => normalize(note).includes(prose)) && tags.every((tag) => tag === "i18n" || (tag === "default" || tag === "defaultValue") && rows.some((row) => row[4] !== "unknown" && new RegExp(`@${tag}\\s+${row[4].replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}(?:\\s|$)`, "u").test(body)));
+      if (duplicate)
+        plain += " ";
+      else {
+        flush();
+        declaration += comment;
+      }
+      i = end + 2;
+    } else {
+      plain += raw[i++];
+    }
+  }
+  flush();
+  declaration = declaration.trim();
+  if (/^\{[^{}]*\}$/u.test(declaration) && !declaration.includes("/*") && !declaration.includes("//")) {
+    const fields = declaration.slice(1, -1).split(";").map((item) => item.trim()).filter(Boolean);
+    if (fields.length > 0 && fields.every((field) => {
+      const match = /^(readonly\s+)?([\w$]+)(\?)?\s*:\s*(.+)$/su.exec(field);
+      return match !== null && rows.some((row) => row[1] === match[2] && row[2].trim() === match[4].trim() && row[3] === (match[3] ? "optional" : "required") && (!match[1] || row[5]?.includes("readonly")));
+    }))
+      return;
+  }
+  return declaration;
+}
+
+// src/indexerPublicContractTable.ts
+function record2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+var text = (value) => typeof value === "string" ? value : "";
+function projectIndexerPublicContractTable(fact) {
+  const value = record2(fact.value);
+  if (value === undefined)
+    return;
+  const rows = [];
+  const add = (field, owner2) => {
+    rows.push([
+      owner2,
+      text(field.name),
+      text(field.typeAnnotation ?? field.type ?? field.signature),
+      field.optional === true ? "optional" : field.optional === false ? "required" : "not declared",
+      field.defaultValue === undefined ? "unknown" : typeof field.defaultValue === "string" ? field.defaultValue : JSON.stringify(field.defaultValue),
+      [
+        field.readonly === true ? "readonly" : "",
+        field.rest === true ? "rest" : "",
+        text(field.location),
+        field.number === undefined ? "" : `field ${String(field.number)}`,
+        field.repeated === true ? "repeated" : "",
+        text(field.oneof),
+        text(field.doc ?? field.description),
+        field.constraints === undefined ? "" : JSON.stringify(field.constraints)
+      ].filter(Boolean).join("; ")
+    ]);
+    if (Array.isArray(field.fields))
+      for (const item of field.fields) {
+        const child = record2(item);
+        if (child !== undefined)
+          add(child, `${owner2}.${text(field.name)}`);
+      }
+  };
+  const owner = text(value.name ?? value.qualifiedName);
+  const hasMembers = Array.isArray(value.members) && value.members.length > 0;
+  if (!hasMembers && value.kind !== "component" && (typeof value.typeAnnotation === "string" || typeof value.initializer === "string")) {
+    rows.push([owner, "declaration", [text(value.typeAnnotation), typeof value.initializer === "string" ? `= ${value.initializer}` : ""].filter(Boolean).join(" "), "", "", ""]);
+  }
+  const registration = record2(value.registration);
+  if (registration !== undefined)
+    rows.push([
+      text(registration.kind),
+      text(registration.key),
+      text(registration.handler),
+      "",
+      "",
+      [
+        text(registration.method),
+        Array.isArray(registration.middleware) ? registration.middleware.map(String).join(" → ") : ""
+      ].filter(Boolean).join("; ")
+    ]);
+  if (Array.isArray(value.members))
+    for (const member of value.members) {
+      const field = record2(member);
+      if (field === undefined)
+        continue;
+      const exportedTypeMember = value.visibility === "exported" && (value.kind === "type" || value.kind === "interface") && (field.kind === "prop" || field.kind === "method");
+      const hidden = field.visibility === "private" || field.visibility === "protected" || /(?:^|\s)@(internal|private|protected)\b/u.test(text(field.doc));
+      if (!hidden && (field.visibility !== "internal" || exportedTypeMember))
+        add(field, owner);
+    }
+  if (Array.isArray(value.params) && value.kind !== "component")
+    for (const parameter of value.params) {
+      const field = record2(parameter);
+      if (field !== undefined)
+        add(field, owner);
+    }
+  if (Array.isArray(value.fields))
+    for (const member of value.fields) {
+      const field = record2(member);
+      if (field !== undefined)
+        add(field, owner);
+    }
+  if (Array.isArray(value.throws))
+    for (const item of value.throws) {
+      const field = record2(item);
+      if (field !== undefined)
+        add(field, `${owner} throws`);
+    }
+  for (const [key, label] of [["input_type", "request"], ["output_type", "response"], ["return_type", "return"]]) {
+    if (typeof value[key] === "string")
+      rows.push([owner, label, value[key], "", "", [
+        key === "input_type" && value.client_streaming === true ? "client streaming" : "",
+        key === "output_type" && value.server_streaming === true ? "server streaming" : "",
+        value.oneway === true ? "oneway" : ""
+      ].filter(Boolean).join("; ")]);
+  }
+  if (Array.isArray(value.overloads))
+    for (const signature of value.overloads) {
+      if (typeof signature === "string")
+        rows.push([owner, "signature", signature, "", "", ""]);
+    }
+  else if (typeof value.signature === "string")
+    rows.push([owner, "signature", value.signature, "", "", ""]);
+  if (Array.isArray(value.publicEntrypoints))
+    for (const entry of value.publicEntrypoints) {
+      if (typeof entry === "string")
+        rows.push([owner, "export entry", entry, "", "", ""]);
+    }
+  if (typeof value.handler === "string" && (typeof value.path === "string" || typeof value.method === "string")) {
+    rows.push([text(value.method), text(value.path), value.handler, "", "", Array.isArray(value.middleware) ? value.middleware.map(String).join(" → ") : ""]);
+  }
+  if (rows.length === 0)
+    return;
+  const declaration = (hasMembers || value.kind === "component") && typeof value.typeAnnotation === "string" ? compactContractDeclaration(value.typeAnnotation, rows) : undefined;
+  const redundantComponent = value.kind === "component" && value.contractResolution !== "declaration-only" && hasMembers && typeof value.propsType === "string" && [value.propsType, `FC<${value.propsType}>`, `React.FC<${value.propsType}>`].includes(declaration ?? "");
+  return {
+    columns: ["Contract", "Name", "Declaration", "Required", "Default", "Notes"],
+    rows,
+    declaration_status: redundantComponent ? "component-wrapper" : declaration !== undefined ? "retained" : typeof value.typeAnnotation === "string" && hasMembers ? "table-complete" : "not-provided",
+    ...declaration !== undefined && !redundantComponent ? { declaration, declarationName: owner } : {}
+  };
+}
+
 // src/indexerSubjectIdentity.ts
 var normalizedSubjectFieldSchema = exports_external.string().min(1).refine((value) => value.normalize("NFC") === value, "SubjectKey fields must use Unicode NFC normalization");
 var indexerSubjectKeySchema = exports_external.object({
@@ -11084,6 +11356,8 @@ var indexerArtifactFactSchema = exports_external.object({
 var indexerDeterministicBlockRendererSchema = exports_external.enum([
   "bullet-list",
   "key-value-table",
+  "multi-column-table",
+  "public-contract-table",
   "json-code-block"
 ]);
 var deterministicArtifactBlockSchema = exports_external.object({
@@ -11127,6 +11401,47 @@ function renderIndexerDeterministicFacts(input) {
   }
   const facts = [...input.facts].sort((left, right) => compareIndexerCanonicalText(left.fact_ref, right.fact_ref));
   const value = projectIndexerFactValue(facts);
+  if (input.renderer === "public-contract-table") {
+    const support = publicContractSupport(facts, input.supporting_facts ?? []);
+    const supportingRefs = new Set(support.map((fact) => fact.fact_ref));
+    const tables = reconcilePublicContractFacts([...facts, ...support]).flatMap((fact) => {
+      if (supportingRefs.has(fact.fact_ref) && typeof fact.value === "object" && fact.value !== null && !Array.isArray(fact.value) && fact.value.kind === "component")
+        return [];
+      const table = projectIndexerPublicContractTable(fact);
+      return table === undefined ? [] : [table];
+    });
+    if (tables.length === 0)
+      throw new TypeError("public-contract-table requires declared public contracts");
+    const rendered = renderIndexerDeterministicFacts({ renderer: "multi-column-table", facts: [{
+      ...facts[0],
+      value: { columns: tables[0].columns, rows: tables.flatMap((table) => table.rows) }
+    }] });
+    const declarations = [...new Map(tables.filter((table) => table.declaration !== undefined).map((table) => [JSON.stringify([table.declarationName, table.declaration]), table])).values()];
+    return [rendered, ...declarations.map((table) => {
+      const declaration = table.declaration;
+      const name = (table.declarationName || "Contract").replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+      const fence = "`".repeat(Math.max(3, ...[...declaration.matchAll(/`+/gu)].map((match) => match[0].length + 1)));
+      return `<details>
+<summary>${name}: type details</summary>
+
+${fence}typescript
+${declaration}
+${fence}
+
+</details>`;
+    })].join(`
+
+`);
+  }
+  if (input.renderer === "multi-column-table") {
+    const table = exports_external.object({ columns: exports_external.array(exports_external.string()).min(1), rows: exports_external.array(exports_external.array(exports_external.string())) }).strict().parse(value);
+    if (table.rows.some((row) => row.length !== table.columns.length)) {
+      throw new TypeError("multi-column-table rows must match the declared columns");
+    }
+    const cell = (text2) => text2.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("|", "&#124;").replace(/\r?\n/gu, "<br>");
+    return [table.columns, table.columns.map(() => "---"), ...table.rows].map((row) => `| ${row.map(cell).join(" | ")} |`).join(`
+`);
+  }
   if (input.renderer === "bullet-list") {
     if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
       throw new TypeError("bullet-list deterministic block requires a string-list Fact projection");
@@ -11185,8 +11500,12 @@ function validateIndexerRenderedContentBlock(value) {
   return block;
 }
 function materializeIndexerStructuredContent(input) {
+  const key = input.render_cache === undefined ? undefined : indexerProtocolDigest({ blocks: input.blocks, facts: input.facts });
+  const cached = key === undefined ? undefined : input.render_cache?.get(key);
+  if (cached !== undefined)
+    return structuredClone(cached);
   const facts = new Map(input.facts.map((fact) => [fact.fact_ref, fact]));
-  return input.blocks.map((block) => {
+  const rendered = input.blocks.map((block) => {
     if (block.layer === "semantic-prose") {
       return buildIndexerRenderedContentBlock({
         layer: block.layer,
@@ -11201,16 +11520,25 @@ function materializeIndexerStructuredContent(input) {
       }
       return fact;
     });
+    const support = block.renderer === "public-contract-table" ? publicContractSupport(referenced, input.facts) : [];
+    const consumed = [...referenced, ...support];
     return buildIndexerRenderedContentBlock({
       layer: block.layer,
       markdown: renderIndexerDeterministicFacts({
         renderer: block.renderer,
-        facts: referenced
+        facts: referenced,
+        supporting_facts: support
       }),
-      fact_refs: referenced.map((fact) => fact.fact_ref),
-      evidence_refs: referenced.flatMap((fact) => fact.evidence_refs)
+      fact_refs: consumed.map((fact) => fact.fact_ref),
+      evidence_refs: consumed.flatMap((fact) => fact.evidence_refs)
     });
   });
+  if (key !== undefined && input.render_cache !== undefined) {
+    if (input.render_cache.size >= 256)
+      input.render_cache.delete(input.render_cache.keys().next().value);
+    input.render_cache.set(key, structuredClone(rendered));
+  }
+  return rendered;
 }
 
 // src/indexerArtifact.ts
@@ -11244,6 +11572,7 @@ var indexerTemplateArtifactSchema = exports_external.object({
 var indexerSectionArtifactSchema = exports_external.object({
   ...artifactCommonFields,
   representation: exports_external.literal("sections"),
+  template_id: indexerIdSchema.optional(),
   sections: exports_external.array(indexerArtifactSectionSchema).min(1)
 }).strict();
 var indexerArtifactSchema = exports_external.discriminatedUnion("representation", [
@@ -12233,7 +12562,8 @@ function indexerParserLockedDependency(lockValue) {
 // src/indexerRestrictedSelector.ts
 var indexerSelectorFactPathSchema = exports_external.string().regex(/^[a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_]*)*$/u);
 var scalarSchema = exports_external.union([exports_external.string(), exports_external.number().finite(), exports_external.boolean()]);
-var expressionSchema = exports_external.lazy(() => exports_external.union([
+var expressionSchema = exports_external.lazy(() => expressionVariantsSchema);
+var expressionVariantsSchema = exports_external.union([
   exports_external.object({
     op: exports_external.enum(["all", "any"]),
     args: exports_external.array(expressionSchema).min(1)
@@ -12265,7 +12595,7 @@ var expressionSchema = exports_external.lazy(() => exports_external.union([
     fact: indexerSelectorFactPathSchema,
     value: exports_external.number().finite()
   }).strict()
-]));
+]);
 var indexerRestrictedSelectorSchema = exports_external.object({
   protocol: exports_external.literal("context.indexer.selector/v1"),
   expression: expressionSchema
@@ -12354,14 +12684,15 @@ var INDEXER_SELECTOR_OPERATORS = [
 ];
 
 // src/indexerProfileContract.ts
-var canonicalParametersSchema = exports_external.lazy(() => exports_external.union([
+var canonicalParametersSchema = exports_external.lazy(() => canonicalParameterVariantsSchema);
+var canonicalParameterVariantsSchema = exports_external.union([
   exports_external.null(),
   exports_external.boolean(),
   exports_external.number().finite(),
   exports_external.string(),
   exports_external.array(canonicalParametersSchema),
   exports_external.record(canonicalParametersSchema)
-]));
+]);
 var indexerOperatorContractSchema = exports_external.object({
   protocol: exports_external.literal("context.indexer.operator-contract/v1"),
   version: indexerSemverSchema,
@@ -12935,9 +13266,13 @@ var instructionResourceSchema = exports_external.object({
   addDuplicateIssues(value.profiles, context, "profiles");
 });
 var templateResourceSchema = exports_external.object({
+  kind: exports_external.enum(["procedure", "page-program"]).optional(),
   id: indexerIdSchema,
   profile: indexerIdSchema,
-  path: portableIndexerPathSchema
+  path: portableIndexerPathSchema,
+  reader_goal: indexerIdSchema.optional(),
+  guidance_path: portableIndexerPathSchema.optional(),
+  delivery: exports_external.enum(["profile", "selected"]).optional()
 }).strict();
 var providerResourcesSchema = exports_external.object({
   program: indexerProgramSchema.optional(),
@@ -13104,6 +13439,21 @@ var indexerProviderManifestSchema = exports_external.object({
       });
     }
   });
+  const supports = value.customization?.supports ?? [];
+  if (supports.includes("config") && value.provider.config_schema === undefined) {
+    context.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      message: "customization supports config but the Provider declares no config_schema",
+      path: ["customization", "supports"]
+    });
+  }
+  if (supports.includes("program-extend") && value.provider.program === undefined) {
+    context.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      message: "customization supports program-extend but the Provider declares no program",
+      path: ["customization", "supports"]
+    });
+  }
 });
 function parseYamlDocument(source, label) {
   const document = $parseDocument(source, { uniqueKeys: true });
@@ -13125,7 +13475,7 @@ function referencedProviderPaths(manifest) {
     ...manifest.authoring_inspector === undefined ? [] : [manifest.authoring_inspector.execution.entry],
     ...manifest.provider.program === undefined ? [] : [manifest.provider.program.execution.entry],
     ...(manifest.provider.instructions ?? []).map((item) => item.path),
-    ...(manifest.provider.templates ?? []).map((item) => item.path),
+    ...(manifest.provider.templates ?? []).flatMap((item) => [item.path, ...item.guidance_path === undefined ? [] : [item.guidance_path]]),
     ...(manifest.provides.composers ?? []).flatMap((item) => item.contract === undefined ? [] : [item.contract.instruction]),
     ...manifest.provider.config_schema === undefined ? [] : [manifest.provider.config_schema],
     ...manifest.customization?.guide === undefined ? [] : [manifest.customization.guide],
@@ -13203,10 +13553,12 @@ var requirementQuestionSchema = exports_external.object({
 var requirementExclusionSchema = exports_external.object({
   id: indexerIdSchema,
   scope: targetScopeSchema,
-  reason: exports_external.string().min(1)
+  reason: exports_external.string().min(1),
+  paths: exports_external.array(exports_external.string().min(1).refine((path) => !path.startsWith("/") && !path.includes("\\") && !path.split("/").some((part) => part === ".." || part === ".") && !/[?*]/u.test(path), "Use an exact repository-relative file or directory path, without globs or traversal")).min(1).optional()
 }).strict();
 var indexRequirementSchema = exports_external.object({
   id: indexerIdSchema,
+  purpose: exports_external.string().trim().min(1).optional(),
   reader_goals: exports_external.array(indexerIdSchema).min(1),
   coverage_domains: exports_external.record(indexerIdSchema, exports_external.enum(["required", "optional", "out-of-scope"])),
   questions: exports_external.array(requirementQuestionSchema).optional(),
@@ -14309,14 +14661,15 @@ function validateIndexerControlledInvocation(value) {
   return invocation;
 }
 // src/indexerParserFactView.ts
-var canonicalJsonSchema2 = exports_external.lazy(() => exports_external.union([
-  exports_external.null(),
-  exports_external.boolean(),
-  exports_external.number().finite(),
+var canonicalJsonSchema2 = exports_external.lazy(() => canonicalJsonVariantsSchema);
+var canonicalJsonVariantsSchema = exports_external.union([
   exports_external.string(),
+  exports_external.number().finite(),
+  exports_external.boolean(),
+  exports_external.null(),
   exports_external.array(canonicalJsonSchema2),
   exports_external.record(canonicalJsonSchema2)
-]));
+]);
 var parserFactSchema = exports_external.object({
   fact_ref: indexerCanonicalRefSchema,
   kind: indexerIdSchema,
@@ -14648,6 +15001,164 @@ function buildIndexerMergedParserFactView(input) {
   });
 }
 
+// src/indexerKnowledgeDependency.ts
+var indexerKnowledgeDependencySchema = exports_external.object({
+  artifact_ref: indexerCanonicalRefSchema,
+  section_refs: exports_external.array(indexerCanonicalRefSchema).default([]),
+  required: exports_external.boolean().default(true)
+}).strict();
+
+class IndexerKnowledgeDependencyCycleError extends TypeError {
+  artifact_refs;
+  constructor(artifact_refs) {
+    super(`Knowledge dependency cycle: ${artifact_refs.join(" -> ")}. Revise the Partition dependency plan.`);
+    this.artifact_refs = artifact_refs;
+    this.name = "IndexerKnowledgeDependencyCycleError";
+  }
+}
+function validateIndexerKnowledgeDependencyGraph(nodes) {
+  const graph = new Map;
+  for (const node of nodes) {
+    indexerCanonicalRefSchema.parse(node.artifact_ref);
+    if (graph.has(node.artifact_ref))
+      throw new TypeError(`Knowledge article has duplicate responsibility: ${node.artifact_ref}`);
+    const dependencies = node.dependencies.map((dependency) => indexerKnowledgeDependencySchema.parse(dependency));
+    if (new Set(dependencies.map((dependency) => dependency.artifact_ref)).size !== dependencies.length) {
+      throw new TypeError(`Knowledge article repeats a dependency: ${node.artifact_ref}`);
+    }
+    if (dependencies.some((dependency) => new Set(dependency.section_refs).size !== dependency.section_refs.length)) {
+      throw new TypeError(`Knowledge article repeats a supporting section: ${node.artifact_ref}`);
+    }
+    graph.set(node.artifact_ref, dependencies);
+  }
+  const complete = new Set;
+  const active = new Set;
+  const visit2 = (ref, trail) => {
+    if (active.has(ref))
+      throw new IndexerKnowledgeDependencyCycleError([...trail.slice(trail.indexOf(ref)), ref]);
+    if (complete.has(ref))
+      return;
+    active.add(ref);
+    for (const dependency of graph.get(ref) ?? [])
+      visit2(dependency.artifact_ref, [...trail, ref]);
+    active.delete(ref);
+    complete.add(ref);
+  };
+  for (const ref of graph.keys())
+    visit2(ref, []);
+}
+var indexerKnowledgeDependencyVersionSchema = exports_external.object({
+  artifact_ref: indexerCanonicalRefSchema,
+  approved_content_digest: indexerDigestSchema,
+  projection_digest: indexerDigestSchema
+}).strict();
+function indexerKnowledgeDependencyFingerprint(versions) {
+  const parsed = versions.map((version) => indexerKnowledgeDependencyVersionSchema.parse(version));
+  if (new Set(parsed.map((version) => version.artifact_ref)).size !== parsed.length) {
+    throw new TypeError("Knowledge dependency versions repeat an article");
+  }
+  return indexerProtocolDigest(parsed.sort((left, right) => compareIndexerCanonicalText(left.artifact_ref, right.artifact_ref)));
+}
+function impactedIndexerKnowledgeArticles(nodes, changed) {
+  validateIndexerKnowledgeDependencyGraph(nodes);
+  const reverse = new Map;
+  for (const node of nodes)
+    for (const dependency of node.dependencies) {
+      const readers = reverse.get(dependency.artifact_ref) ?? new Set;
+      readers.add(node.artifact_ref);
+      reverse.set(dependency.artifact_ref, readers);
+    }
+  const impacted = new Set(changed);
+  const queue = [...changed];
+  for (let cursor = 0;cursor < queue.length; cursor++) {
+    for (const reader of reverse.get(queue[cursor]) ?? []) {
+      if (impacted.has(reader))
+        continue;
+      impacted.add(reader);
+      queue.push(reader);
+    }
+  }
+  return [...impacted].filter((ref) => !changed.has(ref)).sort();
+}
+
+// src/indexerArticlePlan.ts
+var indexerArticleKeySchema = exports_external.string().regex(/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u);
+var indexerArticlePlanSchema = exports_external.object({
+  key: indexerArticleKeySchema,
+  title: exports_external.string().min(1),
+  reader_task: exports_external.string().min(1),
+  artifact_intent: exports_external.string().min(1),
+  template_id: exports_external.string().min(1).optional(),
+  required: exports_external.boolean(),
+  sections: exports_external.array(exports_external.object({
+    key: indexerArticleKeySchema,
+    heading: exports_external.string().min(1),
+    required: exports_external.boolean()
+  }).strict()).min(1),
+  question_targets: exports_external.array(exports_external.string().min(1)).default([]),
+  knowledge_dependencies: exports_external.array(indexerKnowledgeDependencySchema).optional()
+}).strict();
+function validateIndexerArticlePlan(articles, targets) {
+  if (!articles.length || !articles.some((article) => article.required)) {
+    throw new TypeError("article plan needs at least one required article; revise the current Partition plan");
+  }
+  const keys = new Set, owners = new Set;
+  for (const article of articles) {
+    indexerArticlePlanSchema.parse(article);
+    if (keys.has(article.key))
+      throw new TypeError(`duplicate article key ${article.key}; choose stable unique keys in Partition`);
+    keys.add(article.key);
+    if (new Set(article.sections.map((section) => section.key)).size !== article.sections.length) {
+      throw new TypeError(`article ${article.key} repeats a section key; revise its section plan`);
+    }
+    for (const target of article.question_targets) {
+      if (!article.required || owners.has(target) || targets !== undefined && !targets.includes(target)) {
+        throw new TypeError(`article ${article.key} has invalid question responsibility ${target}; assign each group target to one required article`);
+      }
+      owners.add(target);
+    }
+  }
+  if (targets?.some((target) => !owners.has(target))) {
+    throw new TypeError("article plan leaves a question without a primary article; revise the current Partition plan");
+  }
+}
+function indexerArticleSectionKey(article, section) {
+  return `${article}--${section}`;
+}
+function validateIndexerPlannedArticles(result, articles) {
+  const warnings = [];
+  validateIndexerArticlePlan(articles);
+  const planned = new Map(articles.map((article) => [article.key, article]));
+  for (const artifact of result.artifacts) {
+    const article = planned.get(artifact.artifact_id);
+    if (!article)
+      throw new TypeError(`unplanned article ${artifact.artifact_id}; revise Partition before adding an article`);
+    if (artifact.template_id !== article.template_id) {
+      throw new TypeError(`article ${article.key} changes its accepted template; use the planned template or revise Partition`);
+    }
+    const sections = artifact.representation === "sections" ? artifact.sections : artifact.section_projections;
+    const expected = new Map(article.sections.map((section) => [indexerArticleSectionKey(article.key, section.key), section]));
+    for (const section of sections) {
+      if (!expected.has(section.section_key))
+        warnings.push({ code: "article-outline-drift", message: `Article ${article.key} includes additional section ${section.section_key}. Review its relevance; this does not block publication.` });
+      const intent = [result.source_role, section.document_kind, section.reader_goal, section.artifact_kind].join("/");
+      if (intent !== article.artifact_intent)
+        throw new TypeError(`article ${article.key} changes its accepted intent; use ${article.artifact_intent}`);
+    }
+    for (const [key, section] of expected) {
+      if (section.required && !sections.some((actual) => actual.section_key === key)) {
+        warnings.push({ code: "article-outline-gap", message: `Article ${article.key} omits suggested section ${section.key}. Explain material limits or add useful evidence when available; this does not block publication.` });
+      }
+    }
+  }
+  for (const article of articles) {
+    if (article.required && !result.artifacts.some((artifact) => artifact.artifact_id === article.key)) {
+      throw new TypeError(`missing required article ${article.key}; complete the accepted article set before submitting`);
+    }
+  }
+  return warnings;
+}
+
 // src/indexerArtifactPolicy.ts
 var canonicalJsonSchema3 = exports_external.lazy(() => exports_external.union([
   exports_external.null(),
@@ -15672,7 +16183,7 @@ function validateTargetExists(input) {
     return;
   }
   const fact = file.facts.find((candidate) => candidate.fact_ref === target.source_fact_ref);
-  if (fact === undefined || fact.qualified_item_path !== target.qualified_item_path || fact.signature_digest !== target.signature_digest) {
+  if (fact === undefined || fact.qualified_item_path !== target.qualified_item_path) {
     throw new TypeError("structured declaration source item does not exist");
   }
 }
@@ -15694,7 +16205,7 @@ function validateIndexerStructuredDeclarationSet(input) {
     throw new TypeError("structured declaration set is non-canonical or invalid");
   }
   const inventory = validateIndexerSourceIdentityInventory(input.source_identity_inventory);
-  if (value.source_identity_inventory_digest !== inventory.inventory_digest || inventory.source_ref !== input.expected_source_ref || inventory.module_ref !== input.expected_module_ref) {
+  if (inventory.source_ref !== input.expected_source_ref || inventory.module_ref !== input.expected_module_ref) {
     throw new TypeError("structured declarations do not match current source identity");
   }
   const evidence = new Set(canonicalUnique4(input.known_evidence_refs, "known declaration evidence"));
@@ -15723,7 +16234,7 @@ function indexerSectionEvidenceCarrierRef(input) {
   return `section-evidence:${indexerProtocolDigest(input)}`;
 }
 
-// src/indexerGeneratedAuthoringAudit.ts
+// src/indexerStructuredClaims.ts
 var structuredClaimOwnerSchema = exports_external.object({
   artifact_id: indexerIdSchema,
   section_key: indexerIdSchema
@@ -15742,53 +16253,6 @@ var indexerStructuredClaimSetSchema = exports_external.object({
   claims: exports_external.array(structuredClaimSchema).min(1),
   claims_digest: indexerDigestSchema
 }).strict();
-var generatedAuthoringFindingSchema = exports_external.object({
-  code: exports_external.enum([
-    "generated-placeholder",
-    "empty-required-section"
-  ]),
-  artifact_id: indexerIdSchema,
-  section_key: indexerIdSchema.nullable(),
-  content_ref: exports_external.string().min(1)
-}).strict();
-var semanticProseReviewTargetSchema = exports_external.object({
-  artifact_id: indexerIdSchema,
-  section_key: indexerIdSchema.nullable(),
-  content_ref: exports_external.string().min(1),
-  advisory_code: exports_external.literal("semantic-prose-agent-review-required")
-}).strict();
-var indexerGeneratedAuthoringAuditSchema = exports_external.object({
-  protocol: exports_external.literal("context.indexer.generated-authoring-audit/v1"),
-  artifact_result_digest: indexerDigestSchema,
-  hard_findings: exports_external.array(generatedAuthoringFindingSchema),
-  structured_claim_count: exports_external.number().int().nonnegative(),
-  evidence_covered_structured_claim_count: exports_external.number().int().nonnegative(),
-  semantic_prose_review_targets: exports_external.array(semanticProseReviewTargetSchema),
-  agent_review_required: exports_external.boolean(),
-  audit_digest: indexerDigestSchema
-}).strict();
-function markdownProseOnly(markdown) {
-  const prose = [];
-  let fence;
-  for (const line of markdown.split(`
-`)) {
-    const opening = line.match(/^ {0,3}(`{3,}|~{3,})/u)?.[1];
-    if (fence === undefined && opening !== undefined) {
-      fence = { marker: opening[0], length: opening.length };
-      continue;
-    }
-    if (fence !== undefined) {
-      const closing = line.match(/^ {0,3}(`{3,}|~{3,})\s*$/u)?.[1];
-      if (closing !== undefined && closing[0] === fence.marker && closing.length >= fence.length) {
-        fence = undefined;
-      }
-      continue;
-    }
-    prose.push(line.replace(/(`+)[^`]*?\1/gu, ""));
-  }
-  return prose.join(`
-`);
-}
 function assertCanonicalUnique(values, label) {
   const expected = [...new Set(values)].sort(compareIndexerCanonicalText);
   if (expected.length !== values.length || expected.some((value, index) => value !== values[index])) {
@@ -15848,135 +16312,6 @@ function validateIndexerStructuredClaimSet(input) {
   }
   return value;
 }
-function containsIndexerControlledAuthoringPlaceholder(markdown) {
-  const prose = markdownProseOnly(markdown);
-  if (/\{\{|\}\}|<!--/u.test(prose))
-    return true;
-  if (/\[(?:TODO|TBD|待补充|待生成|placeholder(?:[^\]]*)?|example|your\s+[^\]]+)\]/iu.test(prose) || /<(?:TODO|TBD|待补充|待生成|placeholder(?:[^>]*)?|example|your[-_ ][^>]+)>/iu.test(prose)) {
-    return true;
-  }
-  return prose.split(`
-`).some((line) => {
-    const marker = line.trim().replace(/^#{1,6}\s+/u, "").replace(/^[-*+]\s+/u, "").trim();
-    return /^(?:TODO|TBD|待补充|待生成|占位|placeholder|coming soon)[.!。！?？…]*$/iu.test(marker);
-  });
-}
-function hasSubstantiveMarkdown(markdown) {
-  return markdown.split(`
-`).some((line) => {
-    const value = line.trim();
-    return value.length > 0 && !/^#{1,6}(?:\s+.*)?$/u.test(value) && !/^[-|:\s]+$/u.test(value) && !/^<!--.*-->$/u.test(value) && !containsIndexerControlledAuthoringPlaceholder(value);
-  });
-}
-function stringLeaves(value) {
-  if (typeof value === "string")
-    return [value];
-  if (Array.isArray(value))
-    return value.flatMap(stringLeaves);
-  if (value !== null && typeof value === "object") {
-    return Object.values(value).flatMap(stringLeaves);
-  }
-  return [];
-}
-function auditPayload(value) {
-  return value;
-}
-function buildIndexerGeneratedAuthoringAudit(result) {
-  const hardFindings = [];
-  const reviewTargets = [];
-  for (const artifact of result.artifacts) {
-    if (artifact.representation === "sections") {
-      for (const section of artifact.sections) {
-        let sectionHasSubstance = false;
-        for (const block of section.blocks) {
-          if (block.layer === "deterministic-block") {
-            sectionHasSubstance = true;
-            continue;
-          }
-          const contentRef = `block:${block.block_id}`;
-          reviewTargets.push({
-            artifact_id: artifact.artifact_id,
-            section_key: section.section_key,
-            content_ref: contentRef,
-            advisory_code: "semantic-prose-agent-review-required"
-          });
-          if (containsIndexerControlledAuthoringPlaceholder(block.markdown)) {
-            hardFindings.push({
-              code: "generated-placeholder",
-              artifact_id: artifact.artifact_id,
-              section_key: section.section_key,
-              content_ref: contentRef
-            });
-          }
-          if (hasSubstantiveMarkdown(block.markdown))
-            sectionHasSubstance = true;
-        }
-        if (!sectionHasSubstance) {
-          hardFindings.push({
-            code: "empty-required-section",
-            artifact_id: artifact.artifact_id,
-            section_key: section.section_key,
-            content_ref: `section:${section.section_key}`
-          });
-        }
-      }
-      continue;
-    }
-    for (const [variableId, variable] of Object.entries(artifact.variables)) {
-      if (variable.fact_refs.length > 0)
-        continue;
-      const contentRef = `variable:${variableId}`;
-      reviewTargets.push({
-        artifact_id: artifact.artifact_id,
-        section_key: null,
-        content_ref: contentRef,
-        advisory_code: "semantic-prose-agent-review-required"
-      });
-      if (stringLeaves(variable.value).some(containsIndexerControlledAuthoringPlaceholder)) {
-        hardFindings.push({
-          code: "generated-placeholder",
-          artifact_id: artifact.artifact_id,
-          section_key: null,
-          content_ref: contentRef
-        });
-      }
-    }
-  }
-  hardFindings.sort((left, right) => compareIndexerCanonicalText(`${left.artifact_id}\x00${left.section_key ?? ""}\x00${left.content_ref}\x00${left.code}`, `${right.artifact_id}\x00${right.section_key ?? ""}\x00${right.content_ref}\x00${right.code}`));
-  reviewTargets.sort((left, right) => compareIndexerCanonicalText(`${left.artifact_id}\x00${left.section_key ?? ""}\x00${left.content_ref}`, `${right.artifact_id}\x00${right.section_key ?? ""}\x00${right.content_ref}`));
-  const claimCount = result.structured_claims?.claims.length ?? 0;
-  const payload = indexerGeneratedAuthoringAuditSchema.omit({ audit_digest: true }).parse({
-    protocol: "context.indexer.generated-authoring-audit/v1",
-    artifact_result_digest: result.output_digest,
-    hard_findings: hardFindings,
-    structured_claim_count: claimCount,
-    evidence_covered_structured_claim_count: claimCount,
-    semantic_prose_review_targets: reviewTargets,
-    agent_review_required: reviewTargets.length > 0
-  });
-  return indexerGeneratedAuthoringAuditSchema.parse({
-    ...payload,
-    audit_digest: indexerProtocolDigest(auditPayload(payload))
-  });
-}
-function validateIndexerGeneratedAuthoringAudit(value) {
-  const audit = indexerGeneratedAuthoringAuditSchema.parse(value);
-  if (audit.evidence_covered_structured_claim_count !== audit.structured_claim_count || audit.agent_review_required !== audit.semantic_prose_review_targets.length > 0) {
-    throw new TypeError("generated authoring audit coverage/review state is inconsistent");
-  }
-  const { audit_digest: _digest, ...payload } = audit;
-  if (audit.audit_digest !== indexerProtocolDigest(auditPayload(payload))) {
-    throw new TypeError("generated authoring audit digest is invalid");
-  }
-  return audit;
-}
-function assertIndexerGeneratedAuthoringAuditClear(audit) {
-  validateIndexerGeneratedAuthoringAudit(audit);
-  if (audit.hard_findings.length > 0) {
-    const finding = audit.hard_findings[0];
-    throw new TypeError(`generated authoring audit failed: ${finding.code} at ${finding.artifact_id}/${finding.content_ref}`);
-  }
-}
 
 // src/indexerArtifactResult.ts
 var indexerEvidenceBindingSchema = exports_external.object({
@@ -16360,8 +16695,10 @@ function validateIndexerArtifactResult(input) {
   if (indexerArtifactResultDigest(payload) !== result.output_digest) {
     throw new TypeError("ArtifactResult output digest is invalid");
   }
+  if (input.planned_articles !== undefined)
+    validateIndexerPlannedArticles(result, input.planned_articles);
   const expectedProvider = input.expected_provider;
-  if (result.author_workset_digest !== input.workset.workset_digest || result.partition_plan_binding_digest !== input.workset.partition_plan_binding_digest || result.group_projection_digest !== input.workset.group_projection_digest || result.indexer_id !== input.workset.indexer_id || result.requirement_ref !== input.workset.requirement_ref || result.source_ref !== input.workset.source_ref || result.module_ref !== input.workset.module_ref || result.logical_unit.group_key !== input.workset.group_key || result.logical_unit.logical_unit_ref !== input.workset.logical_unit_ref || canonicalIndexerJson(result.logical_unit.subject_key) !== canonicalIndexerJson(input.expected_subject_key) || result.provider_layer_ref !== expectedProvider.layer_ref || result.provider_integrity !== expectedProvider.integrity || result.provider_bundle_digest !== expectedProvider.bundle_digest || result.config_fingerprint !== expectedProvider.config_fingerprint || result.customization_fingerprint !== expectedProvider.customization_fingerprint || result.input_digest !== input.expected_input_digest) {
+  if (result.author_workset_digest !== input.workset.workset_digest || result.partition_plan_binding_digest !== input.workset.partition_plan_binding_digest || result.group_projection_digest !== input.workset.group_projection_digest || result.indexer_id !== input.workset.indexer_id || result.requirement_ref !== input.workset.requirement_ref || result.source_ref !== input.workset.source_ref || result.module_ref !== input.workset.module_ref || result.logical_unit.group_key !== input.workset.group_key || result.logical_unit.logical_unit_ref !== input.workset.logical_unit_ref || canonicalIndexerJson(result.logical_unit.subject_key) !== canonicalIndexerJson(input.expected_subject_key) || result.provider_layer_ref !== expectedProvider.layer_ref || result.input_digest !== input.expected_input_digest) {
     throw new TypeError("ArtifactResult does not match its author authority/workset");
   }
   if (!input.allowed_source_roles.includes(result.source_role)) {
@@ -16422,7 +16759,6 @@ function validateIndexerArtifactResult(input) {
     authorized_carriers: input.authorized_declaration_carriers
   });
   validateStructuredClaims({ result, evidence_refs: evidenceRefs, facts });
-  assertIndexerGeneratedAuthoringAuditClear(buildIndexerGeneratedAuthoringAudit(result));
   validateTargetResolution(result, input.workset.target_resolution_view, evidenceRefs);
   validateQuestions({ result, allowed_question_targets: input.allowed_question_targets });
   return result;
@@ -16478,12 +16814,12 @@ var logicalUnitNodeInputSchema = exports_external.object({
   targets: dependencyTargetsSchema
 }).strict();
 var resourceNodeInputSchema = exports_external.object({
-  kind: exports_external.enum(["template-policy-fragment", "contract-metric"]),
+  kind: exports_external.enum(["template-policy-fragment", "contract-metric", "approved-knowledge"]),
   target_ref: indexerCanonicalRefSchema,
   content_digest: indexerDigestSchema,
   targets: dependencyTargetsSchema
 }).strict();
-var indexerPositiveDependencyNodeInputSchema = exports_external.union([
+var indexerPositiveDependencyNodeInputSchema = exports_external.discriminatedUnion("kind", [
   sourceSpanNodeInputSchema,
   selectedFactNodeInputSchema,
   logicalUnitNodeInputSchema,
@@ -16515,7 +16851,7 @@ var indexerLogicalUnitDependencyNodeSchema = logicalUnitNodeInputSchema.extend({
 var indexerResourceDependencyNodeSchema = resourceNodeInputSchema.extend({
   node_ref: indexerCanonicalRefSchema
 }).strict();
-var indexerPositiveDependencyNodeSchema = exports_external.union([
+var indexerPositiveDependencyNodeSchema = exports_external.discriminatedUnion("kind", [
   indexerSourceSpanDependencyNodeSchema,
   indexerSelectedFactDependencyNodeSchema,
   indexerLogicalUnitDependencyNodeSchema,
@@ -16661,6 +16997,218 @@ function indexerDependencyTargetMatches(input) {
   return input.target.level === "logical-unit" || input.target.artifact_kind === input.artifact_kind && (input.target.level === "artifact-kind" || input.target.section_key === input.section_key);
 }
 
+// src/indexerCompositionFactDependencies.ts
+function compositionFactDependencies(input) {
+  const composition = validateIndexerLayerCompositionInput(input.composition_input);
+  if (composition.workset_digest !== input.workset.workset_digest || composition.final_authority_layer_ref !== input.result.provider_layer_ref) {
+    throw new TypeError("extension composition belongs to another author run");
+  }
+  const selected = new Map(input.dependency_view.positive_nodes.flatMap((node) => node.kind === "selected-fact" ? [[node.fact_ref, node]] : []));
+  const spans = new Map(input.dependency_view.positive_nodes.flatMap((node) => node.kind === "source-span" ? [[node.node_ref, node]] : []));
+  return composition.accepted_fragments.flatMap((fragment) => {
+    if (fragment.payload.protocol !== "context.indexer.fragment.fact-enrichment/v1")
+      return [];
+    return fragment.payload.facts.map((fact) => {
+      if (fact.target_ref !== input.workset.logical_unit_ref) {
+        throw new TypeError("extension fact belongs to another logical unit");
+      }
+      const sourceSpanRefs = [...new Set(fact.evidence_refs.flatMap((ref) => {
+        const source = selected.get(ref.ref);
+        if (source === undefined) {
+          throw new TypeError(`extension fact references unavailable source fact ${ref.ref}`);
+        }
+        return source.source_span_node_refs;
+      }))].sort(compareIndexerCanonicalText);
+      const evidenceRefs = [...new Set(sourceSpanRefs.map((ref) => {
+        const span = spans.get(ref);
+        if (span === undefined)
+          throw new TypeError("extension fact has no authorized source span");
+        return span.evidence_ref;
+      }))].sort(compareIndexerCanonicalText);
+      const factRef = `layer-fact:${fragment.fragment_digest}/${fact.fact_id}`;
+      const node = {
+        kind: "selected-fact",
+        fact_ref: factRef,
+        fact_digest: indexerProtocolDigest({
+          fact_ref: factRef,
+          fact_kind: fact.fact_id,
+          subject_key: input.result.logical_unit.subject_key,
+          value: fact.value,
+          evidence_refs: evidenceRefs
+        }),
+        source_span_node_refs: sourceSpanRefs,
+        targets: []
+      };
+      return { ...node, node_ref: indexerDependencyNodeRef({ polarity: "positive", node }) };
+    });
+  });
+}
+
+// src/indexerExampleIdentity.ts
+var exampleObservationSchema = exports_external.object({
+  observation_ref: indexerCanonicalRefSchema,
+  example_ref: indexerCanonicalRefSchema,
+  public_target_ref: indexerCanonicalRefSchema,
+  scenario_key: indexerIdSchema,
+  source_ref: indexerCanonicalRefSchema,
+  module_ref: indexerCanonicalRefSchema.nullable(),
+  full_relative_path: portableIndexerPathSchema,
+  content_digest: indexerDigestSchema,
+  evidence_refs: exports_external.array(indexerCanonicalRefSchema).min(1)
+}).strict();
+var indexerExampleInventorySchema = exports_external.object({
+  protocol: exports_external.literal("context.indexer.example-inventory/v1"),
+  source_scope_digest: indexerDigestSchema,
+  observations: exports_external.array(exampleObservationSchema),
+  inventory_digest: indexerDigestSchema
+}).strict();
+function canonicalUnique5(values, field) {
+  const sorted = [...values].sort(compareIndexerCanonicalText);
+  if (new Set(sorted).size !== sorted.length) {
+    throw new TypeError(`${field} must not contain duplicate identities`);
+  }
+  return sorted;
+}
+function normalizeIndexerExampleRelativePath(value) {
+  const normalized = value.normalize("NFC").replaceAll("\\", "/").replace(/^\.\//u, "");
+  return portableIndexerPathSchema.parse(normalized);
+}
+function indexerExampleRef(input) {
+  const identity2 = {
+    public_target_ref: indexerCanonicalRefSchema.parse(input.public_target_ref),
+    scenario_key: indexerIdSchema.parse(input.scenario_key),
+    full_relative_path: normalizeIndexerExampleRelativePath(input.full_relative_path)
+  };
+  return `example:${indexerProtocolDigest(identity2)}`;
+}
+function indexerExampleObservationRef(input) {
+  return `example-observation:${indexerProtocolDigest(input)}`;
+}
+function indexerExampleInventoryDigest(value) {
+  return indexerProtocolDigest(value);
+}
+function normalizeObservation(input) {
+  const fullRelativePath = normalizeIndexerExampleRelativePath(input.full_relative_path);
+  const publicTargetRef = indexerCanonicalRefSchema.parse(input.public_target_ref);
+  const scenarioKey = indexerIdSchema.parse(input.scenario_key);
+  const sourceRef = indexerCanonicalRefSchema.parse(input.source_ref);
+  const moduleRef = input.module_ref === null ? null : indexerCanonicalRefSchema.parse(input.module_ref);
+  const contentDigest = indexerDigestSchema.parse(input.content_digest);
+  const exampleRef = indexerExampleRef({
+    public_target_ref: publicTargetRef,
+    scenario_key: scenarioKey,
+    full_relative_path: fullRelativePath
+  });
+  return exampleObservationSchema.parse({
+    observation_ref: indexerExampleObservationRef({
+      example_ref: exampleRef,
+      source_ref: sourceRef,
+      module_ref: moduleRef,
+      content_digest: contentDigest
+    }),
+    example_ref: exampleRef,
+    public_target_ref: publicTargetRef,
+    scenario_key: scenarioKey,
+    source_ref: sourceRef,
+    module_ref: moduleRef,
+    full_relative_path: fullRelativePath,
+    content_digest: contentDigest,
+    evidence_refs: canonicalUnique5(input.evidence_refs, "example evidence_refs")
+  });
+}
+function buildIndexerExampleInventory(input) {
+  const byObservation = new Map;
+  for (const observationInput of input.observations) {
+    const observation = normalizeObservation(observationInput);
+    const current = byObservation.get(observation.observation_ref);
+    if (current === undefined) {
+      byObservation.set(observation.observation_ref, observation);
+      continue;
+    }
+    const currentCore = { ...current, evidence_refs: undefined };
+    const nextCore = { ...observation, evidence_refs: undefined };
+    if (canonicalIndexerJson(currentCore) !== canonicalIndexerJson(nextCore)) {
+      throw new TypeError("example observation identity collision");
+    }
+    current.evidence_refs = [...new Set([
+      ...current.evidence_refs,
+      ...observation.evidence_refs
+    ])].sort(compareIndexerCanonicalText);
+  }
+  const observations = [...byObservation.values()].sort((left, right) => compareIndexerCanonicalText(left.observation_ref, right.observation_ref));
+  const payload = {
+    protocol: "context.indexer.example-inventory/v1",
+    source_scope_digest: indexerDigestSchema.parse(input.source_scope_digest),
+    observations
+  };
+  return indexerExampleInventorySchema.parse({
+    ...payload,
+    inventory_digest: indexerExampleInventoryDigest(payload)
+  });
+}
+function validateIndexerExampleInventory(input) {
+  const value = indexerExampleInventorySchema.parse(input.value);
+  const rebuilt = buildIndexerExampleInventory({
+    source_scope_digest: value.source_scope_digest,
+    observations: value.observations
+  });
+  if (canonicalIndexerJson(rebuilt) !== canonicalIndexerJson(value)) {
+    throw new TypeError("example inventory is non-canonical or has an invalid digest");
+  }
+  if (input.expected_source_scope_digest !== undefined && value.source_scope_digest !== input.expected_source_scope_digest) {
+    throw new TypeError("example inventory belongs to another source scope");
+  }
+  if (input.known_evidence_refs !== undefined) {
+    const known = new Set(canonicalUnique5(input.known_evidence_refs, "known_evidence_refs"));
+    if (value.observations.some((item) => item.evidence_refs.some((evidenceRef) => !known.has(evidenceRef)))) {
+      throw new TypeError("example inventory references unknown evidence");
+    }
+  }
+  return value;
+}
+
+// src/indexerExampleFactDependencies.ts
+function exampleFactDependencies(input) {
+  const examples = input.result.facts.filter((fact) => fact.fact_kind === "example-candidate");
+  if (!examples.length)
+    return [];
+  const observationSchema = indexerExampleInventorySchema.shape.observations.element;
+  const observations = examples.map((fact) => {
+    if (fact.value === null || typeof fact.value !== "object" || Array.isArray(fact.value)) {
+      throw new TypeError("Example selection must identify an authorized source observation");
+    }
+    const { inventory_digest, ...value } = fact.value;
+    return { fact, inventory_digest, observation: observationSchema.parse(value) };
+  });
+  const inventory = validateIndexerExampleInventory({ value: {
+    protocol: "context.indexer.example-inventory/v1",
+    source_scope_digest: input.workset.source_scope_digest,
+    observations: observations.map((item) => item.observation).sort((a, b) => compareIndexerCanonicalText(a.observation_ref, b.observation_ref)),
+    inventory_digest: observations[0].inventory_digest
+  }, expected_source_scope_digest: input.workset.source_scope_digest });
+  const spans = new Map(input.dependency_view.positive_nodes.flatMap((node) => node.kind === "source-span" ? [[node.evidence_ref, node]] : []));
+  return observations.map(({ fact, observation, inventory_digest }) => {
+    if (inventory_digest !== inventory.inventory_digest || observation.public_target_ref !== input.workset.logical_unit_ref || fact.fact_ref !== `fact:example-${indexerProtocolDigest(observation).slice(7)}` || canonicalIndexerJson(fact.subject_key) !== canonicalIndexerJson(input.result.logical_unit.subject_key) || canonicalIndexerJson([...fact.evidence_refs].sort(compareIndexerCanonicalText)) !== canonicalIndexerJson(observation.evidence_refs)) {
+      throw new TypeError("Example selection identity does not match its current task");
+    }
+    const sourceRefs = observation.evidence_refs.map((ref) => {
+      const span = spans.get(ref);
+      if (!span || span.source_ref !== observation.source_ref || span.module_ref !== observation.module_ref || span.locator.path !== observation.full_relative_path || span.content_digest !== observation.content_digest) {
+        throw new TypeError("Example selection source is outside the current dependency view or has changed");
+      }
+      return span.node_ref;
+    }).sort(compareIndexerCanonicalText);
+    const node = {
+      kind: "selected-fact",
+      fact_ref: fact.fact_ref,
+      fact_digest: indexerProtocolDigest(fact),
+      source_span_node_refs: sourceRefs,
+      targets: []
+    };
+    return { ...node, node_ref: indexerDependencyNodeRef({ polarity: "positive", node }) };
+  });
+}
+
 // src/indexerRunProtocolCommon.ts
 var indexerRunFinalAuthoritySchema = exports_external.object({
   layer_ref: indexerProviderLayerRefSchema,
@@ -16794,6 +17342,10 @@ function buildIndexerPrimaryRegistryProjection(input) {
     owned_scope: "ref" in binding.owned_scope ? binding.owned_scope : { targets: canonicalTargets2(binding.owned_scope.targets) }
   })).sort((left, right) => compareIndexerCanonicalText(indexerProtocolDigest(left), indexerProtocolDigest(right)));
   const additionalProfiles = [...entry.profile.additional ?? []].sort((left, right) => compareIndexerCanonicalText(`${left.provider}\x00${left.id}\x00${left.kind}`, `${right.provider}\x00${right.id}\x00${right.kind}`));
+  const readRequirementIds = new Set(entry.read_scope.refs.flatMap((ref) => {
+    const match = /^requirement:([^#]+)#/u.exec(ref);
+    return match ? [match[1]] : [];
+  }));
   const payload = {
     protocol: "context.indexer.primary-registry-projection/v1",
     indexer_id: entry.id,
@@ -16801,6 +17353,7 @@ function buildIndexerPrimaryRegistryProjection(input) {
     requirement_bindings: requirementBindings,
     read_scope: {
       refs: [...entry.read_scope.refs].sort(compareIndexerCanonicalText),
+      requirements: input.registry.requirements.filter((requirement) => readRequirementIds.has(requirement.id)).sort((a, b) => compareIndexerCanonicalText(a.id, b.id)),
       ...entry.read_scope.extra_targets === undefined ? {} : { extra_targets: canonicalTargets2(entry.read_scope.extra_targets) }
     },
     profile: {
@@ -17109,7 +17662,7 @@ var indexerArtifactDependencySetSchema = exports_external.object({
   artifacts: exports_external.array(artifactDependencySchema),
   dependency_set_digest: indexerDigestSchema
 }).strict();
-function canonicalUnique5(values) {
+function canonicalUnique6(values) {
   return [...new Set(values)].sort(compareIndexerCanonicalText);
 }
 function versionedPositive(node) {
@@ -17132,8 +17685,8 @@ function artifactDependency(value) {
 }
 function artifactSections(artifact) {
   if (artifact.representation === "template") {
-    const factRefs = canonicalUnique5(Object.values(artifact.variables).flatMap((variable) => variable.fact_refs));
-    const evidenceRefs = canonicalUnique5(Object.values(artifact.variables).flatMap((variable) => variable.evidence_refs));
+    const factRefs = canonicalUnique6(Object.values(artifact.variables).flatMap((variable) => variable.fact_refs));
+    const evidenceRefs = canonicalUnique6(Object.values(artifact.variables).flatMap((variable) => variable.evidence_refs));
     return artifact.section_projections.map((section) => ({
       section_key: section.section_key,
       fact_refs: factRefs,
@@ -17142,8 +17695,8 @@ function artifactSections(artifact) {
   }
   return artifact.sections.map((section) => ({
     section_key: section.section_key,
-    fact_refs: canonicalUnique5(section.blocks.flatMap((block) => block.layer === "deterministic-block" ? block.fact_refs : [])),
-    evidence_refs: canonicalUnique5(section.blocks.flatMap((block) => block.layer === "semantic-prose" ? block.evidence_refs : []))
+    fact_refs: canonicalUnique6(section.blocks.flatMap((block) => block.layer === "deterministic-block" ? block.fact_refs : [])),
+    evidence_refs: canonicalUnique6(section.blocks.flatMap((block) => block.layer === "semantic-prose" ? block.evidence_refs : []))
   }));
 }
 function dependencySetPayload(value) {
@@ -17155,7 +17708,7 @@ function indexerArtifactDependencySetDigest(value) {
 }
 function assertBoundInputs(input) {
   const { result, workset, runEnvelope, dependencyView } = input;
-  if (dependencyView.view_digest !== workset.group_dependency_view_digest || runEnvelope.dependency_view_digest !== dependencyView.view_digest || dependencyView.source_ref !== result.source_ref || dependencyView.module_ref !== result.module_ref || dependencyView.logical_unit_ref !== result.logical_unit.logical_unit_ref || runEnvelope.workset_digest !== workset.workset_digest || runEnvelope.logical_unit_ref !== result.logical_unit.logical_unit_ref || runEnvelope.source_ref !== result.source_ref || runEnvelope.module_ref !== result.module_ref || runEnvelope.indexer_id !== result.indexer_id || runEnvelope.source_role !== result.source_role || runEnvelope.provider_layer_ref !== result.provider_layer_ref || runEnvelope.provider_integrity !== result.provider_integrity || runEnvelope.provider_bundle_digest !== result.provider_bundle_digest || runEnvelope.config_fingerprint !== result.config_fingerprint || runEnvelope.customization_fingerprint !== result.customization_fingerprint) {
+  if (dependencyView.view_digest !== workset.group_dependency_view_digest || runEnvelope.dependency_view_digest !== dependencyView.view_digest || dependencyView.source_ref !== result.source_ref || dependencyView.module_ref !== result.module_ref || dependencyView.logical_unit_ref !== result.logical_unit.logical_unit_ref || runEnvelope.workset_digest !== workset.workset_digest || runEnvelope.logical_unit_ref !== result.logical_unit.logical_unit_ref || runEnvelope.source_ref !== result.source_ref || runEnvelope.module_ref !== result.module_ref || runEnvelope.indexer_id !== result.indexer_id || runEnvelope.source_role !== result.source_role || runEnvelope.provider_layer_ref !== result.provider_layer_ref) {
     throw new TypeError("Artifact dependency inputs do not bind the same current author run");
   }
   const logical = dependencyView.positive_nodes.find((node) => node.kind === "logical-unit");
@@ -17184,6 +17737,7 @@ function buildIndexerArtifactDependencySet(input) {
   });
   const sourceNodes = dependencyView.positive_nodes.filter((node) => node.kind === "source-span");
   const sourceByEvidence = new Map(sourceNodes.map((node) => [node.evidence_ref, node]));
+  const sourceByNode = new Map(sourceNodes.map((node) => [node.node_ref, node]));
   const evidenceByRef = new Map(input.result.evidence_bindings.map((evidence) => {
     let node = sourceByEvidence.get(evidence.evidence_ref);
     const belongsToPrimary = evidence.source_ref === input.workset.source_ref && evidence.module_ref === input.workset.module_ref;
@@ -17206,46 +17760,57 @@ function buildIndexerArtifactDependencySet(input) {
         node_ref: indexerDependencyNodeRef({ polarity: "positive", node: supplemental })
       });
     }
-    if (node === undefined || canonicalIndexerJson({
-      source_ref: node.source_ref,
-      module_ref: node.module_ref,
-      locator: node.locator,
-      content_digest: node.content_digest
-    }) !== canonicalIndexerJson({
-      source_ref: evidence.source_ref,
-      module_ref: evidence.module_ref,
-      locator: evidence.locator,
-      content_digest: evidence.content_digest
-    })) {
-      throw new TypeError(`evidence ${evidence.evidence_ref} is absent or stale in the dependency view`);
+    if (node === undefined || node.source_ref !== evidence.source_ref || node.module_ref !== evidence.module_ref || node.locator.path !== evidence.locator.path || node.content_digest !== evidence.content_digest) {
+      throw new TypeError(`Source ${evidence.evidence_ref} is unavailable or its file content changed; refresh the current task's source material`);
     }
-    return [evidence.evidence_ref, versionedPositive(node)];
+    const current = { ...node, locator: evidence.locator };
+    return [evidence.evidence_ref, versionedPositive({
+      ...current,
+      node_ref: indexerDependencyNodeRef({ polarity: "positive", node: current })
+    })];
   }));
-  const factNodes = dependencyView.positive_nodes.filter((node) => node.kind === "selected-fact");
+  const factNodes = [
+    ...dependencyView.positive_nodes.filter((node) => node.kind === "selected-fact"),
+    ...exampleFactDependencies({ workset: input.workset, dependency_view: dependencyView, result: input.result }),
+    ...input.composition_input === undefined ? [] : compositionFactDependencies({
+      composition_input: input.composition_input,
+      workset: input.workset,
+      dependency_view: dependencyView,
+      result: input.result
+    })
+  ];
   const factNodeByRef = new Map(factNodes.map((node) => [node.fact_ref, node]));
   const factByRef = new Map(input.result.facts.map((fact) => {
     const node = factNodeByRef.get(fact.fact_ref);
-    const sourceSpanNodeRefs = canonicalUnique5(fact.evidence_refs.map((ref) => {
+    const sourceSpanNodeRefs = canonicalUnique6(fact.evidence_refs.map((ref) => {
       const evidence = evidenceByRef.get(ref);
       if (evidence === undefined) {
         throw new TypeError(`Fact ${fact.fact_ref} references evidence outside the dependency view`);
       }
       return evidence.node_ref;
     }));
-    if (node === undefined || node.fact_digest !== indexerProtocolDigest(fact) || canonicalIndexerJson(node.source_span_node_refs) !== canonicalIndexerJson(sourceSpanNodeRefs)) {
-      throw new TypeError(`Fact ${fact.fact_ref} is absent or stale in the dependency view`);
+    if (node === undefined) {
+      throw new TypeError(`Fact ${fact.fact_ref} is not available in the current task; use a supplied Fact or source_items reference`);
     }
-    return [fact.fact_ref, versionedPositive(node)];
+    const expectedEvidence = canonicalUnique6(node.source_span_node_refs.map((ref) => sourceByNode.get(ref).evidence_ref));
+    if (canonicalIndexerJson(expectedEvidence) !== canonicalIndexerJson(canonicalUnique6(fact.evidence_refs))) {
+      throw new TypeError(`Fact ${fact.fact_ref} refers to a different source than the current task`);
+    }
+    return [fact.fact_ref, versionedPositive({
+      ...node,
+      fact_digest: indexerProtocolDigest(fact),
+      source_span_node_refs: sourceSpanNodeRefs
+    })];
   }));
   const logical = versionedPositive(dependencyView.positive_nodes.find((node) => node.kind === "logical-unit"));
-  const resources = dependencyView.positive_nodes.filter((node) => node.kind === "template-policy-fragment" || node.kind === "contract-metric").map(versionedPositive);
+  const resources = dependencyView.positive_nodes.filter((node) => node.kind === "template-policy-fragment" || node.kind === "contract-metric" || node.kind === "approved-knowledge").map(versionedPositive);
   const negatives = dependencyView.negative_nodes.map(versionedNegative);
   const usedPositive = new Map([[logical.node_ref, logical]]);
   const usedNegative = new Map;
   const artifacts = input.result.artifacts.map((artifact) => {
     const sections = artifactSections(artifact).map((section) => {
       const facts = section.fact_refs.map((ref) => factByRef.get(ref));
-      const evidenceRefs = canonicalUnique5([
+      const evidenceRefs = canonicalUnique6([
         ...section.evidence_refs,
         ...section.fact_refs.flatMap((ref) => input.result.facts.find((fact) => fact.fact_ref === ref).evidence_refs)
       ]);
@@ -17271,20 +17836,20 @@ function buildIndexerArtifactDependencySet(input) {
       }
       return sectionDependency({
         section_key: section.section_key,
-        positive_dependency_refs: canonicalUnique5([
+        positive_dependency_refs: canonicalUnique6([
           logical.dependency_ref,
           ...facts.map((item) => item.dependency_ref),
           ...evidence.map((item) => item.dependency_ref),
           ...sectionResources.map((item) => item.dependency_ref)
         ]),
-        negative_dependency_refs: canonicalUnique5(sectionNegatives.map((item) => item.dependency_ref))
+        negative_dependency_refs: canonicalUnique6(sectionNegatives.map((item) => item.dependency_ref))
       });
     }).sort((left, right) => compareIndexerCanonicalText(left.section_key, right.section_key));
     return artifactDependency({
       artifact_id: artifact.artifact_id,
       artifact_kind: artifact.artifact_kind,
-      positive_dependency_refs: canonicalUnique5(sections.flatMap((section) => section.positive_dependency_refs)),
-      negative_dependency_refs: canonicalUnique5(sections.flatMap((section) => section.negative_dependency_refs)),
+      positive_dependency_refs: canonicalUnique6(sections.flatMap((section) => section.positive_dependency_refs)),
+      negative_dependency_refs: canonicalUnique6(sections.flatMap((section) => section.negative_dependency_refs)),
       sections
     });
   }).sort((left, right) => compareIndexerCanonicalText(left.artifact_id, right.artifact_id));
@@ -17327,6 +17892,7 @@ function validateIndexerArtifactDependencySet(input) {
     workset: input.workset,
     run_envelope: input.run_envelope,
     dependency_view: input.dependency_view,
+    ...input.composition_input === undefined ? {} : { composition_input: input.composition_input },
     ...input.authorized_evidence_targets === undefined ? {} : { authorized_evidence_targets: input.authorized_evidence_targets }
   });
   if (canonicalIndexerJson(expected) !== canonicalIndexerJson(value)) {
@@ -17412,7 +17978,8 @@ function validateIndexerTargetResolutionView(value) {
 }
 var indexerRepairIntentPayloadSchema = exports_external.object({
   target_ref: exports_external.string().min(1),
-  instruction: exports_external.string().trim().min(1)
+  instruction: exports_external.string().trim().min(1),
+  current_markdown: exports_external.string().optional()
 }).strict();
 var indexerRepairIntentSchema = indexerRepairIntentPayloadSchema.extend({
   intent_digest: indexerDigestSchema
@@ -17683,6 +18250,15 @@ var partitionGroupSchema = exports_external.object({
   subject_intent: exports_external.enum(["primary", "enrich-or-independent"]),
   logical_unit_ref: indexerCanonicalRefSchema,
   label: exports_external.string().min(1),
+  scope_change: exports_external.object({ removed_member_ids: exports_external.array(indexerCanonicalRefSchema).min(1) }).strict().optional(),
+  reader_task: exports_external.string().min(1).optional(),
+  outline: exports_external.array(exports_external.string().min(1)).optional(),
+  artifact_intent: exports_external.string().min(1).optional(),
+  template_id: exports_external.string().min(1).optional(),
+  articles: exports_external.array(indexerArticlePlanSchema).min(1).optional(),
+  priority: exports_external.number().int().nonnegative().optional(),
+  delivery_boundary: exports_external.boolean().optional(),
+  ready_for_author: exports_external.boolean().optional(),
   reader_question_refs: exports_external.array(indexerCanonicalRefSchema),
   question_target_bindings: exports_external.array(questionTargetBindingSchema),
   member_ids: exports_external.array(indexerCanonicalRefSchema).min(1)
@@ -17841,6 +18417,8 @@ function validateGroups(plan, allowedQuestions, allowedTargets) {
     if (targetRefs.some((ref) => !allowedTargets.has(ref))) {
       throw new TypeError(`partition group ${group.group_key} creates an unknown question target`);
     }
+    if (group.articles !== undefined)
+      validateIndexerArticlePlan(group.articles, group.question_target_bindings.filter((binding) => binding.role === "primary-carrier").map((binding) => binding.target_ref));
     groups.set(group.group_key, group);
   }
   return groups;
@@ -17926,11 +18504,13 @@ function validateIndexerPartitionPlan(input) {
   });
   if (plan.status === "complete") {
     if (plan.groups.length === 0) {
-      if (plan.reader_question_refs.length > 0 || (input.required_question_target_refs ?? input.workset.allowed_question_target_refs).length > 0 || plan.member_dispositions.some((item) => item.inventory_disposition === "owned")) {
+      if (plan.reader_question_refs.length > 0 || input.workset.reader_question_refs.length > 0 || (input.required_question_target_refs ?? input.workset.allowed_question_target_refs).length > 0 && !plan.member_dispositions.every((item) => item.inventory_disposition === "excluded-with-reason") || plan.member_dispositions.some((item) => item.inventory_disposition === "owned")) {
         throw new TypeError("empty complete PartitionPlan requires no reader questions, no targets, and no owned members");
       }
     }
-    validateQuestionTargetClosure(plan, input.required_question_target_refs ?? input.workset.allowed_question_target_refs);
+    if (plan.groups.length > 0 || plan.member_dispositions.length === 0) {
+      validateQuestionTargetClosure(plan, input.required_question_target_refs ?? input.workset.allowed_question_target_refs);
+    }
   } else {
     const closed = new Set(plan.member_dispositions.map((item) => item.member_id));
     const expectedUnassigned = canonicalInventory.map((member) => member.member_id).filter((id) => !closed.has(id)).sort();
@@ -18022,7 +18602,7 @@ function indexerCatalogFallbackImplementationDigest(cliReleaseDigest) {
     cli_release_digest: indexerDigestSchema.parse(cliReleaseDigest)
   });
 }
-function canonicalUnique6(values, field) {
+function canonicalUnique7(values, field) {
   const sorted = [...values].sort(compareIndexerCanonicalText);
   if (new Set(sorted).size !== sorted.length) {
     throw new TypeError(`${field} must not contain duplicate identities`);
@@ -18060,7 +18640,7 @@ function assertLocalDeclarations(input) {
     if (!Number.isSafeInteger(declaration.priority) || declaration.priority < 0) {
       throw new TypeError("local partition strategy priority must be a non-negative integer");
     }
-    const profiles = canonicalUnique6(declaration.profiles, "local strategy profiles");
+    const profiles = canonicalUnique7(declaration.profiles, "local strategy profiles");
     if (profiles.some((profile) => !input.selectedProfiles.has(profile))) {
       throw new TypeError("local partition strategy references an unselected profile");
     }
@@ -18080,7 +18660,7 @@ function providerImplementationDigest(input) {
 }
 function resolveIndexerPartitionStrategies(input) {
   const indexerId = indexerIdSchema.parse(input.indexer_id);
-  const selectedProfiles = canonicalUnique6(input.selected_profile_ids, "selected partition profiles");
+  const selectedProfiles = canonicalUnique7(input.selected_profile_ids, "selected partition profiles");
   const selectedProfileSet = new Set(selectedProfiles);
   const manifest = indexerProviderManifestSchema.parse(input.provider.manifest);
   if (manifest.id !== input.provider.id || manifest.version !== input.provider.version) {
@@ -18220,7 +18800,7 @@ function resolveIndexerPartitionStrategies(input) {
 }
 function validateIndexerPartitionStrategyResolution(valueInput) {
   const value = indexerPartitionStrategyResolutionSchema.parse(valueInput);
-  if (canonicalIndexerJson(value.selected_profile_ids) !== canonicalIndexerJson(canonicalUnique6(value.selected_profile_ids, "resolved selected_profile_ids"))) {
+  if (canonicalIndexerJson(value.selected_profile_ids) !== canonicalIndexerJson(canonicalUnique7(value.selected_profile_ids, "resolved selected_profile_ids"))) {
     throw new TypeError("resolved selected_profile_ids are not canonical");
   }
   const expected = [...value.strategies].sort((left, right) => compareIndexerCanonicalText(strategySortKey(left), strategySortKey(right)));
@@ -18427,26 +19007,26 @@ function validateAttemptDigest(attempt) {
   }
 }
 function validateIndexerPartitionConvergenceRecord(value) {
-  const record = indexerPartitionConvergenceRecordSchema.parse(value);
-  record.attempts.forEach((attempt, index) => {
+  const record3 = indexerPartitionConvergenceRecordSchema.parse(value);
+  record3.attempts.forEach((attempt, index) => {
     validateAttemptDigest(attempt);
     if (attempt.strategy_order !== index) {
       throw new TypeError("partition convergence attempts must use contiguous strategy order");
     }
-    const expectedPrevious = index === 0 ? null : record.attempts[index - 1].attempt_digest;
+    const expectedPrevious = index === 0 ? null : record3.attempts[index - 1].attempt_digest;
     if (attempt.previous_attempt_digest !== expectedPrevious) {
       throw new TypeError("partition convergence attempt lineage is invalid");
     }
   });
-  const last = record.attempts.at(-1);
-  const validDecision = record.decision === "accepted" ? last.classification === "semantic" && record.accepted_plan_hash === last.partition_plan_hash && record.next_strategy_attempt === null && record.outcome === "completed" : record.decision === "retry-required" ? last.classification !== "semantic" && last.classification !== "blocking-input-damage" && record.accepted_plan_hash === null && record.next_strategy_attempt !== null && record.next_strategy_attempt.previous_attempt_digest === last.attempt_digest && record.outcome === "partial" : record.decision === "catalog-fallback-required" ? last.classification !== "semantic" && last.classification !== "blocking-input-damage" && record.accepted_plan_hash === null && record.next_strategy_attempt !== null && record.next_strategy_attempt.strategy_ref.kind === "cli-builtin" && record.next_strategy_attempt.strategy_ref.strategy_id === INDEXER_CATALOG_FALLBACK_STRATEGY_ID && record.next_strategy_attempt.previous_attempt_digest === last.attempt_digest && record.outcome === "partial" : last.classification === "blocking-input-damage" && record.accepted_plan_hash === null && record.next_strategy_attempt === null && record.outcome === "failed";
+  const last = record3.attempts.at(-1);
+  const validDecision = record3.decision === "accepted" ? last.classification === "semantic" && record3.accepted_plan_hash === last.partition_plan_hash && record3.next_strategy_attempt === null && record3.outcome === "completed" : record3.decision === "retry-required" ? last.classification !== "semantic" && last.classification !== "blocking-input-damage" && record3.accepted_plan_hash === null && record3.next_strategy_attempt !== null && record3.next_strategy_attempt.previous_attempt_digest === last.attempt_digest && record3.outcome === "partial" : record3.decision === "catalog-fallback-required" ? last.classification !== "semantic" && last.classification !== "blocking-input-damage" && record3.accepted_plan_hash === null && record3.next_strategy_attempt !== null && record3.next_strategy_attempt.strategy_ref.kind === "cli-builtin" && record3.next_strategy_attempt.strategy_ref.strategy_id === INDEXER_CATALOG_FALLBACK_STRATEGY_ID && record3.next_strategy_attempt.previous_attempt_digest === last.attempt_digest && record3.outcome === "partial" : last.classification === "blocking-input-damage" && record3.accepted_plan_hash === null && record3.next_strategy_attempt === null && record3.outcome === "failed";
   if (!validDecision)
     throw new TypeError("partition convergence decision is inconsistent");
-  const payload = Object.fromEntries(Object.entries(record).filter(([key]) => key !== "convergence_digest"));
-  if (indexerProtocolDigest(payload) !== record.convergence_digest) {
+  const payload = Object.fromEntries(Object.entries(record3).filter(([key]) => key !== "convergence_digest"));
+  if (indexerProtocolDigest(payload) !== record3.convergence_digest) {
     throw new TypeError("partition convergence digest is invalid");
   }
-  return record;
+  return record3;
 }
 function convergeIndexerPartitionPlan(input) {
   const strategies = canonicalStrategies(input.authorized_strategies);
@@ -18640,7 +19220,6 @@ function validateIndexerMainRunResult(input) {
     throw new TypeError("main run Result does not match its request/stage/input view");
   }
   let operationResult;
-  let authoringAudit = null;
   let artifactDependencySet = null;
   const runEnvelope = buildIndexerRunEnvelope({
     workset: request.workset,
@@ -18674,6 +19253,7 @@ function validateIndexerMainRunResult(input) {
       expected_provider: request.final_authority,
       expected_input_digest: request.execution_request_digest,
       expected_subject_key: input.validation.expected_subject_key,
+      ...input.validation.page_plan?.articles === undefined ? {} : { planned_articles: input.validation.page_plan.articles },
       artifact_policy_eligibility: input.validation.artifact_policy_eligibility,
       allowed_source_roles: input.validation.allowed_source_roles,
       ...input.validation.authorized_evidence_targets === undefined ? {} : {
@@ -18688,12 +19268,12 @@ function validateIndexerMainRunResult(input) {
     if (operationResult.source_role !== request.run_environment.source_role) {
       throw new TypeError("author Result source role does not match the run environment");
     }
-    authoringAudit = buildIndexerGeneratedAuthoringAudit(operationResult);
     artifactDependencySet = buildIndexerArtifactDependencySet({
       result: operationResult,
       workset: request.workset,
       run_envelope: runEnvelope,
       dependency_view: input.validation.dependency_view,
+      composition_input: request.composition_input,
       ...input.validation.authorized_evidence_targets === undefined ? {} : {
         authorized_evidence_targets: input.validation.authorized_evidence_targets
       }
@@ -18705,7 +19285,6 @@ function validateIndexerMainRunResult(input) {
     request,
     result,
     operation_result: operationResult,
-    authoring_audit: authoringAudit,
     artifact_dependency_set: artifactDependencySet,
     run_envelope: runEnvelope
   };
@@ -19175,11 +19754,7 @@ function validateIndexerInspectorResult(input) {
     if (expectedVariants === undefined) {
       throw new TypeError("inspector projection targets an inactive profile");
     }
-    for (const [axisId, value] of Object.entries(expectedVariants)) {
-      if (item.payload.profile_variants[axisId] !== value) {
-        throw new TypeError("inspector projection variant drifted from the active Registry profile");
-      }
-    }
+    assertIndexerInspectorProfileVariants(item.payload, expectedVariants);
     for (const sourceFactRef of item.payload.source_fact_refs) {
       if (!inputFactRefs.has(sourceFactRef)) {
         throw new TypeError("inspector projection references a fact outside its input View");
@@ -19201,6 +19776,15 @@ function validateIndexerInspectorResult(input) {
   }
   return { result, evidence, fact_payloads: result.fact_payloads };
 }
+function assertIndexerInspectorProfileVariants(projection, expected) {
+  for (const [axis, expectedValue] of Object.entries(expected)) {
+    const observed = projection.profile_variants[axis];
+    if (observed === undefined && projection.status !== "available")
+      continue;
+    if (observed !== expectedValue)
+      throw new TypeError("inspector projection variant drifted from the active Registry profile");
+  }
+}
 // src/indexerAuthorizedWorksetView.ts
 function isIndexerJson(value, ancestors = new WeakSet) {
   if (value === null || typeof value === "string" || typeof value === "boolean") {
@@ -19281,7 +19865,7 @@ var indexerAuthorizedWorksetViewSchema = exports_external.object({
   addDuplicateIssues(value.projection_input_digests, context, "projection_input_digests");
   addDuplicateIssues(value.items.map((item) => item.ref), context, "items.ref");
 });
-function canonicalUnique7(values, field) {
+function canonicalUnique8(values, field) {
   const sorted = [...values].sort(compareIndexerCanonicalText);
   if (new Set(sorted).size !== sorted.length) {
     throw new TypeError(`${field} must contain unique values`);
@@ -19301,7 +19885,7 @@ function canonicalItem(value) {
 function canonicalSource(value) {
   const payload = authorizedWorksetViewSourcePayloadSchema.parse({
     ...value,
-    input_digests: canonicalUnique7(value.input_digests, "source.input_digests"),
+    input_digests: canonicalUnique8(value.input_digests, "source.input_digests"),
     items: canonicalItems(value.items)
   });
   return indexerAuthorizedWorksetViewSourceSchema.parse({
@@ -19617,7 +20201,7 @@ function buildIndexerAuthorizedWorksetView(input) {
 }
 function validateIndexerAuthorizedWorksetView(value) {
   const view = indexerAuthorizedWorksetViewSchema.parse(value);
-  const projectionInputDigests = canonicalUnique7(view.projection_input_digests, "projection_input_digests");
+  const projectionInputDigests = canonicalUnique8(view.projection_input_digests, "projection_input_digests");
   if (projectionInputDigests.some((digest, index) => digest !== view.projection_input_digests[index])) {
     throw new TypeError("projection_input_digests must use canonical ordering");
   }
@@ -22974,7 +23558,7 @@ function compareCoverageDomains(oldRequirement, newRequirement, changes) {
   }
 }
 function exclusionCells(requirement) {
-  return new Set((requirement.exclusions ?? []).flatMap((exclusion) => [...targetCellSet2(exclusion.scope.targets)].map((cell) => `${exclusion.id}\x00${cell}`)));
+  return new Set((requirement.exclusions ?? []).flatMap((exclusion) => [...targetCellSet2(exclusion.scope.targets)].map((cell) => `${exclusion.id}\x00${cell}\x00${JSON.stringify([...exclusion.paths ?? []].sort())}`)));
 }
 function questionViewMap(views) {
   return new Map(views.map((view) => [`${view.ref}\x00${view.contractDigest}`, view]));
@@ -23138,6 +23722,14 @@ function compareIndexRequirementContraction(oldRequirement, newRequirement, opti
     throw new TypeError("Requirement comparator cannot replace a requirement identity");
   }
   const changes = [];
+  if (oldRequirement.purpose !== newRequirement.purpose) {
+    addChange(changes, {
+      area: "reader-goals",
+      path: "purpose",
+      relation: "incomparable",
+      detail: "reader purpose changed; its semantic relationship requires the stated user decision"
+    });
+  }
   compareSetArea({
     oldValues: targetCellSet2(oldRequirement.target_scope.targets),
     newValues: targetCellSet2(newRequirement.target_scope.targets),
@@ -23511,6 +24103,7 @@ function normalizeRequirement(requirement) {
   })).sort((left, right) => compareIndexerCanonicalText(left.source_ref, right.source_ref));
   return {
     id: requirement.id,
+    ...requirement.purpose === undefined ? {} : { purpose: requirement.purpose },
     reader_goals: sortedUnique4(requirement.reader_goals, "reader_goals"),
     coverage_domains: Object.fromEntries(Object.entries(requirement.coverage_domains).sort(([left], [right]) => compareIndexerCanonicalText(left, right))),
     ...requirement.questions === undefined ? {} : {
@@ -26678,7 +27271,7 @@ var DIRECT_FACT_KIND_MAPPING = {
   "downstream-callsite": "downstream-callsite",
   "state-transition": "state-transition"
 };
-function record(value) {
+function record3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function parserFactMemberKind(fact) {
@@ -26687,7 +27280,7 @@ function parserFactMemberKind(fact) {
     return direct;
   if (fact.denominator !== "symbol")
     return null;
-  const symbolKind = record(fact.payload)?.kind;
+  const symbolKind = record3(fact.payload)?.kind;
   return symbolKind === "component" ? "component" : "entry";
 }
 function buildIndexerPartitionInventoryFromParserFactView(value) {
@@ -26786,7 +27379,7 @@ function nodePolarity(node) {
 function nodeVersionRef(node) {
   return indexerDependencyVersionRef({ polarity: nodePolarity(node), node });
 }
-function canonicalUnique8(values) {
+function canonicalUnique9(values) {
   return [...new Set(values)].sort(compareIndexerCanonicalText);
 }
 function validateImpactInputs(input) {
@@ -26837,7 +27430,7 @@ function refsForCurrentNode(input) {
     section_key: section.section_key
   })));
   return {
-    artifactIds: canonicalUnique8(sections.map((section) => section.artifact_id)),
+    artifactIds: canonicalUnique9(sections.map((section) => section.artifact_id)),
     sections
   };
 }
@@ -26845,7 +27438,7 @@ function buildDependencyChanges(input) {
   const previousNodes = new Map([...input.previousView.positive_nodes, ...input.previousView.negative_nodes].map((node) => [node.node_ref, node]));
   const currentNodes = new Map([...input.currentView.positive_nodes, ...input.currentView.negative_nodes].map((node) => [node.node_ref, node]));
   const previousDependencies = new Map([...input.previousSet.positive_dependencies, ...input.previousSet.negative_dependencies].map((dependency) => [dependency.node_ref, dependency]));
-  return canonicalUnique8([...previousNodes.keys(), ...currentNodes.keys()]).flatMap((nodeRef) => {
+  return canonicalUnique9([...previousNodes.keys(), ...currentNodes.keys()]).flatMap((nodeRef) => {
     const previous = previousNodes.get(nodeRef);
     const current = currentNodes.get(nodeRef);
     const previousRef = previous === undefined ? null : nodeVersionRef(previous);
@@ -26870,7 +27463,7 @@ function buildDependencyChanges(input) {
       change: previous === undefined ? "added" : current === undefined ? "removed" : "changed",
       previous_dependency_ref: previousRef,
       current_dependency_ref: currentRef,
-      affected_artifact_ids: canonicalUnique8([
+      affected_artifact_ids: canonicalUnique9([
         ...fromPrevious.artifactIds,
         ...fromCurrent.artifactIds
       ]),
@@ -26917,14 +27510,14 @@ function buildIndexerIncrementalImpactReport(input) {
   }
   const artifacts = validated.previousSet.artifacts.map((artifact) => {
     const sections = artifact.sections.map((section) => {
-      const changed2 = canonicalUnique8(changedBySection.get(`${artifact.artifact_id}\x00${section.section_key}`) ?? []);
+      const changed2 = canonicalUnique9(changedBySection.get(`${artifact.artifact_id}\x00${section.section_key}`) ?? []);
       return {
         section_key: section.section_key,
         state: changed2.length === 0 ? "current" : "stale",
         changed_node_refs: changed2
       };
     });
-    const changed = canonicalUnique8(sections.flatMap((section) => section.changed_node_refs));
+    const changed = canonicalUnique9(sections.flatMap((section) => section.changed_node_refs));
     return {
       artifact_id: artifact.artifact_id,
       artifact_kind: artifact.artifact_kind,
@@ -27295,11 +27888,11 @@ var indexerMainAcceptedRecordSchema = exports_external.object({
   acceptance_digest: indexerDigestSchema
 }).strict();
 function validateIndexerMainAcceptedRecord(value) {
-  const record2 = indexerMainAcceptedRecordSchema.parse(value);
-  if (record2.stage === "author" !== (record2.artifact_dependency_set_digest !== null)) {
+  const record4 = indexerMainAcceptedRecordSchema.parse(value);
+  if (record4.stage === "author" !== (record4.artifact_dependency_set_digest !== null)) {
     throw new TypeError("accepted author records require an Artifact dependency set and partition records forbid one");
   }
-  return record2;
+  return record4;
 }
 function buildIndexerMainAcceptedRecord(input) {
   const payload2 = {
@@ -27384,41 +27977,41 @@ var indexerMainWorksetStatusSchema = exports_external.object({
 function observeIndexerMainWorksetState(input) {
   const currentSet = validateIndexerMainWorksetSet(input.workset_set);
   const records = input.records.map((value) => {
-    const record2 = indexerMainStateRecordSchema.parse(value);
-    if (record2.state === "accepted") {
-      const { state: _state, ...accepted2 } = record2;
+    const record4 = indexerMainStateRecordSchema.parse(value);
+    if (record4.state === "accepted") {
+      const { state: _state, ...accepted2 } = record4;
       validateIndexerMainAcceptedRecord(accepted2);
     }
-    return record2;
+    return record4;
   });
-  if (new Set(records.map((record2) => record2.workset_digest)).size !== records.length) {
+  if (new Set(records.map((record4) => record4.workset_digest)).size !== records.length) {
     throw new TypeError("main workset state contains duplicate workset records");
   }
-  const byDigest = new Map(records.map((record2) => [record2.workset_digest, record2]));
+  const byDigest = new Map(records.map((record4) => [record4.workset_digest, record4]));
   const currentItems = new Map(currentSet.items.map((item) => [item.workset_digest, item]));
-  for (const record2 of records) {
-    const item = currentItems.get(record2.workset_digest);
+  for (const record4 of records) {
+    const item = currentItems.get(record4.workset_digest);
     if (item === undefined) {
       throw new TypeError("main workset state contains a record outside the current set");
     }
-    if (record2.state === "accepted") {
+    if (record4.state === "accepted") {
       const payload3 = {
-        protocol: record2.protocol,
-        workset_digest: record2.workset_digest,
-        stage: record2.stage,
-        execution_request_digest: record2.execution_request_digest,
-        result_digest: record2.result_digest,
-        receipt_digest: record2.receipt_digest,
-        run_envelope_digest: record2.run_envelope_digest,
-        artifact_dependency_set_digest: record2.artifact_dependency_set_digest
+        protocol: record4.protocol,
+        workset_digest: record4.workset_digest,
+        stage: record4.stage,
+        execution_request_digest: record4.execution_request_digest,
+        result_digest: record4.result_digest,
+        receipt_digest: record4.receipt_digest,
+        run_envelope_digest: record4.run_envelope_digest,
+        artifact_dependency_set_digest: record4.artifact_dependency_set_digest
       };
-      if (record2.stage !== item.stage || indexerProtocolDigest(payload3) !== record2.acceptance_digest) {
+      if (record4.stage !== item.stage || indexerProtocolDigest(payload3) !== record4.acceptance_digest) {
         throw new TypeError("accepted main result record is stale or has an invalid digest");
       }
     }
-    if (record2.state === "failed") {
-      const dependencies = [...record2.dependency_digests].sort(compareIndexerCanonicalText);
-      if (new Set(dependencies).size !== dependencies.length || dependencies.some((digest, index) => digest !== record2.dependency_digests[index])) {
+    if (record4.state === "failed") {
+      const dependencies = [...record4.dependency_digests].sort(compareIndexerCanonicalText);
+      if (new Set(dependencies).size !== dependencies.length || dependencies.some((digest, index) => digest !== record4.dependency_digests[index])) {
         throw new TypeError("failed main result dependencies must be unique and canonical");
       }
     }
@@ -27431,22 +28024,22 @@ function observeIndexerMainWorksetState(input) {
     }
   }));
   const counts = {
-    pending: joined.filter(({ record: record2 }) => record2.state === "pending" || record2.state === "running").length,
-    accepted: joined.filter(({ record: record2 }) => record2.state === "accepted").length,
-    failed: joined.filter(({ record: record2 }) => record2.state === "failed").length,
-    stale: joined.filter(({ record: record2 }) => record2.state === "stale").length
+    pending: joined.filter(({ record: record4 }) => record4.state === "pending" || record4.state === "running").length,
+    accepted: joined.filter(({ record: record4 }) => record4.state === "accepted").length,
+    failed: joined.filter(({ record: record4 }) => record4.state === "failed").length,
+    stale: joined.filter(({ record: record4 }) => record4.state === "stale").length
   };
-  const nextRefs = joined.filter(({ record: record2 }) => record2.state !== "accepted" && record2.state !== "running").map(({ item, record: record2 }) => ({
+  const nextRefs = joined.filter(({ record: record4 }) => record4.state !== "accepted" && record4.state !== "running").map(({ item, record: record4 }) => ({
     ...item,
-    state: record2.state
+    state: record4.state
   }));
-  const accepted = joined.filter((item) => item.record.state === "accepted").map(({ record: record2 }) => ({
-    workset_digest: record2.workset_digest,
-    execution_request_digest: record2.execution_request_digest,
-    result_digest: record2.result_digest,
-    receipt_digest: record2.receipt_digest,
-    run_envelope_digest: record2.run_envelope_digest,
-    artifact_dependency_set_digest: record2.artifact_dependency_set_digest
+  const accepted = joined.filter((item) => item.record.state === "accepted").map(({ record: record4 }) => ({
+    workset_digest: record4.workset_digest,
+    execution_request_digest: record4.execution_request_digest,
+    result_digest: record4.result_digest,
+    receipt_digest: record4.receipt_digest,
+    run_envelope_digest: record4.run_envelope_digest,
+    artifact_dependency_set_digest: record4.artifact_dependency_set_digest
   })).sort((left, right) => compareIndexerCanonicalText(left.workset_digest, right.workset_digest));
   const outcome = counts.failed > 0 ? "index-main-workset-failed" : counts.stale > 0 ? "index-main-workset-stale" : counts.pending > 0 ? "index-main-workset-pending" : "complete";
   const payload2 = {
@@ -27471,35 +28064,218 @@ function observeIndexerMainWorksetState(input) {
   });
 }
 // src/indexerAgentStepProtocol.ts
-var indexerAgentStepInputSchema = exports_external.object({
-  protocol: exports_external.literal("context.indexer.agent-step-input/v1"),
-  run_request: indexerProgramRunRequestSchema,
+var indexerAgentStepTaskSchema = exports_external.object({
+  task_key: exports_external.string().regex(/^task-[0-9]{3}$/u),
+  workset_digest: indexerDigestSchema,
+  execution_request_digest: indexerDigestSchema,
+  consumed_input_view_digest: indexerDigestSchema,
+  workset_view_resource_id: exports_external.string().regex(/^authorized-indexer-workset-view\/task-[0-9]{3}$/u),
+  workset_view_request_digest: indexerDigestSchema
+}).strict();
+var indexerMainAgentStepInputSchema = exports_external.object({
+  protocol: exports_external.literal("context.indexer.agent-step-input/v2"),
+  stage: exports_external.enum(["partition", "author"]),
+  transport: indexerMainTransportBatchSchema,
   instruction_request_digest: indexerDigestSchema,
+  tasks: exports_external.array(indexerAgentStepTaskSchema).min(1),
   input_digest: indexerDigestSchema
 }).strict();
+var indexerPostAuthorAgentStepTaskSchema = exports_external.object({
+  task_key: exports_external.string().regex(/^task-[0-9]{3}$/u),
+  workset_digest: indexerDigestSchema,
+  request_digest: indexerDigestSchema,
+  primary_result_view_digest: indexerDigestSchema,
+  workset_view_resource_id: exports_external.string().regex(/^authorized-indexer-workset-view\/task-[0-9]{3}$/u)
+}).strict();
+var indexerPostAuthorAgentStepInputSchema = exports_external.object({
+  protocol: exports_external.literal("context.indexer.agent-step-input/v2"),
+  stage: exports_external.literal("post-author"),
+  instruction_request_digest: indexerDigestSchema,
+  tasks: exports_external.array(indexerPostAuthorAgentStepTaskSchema).min(1),
+  input_digest: indexerDigestSchema
+}).strict();
+var indexerAgentStepInputSchema = exports_external.discriminatedUnion("stage", [
+  indexerMainAgentStepInputSchema,
+  indexerPostAuthorAgentStepInputSchema
+]);
 function indexerAgentStepInputDigest(value) {
-  return indexerProtocolDigest(value);
+  const { input_digest: _digest, ...payload2 } = value;
+  return indexerProtocolDigest(payload2);
 }
 function buildIndexerAgentStepInput(input) {
-  const runRequest = validateIndexerProgramRunRequest(input.run_request);
+  if (input.run_requests.length === 0) {
+    throw new TypeError("Indexer Agent step requires at least one run request");
+  }
+  const runRequests = input.run_requests.map(validateIndexerProgramRunRequest);
+  if (input.workset_view_requests.length !== runRequests.length) {
+    throw new TypeError("Indexer Agent step must have one View per run request");
+  }
+  const stage = runRequests[0].workset.stage;
+  if (runRequests.some((request) => request.workset.stage !== stage)) {
+    throw new TypeError("Indexer Agent step batch must contain one stage");
+  }
+  const transport = buildIndexerMainTransportBatch(runRequests.map((request) => request.workset));
+  const tasks = runRequests.map((request, index) => {
+    const taskKey = `task-${String(index + 1).padStart(3, "0")}`;
+    const view = input.workset_view_requests[index];
+    if (view.workset_digest !== request.workset.workset_digest || view.resource_id !== `authorized-indexer-workset-view/${taskKey}`) {
+      throw new TypeError("Indexer Agent step View mapping does not match its workset");
+    }
+    return {
+      task_key: taskKey,
+      workset_digest: request.workset.workset_digest,
+      execution_request_digest: request.execution_request_digest,
+      consumed_input_view_digest: request.composition_input.view_digest,
+      workset_view_resource_id: view.resource_id,
+      workset_view_request_digest: view.request_digest
+    };
+  });
   const payload2 = {
-    protocol: "context.indexer.agent-step-input/v1",
-    run_request: runRequest,
-    instruction_request_digest: indexerDigestSchema.parse(input.instruction_request_digest)
+    protocol: "context.indexer.agent-step-input/v2",
+    stage,
+    transport,
+    instruction_request_digest: indexerDigestSchema.parse(input.instruction_request_digest),
+    tasks
   };
-  return indexerAgentStepInputSchema.parse({
+  return indexerMainAgentStepInputSchema.parse({
+    ...payload2,
+    input_digest: indexerAgentStepInputDigest(payload2)
+  });
+}
+function buildIndexerPostAuthorAgentStepInput(input) {
+  if (input.fragment_requests.length === 0) {
+    throw new TypeError("post-author Agent step requires at least one fragment request");
+  }
+  const requests = input.fragment_requests.map(validateIndexerPostAuthorFragmentRequest);
+  const tasks = requests.map((request, index) => {
+    const taskKey = `task-${String(index + 1).padStart(3, "0")}`;
+    return {
+      task_key: taskKey,
+      workset_digest: request.workset.workset_digest,
+      request_digest: request.request_digest,
+      primary_result_view_digest: request.primary_result_view.view_digest,
+      workset_view_resource_id: `authorized-indexer-workset-view/${taskKey}`
+    };
+  });
+  const payload2 = {
+    protocol: "context.indexer.agent-step-input/v2",
+    stage: "post-author",
+    instruction_request_digest: indexerDigestSchema.parse(input.instruction_request_digest),
+    tasks
+  };
+  return indexerPostAuthorAgentStepInputSchema.parse({
     ...payload2,
     input_digest: indexerAgentStepInputDigest(payload2)
   });
 }
 function validateIndexerAgentStepInput(value) {
   const input = indexerAgentStepInputSchema.parse(value);
-  const rebuilt = buildIndexerAgentStepInput(input);
-  if (rebuilt.input_digest !== input.input_digest) {
+  if (input.input_digest !== indexerAgentStepInputDigest(input)) {
     throw new TypeError("Indexer Agent step input digest is invalid");
   }
+  if (input.stage === "post-author") {
+    if (new Set(input.tasks.map((task) => task.task_key)).size !== input.tasks.length) {
+      throw new TypeError("post-author Agent step task keys must be unique");
+    }
+    return input;
+  }
+  if (input.transport.worksets.length !== input.tasks.length || input.transport.worksets.some((workset, index) => workset.stage !== input.stage || workset.workset_digest !== input.tasks[index].workset_digest)) {
+    throw new TypeError("Indexer Agent step transport does not match its task manifest");
+  }
   return input;
 }
+// src/readingStructure.ts
+var readingStructureEntrySchema = exports_external.object({
+  key: exports_external.string().min(1),
+  parent: exports_external.string().min(1).nullable(),
+  title: exports_external.string().min(1),
+  order: exports_external.number().finite().default(0),
+  target: exports_external.object({
+    artifact_ref: exports_external.string().min(1),
+    section_key: exports_external.string().min(1).optional()
+  }).strict().optional()
+}).strict();
+var readingStructureUpdateSchema = exports_external.object({
+  expected_revision: exports_external.string().nullable(),
+  upsert: exports_external.array(readingStructureEntrySchema).default([]),
+  remove: exports_external.array(exports_external.string().min(1)).default([])
+}).strict();
+var readingStructureSchema = exports_external.object({
+  protocol: exports_external.literal("context.reading-structure/v1"),
+  revision: exports_external.string().min(1),
+  entries: exports_external.array(readingStructureEntrySchema)
+}).strict();
+function validateEntries(entries) {
+  const indexed = new Map(entries.map((entry) => [entry.key, entry]));
+  if (indexed.size !== entries.length)
+    throw new TypeError("reading entries must have unique keys");
+  for (const entry of entries) {
+    const visited = new Set;
+    let current = entry;
+    while (current !== undefined) {
+      if (visited.has(current.key))
+        throw new TypeError("reading structure contains a parent cycle");
+      visited.add(current.key);
+      if (current.parent === null)
+        break;
+      const parent = indexed.get(current.parent);
+      if (parent === undefined)
+        throw new TypeError(`reading entry ${current.key} has an unknown parent`);
+      current = parent;
+    }
+  }
+}
+function validateReadingStructure(value) {
+  const result = readingStructureSchema.parse(value);
+  validateEntries(result.entries);
+  const { revision, ...payload2 } = result;
+  if (indexerProtocolDigest(payload2) !== revision)
+    throw new TypeError("reading structure revision does not match its content");
+  return result;
+}
+function updateReadingStructure(current, value) {
+  const update = readingStructureUpdateSchema.parse(value);
+  if ((current?.revision ?? null) !== update.expected_revision)
+    throw new TypeError("reading structure changed; reread the current structure before applying this edit");
+  const keys = update.upsert.map((entry) => entry.key);
+  if (new Set(keys).size !== keys.length || new Set(update.remove).size !== update.remove.length || keys.some((key) => update.remove.includes(key))) {
+    throw new TypeError("reading structure update contains conflicting entry identities");
+  }
+  const entries = new Map(current?.entries.map((entry) => [entry.key, entry]) ?? []);
+  for (const key of update.remove)
+    entries.delete(key);
+  for (const entry of update.upsert)
+    entries.set(entry.key, entry);
+  const payload2 = {
+    protocol: "context.reading-structure/v1",
+    entries: [...entries.values()].sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0)
+  };
+  validateEntries(payload2.entries);
+  return { ...payload2, revision: indexerProtocolDigest(payload2) };
+}
+function projectReadingStructure(structure, targets) {
+  const children = new Map;
+  for (const entry of structure.entries)
+    children.set(entry.parent, [...children.get(entry.parent) ?? [], entry]);
+  const warnings = [];
+  function project(parent) {
+    return (children.get(parent) ?? []).sort((a, b) => a.order - b.order || a.key.localeCompare(b.key)).flatMap((entry) => {
+      const descendants = project(entry.key);
+      const identity2 = entry.target === undefined ? undefined : readingTargetKey(entry.target);
+      const href = identity2 === undefined ? undefined : targets.get(identity2);
+      if (identity2 !== undefined && href === undefined)
+        warnings.push({ entry: entry.key, code: "reading-target-unavailable", target: identity2 });
+      if (href === undefined && descendants.length === 0)
+        return [];
+      return [{ key: entry.key, title: entry.title, ...href === undefined ? {} : { href }, children: descendants }];
+    });
+  }
+  return { entries: project(null), warnings };
+}
+function readingTargetKey(target) {
+  return target.section_key === undefined ? target.artifact_ref : `${target.artifact_ref}#${encodeURIComponent(target.section_key)}`;
+}
+
 // src/indexerSemanticInput.ts
 var providerObservationSchema = exports_external.object({
   skill: exports_external.string().min(1),
@@ -27525,9 +28301,6 @@ var indexerProviderResolutionSemanticInputSchema = exports_external.object({
     value: exports_external.unknown()
   }).strict().optional()
 }).strict();
-var indexerProviderFinalizationSemanticInputSchema = exports_external.object({
-  stage: exports_external.literal("provider-finalization")
-}).strict();
 var indexerProviderProgramAuthorizationSemanticInputSchema = exports_external.object({
   stage: exports_external.literal("provider-program-authorization"),
   decision: exports_external.enum(["approved", "rejected"])
@@ -27544,6 +28317,12 @@ var partitionGroupSchema2 = exports_external.object({
   key: exports_external.string().min(1),
   title: exports_external.string().min(1),
   reader_task: exports_external.string().min(1),
+  artifact_intent: exports_external.string().min(1).optional(),
+  template_id: exports_external.string().min(1).optional(),
+  articles: exports_external.array(indexerArticlePlanSchema).min(1).optional(),
+  priority: exports_external.number().int().nonnegative().optional(),
+  delivery_boundary: exports_external.boolean().optional(),
+  ready_for_author: exports_external.boolean().optional(),
   subject: subjectChoiceSchema,
   subject_intent: exports_external.enum(["primary", "enrich-or-independent"]),
   members: exports_external.array(exports_external.string().min(1)).min(1),
@@ -27565,8 +28344,6 @@ var partitionUnsupportedSchema = exports_external.object({
 var completePartitionInputSchema = exports_external.object({
   stage: exports_external.literal("partition"),
   outcome: exports_external.literal("complete"),
-  unit_type: exports_external.string().min(1),
-  partition_axis: exports_external.string().min(1),
   groups: exports_external.array(partitionGroupSchema2),
   excluded: exports_external.array(partitionDispositionSchema).default([]),
   unsupported: exports_external.array(partitionUnsupportedSchema).default([])
@@ -27574,8 +28351,6 @@ var completePartitionInputSchema = exports_external.object({
 var failedPartitionInputSchema = exports_external.object({
   stage: exports_external.literal("partition"),
   outcome: exports_external.literal("failed"),
-  unit_type: exports_external.string().min(1),
-  partition_axis: exports_external.string().min(1),
   groups: exports_external.array(partitionGroupSchema2).default([]),
   excluded: exports_external.array(partitionDispositionSchema).default([]),
   unsupported: exports_external.array(partitionUnsupportedSchema).default([]),
@@ -27600,18 +28375,38 @@ var indexerPartitionSemanticInputSchema = exports_external.union([
 function validateIndexerPartitionSemanticInput(value) {
   return indexerPartitionSemanticInputSchema.parse(value);
 }
+var authorVisualSchema = exports_external.object({
+  resource: exports_external.string().min(1),
+  also_read: exports_external.array(exports_external.string().min(1)).optional(),
+  context: exports_external.array(exports_external.string()).default([]),
+  requirements: exports_external.string().default(""),
+  disposition: exports_external.enum(["converted", "retained"]),
+  format: exports_external.enum(["mermaid", "table", "original"]),
+  markdown: exports_external.string().optional(),
+  reason: exports_external.string().optional()
+}).strict();
 var authorSectionSchema = exports_external.object({
   key: exports_external.string().min(1),
   heading: exports_external.string().min(1),
+  visuals: exports_external.array(authorVisualSchema).optional(),
   markdown: exports_external.string().min(1),
-  source_items: exports_external.array(exports_external.string().min(1)).min(1),
+  source_items: exports_external.array(exports_external.string().min(1)).default([]),
   facts: exports_external.array(exports_external.string().min(1)).default([]),
   answers: exports_external.array(exports_external.string().min(1)).default([])
 }).strict();
+var authorTemplateVariablesSchema = exports_external.record(exports_external.union([
+  exports_external.string(),
+  exports_external.object({
+    value: exports_external.string(),
+    source_items: exports_external.array(exports_external.string().min(1)).default([]),
+    facts: exports_external.array(exports_external.string().min(1)).default([])
+  }).strict()
+]));
 var authorMemberDispositionSchema = exports_external.object({
   item: exports_external.string().min(1),
   state: exports_external.enum(["covered", "catalog-only", "unsupported"]),
   section: exports_external.string().min(1).optional(),
+  article: indexerArticleKeySchema.optional(),
   reason_code: exports_external.string().min(1).optional()
 }).strict();
 var authorMaterialGapSchema = exports_external.object({
@@ -27623,11 +28418,24 @@ var authorDiagnosticSchema = exports_external.object({
   message: exports_external.string().min(1),
   target: exports_external.string().min(1).optional()
 }).strict();
-var indexerAuthorSemanticInputSchema = exports_external.object({
+var authorInputBaseSchema = exports_external.object({
   stage: exports_external.literal("author"),
   group_key: exports_external.string().min(1),
   outcome: exports_external.enum(["publish", "catalog-only", "request-material", "unsupported"]),
+  articles: exports_external.array(exports_external.object({
+    key: indexerArticleKeySchema,
+    title: exports_external.string().min(1),
+    summary: exports_external.string().min(1),
+    artifact_intent: exports_external.string().min(1).optional(),
+    template_variables: authorTemplateVariablesSchema.optional(),
+    sections: exports_external.array(authorSectionSchema).min(1)
+  }).strict()).min(1).optional(),
   artifact_intent: exports_external.string().min(1).optional(),
+  template_variables: authorTemplateVariablesSchema.optional(),
+  example_candidates: exports_external.array(exports_external.object({
+    scenario_key: indexerIdSchema,
+    source_item: exports_external.string().min(1)
+  }).strict()).optional(),
   policy: exports_external.string().min(1).optional(),
   target_resolutions: exports_external.array(exports_external.object({
     target: exports_external.string().min(1),
@@ -27637,39 +28445,83 @@ var indexerAuthorSemanticInputSchema = exports_external.object({
   title: exports_external.string().min(1).optional(),
   summary: exports_external.string().min(1).optional(),
   sections: exports_external.array(authorSectionSchema).default([]),
-  member_dispositions: exports_external.array(authorMemberDispositionSchema),
+  member_dispositions: exports_external.array(exports_external.union([
+    authorMemberDispositionSchema,
+    authorMemberDispositionSchema.omit({ item: true }).extend({ items: exports_external.array(exports_external.string().min(1)).min(1) }).strict()
+  ])).transform((entries) => entries.flatMap((entry) => {
+    if ("item" in entry)
+      return [entry];
+    const { items, ...disposition } = entry;
+    return items.map((item) => ({ item, ...disposition }));
+  })),
   material_gaps: exports_external.array(authorMaterialGapSchema).default([]),
   diagnostics: exports_external.array(authorDiagnosticSchema).default([])
+}).strict();
+var indexerAuthorSemanticInputSchema = exports_external.union([
+  authorInputBaseSchema.extend({
+    outcome: exports_external.literal("publish"),
+    title: exports_external.string().min(1),
+    summary: exports_external.string().min(1),
+    sections: exports_external.array(authorSectionSchema).min(1)
+  }),
+  authorInputBaseSchema.extend({
+    outcome: exports_external.literal("publish"),
+    articles: authorInputBaseSchema.shape.articles.unwrap(),
+    title: exports_external.string().optional(),
+    summary: exports_external.string().optional(),
+    sections: exports_external.array(authorSectionSchema).max(0).default([])
+  }),
+  authorInputBaseSchema.extend({ outcome: exports_external.literal("catalog-only") }),
+  authorInputBaseSchema.extend({ outcome: exports_external.literal("request-material") }),
+  authorInputBaseSchema.extend({ outcome: exports_external.literal("unsupported") })
+]);
+var indexerPartitionBatchSemanticInputSchema = exports_external.object({
+  stage: exports_external.literal("partition"),
+  results: exports_external.array(exports_external.object({
+    task_key: exports_external.string().regex(/^task-[0-9]{3}$/u),
+    result: indexerPartitionSemanticInputSchema
+  }).strict()).min(1)
 }).strict().superRefine((value, context) => {
-  if (value.outcome === "publish" && value.sections.length === 0) {
-    context.addIssue({
-      code: exports_external.ZodIssueCode.custom,
-      path: ["sections"],
-      message: "publish requires at least one reader-facing section"
-    });
-  }
-  if (value.outcome === "publish" && value.title === undefined) {
+  const keys = value.results.map((result) => result.task_key);
+  if (new Set(keys).size !== keys.length) {
     context.addIssue({
       code: exports_external.ZodIssueCode.custom,
-      path: ["title"],
-      message: "publish requires a reader-facing title"
+      path: ["results"],
+      message: "partition batch task keys must be unique"
     });
   }
-  if (value.outcome === "publish" && value.summary === undefined) {
+});
+var indexerAuthorBatchSemanticInputSchema = exports_external.object({
+  stage: exports_external.literal("author"),
+  results: exports_external.array(exports_external.object({
+    task_key: exports_external.string().regex(/^task-[0-9]{3}$/u),
+    result: indexerAuthorSemanticInputSchema
+  }).strict()).min(1)
+}).strict().superRefine((value, context) => {
+  const keys = value.results.map((result) => result.task_key);
+  if (new Set(keys).size !== keys.length) {
     context.addIssue({
       code: exports_external.ZodIssueCode.custom,
-      path: ["summary"],
-      message: "publish requires a reader-facing summary"
+      path: ["results"],
+      message: "author batch task keys must be unique"
     });
   }
 });
+var indexerMainBatchSubmissionEnvelopeSchema = exports_external.object({
+  stage: exports_external.enum(["partition", "author", "post-author"]),
+  results: exports_external.array(exports_external.object({
+    task_key: exports_external.string(),
+    result: exports_external.unknown()
+  }).strict()).min(1)
+}).strict();
 var postAuthorSectionSchema = exports_external.object({
   key: exports_external.string().min(1),
   heading: exports_external.string().min(1),
+  visuals: exports_external.array(authorVisualSchema).optional(),
   markdown: exports_external.string().min(1),
   source_refs: exports_external.array(exports_external.string().min(1)).min(1)
 }).strict();
-var indexerPostAuthorSemanticInputSchema = exports_external.object({
+var postAuthorInputBaseSchema = exports_external.object({
   stage: exports_external.literal("post-author"),
   outcome: exports_external.enum(["complete", "failed"]),
   proposals: exports_external.array(exports_external.object({
@@ -27680,176 +28532,120 @@ var indexerPostAuthorSemanticInputSchema = exports_external.object({
     sections: exports_external.array(postAuthorSectionSchema).min(1)
   }).strict()).default([]),
   diagnostics: exports_external.array(authorDiagnosticSchema).default([])
+}).strict();
+var indexerPostAuthorSemanticInputSchema = exports_external.discriminatedUnion("outcome", [
+  postAuthorInputBaseSchema.extend({ outcome: exports_external.literal("complete") }),
+  postAuthorInputBaseSchema.extend({
+    outcome: exports_external.literal("failed"),
+    diagnostics: exports_external.array(authorDiagnosticSchema).min(1)
+  })
+]);
+var indexerPostAuthorBatchSemanticInputSchema = exports_external.object({
+  stage: exports_external.literal("post-author"),
+  results: exports_external.array(exports_external.object({
+    task_key: exports_external.string().regex(/^task-[0-9]{3}$/u),
+    result: indexerPostAuthorSemanticInputSchema
+  }).strict()).min(1)
 }).strict().superRefine((value, context) => {
-  if (value.outcome === "failed" && value.diagnostics.length === 0) {
+  const keys = value.results.map((result) => result.task_key);
+  if (new Set(keys).size !== keys.length) {
     context.addIssue({
       code: exports_external.ZodIssueCode.custom,
-      path: ["diagnostics"],
-      message: "failed post-author composition requires a diagnostic"
+      path: ["results"],
+      message: "post-author batch task keys must be unique"
     });
   }
 });
-var indexerStructureReviewInputSchema = exports_external.object({
+var structureReviewBaseSchema = exports_external.object({
   stage: exports_external.literal("structure-review"),
-  decision: exports_external.enum(["approved", "request-adjustment"]),
+  reading_structure: readingStructureUpdateSchema.optional(),
+  decision: exports_external.enum(["approved", "exclude-obsolete", "request-adjustment"]),
   feedback: exports_external.string().min(1).optional()
-}).strict().superRefine((value, context) => {
-  if (value.decision === "request-adjustment" && value.feedback === undefined) {
-    context.addIssue({
-      code: exports_external.ZodIssueCode.custom,
-      path: ["feedback"],
-      message: "request-adjustment requires feedback"
-    });
-  }
-});
-var indexerLayoutConfirmationInputSchema = exports_external.object({
+}).strict();
+var indexerStructureReviewInputSchema = exports_external.discriminatedUnion("decision", [
+  structureReviewBaseSchema.extend({ decision: exports_external.literal("approved") }),
+  structureReviewBaseSchema.extend({ decision: exports_external.literal("exclude-obsolete") }),
+  structureReviewBaseSchema.extend({
+    decision: exports_external.literal("request-adjustment"),
+    feedback: exports_external.string().min(1)
+  })
+]);
+var layoutConfirmationBaseSchema = exports_external.object({
   stage: exports_external.literal("layout-confirmation"),
   decision: exports_external.enum(["approved", "rejected"]),
-  feedback: exports_external.string().min(1).optional()
-}).strict().superRefine((value, context) => {
-  if (value.decision === "rejected" && value.feedback === undefined) {
-    context.addIssue({
-      code: exports_external.ZodIssueCode.custom,
-      path: ["feedback"],
-      message: "rejected layout confirmation requires feedback"
-    });
-  }
-});
+  feedback: exports_external.string().min(1).optional(),
+  paths: exports_external.array(exports_external.object({
+    artifact_ref: exports_external.string().min(1),
+    output_path: exports_external.string().min(1)
+  }).strict()).min(1).optional()
+}).strict();
+var indexerLayoutConfirmationInputSchema = exports_external.discriminatedUnion("decision", [
+  layoutConfirmationBaseSchema.extend({ decision: exports_external.literal("approved") }),
+  layoutConfirmationBaseSchema.omit({ paths: true }).extend({
+    decision: exports_external.literal("rejected"),
+    feedback: exports_external.string().min(1)
+  })
+]);
+var approvedRevisionSemanticInputSchema = exports_external.union([
+  exports_external.object({ stage: exports_external.literal("approved-revision"), markdown: exports_external.string().min(1) }).strict(),
+  exports_external.object({
+    stage: exports_external.literal("approved-revision"),
+    sections: exports_external.array(exports_external.object({
+      section_id: exports_external.string().min(1),
+      content: exports_external.array(exports_external.union([
+        exports_external.object({ markdown: exports_external.string() }).strict(),
+        exports_external.object({ program: exports_external.string().min(1) }).strict()
+      ])).min(1)
+    }).strict()).min(1)
+  }).strict()
+]);
+var sourceUpdateSemanticInputSchema = exports_external.object({
+  stage: exports_external.literal("source-update"),
+  decisions: exports_external.array(exports_external.object({
+    path: exports_external.string().min(1),
+    instruction: exports_external.string().trim().min(1).optional(),
+    supporting_sources: exports_external.array(exports_external.string().min(1)).min(1).optional()
+  }).strict()),
+  scope_summary: exports_external.string().trim().min(1),
+  new_topics: exports_external.array(exports_external.object({
+    path: exports_external.string().trim().min(1),
+    title: exports_external.string().trim().min(1),
+    source_refs: exports_external.array(exports_external.string().min(1)).min(1),
+    instruction: exports_external.string().trim().min(1)
+  }).strict())
+}).strict();
+var indexerCurrentActionInputDefinitions = {
+  sourceUpdate: sourceUpdateSemanticInputSchema,
+  approvedRevision: approvedRevisionSemanticInputSchema,
+  providerSelection: indexerProviderSelectionSemanticInputSchema,
+  providerResolution: indexerProviderResolutionSemanticInputSchema,
+  providerProgramAuthorization: indexerProviderProgramAuthorizationSemanticInputSchema,
+  partitionBatch: indexerPartitionBatchSemanticInputSchema,
+  authorBatch: indexerAuthorBatchSemanticInputSchema,
+  postAuthor: indexerPostAuthorBatchSemanticInputSchema,
+  structureReview: indexerStructureReviewInputSchema,
+  layoutConfirmation: indexerLayoutConfirmationInputSchema
+};
 var indexerCurrentActionInputSchema = exports_external.union([
+  sourceUpdateSemanticInputSchema,
+  approvedRevisionSemanticInputSchema,
   indexerProviderSelectionSemanticInputSchema,
   indexerProviderResolutionSemanticInputSchema,
   indexerProviderProgramAuthorizationSemanticInputSchema,
-  indexerProviderFinalizationSemanticInputSchema,
-  indexerPartitionSemanticInputSchema,
-  indexerAuthorSemanticInputSchema,
-  indexerPostAuthorSemanticInputSchema,
+  indexerPartitionBatchSemanticInputSchema,
+  indexerAuthorBatchSemanticInputSchema,
+  indexerPostAuthorBatchSemanticInputSchema,
   indexerStructureReviewInputSchema,
   indexerLayoutConfirmationInputSchema
 ]);
 function validateIndexerCurrentActionInput(value) {
   return indexerCurrentActionInputSchema.parse(value);
 }
-// src/indexerExampleIdentity.ts
-var exampleObservationSchema = exports_external.object({
-  observation_ref: indexerCanonicalRefSchema,
-  example_ref: indexerCanonicalRefSchema,
-  public_target_ref: indexerCanonicalRefSchema,
-  scenario_key: indexerIdSchema,
-  source_ref: indexerCanonicalRefSchema,
-  module_ref: indexerCanonicalRefSchema.nullable(),
-  full_relative_path: portableIndexerPathSchema,
-  content_digest: indexerDigestSchema,
-  evidence_refs: exports_external.array(indexerCanonicalRefSchema).min(1)
-}).strict();
-var indexerExampleInventorySchema = exports_external.object({
-  protocol: exports_external.literal("context.indexer.example-inventory/v1"),
-  source_scope_digest: indexerDigestSchema,
-  observations: exports_external.array(exampleObservationSchema),
-  inventory_digest: indexerDigestSchema
-}).strict();
-function canonicalUnique9(values, field) {
-  const sorted = [...values].sort(compareIndexerCanonicalText);
-  if (new Set(sorted).size !== sorted.length) {
-    throw new TypeError(`${field} must not contain duplicate identities`);
-  }
-  return sorted;
-}
-function normalizeIndexerExampleRelativePath(value) {
-  const normalized = value.normalize("NFC").replaceAll("\\", "/").replace(/^\.\//u, "");
-  return portableIndexerPathSchema.parse(normalized);
-}
-function indexerExampleRef(input) {
-  const identity2 = {
-    public_target_ref: indexerCanonicalRefSchema.parse(input.public_target_ref),
-    scenario_key: indexerIdSchema.parse(input.scenario_key),
-    full_relative_path: normalizeIndexerExampleRelativePath(input.full_relative_path)
-  };
-  return `example:${indexerProtocolDigest(identity2)}`;
-}
-function indexerExampleObservationRef(input) {
-  return `example-observation:${indexerProtocolDigest(input)}`;
-}
-function indexerExampleInventoryDigest(value) {
-  return indexerProtocolDigest(value);
-}
-function normalizeObservation(input) {
-  const fullRelativePath = normalizeIndexerExampleRelativePath(input.full_relative_path);
-  const publicTargetRef = indexerCanonicalRefSchema.parse(input.public_target_ref);
-  const scenarioKey = indexerIdSchema.parse(input.scenario_key);
-  const sourceRef = indexerCanonicalRefSchema.parse(input.source_ref);
-  const moduleRef = input.module_ref === null ? null : indexerCanonicalRefSchema.parse(input.module_ref);
-  const contentDigest2 = indexerDigestSchema.parse(input.content_digest);
-  const exampleRef = indexerExampleRef({
-    public_target_ref: publicTargetRef,
-    scenario_key: scenarioKey,
-    full_relative_path: fullRelativePath
-  });
-  return exampleObservationSchema.parse({
-    observation_ref: indexerExampleObservationRef({
-      example_ref: exampleRef,
-      source_ref: sourceRef,
-      module_ref: moduleRef,
-      content_digest: contentDigest2
-    }),
-    example_ref: exampleRef,
-    public_target_ref: publicTargetRef,
-    scenario_key: scenarioKey,
-    source_ref: sourceRef,
-    module_ref: moduleRef,
-    full_relative_path: fullRelativePath,
-    content_digest: contentDigest2,
-    evidence_refs: canonicalUnique9(input.evidence_refs, "example evidence_refs")
-  });
-}
-function buildIndexerExampleInventory(input) {
-  const byObservation = new Map;
-  for (const observationInput of input.observations) {
-    const observation = normalizeObservation(observationInput);
-    const current = byObservation.get(observation.observation_ref);
-    if (current === undefined) {
-      byObservation.set(observation.observation_ref, observation);
-      continue;
-    }
-    const currentCore = { ...current, evidence_refs: undefined };
-    const nextCore = { ...observation, evidence_refs: undefined };
-    if (canonicalIndexerJson(currentCore) !== canonicalIndexerJson(nextCore)) {
-      throw new TypeError("example observation identity collision");
-    }
-    current.evidence_refs = [...new Set([
-      ...current.evidence_refs,
-      ...observation.evidence_refs
-    ])].sort(compareIndexerCanonicalText);
-  }
-  const observations = [...byObservation.values()].sort((left, right) => compareIndexerCanonicalText(left.observation_ref, right.observation_ref));
-  const payload2 = {
-    protocol: "context.indexer.example-inventory/v1",
-    source_scope_digest: indexerDigestSchema.parse(input.source_scope_digest),
-    observations
-  };
-  return indexerExampleInventorySchema.parse({
-    ...payload2,
-    inventory_digest: indexerExampleInventoryDigest(payload2)
-  });
-}
-function validateIndexerExampleInventory(input) {
-  const value = indexerExampleInventorySchema.parse(input.value);
-  const rebuilt = buildIndexerExampleInventory({
-    source_scope_digest: value.source_scope_digest,
-    observations: value.observations
-  });
-  if (canonicalIndexerJson(rebuilt) !== canonicalIndexerJson(value)) {
-    throw new TypeError("example inventory is non-canonical or has an invalid digest");
-  }
-  if (input.expected_source_scope_digest !== undefined && value.source_scope_digest !== input.expected_source_scope_digest) {
-    throw new TypeError("example inventory belongs to another source scope");
+function parseIndexerCurrentActionSubmission(value) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value) && (Reflect.get(value, "stage") === "partition" || Reflect.get(value, "stage") === "author" || Reflect.get(value, "stage") === "post-author")) {
+    return indexerMainBatchSubmissionEnvelopeSchema.parse(value);
   }
-  if (input.known_evidence_refs !== undefined) {
-    const known = new Set(canonicalUnique9(input.known_evidence_refs, "known_evidence_refs"));
-    if (value.observations.some((item) => item.evidence_refs.some((evidenceRef) => !known.has(evidenceRef)))) {
-      throw new TypeError("example inventory references unknown evidence");
-    }
-  }
-  return value;
+  return validateIndexerCurrentActionInput(value);
 }
 // src/indexerExampleIdentityAudit.ts
 var collisionSchema = exports_external.object({
@@ -28565,26 +29361,26 @@ function fallbackStrategy(input) {
   return attempt;
 }
 function validateIndexerCatalogFallbackRecord(value) {
-  const record2 = indexerCatalogFallbackRecordSchema.parse(value);
-  const payload2 = Object.fromEntries(Object.entries(record2).filter(([key]) => key !== "fallback_digest"));
-  if (indexerProtocolDigest(payload2) !== record2.fallback_digest) {
+  const record4 = indexerCatalogFallbackRecordSchema.parse(value);
+  const payload2 = Object.fromEntries(Object.entries(record4).filter(([key]) => key !== "fallback_digest"));
+  if (indexerProtocolDigest(payload2) !== record4.fallback_digest) {
     throw new TypeError("catalog fallback digest is invalid");
   }
-  const planPayload2 = Object.fromEntries(Object.entries(record2.partition_plan).filter(([key]) => key !== "canonical_hash"));
-  const group = record2.partition_plan.groups[0];
-  const catalogMembers = [...record2.catalog_block.member_ids].sort(compareIndexerCanonicalText);
-  const ownedMembers2 = record2.partition_plan.member_dispositions.map((disposition) => {
+  const planPayload2 = Object.fromEntries(Object.entries(record4.partition_plan).filter(([key]) => key !== "canonical_hash"));
+  const group = record4.partition_plan.groups[0];
+  const catalogMembers = [...record4.catalog_block.member_ids].sort(compareIndexerCanonicalText);
+  const ownedMembers2 = record4.partition_plan.member_dispositions.map((disposition) => {
     if (disposition.inventory_disposition !== "owned" || disposition.group_key !== "catalog-root") {
       throw new TypeError("catalog fallback members must all belong to catalog-root");
     }
     return disposition.member_id;
   });
-  if (record2.partition_plan.status !== "complete" || record2.partition_plan.canonical_hash !== indexerPartitionPlanCanonicalHash(planPayload2) || record2.partition_plan.partition_axis !== INDEXER_CATALOG_FALLBACK_STRATEGY_ID || record2.partition_plan.groups.length !== 1 || group?.group_key !== "catalog-root" || group.subject_intent !== "primary" || group.question_target_bindings.some((binding) => binding.role !== "primary-carrier") || group.logical_unit_ref !== record2.catalog_block.logical_unit_ref || new Set(record2.catalog_block.member_ids).size !== record2.catalog_block.member_ids.length || canonicalIndexerJson(record2.catalog_block.member_ids) !== canonicalIndexerJson(catalogMembers) || canonicalIndexerJson(group.member_ids) !== canonicalIndexerJson(record2.catalog_block.member_ids) || canonicalIndexerJson(ownedMembers2.sort(compareIndexerCanonicalText)) !== canonicalIndexerJson(record2.catalog_block.member_ids) || record2.catalog_block.member_ids_digest !== indexerProtocolDigest({
-    member_ids: record2.catalog_block.member_ids
-  }) || record2.continuation_policy.split_of !== record2.catalog_block.logical_unit_ref || record2.continuation_policy.navigation_identity !== record2.catalog_block.logical_unit_ref || record2.continuation_policy.review_identity !== record2.catalog_block.logical_unit_ref) {
+  if (record4.partition_plan.status !== "complete" || record4.partition_plan.canonical_hash !== indexerPartitionPlanCanonicalHash(planPayload2) || record4.partition_plan.partition_axis !== INDEXER_CATALOG_FALLBACK_STRATEGY_ID || record4.partition_plan.groups.length !== 1 || group?.group_key !== "catalog-root" || group.subject_intent !== "primary" || group.question_target_bindings.some((binding) => binding.role !== "primary-carrier") || group.logical_unit_ref !== record4.catalog_block.logical_unit_ref || new Set(record4.catalog_block.member_ids).size !== record4.catalog_block.member_ids.length || canonicalIndexerJson(record4.catalog_block.member_ids) !== canonicalIndexerJson(catalogMembers) || canonicalIndexerJson(group.member_ids) !== canonicalIndexerJson(record4.catalog_block.member_ids) || canonicalIndexerJson(ownedMembers2.sort(compareIndexerCanonicalText)) !== canonicalIndexerJson(record4.catalog_block.member_ids) || record4.catalog_block.member_ids_digest !== indexerProtocolDigest({
+    member_ids: record4.catalog_block.member_ids
+  }) || record4.continuation_policy.split_of !== record4.catalog_block.logical_unit_ref || record4.continuation_policy.navigation_identity !== record4.catalog_block.logical_unit_ref || record4.continuation_policy.review_identity !== record4.catalog_block.logical_unit_ref) {
     throw new TypeError("catalog fallback single-parent projection is inconsistent");
   }
-  return record2;
+  return record4;
 }
 function buildIndexerCatalogFallback(input) {
   const convergence = validateIndexerPartitionConvergenceRecord(input.convergence);
@@ -28937,7 +29733,7 @@ var fanOutAuditPayloadSchema = exports_external.object({
 var indexerProjectedArtifactFanOutAuditSchema = fanOutAuditPayloadSchema.extend({
   audit_digest: indexerDigestSchema
 }).strict();
-function auditPayload2(audit) {
+function auditPayload(audit) {
   const { audit_digest: _digest, ...payload3 } = audit;
   return payload3;
 }
@@ -29139,7 +29935,7 @@ function auditIndexerProjectedArtifactFanOut(input) {
 }
 function validateIndexerProjectedArtifactFanOutAudit(value) {
   const audit = indexerProjectedArtifactFanOutAuditSchema.parse(value);
-  if (indexerProtocolDigest(auditPayload2(audit)) !== audit.audit_digest) {
+  if (indexerProtocolDigest(auditPayload(audit)) !== audit.audit_digest) {
     throw new TypeError("projected Artifact fan-out audit digest is invalid");
   }
   const expectedState = stateForCount(audit.summary.unassigned_projected_artifact_count);
@@ -29496,7 +30292,8 @@ var layoutProposalPayloadSchema = exports_external.object({
     node_ref: indexerCanonicalRefSchema,
     subject_key: indexerSubjectKeySchema
   }).strict(),
-  artifacts: exports_external.array(layoutArtifactSchema)
+  artifacts: exports_external.array(layoutArtifactSchema),
+  delivery_artifact_ids: exports_external.array(exports_external.string().min(1)).min(1).optional()
 }).strict();
 var indexerLayoutProposalSchema = layoutProposalPayloadSchema.extend({
   proposal_digest: indexerDigestSchema
@@ -29534,7 +30331,7 @@ function indexerLayoutSectionRef(currentArtifactRef, sectionIdentityRef) {
     section_identity_ref: sectionIdentityRef
   })}`;
 }
-function viewRef(currentArtifactRef, collection) {
+function indexerLayoutViewRef(currentArtifactRef, collection) {
   return `view:artifact:${indexerProtocolDigest({
     protocol: "context.indexer.internal-view-identity/v1",
     artifact_ref: currentArtifactRef,
@@ -29542,6 +30339,10 @@ function viewRef(currentArtifactRef, collection) {
   })}`;
 }
 function readerPathSlug(value) {
+  const identity2 = value.trim();
+  if (/^(?:artifact|evidence|node|section|view):/iu.test(identity2) || /(?:^|[:/_-])sha256(?::|$)/iu.test(identity2) || /^[a-f\d]{32,}$/iu.test(identity2) || /^\d{8,14}$/u.test(identity2) || /^[a-f\d]{8}(?:-[a-f\d]{4}){3}-[a-f\d]{12}$/iu.test(identity2)) {
+    throw new TypeError("layout resolver rejects machine identity in a reader-facing path");
+  }
   const slug = value.normalize("NFC").replace(/([\p{Ll}\p{N}])(\p{Lu})/gu, "$1-$2").replace(/(\p{Lu})(\p{Lu}\p{Ll})/gu, "$1-$2").toLowerCase().replace(/[^\p{Letter}\p{Number}]+/gu, "-").replace(/^-+|-+$/gu, "");
   if (slug.length === 0) {
     throw new TypeError("layout resolver requires a reader-readable semantic path identity");
@@ -29549,14 +30350,17 @@ function readerPathSlug(value) {
   return slug;
 }
 function outputPath(input) {
-  const moduleIdentity = input.module_ref?.replace(/^module:/u, "") ?? input.subject_key.namespace;
-  return `knowledge/${input.collection}/${readerPathSlug(moduleIdentity)}/${readerPathSlug(input.artifact_id)}.md`;
+  const namespace = readerPathSlug(input.subject_key.namespace);
+  const subject = readerPathSlug(input.subject_key.local_key);
+  const suffix = input.primary ? "" : input.duplicate_kind ? `-${readerPathSlug(input.artifact.artifact_kind)}-${readerPathSlug(input.artifact.artifact_id)}` : `-${readerPathSlug(input.artifact.artifact_kind)}`;
+  return `knowledge/${input.collection}/${namespace}/${subject}${suffix}.md`;
 }
-function structuredSections(artifact, facts) {
+function structuredSections(artifact, facts, render_cache) {
   return artifact.sections.map((section) => {
     const contentBlocks = materializeIndexerStructuredContent({
       blocks: section.blocks,
-      facts
+      facts,
+      render_cache
     });
     const evidenceRefs = [...new Set(contentBlocks.flatMap((block) => block.evidence_refs))].sort(compareIndexerCanonicalText);
     return {
@@ -29657,12 +30461,17 @@ function resolveIndexerLayout(input) {
   if (bundleById.size !== (artifactBundle?.artifacts.length ?? 0) || bundleById.size !== effective.artifacts.length) {
     throw new TypeError("layout resolver requires one Artifact Bundle entry per Artifact");
   }
+  const requiredArtifactIds = new Set((artifactBundle?.artifacts ?? []).filter((artifact) => artifact.purpose === "required").map((artifact) => artifact.artifact_id));
+  const artifactKindCounts = new Map;
+  for (const artifact of effective.artifacts) {
+    artifactKindCounts.set(artifact.artifact_kind, (artifactKindCounts.get(artifact.artifact_kind) ?? 0) + 1);
+  }
   const artifacts = effective.artifacts.map((artifact) => {
     const bundleEntry = bundleById.get(artifact.artifact_id);
     if (bundleEntry === undefined || bundleEntry.artifact_kind !== artifact.artifact_kind) {
       throw new TypeError(`Artifact ${artifact.artifact_id} is absent from its closed Bundle`);
     }
-    const sections = artifact.representation === "sections" ? structuredSections(artifact, result.facts) : (() => {
+    const sections = artifact.representation === "sections" ? structuredSections(artifact, result.facts, input.render_cache) : (() => {
       const rendered = renderedById.get(artifact.artifact_id);
       if (rendered === undefined) {
         throw new TypeError(`template Artifact ${artifact.artifact_id} must be rendered before layout`);
@@ -29698,13 +30507,14 @@ function resolveIndexerLayout(input) {
       node_ref: nodeRef,
       artifact_id: artifact.artifact_id,
       artifact_kind: artifact.artifact_kind,
-      internal_view_ref: viewRef(currentArtifactRef, collection),
+      internal_view_ref: indexerLayoutViewRef(currentArtifactRef, collection),
       collection,
       output_path: outputPath({
         collection,
-        module_ref: result.module_ref,
         subject_key: result.logical_unit.subject_key,
-        artifact_id: artifact.artifact_id
+        artifact,
+        primary: effective.artifacts.length === 1 || requiredArtifactIds.size === 1 && requiredArtifactIds.has(artifact.artifact_id),
+        duplicate_kind: (artifactKindCounts.get(artifact.artifact_kind) ?? 0) > 1
       }),
       shared_artifact_fingerprint_digest: sharedFingerprint.fingerprint_digest,
       purpose: bundleEntry.purpose,
@@ -29740,6 +30550,13 @@ function resolveIndexerLayout(input) {
   if (new Set(sectionIdentities).size !== sectionIdentities.length) {
     throw new TypeError("layout resolver produced colliding logical Section identities");
   }
+  if (input.delivery_artifact_ids !== undefined) {
+    const selected = new Set(input.delivery_artifact_ids);
+    const available = new Set(artifacts.map((artifact) => artifact.artifact_id));
+    if (selected.size !== input.delivery_artifact_ids.length || selected.size === 0 || [...selected].some((id) => !available.has(id))) {
+      throw new TypeError("delivery layout requires unique, available Artifact identities");
+    }
+  }
   const payload3 = layoutProposalPayloadSchema.parse({
     protocol: "context.indexer.layout-proposal/v1",
     indexer_id: result.indexer_id,
@@ -29755,7 +30572,10 @@ function resolveIndexerLayout(input) {
       node_ref: nodeRef,
       subject_key: result.logical_unit.subject_key
     },
-    artifacts
+    artifacts: input.delivery_artifact_ids === undefined ? artifacts : artifacts.filter((artifact) => input.delivery_artifact_ids.includes(artifact.artifact_id)),
+    ...input.delivery_artifact_ids === undefined ? {} : {
+      delivery_artifact_ids: [...input.delivery_artifact_ids].sort(compareIndexerCanonicalText)
+    }
   });
   return indexerLayoutProposalSchema.parse({
     ...payload3,
@@ -29766,12 +30586,14 @@ function validateIndexerLayoutProposal(input) {
   const proposal = indexerLayoutProposalSchema.parse(input.proposal);
   const expected = resolveIndexerLayout({
     artifact_result: input.artifact_result,
+    render_cache: input.render_cache,
     post_author_envelope: input.post_author_envelope,
     profile: proposal.profile,
     profile_contract: input.profile_contract,
     operator_contract: input.operator_contract,
     subject_key_schema_set: input.subject_key_schema_set,
     shared_artifact_fingerprint: proposal.shared_artifact_fingerprint,
+    delivery_artifact_ids: proposal.delivery_artifact_ids,
     ...input.rendered_artifacts === undefined ? {} : { rendered_artifacts: input.rendered_artifacts }
   });
   if (canonicalIndexerJson(expected) !== canonicalIndexerJson(proposal)) {
@@ -29808,7 +30630,7 @@ function validateProposalDigest(value) {
   for (const artifact of proposal.artifacts) {
     if (artifact.purpose === "semantic-split") {
       const parent = artifact.split_of_artifact_ref === null ? undefined : artifacts.get(artifact.split_of_artifact_ref);
-      if (artifact.split_of_artifact_ref === null || artifact.split_boundary === null || artifact.split_of_artifact_ref === artifact.artifact_ref || parent === undefined || parent.purpose === "semantic-split" || parent.artifact_kind !== artifact.artifact_kind || compareIndexerCanonicalText(artifact.split_boundary.start_key, artifact.split_boundary.end_key) > 0) {
+      if (artifact.split_of_artifact_ref === null || artifact.split_boundary === null || artifact.split_of_artifact_ref === artifact.artifact_ref || parent === undefined && proposal.delivery_artifact_ids === undefined || parent !== undefined && (parent.purpose === "semantic-split" || parent.artifact_kind !== artifact.artifact_kind) || compareIndexerCanonicalText(artifact.split_boundary.start_key, artifact.split_boundary.end_key) > 0) {
         throw new TypeError("semantic-split layout Artifact has invalid parent lineage");
       }
     } else if (artifact.split_of_artifact_ref !== null || artifact.split_boundary !== null) {
@@ -30580,21 +31402,7 @@ function normalizedReaderBody(markdown) {
       lines.splice(0, end + 2);
   }
   return lines.join(`
-`).replace(/<!--[\s\S]*?-->/gu, "").trim();
-}
-function isReaderContentLine(line) {
-  const value = line.trim();
-  if (value.length === 0)
-    return false;
-  if (/^#{1,6}(?:\s+.*)?$/u.test(value))
-    return false;
-  if (/^(?:`{3,}|~{3,})(?:[^`]*)?$/u.test(value))
-    return false;
-  if (/^(?:[-=_*]\s*){3,}$/u.test(value))
-    return false;
-  if (/^(?:[-+*]|>)\s*$/u.test(value))
-    return false;
-  return true;
+`).trim();
 }
 function fileMetrics(markdown) {
   const readerBody = normalizedReaderBody(markdown);
@@ -30607,7 +31415,7 @@ function fileMetrics(markdown) {
     }),
     byteCount: Buffer2.byteLength(markdown, "utf8"),
     readerBodyLineCount: lines.length,
-    empty: !lines.some(isReaderContentLine)
+    empty: readerBody.length === 0
   };
 }
 function physicalRef(outputPath2, markdownDigest) {
@@ -30748,7 +31556,7 @@ function logicalUnitRegistrations(input) {
       throw new TypeError(`layout Node ${proposal.node.node_ref} lacks an Artifact Bundle`);
     }
     const entries = bundleEntryById(bundle);
-    if (entries.size !== proposal.artifacts.length || entries.size !== bundle.artifacts.length) {
+    if (proposal.delivery_artifact_ids === undefined && entries.size !== proposal.artifacts.length || entries.size !== bundle.artifacts.length) {
       throw new TypeError(`Artifact Bundle ${bundle.bundle_digest} does not close its layout Artifact set`);
     }
     return proposal.artifacts.map((artifact) => {
@@ -31109,7 +31917,8 @@ function structuredArtifactSections(input) {
   return input.artifact.sections.map((section) => {
     const blocks = materializeIndexerStructuredContent({
       blocks: section.blocks,
-      facts: input.result.facts
+      facts: input.result.facts,
+      render_cache: input.render_cache
     });
     const evidenceRefs = [...new Set(blocks.flatMap((block) => block.evidence_refs))].sort(compareIndexerCanonicalText);
     assertSectionIntegrity({
@@ -31177,7 +31986,7 @@ function candidateFiles(input) {
     artifact.artifact_id,
     artifact
   ]));
-  return input.accepted.effectiveArtifacts.map((artifact) => {
+  return input.accepted.effectiveArtifacts.filter((artifact) => input.proposal.delivery_artifact_ids === undefined || input.proposal.delivery_artifact_ids.includes(artifact.artifact_id)).map((artifact) => {
     const layout = layoutById.get(artifact.artifact_id);
     if (layout === undefined) {
       throw new TypeError(`Candidate compile Result Artifact ${artifact.artifact_id} has no layout`);
@@ -31185,7 +31994,8 @@ function candidateFiles(input) {
     const sections = artifact.representation === "sections" ? structuredArtifactSections({
       result: input.accepted.artifactResult,
       proposal: input.proposal,
-      artifact
+      artifact,
+      render_cache: input.render_cache
     }) : (() => {
       const rendered = renderedById.get(artifact.artifact_id);
       if (rendered === undefined) {
@@ -31197,6 +32007,19 @@ function candidateFiles(input) {
         rendered
       });
     })();
+    for (const section of sections) {
+      if (input.markdown_projection === undefined)
+        continue;
+      section.markdown = input.markdown_projection({
+        markdown: section.markdown,
+        output_path: layout.output_path,
+        artifact_ref: layout.artifact_ref
+      });
+      section.markdown_digest = indexerProtocolDigest({
+        protocol: "context.indexer.physical-section-markdown/v1",
+        markdown: section.markdown
+      });
+    }
     const markdown = sections.map((section) => section.markdown).join(`
 
 `);
@@ -31312,14 +32135,15 @@ function buildIndexerCandidateCompile(input) {
       profile_contract: input.profile_contract,
       operator_contract: input.operator_contract,
       subject_key_schema_set: input.subject_key_schema_set,
-      rendered_artifacts: item.renderedArtifacts
+      rendered_artifacts: item.renderedArtifacts,
+      render_cache: input.render_cache
     });
     const binding = resultBinding({ accepted: item, proposal });
     return {
       accepted: item,
       proposal,
       binding,
-      files: candidateFiles({ accepted: item, proposal, binding })
+      files: candidateFiles({ accepted: item, proposal, binding, markdown_projection: input.markdown_projection, render_cache: input.render_cache })
     };
   }).sort((left, right) => compareIndexerCanonicalText(left.binding.artifact_result_digest, right.binding.artifact_result_digest));
   const files = entries.flatMap((entry) => entry.files).sort((left, right) => compareIndexerCanonicalText(left.output_path, right.output_path));
@@ -31433,7 +32257,12 @@ function validateIndexerProviderContractReferences(input) {
     ...variant.artifact_kinds.required,
     ...variant.artifact_kinds.discretionary
   ]));
-  const sourceRoles = new Set(targetProfiles.flatMap((profile) => profile.layout_mappings.flatMap((mapping) => mapping.source_roles)));
+  const declaredProfileIds = selectedBaseProfileIds({
+    manifest: input.manifest,
+    selectedProfiles: input.manifest.provides.profiles,
+    registeredProfiles: new Set(profilesById.keys())
+  });
+  const sourceRoles = new Set([...declaredProfileIds].flatMap((id) => profilesById.get(id).layout_mappings.flatMap((mapping) => mapping.source_roles)));
   for (const sourceRole of input.manifest.provides.source_roles ?? []) {
     if (!sourceRoles.has(sourceRole)) {
       throw new TypeError(`Provider references unregistered layout source role ${sourceRole}`);
@@ -31753,8 +32582,8 @@ function recoverIndexerMainRunLedger(input) {
   ]));
   const previousByItem = new Map(previous?.entries.map((entry) => [entry.item_ref, entry]));
   const acceptedByIdentity = new Map((input.accepted_records ?? []).map((candidate) => {
-    const record2 = validateIndexerMainAcceptedRecord(candidate);
-    return [indexerMainRunIdentityDigest(record2), record2];
+    const record4 = validateIndexerMainAcceptedRecord(candidate);
+    return [indexerMainRunIdentityDigest(record4), record4];
   }));
   if (acceptedByIdentity.size !== (input.accepted_records ?? []).length) {
     throw new TypeError("accepted main run cache contains duplicate identities");
@@ -31799,31 +32628,52 @@ function replaceEntry(input) {
   return buildLedger({ workset_set: input.ledger.workset_set, entries });
 }
 function startIndexerMainRun(input) {
+  return startIndexerMainRuns({
+    ledger: input.ledger,
+    workset_digests: [input.workset_digest]
+  });
+}
+function startIndexerMainRuns(input) {
   const ledger = validateIndexerMainRunLedger(input.ledger);
-  return replaceEntry({
-    ledger,
-    workset_digest: input.workset_digest,
-    replace: (entry) => {
-      if (entry.state !== "pending" && entry.state !== "stale") {
-        throw new TypeError("only pending or stale main work may start");
-      }
+  if (input.workset_digests.length === 0) {
+    throw new TypeError("main run batch must contain at least one workset");
+  }
+  const requested = new Set(input.workset_digests);
+  if (requested.size !== input.workset_digests.length) {
+    throw new TypeError("main run batch contains duplicate worksets");
+  }
+  const selected = ledger.entries.filter((entry) => requested.has(entry.workset_digest));
+  if (selected.length !== requested.size) {
+    throw new TypeError("main run ledger has no requested workset");
+  }
+  if (new Set(selected.map((entry) => entry.stage)).size !== 1) {
+    throw new TypeError("main run batch must contain one stage");
+  }
+  if (selected.some((entry) => entry.state !== "pending" && entry.state !== "stale")) {
+    throw new TypeError("only pending or stale main work may start");
+  }
+  return buildLedger({
+    workset_set: ledger.workset_set,
+    entries: ledger.entries.map((entry) => {
+      if (!requested.has(entry.workset_digest))
+        return entry;
       const clean = Object.fromEntries(Object.entries(entry).filter(([key]) => key !== "state" && key !== "previous_workset_digest" && key !== "previous_execution_request_digest"));
       return { ...clean, state: "running" };
-    }
+    })
   });
 }
 function acceptIndexerMainRun(input) {
   const ledger = validateIndexerMainRunLedger(input.ledger);
-  const record2 = validateIndexerMainAcceptedRecord(input.accepted_record);
+  const record4 = validateIndexerMainAcceptedRecord(input.accepted_record);
   return replaceEntry({
     ledger,
-    workset_digest: record2.workset_digest,
+    workset_digest: record4.workset_digest,
     replace: (entry) => {
       if (entry.state !== "running") {
         throw new TypeError("main result requires a running ledger entry");
       }
-      assertAcceptedRecord({ record: record2, base: entry });
-      return { ...entry, state: "accepted", accepted_record: record2 };
+      assertAcceptedRecord({ record: record4, base: entry });
+      return { ...entry, state: "accepted", accepted_record: record4 };
     }
   });
 }
@@ -31922,6 +32772,21 @@ function observeIndexerMainRunLedger(value) {
     records
   });
 }
+function invalidateIndexerMainRunWorksets(value, worksets) {
+  const ledger = validateIndexerMainRunLedger(value);
+  if ([...worksets].some((digest) => !ledger.entries.some((entry) => entry.workset_digest === digest))) {
+    throw new TypeError("adjusted workset is not in the current ledger");
+  }
+  return buildLedger({
+    workset_set: ledger.workset_set,
+    entries: ledger.entries.map((entry, index) => !worksets.has(entry.workset_digest) ? entry : {
+      ...entryBase({ item: ledger.workset_set.items[index], execution_request_digest: entry.execution_request_digest }),
+      state: "stale",
+      previous_workset_digest: entry.workset_digest,
+      previous_execution_request_digest: entry.execution_request_digest
+    })
+  });
+}
 // src/indexerPostAuthorRunLedger.ts
 var composerRefSchema = exports_external.string().regex(/^provider:[^#]+#layer:[^#]+#composer:[A-Za-z0-9._-]+$/u);
 var ledgerEntryBase = {
@@ -32322,9 +33187,10 @@ function sameEnvelope(candidate, expected) {
   return parsed.success && indexerProtocolDigest(parsed.data) === indexerProtocolDigest(expected);
 }
 function observeIndexerPostAuthorState(input) {
-  const ledger = recoverIndexerPostAuthorRunLedger({
+  const previous = validateIndexerPostAuthorRunLedger(input.ledger);
+  const ledger = previous.workset_set_digest === input.plan.workset_set.workset_set_digest ? previous : recoverIndexerPostAuthorRunLedger({
     plan: input.plan,
-    previous_ledger: input.ledger,
+    previous_ledger: previous,
     validator_contract_digest: input.validator_contract_digest
   });
   const effectiveSet = validateIndexerEffectiveComposerSet(input.effective_composer_set);
@@ -32381,7 +33247,7 @@ function observeIndexerPostAuthorState(input) {
     };
   }
   const counts = {
-    pending: ledger.entries.filter((entry) => entry.state === "pending").length,
+    pending: ledger.entries.filter((entry) => entry.state === "pending" || entry.state === "running").length,
     accepted: ledger.entries.filter((entry) => entry.state === "accepted").length,
     failed: ledger.entries.filter((entry) => entry.state === "failed").length,
     stale: ledger.entries.filter((entry) => entry.state === "stale").length
@@ -32611,13 +33477,126 @@ var customPhase = (id, run, io = {}) => ({
   writes: io.writes ?? [],
   run
 });
+// src/managedSources.ts
+import { readdir, lstat, realpath as realpath3, readFile as readFile3 } from "node:fs/promises";
+import { join, relative as relative3, isAbsolute as isAbsolute4 } from "node:path";
+
+// src/sessionMetadata.ts
+var sessionChangeSchema = exports_external.object({
+  repository: exports_external.string().trim().min(1).optional(),
+  commit: exports_external.string().regex(/^(?:[a-fA-F0-9]{40}|[a-fA-F0-9]{64})$/u).optional(),
+  mr: exports_external.string().url().refine((value) => /^https?:\/\//u.test(value), "MR/PR must be an HTTP(S) URL").optional()
+}).strict().refine((value) => value.commit !== undefined || value.mr !== undefined, "A session change needs a commit or MR/PR reference");
+var sessionChangesSchema = exports_external.array(sessionChangeSchema);
+function sourceHeader(markdown) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/u.exec(markdown);
+  if (!match)
+    return;
+  const document = $parseDocument(match[1], { uniqueKeys: true });
+  if (document.errors.length)
+    throw new TypeError(`Invalid sessions frontmatter: ${document.errors[0].message}`);
+  const value = document.toJS();
+  if (value !== null && (typeof value !== "object" || Array.isArray(value))) {
+    throw new TypeError("Sessions frontmatter must be a mapping");
+  }
+  return { value: value ?? {}, body: markdown.slice(match[0].length) };
+}
+function readSessionChanges(markdown) {
+  const value = sourceHeader(markdown)?.value.changes;
+  return value === undefined ? undefined : sessionChangesSchema.parse(value);
+}
+function writeSessionChanges(markdown, changes) {
+  if (changes === undefined) {
+    readSessionChanges(markdown);
+    return markdown;
+  }
+  const parsed = sessionChangesSchema.parse(changes);
+  const header = sourceHeader(markdown);
+  const metadata = { ...header?.value ?? {} };
+  if (parsed.length)
+    metadata.changes = parsed;
+  else
+    delete metadata.changes;
+  const body = header?.body ?? markdown;
+  if (!Object.keys(metadata).length)
+    return body;
+  return `---
+${$stringify(metadata)}---
+${body}`;
+}
+
+// src/managedSources.ts
+function assertManagedDocumentName(name) {
+  if (!/^\d{8}\/[^/\\\x00-\x1f\s:#?]+\.md$/u.test(name) || name.includes("/..")) {
+    throw new TypeError("Managed document name must be YYYYMMDD/semantic-name.md inside sources/note or sources/sessions");
+  }
+  const date = name.slice(0, 8);
+  const parsed = new Date(`${date.slice(0, 4)}-${date.slice(4, 6)}-${date.slice(6, 8)}T00:00:00Z`);
+  if (!Number.isFinite(parsed.getTime()) || parsed.toISOString().slice(0, 10).replaceAll("-", "") !== date) {
+    throw new TypeError("Managed document date must be a valid YYYYMMDD date");
+  }
+}
+async function assertManagedDocumentPath(rootDir, type, name) {
+  assertManagedDocumentName(name);
+  const root = await realpath3(rootDir);
+  const parts = ["sources", type, ...name.split("/")];
+  let path = root;
+  for (const part of parts) {
+    path = join(path, part);
+    try {
+      if ((await lstat(path)).isSymbolicLink())
+        throw new TypeError("Managed document paths must not traverse symlinks");
+    } catch (error) {
+      if (!(error && typeof error === "object" && ("code" in error) && error.code === "ENOENT"))
+        throw error;
+    }
+  }
+  const rel = relative3(root, path);
+  if (isAbsolute4(rel) || rel.startsWith("../"))
+    throw new TypeError("Managed document path leaves its workspace");
+  return path;
+}
+async function discoverManagedDocuments(rootDir, type) {
+  const base = join(rootDir, "sources", type);
+  await assertManagedDocumentPath(rootDir, type, "20000101/discovery.md");
+  let dates;
+  try {
+    dates = await readdir(base, { withFileTypes: true });
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT")
+      return [];
+    throw error;
+  }
+  const entries = [];
+  for (const date of dates.sort((a, b) => a.name.localeCompare(b.name))) {
+    if (!date.isDirectory() || !/^\d{8}$/u.test(date.name))
+      continue;
+    for (const file of (await readdir(join(base, date.name), { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
+      if (!file.isFile() || !file.name.endsWith(".md"))
+        continue;
+      const name = `${date.name}/${file.name}`;
+      await assertManagedDocumentPath(rootDir, type, name);
+      const changes = type === "sessions" ? readSessionChanges(await readFile3(join(base, name), "utf8")) : undefined;
+      entries.push({
+        ...changes === undefined ? {} : { changes },
+        id: name,
+        name,
+        namespace: date.name,
+        module: file.name,
+        materializedAt: `sources/${type}/${name}`
+      });
+    }
+  }
+  return entries;
+}
+
 // src/sources.ts
-import { readFile as readFile3 } from "node:fs/promises";
+import { readFile as readFile4 } from "node:fs/promises";
 import { resolve as resolve3 } from "node:path";
 var DEFAULT_REPO_SOURCES_REGISTRY_PATH = "sources/repo/index.yaml";
 var DEFAULT_FILE_SOURCES_REGISTRY_PATH = "sources/file/index.yaml";
 var DEFAULT_LARK_SOURCES_REGISTRY_PATH = "sources/lark/index.yaml";
-var SOURCE_TYPES = ["repo", "file", "lark"];
+var SOURCE_TYPES = ["repo", "file", "lark", "note", "sessions"];
 var SOURCE_NAME_PATTERN = /^[a-z0-9][a-z0-9._-]*$/u;
 var REPO_DATE_NAMESPACE_PATTERN = /^\d{8}$/u;
 function assertSourceType(value, field) {
@@ -32920,7 +33899,7 @@ var parseLarkSourcesRegistry = (input, registryPath) => {
 };
 var readYamlIfPresent = async (absolutePath, emptyValue) => {
   try {
-    const content = await readFile3(absolutePath, "utf8");
+    const content = await readFile4(absolutePath, "utf8");
     return content.trim().length === 0 ? emptyValue : $parse(content);
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -32972,7 +33951,9 @@ var loadSourcesRegistry = async (options = {}) => {
     },
     repos: repoRegistry.repos,
     files,
-    larks
+    larks,
+    notes: await discoverManagedDocuments(rootDir, "note"),
+    sessions: await discoverManagedDocuments(rootDir, "sessions")
   };
   assertGlobalSourceUniqueness(registry);
   return registry;
@@ -33016,6 +33997,221 @@ var allSources = (type) => {
     type
   }];
 };
+// src/processedScopes.ts
+var reference = exports_external.string().min(1).refine((value) => value.trim() === value, {
+  message: "scope references must not have surrounding whitespace"
+});
+var processedScopeSchema = exports_external.object({
+  requirement_ref: reference,
+  source_ref: reference,
+  processed_version: reference,
+  module_refs: exports_external.array(reference).min(1).optional()
+}).strict().superRefine((scope, context) => {
+  if (scope.module_refs && new Set(scope.module_refs).size !== scope.module_refs.length) {
+    context.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      path: ["module_refs"],
+      message: "module_refs must not contain duplicates"
+    });
+  }
+});
+function processedScopeKey(scope) {
+  return JSON.stringify([
+    scope.requirement_ref,
+    scope.source_ref,
+    [...scope.module_refs ?? []].sort()
+  ]);
+}
+var processedScopesSchema = exports_external.array(processedScopeSchema).superRefine((scopes, context) => {
+  const seen = new Set;
+  scopes.forEach((scope, index) => {
+    const key = processedScopeKey(scope);
+    if (seen.has(key)) {
+      context.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: [index],
+        message: "processed_scopes must contain only one latest version per exact scope"
+      });
+    }
+    seen.add(key);
+  });
+});
+function readProcessedScopes(structure) {
+  return processedScopesSchema.parse(structure?.processed_scopes === undefined ? [] : structure.processed_scopes);
+}
+function containsScope(outer, inner) {
+  return outer.requirement_ref === inner.requirement_ref && outer.source_ref === inner.source_ref && (outer.module_refs === undefined || inner.module_refs !== undefined && inner.module_refs.every((module) => outer.module_refs.includes(module)));
+}
+function mergeProcessedScopes(previous, completed) {
+  const updates = processedScopesSchema.parse(completed);
+  const retained = processedScopesSchema.parse(previous).filter((scope) => !updates.some((update) => containsScope(update, scope)));
+  return [...retained, ...updates].sort((a, b) => processedScopeKey(a).localeCompare(processedScopeKey(b)));
+}
+function processedVersionForScope(scopes, scope) {
+  const parsed = processedScopesSchema.parse(scopes);
+  const exact = parsed.find((entry) => processedScopeKey(entry) === processedScopeKey(scope));
+  if (exact)
+    return exact.processed_version;
+  const versions = new Set(parsed.filter((entry) => containsScope(entry, scope)).map((entry) => entry.processed_version));
+  return versions.size === 1 ? [...versions][0] : undefined;
+}
+// src/indexerApprovedKnowledge.ts
+var indexerApprovedKnowledgeSchema = exports_external.object({
+  protocol: exports_external.literal("context.indexer.approved-knowledge/v1"),
+  artifact_ref: indexerCanonicalRefSchema,
+  subject_key: indexerSubjectKeySchema,
+  primary_indexer_id: exports_external.string().min(1).optional(),
+  path: portableIndexerPathSchema,
+  approved_content_digest: indexerDigestSchema,
+  source_versions: exports_external.array(exports_external.object({
+    source_ref: indexerCanonicalRefSchema,
+    module_ref: indexerCanonicalRefSchema.nullable(),
+    version: exports_external.string().min(1)
+  }).strict()).min(1),
+  sections: exports_external.array(exports_external.object({
+    section_ref: indexerCanonicalRefSchema,
+    section_key: exports_external.string().min(1).optional(),
+    markdown: exports_external.string().min(1),
+    fact_refs: exports_external.array(indexerCanonicalRefSchema),
+    evidence_refs: exports_external.array(indexerCanonicalRefSchema).min(1)
+  }).strict()).min(1),
+  facts: exports_external.array(indexerArtifactFactSchema),
+  evidence_bindings: exports_external.array(indexerEvidenceBindingSchema),
+  dependencies: exports_external.array(indexerKnowledgeDependencySchema),
+  dependency_versions: exports_external.array(indexerKnowledgeDependencyVersionSchema).optional(),
+  snapshot_digest: indexerDigestSchema
+}).strict();
+var sourceKey = (source2) => JSON.stringify([source2.source_ref, source2.module_ref]);
+function validateIndexerApprovedKnowledge(value) {
+  const snapshot2 = indexerApprovedKnowledgeSchema.parse(value);
+  const { snapshot_digest, ...payload3 } = snapshot2;
+  if (indexerProtocolDigest(payload3) !== snapshot_digest)
+    throw new TypeError("Approved knowledge snapshot integrity changed");
+  const facts = new Map(snapshot2.facts.map((fact) => [fact.fact_ref, fact]));
+  const evidence = new Map(snapshot2.evidence_bindings.map((binding) => [binding.evidence_ref, binding]));
+  const sources = new Set(snapshot2.source_versions.map(sourceKey));
+  const versions = snapshot2.dependency_versions ?? [];
+  if (new Set(versions.map((version) => version.artifact_ref)).size !== versions.length || versions.some((version) => !snapshot2.dependencies.some((dependency) => dependency.artifact_ref === version.artifact_ref))) {
+    throw new TypeError("Approved knowledge has duplicate or undeclared dependency versions");
+  }
+  if (facts.size !== snapshot2.facts.length || evidence.size !== snapshot2.evidence_bindings.length || sources.size !== snapshot2.source_versions.length || new Set(snapshot2.sections.map((section) => section.section_ref)).size !== snapshot2.sections.length) {
+    throw new TypeError("Approved knowledge snapshot repeats an identity");
+  }
+  for (const binding of evidence.values()) {
+    if (!sources.has(sourceKey(binding)))
+      throw new TypeError("Approved knowledge evidence has no source version");
+    const { binding_digest, ...content } = binding;
+    if (indexerProtocolDigest(content) !== binding_digest)
+      throw new TypeError("Approved knowledge evidence binding changed");
+  }
+  for (const fact of facts.values()) {
+    if (fact.evidence_refs.some((ref) => !evidence.has(ref)))
+      throw new TypeError("Approved knowledge fact has unknown source evidence");
+  }
+  for (const section of snapshot2.sections) {
+    if (section.evidence_refs.some((ref) => !evidence.has(ref)))
+      throw new TypeError("Approved knowledge section has unknown source evidence");
+    for (const ref of section.fact_refs) {
+      const fact = facts.get(ref);
+      if (!fact || fact.evidence_refs.some((evidenceRef) => !section.evidence_refs.includes(evidenceRef))) {
+        throw new TypeError("Approved knowledge section fact is outside its evidence binding");
+      }
+    }
+  }
+  return snapshot2;
+}
+function buildIndexerApprovedKnowledge(payload3) {
+  return validateIndexerApprovedKnowledge({ ...payload3, snapshot_digest: indexerProtocolDigest(payload3) });
+}
+function projectIndexerApprovedKnowledge(input) {
+  const available = new Map(input.snapshots.map((snapshot2) => [snapshot2.artifact_ref, snapshot2]));
+  if (available.size !== input.snapshots.length)
+    throw new TypeError("Approved knowledge projection repeats an article");
+  const scope = new Map(input.authorized_sources.map((source2) => [sourceKey(source2), source2.version]));
+  if (scope.size !== input.authorized_sources.length || new Set(input.dependencies.map((dependency) => dependency.artifact_ref)).size !== input.dependencies.length) {
+    throw new TypeError("Approved knowledge projection repeats a source or dependency identity");
+  }
+  const pending = [];
+  const versions = [];
+  const facts = [];
+  const readingSections = [];
+  const evidence = new Map;
+  for (const value of input.dependencies) {
+    const dependency = indexerKnowledgeDependencySchema.parse(value);
+    const defer = (reason) => pending.push({ artifact_ref: dependency.artifact_ref, required: dependency.required, reason });
+    const raw = available.get(dependency.artifact_ref);
+    if (!raw) {
+      defer("not-approved");
+      continue;
+    }
+    const snapshot2 = validateIndexerApprovedKnowledge(raw);
+    if (input.approved_versions.get(snapshot2.artifact_ref) !== snapshot2.approved_content_digest) {
+      defer("approval-changed");
+      continue;
+    }
+    const sections = dependency.section_refs.length ? snapshot2.sections.filter((section) => dependency.section_refs.includes(section.section_ref)) : snapshot2.sections;
+    if (sections.length !== (dependency.section_refs.length || snapshot2.sections.length)) {
+      defer("section-unavailable");
+      continue;
+    }
+    const factRefs = new Set(sections.flatMap((section) => section.fact_refs));
+    const evidenceRefs = new Set(sections.flatMap((section) => section.evidence_refs));
+    const bindings = snapshot2.evidence_bindings.filter((binding) => evidenceRefs.has(binding.evidence_ref));
+    const selectedSourceKeys = new Set(bindings.map(sourceKey));
+    const sourceVersions = snapshot2.source_versions.filter((source2) => selectedSourceKeys.has(sourceKey(source2)));
+    if (sourceVersions.some((source2) => !scope.has(sourceKey(source2)))) {
+      throw new TypeError(`Approved knowledge is outside the current read scope: ${snapshot2.artifact_ref}`);
+    }
+    if (sourceVersions.some((source2) => scope.get(sourceKey(source2)) !== source2.version)) {
+      defer("source-version-changed");
+      continue;
+    }
+    if (bindings.some((binding) => !input.evidence_kinds.has(binding.kind)))
+      throw new TypeError("Provider cannot consume the approved knowledge evidence kind");
+    for (const binding of bindings) {
+      const previous = evidence.get(binding.evidence_ref);
+      if (previous && previous.binding_digest !== binding.binding_digest)
+        throw new TypeError("Approved knowledge sources have conflicting evidence identities");
+      evidence.set(binding.evidence_ref, binding);
+    }
+    const projectionDigest = indexerProtocolDigest({ snapshot: snapshot2.snapshot_digest, sections: sections.map((section) => section.section_ref).sort() });
+    versions.push({ artifact_ref: snapshot2.artifact_ref, approved_content_digest: snapshot2.approved_content_digest, projection_digest: projectionDigest });
+    for (const section of sections)
+      readingSections.push({
+        artifact_ref: snapshot2.artifact_ref,
+        section_ref: section.section_ref,
+        approved_content_digest: snapshot2.approved_content_digest,
+        evidence_role: "approved-interpretation",
+        markdown: section.markdown,
+        evidence_refs: section.evidence_refs
+      });
+    for (const fact of snapshot2.facts.filter((fact2) => factRefs.has(fact2.fact_ref))) {
+      const value2 = {
+        approved_artifact_ref: snapshot2.artifact_ref,
+        approved_content_digest: snapshot2.approved_content_digest,
+        original_fact_ref: fact.fact_ref,
+        original_subject: fact.subject_key,
+        source_versions: sourceVersions,
+        value: fact.value
+      };
+      facts.push({
+        fact_ref: `fact:approved-${indexerProtocolDigest(value2).slice(7)}`,
+        fact_kind: "approved-knowledge-fact",
+        subject_key: input.subject_key,
+        value: value2,
+        evidence_refs: fact.evidence_refs
+      });
+    }
+  }
+  return {
+    status: pending.some((item) => item.required) ? "waiting" : "ready",
+    pending,
+    versions,
+    facts,
+    reading_sections: readingSections,
+    evidence_bindings: [...evidence.values()]
+  };
+}
 
 // src/index.ts
 function assertUniquePhaseIds(phases) {
@@ -33235,9 +34431,11 @@ var llmsPackage = (definition) => ({
   ...createPackageDefinitionBase("llms", definition)
 });
 export {
+  writeSessionChanges,
   validatedIndexerCustomizationDraftSchema,
   validateValidatedIndexerCustomizationDraft,
   validateResolvedProviderBundle,
+  validateReadingStructure,
   validateIndexerToolSnapshot,
   validateIndexerTargetResolutionView,
   validateIndexerSubjectKeyForSchema,
@@ -33288,6 +34486,7 @@ export {
   validateIndexerPostAuthorRunLedger,
   validateIndexerPostAuthorFragmentResult,
   validateIndexerPostAuthorFragmentRequest,
+  validateIndexerPlannedArticles,
   validateIndexerPhysicalArtifactAudit,
   validateIndexerPartitionStrategyResolution,
   validateIndexerPartitionStrategyAttempt,
@@ -33320,11 +34519,11 @@ export {
   validateIndexerLayoutProposal,
   validateIndexerLayoutChangeReport,
   validateIndexerLayerCompositionInput,
+  validateIndexerKnowledgeDependencyGraph,
   validateIndexerInventoryDispositionSet,
   validateIndexerInspectorResult,
   validateIndexerInspectorRequest,
   validateIndexerIncrementalImpactReport,
-  validateIndexerGeneratedAuthoringAudit,
   validateIndexerFixedDependencySet,
   validateIndexerExampleLinkageAudit,
   validateIndexerExampleInventory,
@@ -33363,7 +34562,9 @@ export {
   validateIndexerArtifactDependencySet,
   validateIndexerArtifactBundlePolicy,
   validateIndexerArtifactBundle,
+  validateIndexerArticlePlan,
   validateIndexerApprovedLayoutProjection,
+  validateIndexerApprovedKnowledge,
   validateIndexerAgentStepInput,
   validateIndexerActivationResult,
   validateIndexerActivationRequest,
@@ -33374,9 +34575,14 @@ export {
   validateArtifactResults,
   validateAndRecordIndexerMainRun,
   validateAndMaterializeIndexerLayerFragment,
+  updateReadingStructure,
   startIndexerPostAuthorRun,
+  startIndexerMainRuns,
   startIndexerMainRun,
+  sourceUpdateSemanticInputSchema,
   source,
+  sessionChangesSchema,
+  sessionChangeSchema,
   sameIndexerParserExecutionPlan,
   sameIndexerApprovedLayout,
   retryIndexerMainPartitionRun,
@@ -33403,19 +34609,34 @@ export {
   recoverIndexerPostAuthorRunLedger,
   recoverIndexerMainRunLedger,
   reconcileIndexerResults,
+  readingTargetKey,
+  readingStructureUpdateSchema,
+  readingStructureSchema,
+  readingStructureEntrySchema,
+  readSessionChanges,
+  readProcessedScopes,
   questionPairs,
+  projectReadingStructure,
   projectIndexerSourceIdentityInventory,
+  projectIndexerPublicContractTable,
   projectIndexerPartitionSubjects,
   projectIndexerFactValue,
+  projectIndexerApprovedKnowledge,
+  processedVersionForScope,
+  processedScopesSchema,
+  processedScopeSchema,
+  processedScopeKey,
   planIndexerPostAuthorComposition,
   parseIndexerRegistry,
   parseIndexerProviderManifest,
+  parseIndexerCurrentActionSubmission,
   ownerCells,
   observeIndexerPostAuthorState,
   observeIndexerMainWorksetState,
   observeIndexerMainRunLedger,
   normalizeIndexerRequirementSet,
   normalizeIndexerExampleRelativePath,
+  mergeProcessedScopes,
   mergeIndexerEvidenceAdapterResults,
   mergeIndexerEvidenceAdapterExecutions,
   mdxJsonDocs,
@@ -33434,6 +34655,7 @@ export {
   isPortableIndexerPath,
   isIndexerProviderProtocol,
   isIndexerLayerFragmentKind,
+  invalidateIndexerMainRunWorksets,
   initializeIndexerPostAuthorRunLedger,
   initializeIndexerMainRunLedger,
   inflationSensitiveHardMaximum,
@@ -33538,7 +34760,6 @@ export {
   indexerProviderManifestSchema,
   indexerProviderLayerRefSchema,
   indexerProviderLayerFragmentSchema,
-  indexerProviderFinalizationSemanticInputSchema,
   indexerProviderCompositionPlanSchema,
   indexerProviderBundleIntegrity,
   indexerProtocolDigest,
@@ -33635,6 +34856,7 @@ export {
   indexerMainRunIdentityDigest,
   indexerMainAcceptedRecordSchema,
   indexerLogicalUnitDependencyNodeSchema,
+  indexerLayoutViewRef,
   indexerLayoutTransitionSchema,
   indexerLayoutSectionRef,
   indexerLayoutSectionIdentityRef,
@@ -33650,6 +34872,9 @@ export {
   indexerLayerFragmentDigest,
   indexerLayerCompositionInputSchema,
   indexerLayerCompositionInputDigest,
+  indexerKnowledgeDependencyVersionSchema,
+  indexerKnowledgeDependencySchema,
+  indexerKnowledgeDependencyFingerprint,
   indexerKnowledgeCollectionSchema2 as indexerKnowledgeCollectionSchema,
   indexerInventoryMembersDigest,
   indexerInventoryMemberSchema,
@@ -33664,7 +34889,6 @@ export {
   indexerIncrementalImpactReportDigest,
   indexerImplementationFingerprint,
   indexerHostExecutionCapabilitiesSchema,
-  indexerGeneratedAuthoringAuditSchema,
   indexerFixedDependencySetSchema,
   indexerExecutionSchema,
   indexerExampleRepresentationSchema,
@@ -33702,6 +34926,7 @@ export {
   indexerCustomizationLadderStepSchema,
   indexerCustomizationDraftSchema,
   indexerCurrentActionInputSchema,
+  indexerCurrentActionInputDefinitions,
   indexerCoverageCompletionReportSchema,
   indexerControlledProgramResultSchema,
   indexerControlledProgramRequestSchema,
@@ -33752,13 +34977,18 @@ export {
   indexerArtifactDependencySetDigest,
   indexerArtifactContentBlockSchema,
   indexerArtifactBundleSchema,
+  indexerArticleSectionKey,
+  indexerArticlePlanSchema,
+  indexerArticleKeySchema,
   indexerApprovedLayoutProjectionSchema,
+  indexerApprovedKnowledgeSchema,
   indexerAgentStepInputSchema,
   indexerAgentStepInputDigest,
   indexerActivationResultSchema,
   indexerActivationRequestSchema,
   indexRequirementSetSchema,
   indexRequirementSchema,
+  impactedIndexerKnowledgeArticles,
   failIndexerPostAuthorRun,
   failIndexerMainRun,
   expectedProviderResolutionFromAction,
@@ -33766,6 +34996,7 @@ export {
   evaluateIndexerCandidateMaterialization,
   enforceIndexerSubjectKeySchemaTransition,
   dispositionMap,
+  discoverManagedDocuments,
   deriveIndexerProgramExecutionPolicy,
   defineProject,
   customPhase,
@@ -33773,7 +35004,6 @@ export {
   coverageDomainCompletionSchema,
   coverageCompletionReportPayloadSchema,
   convergeIndexerPartitionPlan,
-  containsIndexerControlledAuthoringPlaceholder,
   confirmIndexerRequirementWorkset,
   confirmIndexerRequirementChange,
   confirmIndexerRequirementAmendment,
@@ -33830,6 +35060,7 @@ export {
   buildIndexerPrimaryRegistryProjection,
   buildIndexerPrimaryExecutionProjection,
   buildIndexerPostAuthorFragmentRequest,
+  buildIndexerPostAuthorAgentStepInput,
   buildIndexerPartitionInventoryFromParserFactView,
   buildIndexerParserWorksetViewSource,
   buildIndexerParserResolutionLocks,
@@ -33862,7 +35093,6 @@ export {
   buildIndexerInspectorWorksetViewSource,
   buildIndexerInspectorRequest,
   buildIndexerIncrementalImpactReport,
-  buildIndexerGeneratedAuthoringAudit,
   buildIndexerFixedDependencySet,
   buildIndexerExampleLinkageAudit,
   buildIndexerExampleInventory,
@@ -33889,6 +35119,7 @@ export {
   buildIndexerArtifactDependencySet,
   buildIndexerArtifactBundle,
   buildIndexerApprovedLayoutProjection,
+  buildIndexerApprovedKnowledge,
   buildIndexerAgentStepInput,
   buildIndexerActivationRequest,
   authorizeIndexerSubjectReidentification,
@@ -33900,16 +35131,19 @@ export {
   assertTopLevelNamespace,
   assertOkfRoot,
   assertNoReferenceOnlyReaderTargets,
+  assertManagedDocumentPath,
+  assertManagedDocumentName,
   assertMainlineCollection,
   assertKnowledgeCollection,
   assertIndexerPhysicalArtifactAuditPassed,
   assertIndexerParserDependenciesLocked,
-  assertIndexerGeneratedAuthoringAuditClear,
+  assertIndexerInspectorProfileVariants,
   assertIndexerExampleIdentityAuditPassed,
   assertIndexerExampleCandidateDecisionClosure,
   assertIndexerCanonicalOrder,
   assertDocumentMainlineCollection,
   assertDocumentEvidenceSectionMetadata,
+  approvedRevisionSemanticInputSchema,
   analyzeIndexerSubjectKeySchemaTransition,
   allSources,
   acceptIndexerPostAuthorRun,
@@ -33918,6 +35152,7 @@ export {
   OKF_ROOTS,
   MAINLINE_COLLECTIONS,
   KNOWLEDGE_COLLECTIONS,
+  IndexerKnowledgeDependencyCycleError,
   INDEXER_SUBJECT_NORMALIZATIONS,
   INDEXER_SUBJECT_DERIVATION_OPERATORS,
   INDEXER_STRUCTURED_DECLARATION_KINDS,