@c4a/context-cli 0.5.29-beta.29 → 0.5.33-alpha.2

package/cli.js

@@ -8905,11 +8905,35 @@ function validateCompile(value) {
   }
   return compile;
 }
-async function loadConfig(ctxDir) {
-  const configPath = join(ctxDir, "config.yaml");
-  if (!existsSync(configPath)) {
-    throw new Error(`config.yaml not found at ${configPath}`);
+function validateRender(value) {
+  if (value === undefined)
+    return;
+  if (!value || typeof value !== "object") {
+    throw new Error(`config.yaml: render must be an object`);
+  }
+  const r = value;
+  const render = {};
+  if (r.obsidian_mode !== undefined) {
+    if (typeof r.obsidian_mode !== "boolean") {
+      throw new Error(`config.yaml: render.obsidian_mode must be boolean`);
+    }
+    render.obsidian_mode = r.obsidian_mode;
   }
+  if (r.used_by !== undefined) {
+    if (typeof r.used_by !== "boolean") {
+      throw new Error(`config.yaml: render.used_by must be boolean`);
+    }
+    render.used_by = r.used_by;
+  }
+  return render;
+}
+function normalizeRenderConfig(value) {
+  return {
+    obsidian_mode: value?.obsidian_mode ?? DEFAULT_RENDER_CONFIG.obsidian_mode,
+    used_by: value?.used_by ?? DEFAULT_RENDER_CONFIG.used_by
+  };
+}
+async function parseConfigFile(configPath, options) {
   const raw = await readFile(configPath, "utf8");
   let parsed;
   try {
@@ -8918,7 +8942,16 @@ async function loadConfig(ctxDir) {
     const msg = err2 instanceof Error ? err2.message : String(err2);
     throw new Error(`config.yaml parse failed: ${msg}`);
   }
-  const doc = validateConfigRoot(parsed, configPath);
+  if (parsed === null && !options.requireWorkspace)
+    return {};
+  return validateConfigRoot(parsed, configPath);
+}
+async function loadConfig(ctxDir) {
+  const configPath = join(ctxDir, "config.yaml");
+  if (!existsSync(configPath)) {
+    throw new Error(`config.yaml not found at ${configPath}`);
+  }
+  const doc = await parseConfigFile(configPath, { requireWorkspace: true });
   const result = {
     workspace: validateWorkspace(doc)
   };
@@ -8939,12 +8972,28 @@ async function loadConfig(ctxDir) {
   if (compile !== undefined) {
     result.compile = compile;
   }
+  const render = validateRender(doc.render);
+  if (render !== undefined) {
+    result.render = render;
+  }
   return result;
 }
-var import_yaml, VALID_TRUSTS;
+async function loadRenderConfig(ctxDir) {
+  const configPath = join(ctxDir, "config.yaml");
+  if (!existsSync(configPath)) {
+    return { ...DEFAULT_RENDER_CONFIG };
+  }
+  const doc = await parseConfigFile(configPath, { requireWorkspace: false });
+  return normalizeRenderConfig(validateRender(doc.render));
+}
+var import_yaml, VALID_TRUSTS, DEFAULT_RENDER_CONFIG;
 var init_config = __esm(() => {
   import_yaml = __toESM(require_dist(), 1);
   VALID_TRUSTS = ["private", "company", "public"];
+  DEFAULT_RENDER_CONFIG = Object.freeze({
+    obsidian_mode: false,
+    used_by: true
+  });
 });
 
 // src/lib/errors.ts
@@ -29389,7 +29438,7 @@ async function syncEvidenceManifestsForSource(ctxDir, source2, now = new Date) {
   if (await evidenceManifestModeForSource(ctxDir, source2) === "none")
     return;
   for (const snapshot of source2.snapshots) {
-    if (existsSync4(evidenceManifestPath(ctxDir, source2.id, snapshot.content_hash)))
+    if (await readEvidenceManifest(ctxDir, source2.id, snapshot.content_hash))
       continue;
     const manifest = await buildEvidenceManifestForSnapshot({ ctxDir, source: source2, snapshot, now });
     if (manifest)
@@ -29425,23 +29474,35 @@ async function sourceSnapshotForManifest(input) {
     return null;
   const source2 = parsed.sources.map(asSourceEntry).find((entry) => entry?.id === input.sourceId);
   const wantedHash = normalizeStoredHash(input.snapshotHash);
-  const snapshot = source2?.snapshots.map(asSnapshotEntry).find((candidate) => candidate !== null && normalizeStoredHash(candidate.content_hash) === wantedHash);
-  return source2 !== undefined && snapshot !== undefined ? { source: source2, snapshot } : null;
+  const matchingSnapshots = source2?.snapshots.map(asSnapshotEntry).filter((candidate) => candidate !== null && normalizeStoredHash(candidate.content_hash) === wantedHash) ?? [];
+  const snapshot = selectLatestEvidenceSnapshot(matchingSnapshots);
+  return source2 !== undefined && snapshot !== null ? { source: source2, snapshot } : null;
 }
-async function rebuildEvidenceManifest(ctxDir, sourceId, snapshotHash) {
-  const resolved = await sourceSnapshotForManifest({ ctxDir, sourceId, snapshotHash });
-  if (resolved === null)
-    return null;
+async function rebuildEvidenceManifestFromSnapshot(ctxDir, source2, snapshot) {
   const manifest = await buildEvidenceManifestForSnapshot({
     ctxDir,
-    source: resolved.source,
-    snapshot: resolved.snapshot
+    source: source2,
+    snapshot
   });
   if (manifest === null)
     return null;
   await writeEvidenceManifest(ctxDir, manifest);
   return manifest;
 }
+function optionalSnapshotField(value) {
+  return value === undefined || value.length === 0 ? undefined : value;
+}
+function cachedManifestMatchesSnapshot(ctxDir, manifest, snapshot) {
+  if (optionalSnapshotField(manifest.snapshot_file) !== optionalSnapshotField(snapshot.file))
+    return false;
+  if (optionalSnapshotField(manifest.snapshot_dir) !== optionalSnapshotField(snapshot.dir))
+    return false;
+  if (manifest.captured_at !== snapshot.captured_at)
+    return false;
+  if (manifest.snapshot_file !== undefined && !existsSync4(join6(ctxDir, manifest.snapshot_file)))
+    return false;
+  return true;
+}
 async function readCachedEvidenceManifest(path3) {
   if (!existsSync4(path3))
     return null;
@@ -29452,6 +29513,7 @@ async function readCachedEvidenceManifest(path3) {
 }
 async function readEvidenceManifest(ctxDir, sourceId, snapshotHash) {
   const path3 = evidenceManifestPath(ctxDir, sourceId, snapshotHash);
+  const currentSnapshot = await sourceSnapshotForManifest({ ctxDir, sourceId, snapshotHash });
   let parsed;
   try {
     parsed = await readCachedEvidenceManifest(path3);
@@ -29459,10 +29521,10 @@ async function readEvidenceManifest(ctxDir, sourceId, snapshotHash) {
     parsed = null;
   }
   if (parsed === null) {
-    return rebuildEvidenceManifest(ctxDir, sourceId, snapshotHash);
+    return currentSnapshot === null ? null : rebuildEvidenceManifestFromSnapshot(ctxDir, currentSnapshot.source, currentSnapshot.snapshot);
   }
   if (parsed.source_id !== sourceId || normalizeStoredHash(parsed.snapshot_content_hash) !== normalizeStoredHash(snapshotHash)) {
-    const rebuilt = await rebuildEvidenceManifest(ctxDir, sourceId, snapshotHash);
+    const rebuilt = currentSnapshot === null ? null : await rebuildEvidenceManifestFromSnapshot(ctxDir, currentSnapshot.source, currentSnapshot.snapshot);
     if (rebuilt !== null)
       return rebuilt;
     throw new ContextError(ExitCode.WorkspaceStateError, "evidence-manifest identity mismatch", {
@@ -29479,6 +29541,9 @@ async function readEvidenceManifest(ctxDir, sourceId, snapshotHash) {
       }]
     });
   }
+  if (currentSnapshot !== null && !cachedManifestMatchesSnapshot(ctxDir, parsed, currentSnapshot.snapshot)) {
+    return rebuildEvidenceManifestFromSnapshot(ctxDir, currentSnapshot.source, currentSnapshot.snapshot);
+  }
   return parsed;
 }
 async function readLatestEvidenceManifest(ctxDir, source2) {
@@ -31763,7 +31828,9 @@ function splitFrontmatter2(markdown) {
   }
   return {
     frontmatter: parsed,
-    body: normalized.slice(bodyIndex)
+    body: normalized.slice(bodyIndex),
+    bodyLineOffset: normalized.slice(0, bodyIndex).split(`
+`).length - 1
   };
 }
 function toTemporalValue(value) {
@@ -31883,25 +31950,54 @@ function parseContainsList(lines, startIndex, rootSlug) {
   }
   return { entries, edges, nextIndex: index2 };
 }
-function skipDerivedList(lines, startIndex, title) {
-  const heading2 = new RegExp(`^(#{2,6})\\s+${title}\\s*$`).exec(lines[startIndex] ?? "");
+function parseAutoBlockHeading(line, expectedLevel) {
+  const heading2 = /^(#{2,6})\s+(.+?)\s*$/.exec(line);
   if (!heading2)
-    return startIndex;
-  const level = heading2[1]?.length ?? 2;
-  let index2 = startIndex + 1;
+    return null;
+  const level = heading2[1]?.length ?? 0;
+  if (level !== expectedLevel)
+    return null;
+  const title = (heading2[2] ?? "").trim();
+  const kind = AUTO_BLOCK_TITLES.get(title);
+  return kind === undefined ? null : { level, title, kind };
+}
+function autoBlockOpenPattern(kind) {
+  return new RegExp(`^<!--\\s+c4a:auto-block\\s+${kind}\\s+-->$`);
+}
+function consumeAutoBlock(lines, startIndex, expectedLevel, lineOffset = 0) {
+  const heading2 = parseAutoBlockHeading(lines[startIndex] ?? "", expectedLevel);
+  if (heading2 === null)
+    return { matched: false, nextIndex: startIndex };
+  const openIndex = skipBlankLines(lines, startIndex + 1);
+  const opening = lines[openIndex]?.trim() ?? "";
+  if (!autoBlockOpenPattern(heading2.kind).test(opening)) {
+    return { matched: false, nextIndex: startIndex };
+  }
+  let index2 = openIndex + 1;
   while (index2 < lines.length) {
     const line = lines[index2] ?? "";
-    assertNoLegacySectionMarker(line);
-    if (isSectionOpenComment(line))
-      break;
+    if (line.trim() === AUTO_BLOCK_CLOSE) {
+      index2 += 1;
+      while (index2 < lines.length && (lines[index2]?.trim() ?? "") === "")
+        index2 += 1;
+      return { matched: true, nextIndex: index2 };
+    }
     const nextHeading = /^(#{1,6})\s+/.exec(line);
-    if (nextHeading && (nextHeading[1]?.length ?? 0) <= level)
+    if (nextHeading && (nextHeading[1]?.length ?? 0) <= heading2.level) {
       break;
+    }
     index2 += 1;
   }
-  while (index2 < lines.length && (lines[index2]?.trim() ?? "") === "")
-    index2 += 1;
-  return index2;
+  return {
+    matched: false,
+    nextIndex: startIndex,
+    issue: {
+      code: "render-auto-block-unclosed",
+      kind: heading2.kind,
+      title: heading2.title,
+      line: lineOffset + openIndex + 1
+    }
+  };
 }
 function assertNoLegacySectionMarker(line) {
   if (!isLegacySectionOpenComment(line))
@@ -31964,7 +32060,7 @@ function parseFrontmatterNode(lines, index2) {
   }
   return { node: node3, nextIndex: fmEnd + 1 };
 }
-function parseNodeBlock(lines, startIndex, headingLevel) {
+function parseNodeBlock(lines, startIndex, headingLevel, lineOffset = 0) {
   const headingEnd = consumeExpectedHeading(lines, startIndex, headingLevel);
   const frontmatter = parseFrontmatterNode(lines, headingEnd);
   const node3 = frontmatter.node;
@@ -31973,6 +32069,7 @@ function parseNodeBlock(lines, startIndex, headingLevel) {
   const bodyLines = [];
   const containsList = [];
   const children = [];
+  const renderAutoBlockIssues = [];
   const childLevel = headingLevel + 1;
   const childHeadingPattern = new RegExp(`^#{${childLevel}}\\s+.+`);
   while (index2 < lines.length) {
@@ -31987,7 +32084,7 @@ function parseNodeBlock(lines, startIndex, headingLevel) {
     if (childHeadingPattern.test(currentLine)) {
       const peek = peekIsFrontmatterAfterHeading(lines, index2);
       if (peek) {
-        const childResult = parseNodeBlock(lines, index2, childLevel);
+        const childResult = parseNodeBlock(lines, index2, childLevel, lineOffset);
         children.push(childResult.parsed);
         index2 = childResult.nextIndex;
         continue;
@@ -32005,8 +32102,12 @@ function parseNodeBlock(lines, startIndex, headingLevel) {
       index2 = listParsed.nextIndex;
       continue;
     }
-    if (new RegExp(`^#{${headingLevel + 1}}\\s+Related\\s*$`).test(currentLine)) {
-      index2 = skipDerivedList(lines, index2, "Related");
+    const autoBlock = consumeAutoBlock(lines, index2, headingLevel + 1, lineOffset);
+    if (autoBlock.issue !== undefined) {
+      renderAutoBlockIssues.push(autoBlock.issue);
+    }
+    if (autoBlock.matched) {
+      index2 = autoBlock.nextIndex;
       continue;
     }
     if (isSectionGroupHeading(currentLine, headingLevel + 1)) {
@@ -32042,11 +32143,14 @@ function parseNodeBlock(lines, startIndex, headingLevel) {
     parsed: {
       node: node3,
       headingLevel,
+      startLine: lineOffset + startIndex + 1,
+      endLine: lineOffset + index2,
       body: body2,
       sections,
       children,
       containsEdges,
-      containsList
+      containsList,
+      ...renderAutoBlockIssues.length > 0 ? { renderAutoBlockIssues } : {}
     },
     nextIndex: index2
   };
@@ -32079,7 +32183,7 @@ function parsePlainSubHeadingEdges(body2, parentSlug, parentLevel) {
     if (level <= parentLevel)
       continue;
     const title = (match[2] ?? "").trim();
-    if (title.length === 0 || level === parentLevel + 1 && (title === "Contains" || title === "Related" || SECTION_GROUP_TITLES.has(title)))
+    if (title.length === 0 || level === parentLevel + 1 && (AUTO_BLOCK_EXCLUDED_CONTAINS_TITLES.has(title) || SECTION_GROUP_TITLES.has(title)))
       continue;
     if (peekIsFrontmatterAfterHeading(lines, i))
       continue;
@@ -32106,7 +32210,7 @@ function parseNodeMarkdown(markdown) {
   return parsed;
 }
 function parseRootNodeFrontmatterFirst(normalized) {
-  const { frontmatter, body: body2 } = splitFrontmatter2(normalized);
+  const { frontmatter, body: body2, bodyLineOffset } = splitFrontmatter2(normalized);
   const node3 = parseNodeRecord(frontmatter);
   const nodeIssues = validateKnowledgeNode(node3);
   if (nodeIssues.length > 0) {
@@ -32117,7 +32221,9 @@ function parseRootNodeFrontmatterFirst(normalized) {
   let index2 = 0;
   while (index2 < lines.length && (lines[index2]?.trim() ?? "") === "")
     index2 += 1;
+  let rootStartLine = 1;
   if ((lines[index2] ?? "").startsWith("# ")) {
+    rootStartLine = bodyLineOffset + index2 + 1;
     index2 += 1;
     while (index2 < lines.length && (lines[index2]?.trim() ?? "") === "")
       index2 += 1;
@@ -32126,12 +32232,13 @@ function parseRootNodeFrontmatterFirst(normalized) {
   const bodyLines = [];
   const containsList = [];
   const children = [];
+  const renderAutoBlockIssues = [];
   const childLevel = 2;
   while (index2 < lines.length) {
     const currentLine = lines[index2] ?? "";
     assertNoLegacySectionMarker(currentLine);
     if (new RegExp(`^#{${childLevel}}\\s+.+`).test(currentLine) && peekIsFrontmatterAfterHeading(lines, index2)) {
-      const childResult = parseNodeBlock(lines, index2, childLevel);
+      const childResult = parseNodeBlock(lines, index2, childLevel, bodyLineOffset);
       children.push(childResult.parsed);
       index2 = childResult.nextIndex;
       continue;
@@ -32148,8 +32255,12 @@ function parseRootNodeFrontmatterFirst(normalized) {
       index2 = listParsed.nextIndex;
       continue;
     }
-    if (/^##\s+Related\s*$/.test(currentLine)) {
-      index2 = skipDerivedList(lines, index2, "Related");
+    const autoBlock = consumeAutoBlock(lines, index2, 2, bodyLineOffset);
+    if (autoBlock.issue !== undefined) {
+      renderAutoBlockIssues.push(autoBlock.issue);
+    }
+    if (autoBlock.matched) {
+      index2 = autoBlock.nextIndex;
       continue;
     }
     if (isSectionGroupHeading(currentLine, 2)) {
@@ -32184,20 +32295,33 @@ function parseRootNodeFrontmatterFirst(normalized) {
   return {
     node: node3,
     headingLevel: 1,
+    startLine: rootStartLine,
+    endLine: bodyLineOffset + lines.length,
     body: bodyText,
     sections,
     children,
     containsEdges,
-    containsList
+    containsList,
+    ...renderAutoBlockIssues.length > 0 ? { renderAutoBlockIssues } : {}
   };
 }
-var import_yaml10;
+var import_yaml10, AUTO_BLOCK_TITLES, AUTO_BLOCK_EXCLUDED_CONTAINS_TITLES, AUTO_BLOCK_CLOSE = "<!-- /c4a:auto-block -->";
 var init_nodeParser = __esm(() => {
   init_normalize();
   init_nodeDisplayGroups();
   init_nodeParserSections();
   init_knowledge();
   import_yaml10 = __toESM(require_dist(), 1);
+  AUTO_BLOCK_TITLES = new Map([
+    ["Depends On", "depends_on"],
+    ["External Dependencies", "external_dependencies"],
+    ["Used By", "used_by"],
+    ["Related", "related"]
+  ]);
+  AUTO_BLOCK_EXCLUDED_CONTAINS_TITLES = new Set([
+    "Contains",
+    ...AUTO_BLOCK_TITLES.keys()
+  ]);
 });
 
 // src/lib/nodeRenderer.ts
@@ -32347,8 +32471,67 @@ function renderContainsList(entries, headingLevel) {
   return lines.join(`
 `);
 }
-function renderRelatedList(nodeSlug, sections, headingLevel, containsList = [], graphEdges = [], relatedLinks = new Map) {
+function normalizeRenderOptions(options) {
+  return {
+    nodeLinkMode: options?.nodeLinkMode ?? "md",
+    usedBy: options?.usedBy ?? true
+  };
+}
+function formatVersionLabel(value) {
+  const label = String(value);
+  return label.startsWith("v") ? label : `v${label}`;
+}
+function formatVersionAnnotation(entry) {
+  if (entry.valid_from !== undefined && entry.valid_until !== undefined) {
+    return ` — from ${formatVersionLabel(entry.valid_from)} before ${formatVersionLabel(entry.valid_until)}`;
+  }
+  if (entry.valid_from !== undefined) {
+    return ` — since ${formatVersionLabel(entry.valid_from)}`;
+  }
+  if (entry.valid_until !== undefined) {
+    return ` — before ${formatVersionLabel(entry.valid_until)}`;
+  }
+  return "";
+}
+function formatNodeLink(link2, mode) {
+  if (mode === "wiki" && link2.wikiTarget !== undefined && link2.wikiTarget.length > 0) {
+    return `[[${link2.wikiTarget}|${link2.title}]]`;
+  }
+  return `[${link2.title}](${link2.href})`;
+}
+function renderAutoBlock(headingTitle, kind, headingLevel, lines) {
+  if (lines.length === 0)
+    return "";
+  const hashes = "#".repeat(headingLevel);
+  return [
+    `${hashes} ${headingTitle}`,
+    "",
+    `<!-- c4a:auto-block ${kind} -->`,
+    ...lines,
+    "<!-- /c4a:auto-block -->"
+  ].join(`
+`);
+}
+function renderNodeRelationBlock(headingTitle, kind, entries, headingLevel, linkMode) {
+  if (entries === undefined || entries.length === 0)
+    return "";
+  const lines = [...entries].sort((left, right) => left.slug.localeCompare(right.slug)).map((entry) => `- ${formatNodeLink(entry, linkMode)}${formatVersionAnnotation(entry)}`);
+  return renderAutoBlock(headingTitle, kind, headingLevel, lines);
+}
+function renderExternalDependencyBlock(entries, headingLevel) {
+  if (entries === undefined || entries.length === 0)
+    return "";
+  const lines = [...entries].sort((left, right) => left.package.localeCompare(right.package)).map((entry) => {
+    const version2 = entry.version_constraint !== undefined ? ` \`${entry.version_constraint}\`` : "";
+    return `- \`${entry.package}\`${version2}${formatVersionAnnotation(entry)}`;
+  });
+  return renderAutoBlock("External Dependencies", "external_dependencies", headingLevel, lines);
+}
+function renderRelatedList(nodeSlug, sections, headingLevel, containsList = [], graphEdges = [], relatedLinks = new Map, renderOptions, excludedRelatedSlugs = []) {
+  const options = normalizeRenderOptions(renderOptions);
   const contained = new Set(containsList.map((entry) => entry.slug));
+  for (const slug of excludedRelatedSlugs)
+    contained.add(slug);
   for (const edge2 of graphEdges) {
     if (edge2.type !== "contains")
       continue;
@@ -32367,26 +32550,25 @@ function renderRelatedList(nodeSlug, sections, headingLevel, containsList = [],
       related.set(slug, [...related.get(slug) ?? [], section.id]);
     }
   }
-  for (const edge2 of graphEdges) {
-    if (edge2.type === "contains")
-      continue;
-    const target = edge2.from === nodeSlug ? edge2.to : null;
-    if (!target || contained.has(target))
-      continue;
-    const label = `align:${edge2.type}`;
-    related.set(target, [...related.get(target) ?? [], label]);
-  }
   if (related.size === 0)
     return "";
-  const hashes = "#".repeat(headingLevel);
-  const lines = [`${hashes} Related`, ""];
+  const lines = [];
   for (const [slug] of [...related.entries()].sort(([left], [right]) => left.localeCompare(right))) {
     const link2 = relatedLinks.get(slug);
-    const renderedTarget = link2 ? `[${link2.title}](${link2.href})` : `\`${slug}\``;
+    const renderedTarget = link2 ? formatNodeLink(link2, options.nodeLinkMode) : `\`${slug}\``;
     lines.push(`- ${renderedTarget}`);
   }
-  return lines.join(`
-`);
+  return renderAutoBlock("Related", "related", headingLevel, lines);
+}
+function renderRelationBlocks(input, headingLevel) {
+  const options = normalizeRenderOptions(input.renderOptions);
+  const blocks = [
+    renderNodeRelationBlock("Depends On", "depends_on", input.dependsOn, headingLevel, options.nodeLinkMode),
+    renderExternalDependencyBlock(input.externalDependencies, headingLevel),
+    ...options.usedBy ? [renderNodeRelationBlock("Used By", "used_by", input.usedBy, headingLevel, options.nodeLinkMode)] : [],
+    renderRelatedList(input.node.id, input.sections, headingLevel, input.containsList, input.graphEdges, input.relatedLinks, input.renderOptions, [...(input.dependsOn ?? []).map((entry) => entry.slug), ...(input.usedBy ?? []).map((entry) => entry.slug)])
+  ];
+  return blocks.filter((block) => block.length > 0);
 }
 function renderedBody(input) {
   if (input.body !== undefined && input.body.trim().length > 0) {
@@ -32412,13 +32594,13 @@ function renderNodeMarkdown(input) {
       parts.push("", renderChildNodeBlock({
         ...child,
         graphEdges: input.graphEdges ?? [],
-        ...input.relatedLinks !== undefined ? { relatedLinks: input.relatedLinks } : {}
+        ...input.relatedLinks !== undefined ? { relatedLinks: input.relatedLinks } : {},
+        ...input.renderOptions !== undefined ? { renderOptions: input.renderOptions } : {}
       }, 2));
     }
   }
-  const related = renderRelatedList(input.node.id, input.sections, 2, input.containsList, input.graphEdges, input.relatedLinks);
-  if (related.length > 0) {
-    parts.push("", related);
+  for (const block of renderRelationBlocks(input, 2)) {
+    parts.push("", block);
   }
   return `${parts.join(`
 `).replace(/\n{3,}/g, `
@@ -32445,13 +32627,13 @@ function renderChildNodeBlock(input, headingLevel) {
       parts.push("", renderChildNodeBlock({
         ...child,
         graphEdges: input.graphEdges ?? [],
-        ...input.relatedLinks !== undefined ? { relatedLinks: input.relatedLinks } : {}
+        ...input.relatedLinks !== undefined ? { relatedLinks: input.relatedLinks } : {},
+        ...input.renderOptions !== undefined ? { renderOptions: input.renderOptions } : {}
       }, headingLevel + 1));
     }
   }
-  const related = renderRelatedList(input.node.id, input.sections, headingLevel + 1, input.containsList, input.graphEdges, input.relatedLinks);
-  if (related.length > 0) {
-    parts.push("", related);
+  for (const block of renderRelationBlocks(input, headingLevel + 1)) {
+    parts.push("", block);
   }
   return parts.join(`
 `);
@@ -32488,15 +32670,15 @@ function flatSlugForNestedSlug(slug) {
   return pkg && leaf ? `${pkg}-${leaf}` : null;
 }
 
-// src/mdrive/graphEdges.ts
+// src/mdrive/externalDeps.ts
 import { existsSync as existsSync9 } from "node:fs";
 import { readFile as readFile10, readdir as readdir2, rm as rm2 } from "node:fs/promises";
 import { join as join10, relative as relative3, resolve as resolve3 } from "node:path";
 function knowledgeRoot(ctxDir) {
   return join10(ctxDir, "knowledge");
 }
-function graphEdgesPath(ctxDir) {
-  return join10(knowledgeRoot(ctxDir), "_edges.yaml");
+function externalDepsPath(ctxDir) {
+  return join10(knowledgeRoot(ctxDir), "_external.yaml");
 }
 function toPosixPath(value) {
   return value.replace(/\\/g, "/");
@@ -32507,11 +32689,262 @@ function relativeToKnowledge(ctxDir, path3) {
 function isTemporalValue(value) {
   return typeof value === "string" || typeof value === "number";
 }
+function isExternalDep(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const dep = value;
+  return typeof dep.from === "string" && typeof dep.package === "string" && (dep.version_constraint === undefined || typeof dep.version_constraint === "string") && (dep.valid_from === undefined || isTemporalValue(dep.valid_from)) && (dep.valid_until === undefined || isTemporalValue(dep.valid_until));
+}
+function cleanExternalDep(dep, sourcePath) {
+  return {
+    from: dep.from,
+    package: dep.package,
+    ...dep.version_constraint !== undefined ? { version_constraint: dep.version_constraint } : {},
+    ...dep.valid_from !== undefined ? { valid_from: dep.valid_from } : {},
+    ...dep.valid_until !== undefined ? { valid_until: dep.valid_until } : {},
+    ...sourcePath !== undefined ? { source_path: sourcePath } : {}
+  };
+}
+function externalSortKey(dep) {
+  return [
+    dep.from,
+    dep.package,
+    dep.version_constraint ?? "",
+    String(dep.valid_from ?? ""),
+    String(dep.valid_until ?? "")
+  ].join(":");
+}
+async function atomicWriteYaml(path3, value) {
+  await atomicWriteFile(path3, import_yaml12.default.stringify(value));
+}
+function includeTarget(ctxDir, includePath) {
+  if (includePath.startsWith("/") || includePath.length === 0) {
+    return { filePath: includePath, error: "include path must be relative to knowledge/" };
+  }
+  const root2 = resolve3(knowledgeRoot(ctxDir));
+  const target = resolve3(root2, includePath);
+  if (target !== root2 && !target.startsWith(`${root2}/`)) {
+    return { filePath: target, error: "include path must stay under knowledge/" };
+  }
+  return { filePath: target };
+}
+async function readExternalFile(ctxDir, filePath) {
+  const parsed = import_yaml12.default.parse(await readFile10(filePath, "utf8"));
+  const relativePath = relativeToKnowledge(ctxDir, filePath);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return { filePath, relativePath, includes: [], externals: [], rawExternals: [] };
+  }
+  const file = parsed;
+  if (file.schema_version !== 1) {
+    return { filePath, relativePath, includes: [], externals: [], rawExternals: [] };
+  }
+  const includes = Array.isArray(file.includes) ? file.includes.filter((item) => typeof item === "string") : [];
+  const rawExternals = Array.isArray(file.externals) ? file.externals : [];
+  const externals = rawExternals.filter(isExternalDep).map((dep) => cleanExternalDep(dep, relativePath));
+  return { filePath, relativePath, includes, externals, rawExternals };
+}
+async function inspectExternalDeps(ctxDir) {
+  const rootPath = externalDepsPath(ctxDir);
+  const issues = [];
+  const files = [];
+  const visited = new Set;
+  const stack = new Set;
+  const referencedIncludes = new Set;
+  const visit2 = async (filePath, viaInclude) => {
+    const relativePath = relativeToKnowledge(ctxDir, filePath);
+    if (stack.has(filePath)) {
+      issues.push({
+        code: "external-include-cycle",
+        message: `external include cycle detected at "${relativePath}"`,
+        path: viaInclude ?? relativePath
+      });
+      return;
+    }
+    if (visited.has(filePath))
+      return;
+    if (!existsSync9(filePath)) {
+      issues.push({
+        code: "external-include-missing",
+        message: `external include "${viaInclude ?? relativePath}" does not exist`,
+        path: viaInclude ?? relativePath
+      });
+      return;
+    }
+    visited.add(filePath);
+    stack.add(filePath);
+    const file = await readExternalFile(ctxDir, filePath);
+    files.push(file);
+    const includeSeenInFile = new Set;
+    for (const includePath of file.includes) {
+      if (includeSeenInFile.has(includePath)) {
+        issues.push({
+          code: "external-include-duplicate",
+          message: `external include "${includePath}" is declared more than once`,
+          path: file.relativePath
+        });
+      }
+      includeSeenInFile.add(includePath);
+      referencedIncludes.add(includePath);
+      const target = includeTarget(ctxDir, includePath);
+      if (target.error) {
+        issues.push({
+          code: "external-include-outside-knowledge",
+          message: target.error,
+          path: file.relativePath
+        });
+        continue;
+      }
+      await visit2(target.filePath, includePath);
+    }
+    stack.delete(filePath);
+  };
+  if (existsSync9(rootPath)) {
+    await visit2(rootPath);
+  }
+  const entityRoot = join10(knowledgeRoot(ctxDir), "entity");
+  if (existsSync9(entityRoot)) {
+    const entries = await readdir2(entityRoot, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      const packageExternalPath = join10(entityRoot, entry.name, "_external.yaml");
+      const includePath = `entity/${entry.name}/_external.yaml`;
+      if (existsSync9(packageExternalPath) && !referencedIncludes.has(includePath)) {
+        issues.push({
+          code: "external-include-unreachable",
+          message: `external file "${includePath}" exists but is not included by knowledge/_external.yaml`,
+          path: includePath
+        });
+      }
+    }
+  }
+  return {
+    files,
+    externals: files.flatMap((file) => file.externals),
+    issues
+  };
+}
+async function loadExternalDeps(ctxDir) {
+  return (await inspectExternalDeps(ctxDir)).externals;
+}
+async function readRootExternalFile(ctxDir) {
+  const path3 = externalDepsPath(ctxDir);
+  if (!existsSync9(path3))
+    return { schema_version: 1, includes: [], externals: [] };
+  const parsed = import_yaml12.default.parse(await readFile10(path3, "utf8"));
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    return { schema_version: 1, includes: [], externals: [] };
+  const file = parsed;
+  return {
+    schema_version: 1,
+    includes: Array.isArray(file.includes) ? file.includes.filter((item) => typeof item === "string") : [],
+    externals: Array.isArray(file.externals) ? file.externals.filter(isExternalDep).map((dep) => cleanExternalDep(dep)) : []
+  };
+}
+async function writeExternalFile(ctxDir, relativePath, deps, includes = []) {
+  const path3 = join10(knowledgeRoot(ctxDir), relativePath);
+  const file = {
+    schema_version: 1,
+    ...includes.length > 0 ? { includes: [...includes].sort() } : {},
+    externals: [...deps].map((dep) => cleanExternalDep(dep)).sort((left, right) => externalSortKey(left).localeCompare(externalSortKey(right)))
+  };
+  await atomicWriteYaml(path3, file);
+}
+async function syncRootIncludes(ctxDir, packageIncludes) {
+  const root2 = await readRootExternalFile(ctxDir);
+  const rootIncludes = new Set((root2.includes ?? []).filter((include) => !/^entity\/[^/]+\/_external\.yaml$/u.test(include)));
+  for (const include of packageIncludes)
+    rootIncludes.add(include);
+  await writeExternalFile(ctxDir, "_external.yaml", root2.externals, [...rootIncludes]);
+}
+function shouldKeepExistingDep(dep, options) {
+  if (options.fromOwners !== undefined) {
+    return !options.fromOwners.has(ownerSlugForPackageScopedPath(dep.from));
+  }
+  if (options.fromOwner !== undefined) {
+    return dep.from !== options.fromOwner && !dep.from.startsWith(`${options.fromOwner}/`);
+  }
+  if (options.fromPrefix !== undefined)
+    return !dep.from.startsWith(options.fromPrefix);
+  return false;
+}
+async function replaceExternalDepsInternal(ctxDir, deps, options = {}) {
+  const inspection = await inspectExternalDeps(ctxDir);
+  const byPath = new Map;
+  const includesByPath = new Map;
+  for (const file of inspection.files) {
+    const kept = file.externals.filter((dep) => shouldKeepExistingDep(dep, options));
+    byPath.set(file.relativePath, kept);
+    includesByPath.set(file.relativePath, file.includes);
+  }
+  for (const dep of deps) {
+    const relativePath = externalDepRelativePath(dep);
+    const bucket = byPath.get(relativePath) ?? [];
+    byPath.set(relativePath, [...bucket, cleanExternalDep(dep)]);
+  }
+  const packageIncludes = new Set;
+  for (const [relativePath, nextDeps] of byPath) {
+    const includes = includesByPath.get(relativePath) ?? [];
+    const isPackageExternalFile = /^entity\/[^/]+\/_external\.yaml$/u.test(relativePath);
+    if (relativePath === "_external.yaml") {
+      const root2 = await readRootExternalFile(ctxDir);
+      await writeExternalFile(ctxDir, "_external.yaml", nextDeps, root2.includes ?? []);
+      continue;
+    }
+    if (nextDeps.length === 0) {
+      if (isPackageExternalFile && includes.length === 0) {
+        await rm2(join10(knowledgeRoot(ctxDir), relativePath), { force: true });
+      } else {
+        await writeExternalFile(ctxDir, relativePath, [], includes);
+      }
+      continue;
+    }
+    if (isPackageExternalFile)
+      packageIncludes.add(relativePath);
+    await writeExternalFile(ctxDir, relativePath, nextDeps, includes);
+  }
+  for (const [relativePath, nextDeps] of byPath) {
+    const includes = includesByPath.get(relativePath) ?? [];
+    if (/^entity\/[^/]+\/_external\.yaml$/u.test(relativePath) && (nextDeps.length > 0 || includes.length > 0)) {
+      packageIncludes.add(relativePath);
+    }
+  }
+  await syncRootIncludes(ctxDir, packageIncludes);
+  return deps.length;
+}
+async function replaceExternalDepsForOwners(ctxDir, deps, owners) {
+  return replaceExternalDepsInternal(ctxDir, deps, { fromOwners: owners });
+}
+var import_yaml12;
+var init_externalDeps = __esm(() => {
+  init_atomicWrite();
+  import_yaml12 = __toESM(require_dist(), 1);
+});
+
+// src/mdrive/graphEdges.ts
+import { existsSync as existsSync10 } from "node:fs";
+import { readFile as readFile11, readdir as readdir3, rm as rm3 } from "node:fs/promises";
+import { join as join11, relative as relative4, resolve as resolve4 } from "node:path";
+function knowledgeRoot2(ctxDir) {
+  return join11(ctxDir, "knowledge");
+}
+function graphEdgesPath(ctxDir) {
+  return join11(knowledgeRoot2(ctxDir), "_edges.yaml");
+}
+function toPosixPath2(value) {
+  return value.replace(/\\/g, "/");
+}
+function relativeToKnowledge2(ctxDir, path3) {
+  return toPosixPath2(relative4(knowledgeRoot2(ctxDir), path3));
+}
+function isTemporalValue2(value) {
+  return typeof value === "string" || typeof value === "number";
+}
 function isStoredEdge(value) {
   if (!value || typeof value !== "object" || Array.isArray(value))
     return false;
   const edge2 = value;
-  return typeof edge2.type === "string" && edge2.type === EdgeType2.depends_on && typeof edge2.from === "string" && typeof edge2.to === "string" && typeof edge2.grounding === "string" && (edge2.note === undefined || typeof edge2.note === "string") && (edge2.valid_from === undefined || isTemporalValue(edge2.valid_from)) && (edge2.valid_until === undefined || isTemporalValue(edge2.valid_until));
+  return typeof edge2.type === "string" && edge2.type === EdgeType2.depends_on && typeof edge2.from === "string" && typeof edge2.to === "string" && typeof edge2.grounding === "string" && (edge2.note === undefined || typeof edge2.note === "string") && (edge2.valid_from === undefined || isTemporalValue2(edge2.valid_from)) && (edge2.valid_until === undefined || isTemporalValue2(edge2.valid_until));
 }
 function cleanStoredEdge(edge2, sourcePath) {
   return {
@@ -32525,23 +32958,23 @@ function cleanStoredEdge(edge2, sourcePath) {
     ...sourcePath !== undefined ? { source_path: sourcePath } : {}
   };
 }
-async function atomicWriteYaml(path3, value) {
-  await atomicWriteFile(path3, import_yaml12.default.stringify(value));
+async function atomicWriteYaml2(path3, value) {
+  await atomicWriteFile(path3, import_yaml13.default.stringify(value));
 }
-function includeTarget(ctxDir, includePath) {
+function includeTarget2(ctxDir, includePath) {
   if (includePath.startsWith("/") || includePath.length === 0) {
     return { filePath: includePath, error: "include path must be relative to knowledge/" };
   }
-  const root2 = resolve3(knowledgeRoot(ctxDir));
-  const target = resolve3(root2, includePath);
+  const root2 = resolve4(knowledgeRoot2(ctxDir));
+  const target = resolve4(root2, includePath);
   if (target !== root2 && !target.startsWith(`${root2}/`)) {
     return { filePath: target, error: "include path must stay under knowledge/" };
   }
   return { filePath: target };
 }
 async function readEdgeFile(ctxDir, filePath) {
-  const parsed = import_yaml12.default.parse(await readFile10(filePath, "utf8"));
-  const relativePath = relativeToKnowledge(ctxDir, filePath);
+  const parsed = import_yaml13.default.parse(await readFile11(filePath, "utf8"));
+  const relativePath = relativeToKnowledge2(ctxDir, filePath);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
     return { filePath, relativePath, includes: [], edges: [], rawEdges: [] };
   }
@@ -32562,7 +32995,7 @@ async function inspectKnowledgeGraphEdges(ctxDir) {
   const stack = new Set;
   const referencedIncludes = new Set;
   const visit2 = async (filePath, viaInclude) => {
-    const relativePath = relativeToKnowledge(ctxDir, filePath);
+    const relativePath = relativeToKnowledge2(ctxDir, filePath);
     if (stack.has(filePath)) {
       issues.push({
         code: "edge-include-cycle",
@@ -32573,7 +33006,7 @@ async function inspectKnowledgeGraphEdges(ctxDir) {
     }
     if (visited.has(filePath))
       return;
-    if (!existsSync9(filePath)) {
+    if (!existsSync10(filePath)) {
       issues.push({
         code: "edge-include-missing",
         message: `edge include "${viaInclude ?? relativePath}" does not exist`,
@@ -32596,7 +33029,7 @@ async function inspectKnowledgeGraphEdges(ctxDir) {
       }
       includeSeenInFile.add(includePath);
       referencedIncludes.add(includePath);
-      const target = includeTarget(ctxDir, includePath);
+      const target = includeTarget2(ctxDir, includePath);
       if (target.error) {
         issues.push({
           code: "edge-include-outside-knowledge",
@@ -32609,18 +33042,18 @@ async function inspectKnowledgeGraphEdges(ctxDir) {
     }
     stack.delete(filePath);
   };
-  if (existsSync9(rootPath)) {
+  if (existsSync10(rootPath)) {
     await visit2(rootPath);
   }
-  const entityRoot = join10(knowledgeRoot(ctxDir), "entity");
-  if (existsSync9(entityRoot)) {
-    const entries = await readdir2(entityRoot, { withFileTypes: true });
+  const entityRoot = join11(knowledgeRoot2(ctxDir), "entity");
+  if (existsSync10(entityRoot)) {
+    const entries = await readdir3(entityRoot, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const packageEdgePath = join10(entityRoot, entry.name, "_edges.yaml");
+      const packageEdgePath = join11(entityRoot, entry.name, "_edges.yaml");
       const includePath = `entity/${entry.name}/_edges.yaml`;
-      if (existsSync9(packageEdgePath) && !referencedIncludes.has(includePath)) {
+      if (existsSync10(packageEdgePath) && !referencedIncludes.has(includePath)) {
         issues.push({
           code: "edge-include-unreachable",
           message: `edge file "${includePath}" exists but is not included by knowledge/_edges.yaml`,
@@ -32660,9 +33093,9 @@ function edgeSortKey(edge2) {
 }
 async function readRootGraphEdgesFile(ctxDir) {
   const path3 = graphEdgesPath(ctxDir);
-  if (!existsSync9(path3))
+  if (!existsSync10(path3))
     return { schema_version: 1, includes: [], edges: [] };
-  const parsed = import_yaml12.default.parse(await readFile10(path3, "utf8"));
+  const parsed = import_yaml13.default.parse(await readFile11(path3, "utf8"));
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
     return { schema_version: 1, includes: [], edges: [] };
   const file = parsed;
@@ -32673,15 +33106,15 @@ async function readRootGraphEdgesFile(ctxDir) {
   };
 }
 async function writeEdgeFile(ctxDir, relativePath, edges, includes = []) {
-  const path3 = join10(knowledgeRoot(ctxDir), relativePath);
+  const path3 = join11(knowledgeRoot2(ctxDir), relativePath);
   const file = {
     schema_version: 1,
     ...includes.length > 0 ? { includes: [...includes].sort() } : {},
     edges: [...edges].map((edge2) => cleanStoredEdge(edge2)).sort((left, right) => edgeSortKey(left).localeCompare(edgeSortKey(right)))
   };
-  await atomicWriteYaml(path3, file);
+  await atomicWriteYaml2(path3, file);
 }
-async function syncRootIncludes(ctxDir, packageIncludes) {
+async function syncRootIncludes2(ctxDir, packageIncludes) {
   const root2 = await readRootGraphEdgesFile(ctxDir);
   const rootIncludes = new Set((root2.includes ?? []).filter((include) => !/^entity\/[^/]+\/_edges\.yaml$/u.test(include)));
   for (const include of packageIncludes)
@@ -32750,7 +33183,7 @@ async function replaceCodeGraphEdges(ctxDir, grounding, edges) {
     }
     if (nextEdges.length === 0) {
       if (isPackageEdgeFile && includes.length === 0) {
-        await rm2(join10(knowledgeRoot(ctxDir), relativePath), { force: true });
+        await rm3(join11(knowledgeRoot2(ctxDir), relativePath), { force: true });
       } else {
         await writeEdgeFile(ctxDir, relativePath, [], includes);
       }
@@ -32766,7 +33199,7 @@ async function replaceCodeGraphEdges(ctxDir, grounding, edges) {
       packageIncludes.add(relativePath);
     }
   }
-  await syncRootIncludes(ctxDir, packageIncludes);
+  await syncRootIncludes2(ctxDir, packageIncludes);
   return written;
 }
 async function writeKnowledgeGraphEdgeFiles(ctxDir, edges) {
@@ -32792,7 +33225,7 @@ async function writeKnowledgeGraphEdgeFiles(ctxDir, edges) {
     }
     if (bucket.length === 0) {
       if (isPackageEdgeFile && includes.length === 0) {
-        await rm2(join10(knowledgeRoot(ctxDir), relativePath), { force: true });
+        await rm3(join11(knowledgeRoot2(ctxDir), relativePath), { force: true });
       } else {
         await writeEdgeFile(ctxDir, relativePath, [], includes);
       }
@@ -32808,7 +33241,7 @@ async function writeKnowledgeGraphEdgeFiles(ctxDir, edges) {
       packageIncludes.add(relativePath);
     }
   }
-  await syncRootIncludes(ctxDir, packageIncludes);
+  await syncRootIncludes2(ctxDir, packageIncludes);
 }
 async function renameKnowledgeGraphEdgeNode(ctxDir, from, to) {
   const existing = await loadKnowledgeGraphEdges(ctxDir);
@@ -32847,31 +33280,31 @@ async function removeKnowledgeGraphEdgesForNodes(ctxDir, slugs) {
   }
   return removed;
 }
-var import_yaml12;
+var import_yaml13;
 var init_graphEdges = __esm(() => {
   init_atomicWrite();
   init_knowledge();
-  import_yaml12 = __toESM(require_dist(), 1);
+  import_yaml13 = __toESM(require_dist(), 1);
 });
 
 // src/mdrive/shared.ts
-import { existsSync as existsSync10 } from "node:fs";
-import { mkdir as mkdir5, readFile as readFile11, readdir as readdir3, rm as rm3 } from "node:fs/promises";
-import { dirname as dirname6, join as join11, relative as relative4 } from "node:path";
-function toPosixPath2(value) {
+import { existsSync as existsSync11 } from "node:fs";
+import { mkdir as mkdir5, readFile as readFile12, readdir as readdir4, rm as rm4 } from "node:fs/promises";
+import { dirname as dirname6, join as join12, relative as relative5 } from "node:path";
+function toPosixPath3(value) {
   return value.replace(/\\/g, "/");
 }
-function knowledgeRoot2(ctxDir) {
-  return join11(ctxDir, "knowledge");
+function knowledgeRoot3(ctxDir) {
+  return join12(ctxDir, "knowledge");
 }
 function knowledgeDir(ctxDir, type) {
-  return join11(knowledgeRoot2(ctxDir), type);
+  return join12(knowledgeRoot3(ctxDir), type);
 }
 function knowledgeFilePath(ctxDir, type, slug) {
-  return join11(knowledgeDir(ctxDir, type), `${slug}.md`);
+  return join12(knowledgeDir(ctxDir, type), `${slug}.md`);
 }
 function slugFromKnowledgeRelativePath(relativePath) {
-  const normalized = toPosixPath2(relativePath);
+  const normalized = toPosixPath3(relativePath);
   const parts = normalized.split("/");
   if (parts.length === 2 && parts[1]?.endsWith(".md")) {
     return parts[1].slice(0, -3);
@@ -32882,7 +33315,7 @@ function slugFromKnowledgeRelativePath(relativePath) {
   return null;
 }
 function typeFromKnowledgeRelativePath(relativePath) {
-  const [type] = toPosixPath2(relativePath).split("/");
+  const [type] = toPosixPath3(relativePath).split("/");
   return NODE_TYPES.includes(type) ? type : null;
 }
 function derivedContainsEdgeForFile(file) {
@@ -32908,30 +33341,115 @@ async function atomicWriteText(path3, content3) {
   await atomicWriteFile(path3, content3);
 }
 function ctxDirFromKnowledgeFilePath(filePath) {
-  const marker = `${toPosixPath2("/knowledge/")}`;
-  const normalized = toPosixPath2(filePath);
+  const marker = `${toPosixPath3("/knowledge/")}`;
+  const normalized = toPosixPath3(filePath);
   const index2 = normalized.lastIndexOf(marker);
   return index2 >= 0 ? normalized.slice(0, index2) : null;
 }
 async function buildRenderWorkspaceContext(ctxDir, files) {
-  const graphEdges = await loadKnowledgeGraphEdges(ctxDir);
+  const [graphEdges, externalDeps, renderConfig] = await Promise.all([
+    loadKnowledgeGraphEdges(ctxDir),
+    loadExternalDeps(ctxDir),
+    loadRenderConfig(ctxDir)
+  ]);
   const workspaceFiles = files ?? await readWorkspaceNodeFiles(ctxDir);
-  const locatedNodes = flattenWorkspaceNodes(workspaceFiles);
+  return buildRenderWorkspaceContextFromData({
+    files: workspaceFiles,
+    graphEdges,
+    externalDeps,
+    renderOptions: {
+      nodeLinkMode: renderConfig.obsidian_mode ? "wiki" : "md",
+      usedBy: renderConfig.used_by
+    }
+  });
+}
+function buildRenderWorkspaceContextFromData(input) {
+  const locatedNodes = flattenWorkspaceNodes(input.files);
+  const anchorsByFile = new Map(input.files.map((file) => [file.filePath, computeNodeAnchorsForFile(file.root)]));
   const relatedLinksByFile = new Map;
-  for (const file of workspaceFiles) {
+  const relationEntriesByFile = new Map;
+  for (const file of input.files) {
     const links = new Map;
     for (const target of locatedNodes) {
-      const href = target.filePath === file.filePath ? `#${slugify(target.parsed.node.title)}` : buildContainsHref(file.filePath, target.filePath);
-      links.set(target.parsed.node.id, { title: target.parsed.node.title, href });
+      const targetAnchors = anchorsByFile.get(target.filePath) ?? new Map;
+      links.set(target.parsed.node.id, {
+        title: target.parsed.node.title,
+        href: markdownHrefForLocatedNode(file.filePath, target, targetAnchors),
+        wikiTarget: wikiTargetForLocatedNode(target, targetAnchors)
+      });
     }
     relatedLinksByFile.set(file.filePath, links);
+    relationEntriesByFile.set(file.filePath, buildRelationEntriesByNodeSlug(flattenNodeTree(file.root, file.filePath, file.relativePath), input.graphEdges, input.externalDeps, links));
   }
   return {
-    graphEdges,
-    workspaceContains: workspaceFiles.flatMap((file) => file.root.containsEdges),
-    relatedLinksByFile
+    graphEdges: [...input.graphEdges],
+    workspaceContains: input.files.flatMap((file) => file.root.containsEdges),
+    relatedLinksByFile,
+    relationEntriesByFile,
+    renderOptions: input.renderOptions
   };
 }
+function computeNodeAnchorsForFile(root2) {
+  const counts = new Map;
+  const anchors = new Map;
+  const claim = (title) => {
+    const base = slugify(title);
+    const seen = (counts.get(base) ?? 0) + 1;
+    counts.set(base, seen);
+    return seen === 1 ? base : `${base}-${seen}`;
+  };
+  const visit2 = (node3) => {
+    anchors.set(node3.node.id, claim(node3.node.title));
+    for (const child of node3.children)
+      visit2(child);
+  };
+  visit2(root2);
+  return anchors;
+}
+function markdownHrefForLocatedNode(fromFilePath, target, targetAnchors) {
+  const anchor = targetAnchors.get(target.parsed.node.id);
+  if (target.filePath === fromFilePath) {
+    return anchor !== undefined ? `#${anchor}` : "";
+  }
+  const href = buildContainsHref(fromFilePath, target.filePath);
+  return target.path.length > 0 && anchor !== undefined ? `${href}#${anchor}` : href;
+}
+function wikiTargetForLocatedNode(target, targetAnchors) {
+  const base = toPosixPath3(target.relativePath).replace(/\.md$/u, "");
+  const anchor = targetAnchors.get(target.parsed.node.id);
+  return target.path.length > 0 && anchor !== undefined ? `${base}#${anchor}` : base;
+}
+function relationLink(links, slug) {
+  return links.get(slug) ?? { title: slug, href: `${slug}.md`, wikiTarget: slug };
+}
+function toNodeRelationEntry(links, slug, edge2) {
+  return {
+    slug,
+    ...relationLink(links, slug),
+    ...edge2.valid_from !== undefined ? { valid_from: edge2.valid_from } : {},
+    ...edge2.valid_until !== undefined ? { valid_until: edge2.valid_until } : {}
+  };
+}
+function toExternalDependencyEntry(dep) {
+  return {
+    package: dep.package,
+    ...dep.version_constraint !== undefined ? { version_constraint: dep.version_constraint } : {},
+    ...dep.valid_from !== undefined ? { valid_from: dep.valid_from } : {},
+    ...dep.valid_until !== undefined ? { valid_until: dep.valid_until } : {}
+  };
+}
+function buildRelationEntriesByNodeSlug(nodesInFile, graphEdges, externalDeps, links) {
+  const bySlug = new Map;
+  for (const node3 of nodesInFile) {
+    const slug = node3.parsed.node.id;
+    bySlug.set(slug, {
+      dependsOn: graphEdges.filter((edge2) => edge2.type === "depends_on" && edge2.from === slug).map((edge2) => toNodeRelationEntry(links, edge2.to, edge2)),
+      usedBy: graphEdges.filter((edge2) => edge2.type === "depends_on" && edge2.to === slug).map((edge2) => toNodeRelationEntry(links, edge2.from, edge2)),
+      externalDependencies: externalDeps.filter((dep) => dep.from === slug).map(toExternalDependencyEntry)
+    });
+  }
+  return bySlug;
+}
 function collectTreeSlugs(root2, out2 = new Set) {
   out2.add(root2.node.id);
   for (const child of root2.children) {
@@ -32963,27 +33481,79 @@ function collectCurrentContainsEdges(root2) {
   visit2(root2);
   return edges;
 }
+function attachRelationInputs(input, filePath, context) {
+  const relations = context.relationEntriesByFile.get(filePath)?.get(input.node.id);
+  const relatedLinks = context.relatedLinksByFile.get(filePath);
+  const output = {
+    ...input,
+    ...relations !== undefined ? {
+      dependsOn: relations.dependsOn,
+      usedBy: relations.usedBy,
+      externalDependencies: relations.externalDependencies
+    } : {},
+    renderOptions: context.renderOptions
+  };
+  if (relatedLinks !== undefined) {
+    output.relatedLinks = relatedLinks;
+  }
+  if (input.children !== undefined) {
+    output.children = input.children.map((child) => attachRelationInputs(child, filePath, context));
+  }
+  return output;
+}
+function collectRenderInputSlugs(input, out2 = new Set) {
+  out2.add(input.node.id);
+  for (const child of input.children ?? []) {
+    collectRenderInputSlugs(child, out2);
+  }
+  return out2;
+}
+function collectRenderInputChildContains(input) {
+  const edges = [];
+  const visit2 = (current) => {
+    for (const child of current.children ?? []) {
+      edges.push({
+        type: "contains",
+        from: current.node.id,
+        to: child.node.id,
+        grounding: "document"
+      });
+      visit2(child);
+    }
+  };
+  visit2(input);
+  return edges;
+}
+function renderNodeInputForFile(filePath, input, context) {
+  const rootSlugs = collectRenderInputSlugs(input);
+  const workspaceContains = context.workspaceContains.filter((edge2) => !rootSlugs.has(edge2.from));
+  const rootContains = collectRenderInputChildContains(input);
+  const decorated = attachRelationInputs({
+    ...input,
+    graphEdges: [...context.graphEdges, ...workspaceContains, ...rootContains, ...input.graphEdges ?? []]
+  }, filePath, context);
+  return renderNodeMarkdown(decorated);
+}
 async function renderRootForFile(filePath, root2, renderContext) {
   const ctxDir = ctxDirFromKnowledgeFilePath(filePath);
-  const context = renderContext ?? (ctxDir ? await buildRenderWorkspaceContext(ctxDir) : {
-    graphEdges: [],
-    workspaceContains: [],
-    relatedLinksByFile: new Map
-  });
+  if (renderContext === undefined && ctxDir === null) {
+    throw new ContextError(ExitCode.WorkspaceStateError, "renderRootForFile requires a knowledge file path or an explicit render context", { category: "schema-invalid" });
+  }
+  const context = renderContext ?? await buildRenderWorkspaceContext(ctxDir);
   const rootSlugs = collectTreeSlugs(root2);
   const workspaceContains = context.workspaceContains.filter((edge2) => !rootSlugs.has(edge2.from));
   const rootContains = collectCurrentContainsEdges(root2);
-  return renderNodeMarkdown({
+  const decorated = attachRelationInputs({
     ...root2,
-    graphEdges: [...context.graphEdges, ...workspaceContains, ...rootContains],
-    relatedLinks: context.relatedLinksByFile.get(filePath)
-  });
+    graphEdges: [...context.graphEdges, ...workspaceContains, ...rootContains]
+  }, filePath, context);
+  return renderNodeMarkdown(decorated);
 }
 async function atomicRewriteRootFile(filePath, root2, nextFilePath, renderContext) {
   const destination = nextFilePath ?? filePath;
   await atomicWriteText(destination, await renderRootForFile(destination, root2, renderContext));
-  if (destination !== filePath && existsSync10(filePath)) {
-    await rm3(filePath);
+  if (destination !== filePath && existsSync11(filePath)) {
+    await rm4(filePath);
   }
 }
 async function writeStandaloneNodeFile(ctxDir, root2, renderContext) {
@@ -32993,7 +33563,7 @@ async function writeStandaloneNodeFile(ctxDir, root2, renderContext) {
   return filePath;
 }
 function buildContainsHref(fromFilePath, toFilePath) {
-  return toPosixPath2(relative4(dirname6(fromFilePath), toFilePath));
+  return toPosixPath3(relative5(dirname6(fromFilePath), toFilePath));
 }
 function buildContainsEntry(fromFilePath, targetFilePath, targetSlug, targetTitle) {
   return {
@@ -33006,25 +33576,25 @@ async function readWorkspaceNodeFiles(ctxDir) {
   const files = [];
   for (const type of NODE_TYPES) {
     const dir = knowledgeDir(ctxDir, type);
-    if (!existsSync10(dir))
+    if (!existsSync11(dir))
       continue;
-    const entries = await readdir3(dir, { withFileTypes: true });
+    const entries = await readdir4(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile()) {
         if (!entry.name.endsWith(".md") || KNOWLEDGE_IGNORED_FILES.has(entry.name))
           continue;
-        files.push(await readWorkspaceNodeFile(ctxDir, join11(dir, entry.name)));
+        files.push(await readWorkspaceNodeFile(ctxDir, join12(dir, entry.name)));
         continue;
       }
       if (!entry.isDirectory())
         continue;
-      const nestedDir = join11(dir, entry.name);
-      const nestedEntries = await readdir3(nestedDir, { withFileTypes: true });
+      const nestedDir = join12(dir, entry.name);
+      const nestedEntries = await readdir4(nestedDir, { withFileTypes: true });
       for (const nestedEntry of nestedEntries) {
         if (!nestedEntry.isFile() || !nestedEntry.name.endsWith(".md") || KNOWLEDGE_IGNORED_FILES.has(nestedEntry.name)) {
           continue;
         }
-        files.push(await readWorkspaceNodeFile(ctxDir, join11(nestedDir, nestedEntry.name)));
+        files.push(await readWorkspaceNodeFile(ctxDir, join12(nestedDir, nestedEntry.name)));
       }
     }
   }
@@ -33036,8 +33606,8 @@ async function readWorkspaceNodeFiles(ctxDir) {
   return files;
 }
 async function readWorkspaceNodeFile(ctxDir, filePath) {
-  const relativePath = toPosixPath2(relative4(knowledgeRoot2(ctxDir), filePath));
-  const content3 = await readFile11(filePath, "utf8");
+  const relativePath = toPosixPath3(relative5(knowledgeRoot3(ctxDir), filePath));
+  const content3 = await readFile12(filePath, "utf8");
   let root2;
   try {
     root2 = parseNodeMarkdown(content3);
@@ -33195,15 +33765,17 @@ var init_shared = __esm(() => {
   init_nodeParser();
   init_nodeRenderer();
   init_normalize();
+  init_config();
   init_exitCode();
   init_knowledge();
+  init_externalDeps();
   init_graphEdges();
   KNOWLEDGE_IGNORED_FILES = new Set(["_index.md", "changelog.md"]);
 });
 
 // src/incremental/sectionFingerprints.ts
-import { readFile as readFile12 } from "node:fs/promises";
-import { join as join12 } from "node:path";
+import { readFile as readFile13 } from "node:fs/promises";
+import { join as join13 } from "node:path";
 function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -33270,7 +33842,7 @@ function isRawBlocksCache(value) {
 async function loadRawBlocks(path3) {
   let raw;
   try {
-    raw = await readFile12(path3, "utf8");
+    raw = await readFile13(path3, "utf8");
   } catch (err2) {
     const code3 = err2.code;
     if (code3 === "ENOENT")
@@ -33350,7 +33922,7 @@ function normalizeHeadingTitle(value) {
   return normalizeMarkdown(value).trim().replace(/\s+/gu, " ");
 }
 async function anchorForBlock(ctxDir, snapshotFile, block) {
-  const raw = await readFile12(join12(ctxDir, snapshotFile), "utf8");
+  const raw = await readFile13(join13(ctxDir, snapshotFile), "utf8");
   const anchors = extractAnchors(stripFrontmatter(raw));
   if (anchors.length === 0)
     return "document";
@@ -33449,7 +34021,7 @@ function fingerprintEntry(input) {
 async function loadSectionFingerprints(path3) {
   let raw;
   try {
-    raw = await readFile12(path3, "utf8");
+    raw = await readFile13(path3, "utf8");
   } catch (err2) {
     const code3 = err2.code;
     if (code3 === "ENOENT")
@@ -33691,9 +34263,9 @@ var init_sectionFingerprints = __esm(() => {
 });
 
 // src/incremental/sourceDigests.ts
-import { existsSync as existsSync11 } from "node:fs";
-import { readFile as readFile13 } from "node:fs/promises";
-import { join as join13 } from "node:path";
+import { existsSync as existsSync12 } from "node:fs";
+import { readFile as readFile14 } from "node:fs/promises";
+import { join as join14 } from "node:path";
 function sortJson4(value) {
   if (Array.isArray(value))
     return value.map(sortJson4);
@@ -33767,8 +34339,8 @@ async function buildSourceDigests(input) {
         rawBlocks.unknown_inputs.push(unknown2);
         continue;
       }
-      const rawPath = join13(input.ctxDir, snapshot.file);
-      if (!existsSync11(rawPath)) {
+      const rawPath = join14(input.ctxDir, snapshot.file);
+      if (!existsSync12(rawPath)) {
         const unknown2 = unknownInput(source2.id, "snapshot-file-not-found", snapshot.file);
         sourceDigests.unknown_inputs.push(unknown2);
         rawBlocks.unknown_inputs.push(unknown2);
@@ -33776,7 +34348,7 @@ async function buildSourceDigests(input) {
       }
       let raw;
       try {
-        raw = await readFile13(rawPath, "utf8");
+        raw = await readFile14(rawPath, "utf8");
       } catch {
         const unknown2 = unknownInput(source2.id, "snapshot-file-read-failed", snapshot.file);
         sourceDigests.unknown_inputs.push(unknown2);
@@ -34007,257 +34579,6 @@ var init_nodeClassification = __esm(() => {
   ]);
 });
 
-// src/mdrive/externalDeps.ts
-import { existsSync as existsSync12 } from "node:fs";
-import { readFile as readFile14, readdir as readdir4, rm as rm4 } from "node:fs/promises";
-import { join as join14, relative as relative5, resolve as resolve4 } from "node:path";
-function knowledgeRoot3(ctxDir) {
-  return join14(ctxDir, "knowledge");
-}
-function externalDepsPath(ctxDir) {
-  return join14(knowledgeRoot3(ctxDir), "_external.yaml");
-}
-function toPosixPath3(value) {
-  return value.replace(/\\/g, "/");
-}
-function relativeToKnowledge2(ctxDir, path3) {
-  return toPosixPath3(relative5(knowledgeRoot3(ctxDir), path3));
-}
-function isTemporalValue2(value) {
-  return typeof value === "string" || typeof value === "number";
-}
-function isExternalDep(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return false;
-  const dep = value;
-  return typeof dep.from === "string" && typeof dep.package === "string" && (dep.version_constraint === undefined || typeof dep.version_constraint === "string") && (dep.valid_from === undefined || isTemporalValue2(dep.valid_from)) && (dep.valid_until === undefined || isTemporalValue2(dep.valid_until));
-}
-function cleanExternalDep(dep, sourcePath) {
-  return {
-    from: dep.from,
-    package: dep.package,
-    ...dep.version_constraint !== undefined ? { version_constraint: dep.version_constraint } : {},
-    ...dep.valid_from !== undefined ? { valid_from: dep.valid_from } : {},
-    ...dep.valid_until !== undefined ? { valid_until: dep.valid_until } : {},
-    ...sourcePath !== undefined ? { source_path: sourcePath } : {}
-  };
-}
-function externalSortKey(dep) {
-  return [
-    dep.from,
-    dep.package,
-    dep.version_constraint ?? "",
-    String(dep.valid_from ?? ""),
-    String(dep.valid_until ?? "")
-  ].join(":");
-}
-async function atomicWriteYaml2(path3, value) {
-  await atomicWriteFile(path3, import_yaml13.default.stringify(value));
-}
-function includeTarget2(ctxDir, includePath) {
-  if (includePath.startsWith("/") || includePath.length === 0) {
-    return { filePath: includePath, error: "include path must be relative to knowledge/" };
-  }
-  const root2 = resolve4(knowledgeRoot3(ctxDir));
-  const target = resolve4(root2, includePath);
-  if (target !== root2 && !target.startsWith(`${root2}/`)) {
-    return { filePath: target, error: "include path must stay under knowledge/" };
-  }
-  return { filePath: target };
-}
-async function readExternalFile(ctxDir, filePath) {
-  const parsed = import_yaml13.default.parse(await readFile14(filePath, "utf8"));
-  const relativePath = relativeToKnowledge2(ctxDir, filePath);
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    return { filePath, relativePath, includes: [], externals: [], rawExternals: [] };
-  }
-  const file = parsed;
-  if (file.schema_version !== 1) {
-    return { filePath, relativePath, includes: [], externals: [], rawExternals: [] };
-  }
-  const includes = Array.isArray(file.includes) ? file.includes.filter((item) => typeof item === "string") : [];
-  const rawExternals = Array.isArray(file.externals) ? file.externals : [];
-  const externals = rawExternals.filter(isExternalDep).map((dep) => cleanExternalDep(dep, relativePath));
-  return { filePath, relativePath, includes, externals, rawExternals };
-}
-async function inspectExternalDeps(ctxDir) {
-  const rootPath = externalDepsPath(ctxDir);
-  const issues = [];
-  const files = [];
-  const visited = new Set;
-  const stack = new Set;
-  const referencedIncludes = new Set;
-  const visit2 = async (filePath, viaInclude) => {
-    const relativePath = relativeToKnowledge2(ctxDir, filePath);
-    if (stack.has(filePath)) {
-      issues.push({
-        code: "external-include-cycle",
-        message: `external include cycle detected at "${relativePath}"`,
-        path: viaInclude ?? relativePath
-      });
-      return;
-    }
-    if (visited.has(filePath))
-      return;
-    if (!existsSync12(filePath)) {
-      issues.push({
-        code: "external-include-missing",
-        message: `external include "${viaInclude ?? relativePath}" does not exist`,
-        path: viaInclude ?? relativePath
-      });
-      return;
-    }
-    visited.add(filePath);
-    stack.add(filePath);
-    const file = await readExternalFile(ctxDir, filePath);
-    files.push(file);
-    const includeSeenInFile = new Set;
-    for (const includePath of file.includes) {
-      if (includeSeenInFile.has(includePath)) {
-        issues.push({
-          code: "external-include-duplicate",
-          message: `external include "${includePath}" is declared more than once`,
-          path: file.relativePath
-        });
-      }
-      includeSeenInFile.add(includePath);
-      referencedIncludes.add(includePath);
-      const target = includeTarget2(ctxDir, includePath);
-      if (target.error) {
-        issues.push({
-          code: "external-include-outside-knowledge",
-          message: target.error,
-          path: file.relativePath
-        });
-        continue;
-      }
-      await visit2(target.filePath, includePath);
-    }
-    stack.delete(filePath);
-  };
-  if (existsSync12(rootPath)) {
-    await visit2(rootPath);
-  }
-  const entityRoot = join14(knowledgeRoot3(ctxDir), "entity");
-  if (existsSync12(entityRoot)) {
-    const entries = await readdir4(entityRoot, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory())
-        continue;
-      const packageExternalPath = join14(entityRoot, entry.name, "_external.yaml");
-      const includePath = `entity/${entry.name}/_external.yaml`;
-      if (existsSync12(packageExternalPath) && !referencedIncludes.has(includePath)) {
-        issues.push({
-          code: "external-include-unreachable",
-          message: `external file "${includePath}" exists but is not included by knowledge/_external.yaml`,
-          path: includePath
-        });
-      }
-    }
-  }
-  return {
-    files,
-    externals: files.flatMap((file) => file.externals),
-    issues
-  };
-}
-async function loadExternalDeps(ctxDir) {
-  return (await inspectExternalDeps(ctxDir)).externals;
-}
-async function readRootExternalFile(ctxDir) {
-  const path3 = externalDepsPath(ctxDir);
-  if (!existsSync12(path3))
-    return { schema_version: 1, includes: [], externals: [] };
-  const parsed = import_yaml13.default.parse(await readFile14(path3, "utf8"));
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-    return { schema_version: 1, includes: [], externals: [] };
-  const file = parsed;
-  return {
-    schema_version: 1,
-    includes: Array.isArray(file.includes) ? file.includes.filter((item) => typeof item === "string") : [],
-    externals: Array.isArray(file.externals) ? file.externals.filter(isExternalDep).map((dep) => cleanExternalDep(dep)) : []
-  };
-}
-async function writeExternalFile(ctxDir, relativePath, deps, includes = []) {
-  const path3 = join14(knowledgeRoot3(ctxDir), relativePath);
-  const file = {
-    schema_version: 1,
-    ...includes.length > 0 ? { includes: [...includes].sort() } : {},
-    externals: [...deps].map((dep) => cleanExternalDep(dep)).sort((left, right) => externalSortKey(left).localeCompare(externalSortKey(right)))
-  };
-  await atomicWriteYaml2(path3, file);
-}
-async function syncRootIncludes2(ctxDir, packageIncludes) {
-  const root2 = await readRootExternalFile(ctxDir);
-  const rootIncludes = new Set((root2.includes ?? []).filter((include) => !/^entity\/[^/]+\/_external\.yaml$/u.test(include)));
-  for (const include of packageIncludes)
-    rootIncludes.add(include);
-  await writeExternalFile(ctxDir, "_external.yaml", root2.externals, [...rootIncludes]);
-}
-function shouldKeepExistingDep(dep, options) {
-  if (options.fromOwners !== undefined) {
-    return !options.fromOwners.has(ownerSlugForPackageScopedPath(dep.from));
-  }
-  if (options.fromOwner !== undefined) {
-    return dep.from !== options.fromOwner && !dep.from.startsWith(`${options.fromOwner}/`);
-  }
-  if (options.fromPrefix !== undefined)
-    return !dep.from.startsWith(options.fromPrefix);
-  return false;
-}
-async function replaceExternalDepsInternal(ctxDir, deps, options = {}) {
-  const inspection = await inspectExternalDeps(ctxDir);
-  const byPath = new Map;
-  const includesByPath = new Map;
-  for (const file of inspection.files) {
-    const kept = file.externals.filter((dep) => shouldKeepExistingDep(dep, options));
-    byPath.set(file.relativePath, kept);
-    includesByPath.set(file.relativePath, file.includes);
-  }
-  for (const dep of deps) {
-    const relativePath = externalDepRelativePath(dep);
-    const bucket = byPath.get(relativePath) ?? [];
-    byPath.set(relativePath, [...bucket, cleanExternalDep(dep)]);
-  }
-  const packageIncludes = new Set;
-  for (const [relativePath, nextDeps] of byPath) {
-    const includes = includesByPath.get(relativePath) ?? [];
-    const isPackageExternalFile = /^entity\/[^/]+\/_external\.yaml$/u.test(relativePath);
-    if (relativePath === "_external.yaml") {
-      const root2 = await readRootExternalFile(ctxDir);
-      await writeExternalFile(ctxDir, "_external.yaml", nextDeps, root2.includes ?? []);
-      continue;
-    }
-    if (nextDeps.length === 0) {
-      if (isPackageExternalFile && includes.length === 0) {
-        await rm4(join14(knowledgeRoot3(ctxDir), relativePath), { force: true });
-      } else {
-        await writeExternalFile(ctxDir, relativePath, [], includes);
-      }
-      continue;
-    }
-    if (isPackageExternalFile)
-      packageIncludes.add(relativePath);
-    await writeExternalFile(ctxDir, relativePath, nextDeps, includes);
-  }
-  for (const [relativePath, nextDeps] of byPath) {
-    const includes = includesByPath.get(relativePath) ?? [];
-    if (/^entity\/[^/]+\/_external\.yaml$/u.test(relativePath) && (nextDeps.length > 0 || includes.length > 0)) {
-      packageIncludes.add(relativePath);
-    }
-  }
-  await syncRootIncludes2(ctxDir, packageIncludes);
-  return deps.length;
-}
-async function replaceExternalDepsForOwners(ctxDir, deps, owners) {
-  return replaceExternalDepsInternal(ctxDir, deps, { fromOwners: owners });
-}
-var import_yaml13;
-var init_externalDeps = __esm(() => {
-  init_atomicWrite();
-  import_yaml13 = __toESM(require_dist(), 1);
-});
-
 // src/code/codeProjectionHelpers.ts
 function stringField2(row, fields) {
   for (const field of fields) {
@@ -37746,7 +38067,7 @@ function safeTimestamp(value) {
   return value.replace(/[:.]/g, "-");
 }
 function sourceArchiveRelPath(sourceId, droppedAt) {
-  return toPosixPath2(join23("archive", "sources", safePathSegment(sourceId), safeTimestamp(droppedAt)));
+  return toPosixPath3(join23("archive", "sources", safePathSegment(sourceId), safeTimestamp(droppedAt)));
 }
 function archiveAbsPath(ctxDir, relPath) {
   return join23(ctxDir, relPath);
@@ -37769,7 +38090,7 @@ async function addArchiveEntry(input) {
   const kind = await pathKind(fromAbs);
   if (!kind)
     return;
-  const toRel = toPosixPath2(join23(input.archivePath, "raw", input.rel));
+  const toRel = toPosixPath3(join23(input.archivePath, "raw", input.rel));
   const toAbs = join23(input.ctxDir, toRel);
   await mkdir12(dirname11(toAbs), { recursive: true });
   await cp(fromAbs, toAbs, { recursive: kind === "dir" });
@@ -37792,8 +38113,8 @@ async function createDropArchive(input) {
   }
   const knowledgeBefore = [];
   for (const filePath of input.touchedKnowledgeFiles) {
-    const rel = toPosixPath2(relative6(input.ctxDir, filePath));
-    const toRel = toPosixPath2(join23(archivePath, "knowledge", "before", rel));
+    const rel = toPosixPath3(relative6(input.ctxDir, filePath));
+    const toRel = toPosixPath3(join23(archivePath, "knowledge", "before", rel));
     const toAbs = join23(input.ctxDir, toRel);
     await mkdir12(dirname11(toAbs), { recursive: true });
     await cp(filePath, toAbs);
@@ -37873,7 +38194,7 @@ async function walkArchive(absPath, relPath = "") {
     return { files: 0, bytes: 0, rawFiles: 0, knowledgeFiles: 0 };
   const s = await stat(absPath);
   if (s.isFile()) {
-    const normalized = toPosixPath2(relPath);
+    const normalized = toPosixPath3(relPath);
     return {
       files: 1,
       bytes: s.size,
@@ -37970,7 +38291,7 @@ async function summarizeRestoredSourceArchives(ctxDir) {
     for (const archiveDir of await readdir10(sourceRoot, { withFileTypes: true })) {
       if (!archiveDir.isDirectory())
         continue;
-      const archivePath = toPosixPath2(join23("archive", "sources", sourceDir.name, archiveDir.name));
+      const archivePath = toPosixPath3(join23("archive", "sources", sourceDir.name, archiveDir.name));
       const manifest = await readDropArchiveManifest(join23(sourceRoot, archiveDir.name, "manifest.yaml"));
       if (!manifest || !restoredSourceIds.has(manifest.source_id))
         continue;
@@ -41407,11 +41728,11 @@ async function hydrateSourceOwnershipPreviews(ctxDir, ownership) {
   }));
   return changed ? { ...ownership, sources } : ownership;
 }
-async function latestSnapshotHashes(ctxDir) {
+async function latestSnapshotsBySourceId(ctxDir) {
   const sources = await loadSources(ctxDir);
   return new Map(sources.sources.flatMap((source2) => {
     const latest = selectLatestSnapshot(source2.snapshots);
-    return latest === null ? [] : [[source2.id, latest.content_hash]];
+    return latest === null ? [] : [[source2.id, latest]];
   }));
 }
 function compactSourceOwnership(ownership) {
@@ -41525,8 +41846,8 @@ async function readFreshCurrentSourceOwnership(ctxDir, input = {}) {
   const ownership = await readCurrentSourceOwnership(ctxDir, input);
   if (ownership === null)
     return null;
-  const currentHashes = await latestSnapshotHashes(ctxDir);
-  const stale = staleOwnershipSourceIds(ownership, currentHashes);
+  const latestSnapshots = await latestSnapshotsBySourceId(ctxDir);
+  const stale = staleOwnershipSourceIds(ctxDir, ownership, latestSnapshots);
   if (stale.length === 0)
     return ownership;
   const refreshed = await refreshStaleSourceOwnership(ctxDir, ownership);
@@ -41550,11 +41871,19 @@ function publishedSourceOwnershipSummary(record) {
     block_count: record.ownership.summary.blocks
   };
 }
-function staleOwnershipSourceIds(ownership, currentHashes) {
-  return ownership.sources.filter((source2) => {
-    const currentHash = currentHashes.get(source2.source_id);
-    return source2.snapshot_hash === undefined || currentHash === undefined || source2.snapshot_hash !== currentHash;
-  }).map((source2) => source2.source_id);
+function staleOwnershipSourceIds(ctxDir, ownership, latestSnapshots) {
+  return ownership.sources.filter((source2) => sourceOwnershipNeedsRefresh(ctxDir, source2, latestSnapshots.get(source2.source_id))).map((source2) => source2.source_id);
+}
+function sourceOwnershipNeedsRefresh(ctxDir, source2, latest) {
+  if (source2.snapshot_hash === undefined || latest === undefined)
+    return true;
+  if (source2.snapshot_hash !== latest.content_hash)
+    return true;
+  if (latest.file !== undefined && source2.file !== latest.file)
+    return true;
+  if (!existsSync28(join31(ctxDir, source2.file)))
+    return true;
+  return source2.blocks.some((block) => !existsSync28(join31(ctxDir, block.file)));
 }
 function summarizeOwnershipSources(sources) {
   const blocks = sources.flatMap((source2) => source2.blocks);
@@ -41650,14 +41979,17 @@ function refreshedOwnershipBlock(input) {
 async function refreshStaleSourceOwnership(ctxDir, ownership) {
   const sourceFile = await loadSources(ctxDir);
   const sourceById = new Map(sourceFile.sources.map((source2) => [source2.id, source2]));
-  const currentHashes = await latestSnapshotHashes(ctxDir);
+  const latestSnapshots = new Map(sourceFile.sources.flatMap((source2) => {
+    const latest = selectLatestSnapshot(source2.snapshots);
+    return latest === null ? [] : [[source2.id, latest]];
+  }));
   const refreshedSources = [];
   let changed = false;
   for (const source2 of ownership.sources) {
-    const currentHash = currentHashes.get(source2.source_id);
-    if (currentHash === undefined || source2.snapshot_hash === undefined)
+    const latest = latestSnapshots.get(source2.source_id);
+    if (latest === undefined || source2.snapshot_hash === undefined)
       return null;
-    if (source2.snapshot_hash === currentHash) {
+    if (!sourceOwnershipNeedsRefresh(ctxDir, source2, latest)) {
       refreshedSources.push(source2);
       continue;
     }
@@ -41668,7 +42000,7 @@ async function refreshStaleSourceOwnership(ctxDir, ownership) {
     const after = await readLatestEvidenceManifest(ctxDir, entry);
     if (before === null || after === null)
       return null;
-    const file = after.snapshot_file ?? source2.file;
+    const file = after.snapshot_file ?? latest.file ?? source2.file;
     const body2 = await readEvidenceBody(ctxDir, file, entry);
     const blocks = [];
     for (const match of matchEvidenceBlocks(before, after)) {
@@ -41680,19 +42012,19 @@ async function refreshStaleSourceOwnership(ctxDir, ownership) {
         previous: previous3,
         after: match.after,
         file,
-        snapshotHash: currentHash,
+        snapshotHash: latest.content_hash,
         ...textPreview !== undefined ? { textPreview } : {}
       }) : ownershipFromHeadingPeer({
         source: source2,
         block: match.after,
         file,
-        snapshotHash: currentHash,
+        snapshotHash: latest.content_hash,
         ...textPreview !== undefined ? { textPreview } : {}
       }));
     }
     refreshedSources.push({
       source_id: source2.source_id,
-      snapshot_hash: currentHash,
+      snapshot_hash: latest.content_hash,
       file,
       blocks
     });
@@ -42192,6 +42524,363 @@ var init_verifyPromotionCleanup = __esm(() => {
   NAVIGATION_LINK_LABEL_RE = /(?:related|references?|links?|docs?|documents?|navigation|相关|关联|参考|文档|链接|导航|入口|资料)/iu;
 });
 
+// src/mdrive/verifyWorkspaceReader.ts
+import { existsSync as existsSync29 } from "node:fs";
+import { readdir as readdir14, readFile as readFile36 } from "node:fs/promises";
+import { join as join33, relative as relative9 } from "node:path";
+function isIgnoredKnowledgeMarkdown(name) {
+  return name === "_index.md" || name === "changelog.md";
+}
+async function pushUnsupportedNestedMarkdownIssues(root2, dir, issues, depth = 0) {
+  if (depth > MAX_UNSUPPORTED_NESTED_SCAN_DEPTH) {
+    issues.push({
+      severity: "error",
+      code: "file-layout-unsupported",
+      message: "knowledge node files nested under this directory are too deep to scan safely",
+      path: relative9(root2, dir).replace(/\\/g, "/")
+    });
+    return;
+  }
+  const entries = await readdir14(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const filePath = join33(dir, entry.name);
+    if (entry.isSymbolicLink())
+      continue;
+    if (entry.isDirectory()) {
+      await pushUnsupportedNestedMarkdownIssues(root2, filePath, issues, depth + 1);
+      continue;
+    }
+    if (!entry.isFile() || !entry.name.endsWith(".md") || isIgnoredKnowledgeMarkdown(entry.name))
+      continue;
+    const relativePath = relative9(root2, filePath).replace(/\\/g, "/");
+    issues.push({
+      severity: "error",
+      code: "file-layout-unsupported",
+      message: "knowledge node files must live at knowledge/<type>/<slug>.md or knowledge/<type>/<package>/<slug>.md",
+      path: relativePath
+    });
+  }
+}
+async function readParsedKnowledgeFile(root2, filePath) {
+  const relativePath = relative9(root2, filePath).replace(/\\/g, "/");
+  try {
+    const rootNode = parseNodeMarkdown(await readFile36(filePath, "utf8"));
+    const expectedSlug = slugFromKnowledgeRelativePath(relativePath);
+    if (expectedSlug !== null && expectedSlug.includes("/") && rootNode.node.id === expectedSlug) {
+      const parentSlug = expectedSlug.split("/")[0];
+      if (parentSlug) {
+        const edge2 = {
+          type: "contains",
+          from: parentSlug,
+          to: expectedSlug,
+          grounding: "directory",
+          ...rootNode.node.valid_from !== undefined ? { valid_from: rootNode.node.valid_from } : {},
+          ...rootNode.node.valid_until !== undefined ? { valid_until: rootNode.node.valid_until } : {}
+        };
+        rootNode.containsEdges = [edge2, ...rootNode.containsEdges];
+      }
+    }
+    return { filePath, relativePath, root: rootNode };
+  } catch (error) {
+    return {
+      severity: "error",
+      code: "parse-error",
+      message: error instanceof Error ? error.message : String(error),
+      path: relativePath
+    };
+  }
+}
+function pushRenderAutoBlockIssues(node3, relativePath, issues) {
+  for (const issue of node3.renderAutoBlockIssues ?? []) {
+    issues.push({
+      severity: "error",
+      code: issue.code,
+      message: `renderer auto-block "${issue.title}" is missing its closing sentinel`,
+      path: relativePath,
+      slug: node3.node.id,
+      line: issue.line,
+      next_action: "Run context compile --close after fixing the unclosed c4a:auto-block sentinel."
+    });
+  }
+  for (const child of node3.children) {
+    pushRenderAutoBlockIssues(child, relativePath, issues);
+  }
+}
+async function collectParsedWorkspace(ctxDir) {
+  const files = [];
+  const issues = [];
+  const root2 = knowledgeRoot3(ctxDir);
+  if (existsSync29(root2)) {
+    const entries = await readdir14(root2, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && entry.name === "concept") {
+        issues.push({
+          severity: "error",
+          code: "concept-directory-not-allowed",
+          message: "knowledge/concept is not supported; use knowledge/entity with the term tag for named concepts",
+          path: "knowledge/concept"
+        });
+      }
+    }
+  }
+  for (const type of NODE_TYPES) {
+    const dir = join33(root2, type);
+    if (!existsSync29(dir))
+      continue;
+    const entries = await readdir14(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile()) {
+        if (!entry.name.endsWith(".md") || isIgnoredKnowledgeMarkdown(entry.name))
+          continue;
+        const parsed = await readParsedKnowledgeFile(root2, join33(dir, entry.name));
+        if ("root" in parsed) {
+          files.push(parsed);
+          pushRenderAutoBlockIssues(parsed.root, parsed.relativePath, issues);
+        } else
+          issues.push(parsed);
+        continue;
+      }
+      if (!entry.isDirectory())
+        continue;
+      const nestedDir = join33(dir, entry.name);
+      const nestedEntries = await readdir14(nestedDir, { withFileTypes: true });
+      for (const nestedEntry of nestedEntries) {
+        if (nestedEntry.isDirectory()) {
+          await pushUnsupportedNestedMarkdownIssues(root2, join33(nestedDir, nestedEntry.name), issues);
+          continue;
+        }
+        if (!nestedEntry.isFile() || !nestedEntry.name.endsWith(".md") || isIgnoredKnowledgeMarkdown(nestedEntry.name)) {
+          continue;
+        }
+        const parsed = await readParsedKnowledgeFile(root2, join33(nestedDir, nestedEntry.name));
+        if ("root" in parsed) {
+          files.push(parsed);
+          pushRenderAutoBlockIssues(parsed.root, parsed.relativePath, issues);
+        } else
+          issues.push(parsed);
+      }
+    }
+  }
+  return { files, issues };
+}
+function collectAllNodes(files) {
+  return flattenWorkspaceNodes(files.map((file) => ({
+    filePath: file.filePath,
+    relativePath: file.relativePath,
+    root: file.root
+  })));
+}
+var MAX_UNSUPPORTED_NESTED_SCAN_DEPTH = 8;
+var init_verifyWorkspaceReader = __esm(() => {
+  init_nodeParser();
+  init_knowledge();
+  init_shared();
+});
+
+// src/mdrive/verifyRenderBlocks.ts
+import { readFile as readFile37 } from "node:fs/promises";
+import { dirname as dirname13, join as join34, resolve as resolve9 } from "node:path";
+function headingKind(line) {
+  const match = /^(#{2,6})\s+(.+?)\s*$/u.exec(line);
+  if (!match)
+    return null;
+  return AUTO_BLOCK_TITLES2.get((match[2] ?? "").trim()) ?? null;
+}
+function findBlockHeadingStart(lines, openIndex, kind) {
+  let cursor = openIndex - 1;
+  while (cursor >= 0 && (lines[cursor]?.trim() ?? "") === "")
+    cursor -= 1;
+  return cursor >= 0 && headingKind(lines[cursor] ?? "") === kind ? cursor : openIndex;
+}
+function extractAutoBlockSlices(markdown) {
+  const lines = markdown.replace(/\r\n?/g, `
+`).split(`
+`);
+  const occurrences = new Map;
+  const blocks = [];
+  for (let index2 = 0;index2 < lines.length; index2 += 1) {
+    const open2 = AUTO_BLOCK_OPEN.exec((lines[index2] ?? "").trim());
+    if (!open2)
+      continue;
+    const kind = open2[1];
+    let closeIndex = index2 + 1;
+    while (closeIndex < lines.length && (lines[closeIndex]?.trim() ?? "") !== AUTO_BLOCK_CLOSE2) {
+      closeIndex += 1;
+    }
+    if (closeIndex >= lines.length)
+      continue;
+    const start2 = findBlockHeadingStart(lines, index2, kind);
+    const occurrence = (occurrences.get(kind) ?? 0) + 1;
+    occurrences.set(kind, occurrence);
+    blocks.push({
+      key: `${kind}:${occurrence}`,
+      kind,
+      line: start2 + 1,
+      text: lines.slice(start2, closeIndex + 1).join(`
+`)
+    });
+    index2 = closeIndex;
+  }
+  return blocks;
+}
+function blockMap(blocks) {
+  return new Map(blocks.map((block) => [block.key, block]));
+}
+function issuePath(file) {
+  return file.relativePath;
+}
+function slugForLine(root2, line) {
+  let match = root2.node.id;
+  const visit2 = (node3) => {
+    if (node3.startLine !== undefined && line < node3.startLine)
+      return;
+    if (node3.endLine !== undefined && line > node3.endLine)
+      return;
+    match = node3.node.id;
+    for (const child of node3.children) {
+      visit2(child);
+    }
+  };
+  visit2(root2);
+  return match;
+}
+function pushStaleIssue(file, current, expected, issues) {
+  const block = current ?? expected;
+  if (block === undefined)
+    return;
+  issues.push({
+    severity: "error",
+    code: "render-block-stale",
+    message: `renderer auto-block ${block.key} is stale; rerun context compile --close to regenerate it`,
+    path: issuePath(file),
+    slug: slugForLine(file.root, block.line),
+    line: block.line,
+    next_action: "Run context compile --close to regenerate renderer-owned relation blocks."
+  });
+}
+function isExternalHref(href) {
+  return /^[a-z][a-z0-9+.-]*:/iu.test(href) || href.startsWith("//");
+}
+function targetKey(filePath, anchor) {
+  const resolved = resolve9(filePath);
+  return anchor !== undefined && anchor.length > 0 ? `${resolved}#${anchor}` : resolved;
+}
+function markdownHrefTarget(filePath, href) {
+  if (isExternalHref(href))
+    return null;
+  const beforeQuery = href.split("?")[0] ?? "";
+  const hashIndex = beforeQuery.indexOf("#");
+  const pathPart = hashIndex >= 0 ? beforeQuery.slice(0, hashIndex) : beforeQuery;
+  const anchor = hashIndex >= 0 ? beforeQuery.slice(hashIndex + 1) : undefined;
+  const targetPath = pathPart.length === 0 ? filePath : resolve9(dirname13(filePath), pathPart);
+  return targetKey(targetPath, anchor);
+}
+function wikiHrefTarget(ctxDir, target) {
+  const hashIndex = target.indexOf("#");
+  const rawPathPart = hashIndex >= 0 ? target.slice(0, hashIndex) : target;
+  const anchor = hashIndex >= 0 ? target.slice(hashIndex + 1) : undefined;
+  const pathPart = rawPathPart.replace(/^\/+/u, "");
+  const markdownPath = pathPart.endsWith(".md") ? pathPart : `${pathPart}.md`;
+  return targetKey(join34(knowledgeRoot3(ctxDir), markdownPath), anchor);
+}
+function validRenderNodeTargets(files) {
+  const targets = new Set;
+  for (const file of files) {
+    targets.add(targetKey(file.filePath));
+    const anchors = computeNodeAnchorsForFile(file.root);
+    for (const anchor of anchors.values()) {
+      targets.add(targetKey(file.filePath, anchor));
+    }
+  }
+  return targets;
+}
+function pushBrokenHrefIssues(ctxDir, file, block, validTargets, issues) {
+  if (block.kind === "external_dependencies")
+    return;
+  const lines = block.text.split(`
+`);
+  for (let offset = 0;offset < lines.length; offset += 1) {
+    const line = lines[offset] ?? "";
+    for (const match of line.matchAll(MARKDOWN_LINK)) {
+      const href = match[1] ?? "";
+      const target = markdownHrefTarget(file.filePath, href);
+      if (target === null || validTargets.has(target))
+        continue;
+      issues.push({
+        severity: "error",
+        code: "render-block-href-broken",
+        message: `renderer auto-block link target "${href}" does not exist`,
+        path: issuePath(file),
+        slug: slugForLine(file.root, block.line + offset),
+        line: block.line + offset,
+        next_action: "Run context compile --close to regenerate relation block links after fixing the target Node."
+      });
+    }
+    for (const match of line.matchAll(WIKI_LINK)) {
+      const target = match[1] ?? "";
+      const fileTarget = wikiHrefTarget(ctxDir, target);
+      if (validTargets.has(fileTarget))
+        continue;
+      issues.push({
+        severity: "error",
+        code: "render-block-href-broken",
+        message: `renderer auto-block wiki target "${target}" does not exist`,
+        path: issuePath(file),
+        slug: slugForLine(file.root, block.line + offset),
+        line: block.line + offset,
+        next_action: "Run context compile --close to regenerate relation block links after fixing the target Node."
+      });
+    }
+  }
+}
+async function detectRenderBlockIssues(ctxDir, files, issues) {
+  const renderContext = await buildRenderWorkspaceContext(ctxDir, files);
+  const validTargets = validRenderNodeTargets(files);
+  for (const file of files) {
+    const current = extractAutoBlockSlices(await readFile37(file.filePath, "utf8"));
+    const expected = extractAutoBlockSlices(await renderRootForFile(file.filePath, file.root, renderContext));
+    const currentByKey = blockMap(current);
+    const expectedByKey = blockMap(expected);
+    const keys = new Set([...currentByKey.keys(), ...expectedByKey.keys()]);
+    for (const key of [...keys].sort()) {
+      const currentBlock = currentByKey.get(key);
+      const expectedBlock = expectedByKey.get(key);
+      if (currentBlock?.text === expectedBlock?.text)
+        continue;
+      pushStaleIssue(file, currentBlock, expectedBlock, issues);
+    }
+    for (const block of current) {
+      pushBrokenHrefIssues(ctxDir, file, block, validTargets, issues);
+    }
+  }
+}
+async function assertNoUnclosedRenderAutoBlocks(ctxDir) {
+  const { issues } = await collectParsedWorkspace(ctxDir);
+  const unclosed = issues.filter((issue) => issue.code === "render-auto-block-unclosed");
+  if (unclosed.length === 0)
+    return;
+  throw new ContextError(ExitCode.WorkspaceStateError, "unclosed renderer auto-block sentinel", {
+    category: "schema-invalid",
+    issues: unclosed
+  });
+}
+var AUTO_BLOCK_TITLES2, AUTO_BLOCK_CLOSE2 = "<!-- /c4a:auto-block -->", AUTO_BLOCK_OPEN, MARKDOWN_LINK, WIKI_LINK;
+var init_verifyRenderBlocks = __esm(() => {
+  init_errors();
+  init_exitCode();
+  init_shared();
+  init_verifyWorkspaceReader();
+  AUTO_BLOCK_TITLES2 = new Map([
+    ["Depends On", "depends_on"],
+    ["External Dependencies", "external_dependencies"],
+    ["Used By", "used_by"],
+    ["Related", "related"]
+  ]);
+  AUTO_BLOCK_OPEN = /^<!--\s+c4a:auto-block\s+(depends_on|external_dependencies|used_by|related)\s+-->$/u;
+  MARKDOWN_LINK = /\[[^\]]+\]\(([^)]+)\)/gu;
+  WIKI_LINK = /\[\[([^|\]]+)(?:\|[^\]]+)?\]\]/gu;
+});
+
 // src/mdrive/verifyGraphRules.ts
 function edgeIssuePath(edge2) {
   return edge2.source_path ? `knowledge/${edge2.source_path}` : "knowledge/_edges.yaml";
@@ -42859,8 +43548,8 @@ var init_alignPlan = __esm(() => {
 });
 
 // src/evidence/ref.ts
-import { readFile as readFile36 } from "node:fs/promises";
-import { join as join33 } from "node:path";
+import { readFile as readFile38 } from "node:fs/promises";
+import { join as join35 } from "node:path";
 function createSourceRefResolutionCache() {
   return {
     manifests: new Map,
@@ -42952,7 +43641,7 @@ async function rawForManifestUncached(ctxDir, manifest) {
   if (!manifest.snapshot_file)
     return null;
   try {
-    const raw = await readFile36(join33(ctxDir, manifest.snapshot_file), "utf8");
+    const raw = await readFile38(join35(ctxDir, manifest.snapshot_file), "utf8");
     if (manifest.source_type === "note")
       return readNoteMetadata(raw)?.body ?? stripCaptureFrontmatter(raw);
     return stripCaptureFrontmatter(raw);
@@ -43401,9 +44090,9 @@ var init_ref = __esm(() => {
 });
 
 // src/mdrive/verifyCodeSourceRefs.ts
-import { existsSync as existsSync29 } from "node:fs";
-import { readFile as readFile37 } from "node:fs/promises";
-import { join as join34 } from "node:path";
+import { existsSync as existsSync30 } from "node:fs";
+import { readFile as readFile39 } from "node:fs/promises";
+import { join as join36 } from "node:path";
 function codeSourceRefNextAction(code3) {
   if (code3 === "code-source-ref-stale")
     return "Rerun context compile --code <slug> so generated Sections match the current raw code snapshot.";
@@ -43435,17 +44124,17 @@ function sourceSlug2(source2, snapshot) {
 }
 function snapshotDir2(ctxDir, source2, snapshot) {
   if (snapshot.dir)
-    return join34(ctxDir, snapshot.dir);
+    return join36(ctxDir, snapshot.dir);
   const slug = sourceSlug2(source2, snapshot);
   const id2 = snapshot.snapshot_id;
   if (!slug || !id2)
     return null;
-  return join34(ctxDir, "raw", "aspect", "code", slug, id2);
+  return join36(ctxDir, "raw", "aspect", "code", slug, id2);
 }
 async function readJsonl(path9) {
-  if (!existsSync29(path9))
+  if (!existsSync30(path9))
     return [];
-  const text5 = await readFile37(path9, "utf8");
+  const text5 = await readFile39(path9, "utf8");
   const rows = [];
   for (const line of text5.split(/\r?\n/u)) {
     if (line.trim().length === 0)
@@ -43478,11 +44167,11 @@ async function loadCodeSnapshotRecords(ctxDir, source2) {
     const dir = snapshotDir2(ctxDir, source2, snapshot);
     if (!dir)
       continue;
-    records.symbols.push(...annotateRows(await readJsonl(join34(dir, "symbols.jsonl")), snapshot));
-    records.digests.push(...annotateRows(await readJsonl(join34(dir, "digests.jsonl")), snapshot));
-    records.packages.push(...annotateRows(await readJsonl(join34(dir, "packages.jsonl")), snapshot));
-    records.sourceFiles.push(...annotateRows(await readJsonl(join34(dir, "source-files.jsonl")), snapshot));
-    records.edges.push(...annotateRows(await readJsonl(join34(dir, "edges.jsonl")), snapshot));
+    records.symbols.push(...annotateRows(await readJsonl(join36(dir, "symbols.jsonl")), snapshot));
+    records.digests.push(...annotateRows(await readJsonl(join36(dir, "digests.jsonl")), snapshot));
+    records.packages.push(...annotateRows(await readJsonl(join36(dir, "packages.jsonl")), snapshot));
+    records.sourceFiles.push(...annotateRows(await readJsonl(join36(dir, "source-files.jsonl")), snapshot));
+    records.edges.push(...annotateRows(await readJsonl(join36(dir, "edges.jsonl")), snapshot));
   }
   return {
     symbols: records.symbols,
@@ -43930,141 +44619,6 @@ var init_verifySourceRules = __esm(() => {
   init_verifySourceRefs();
 });
 
-// src/mdrive/verifyWorkspaceReader.ts
-import { existsSync as existsSync30 } from "node:fs";
-import { readdir as readdir14, readFile as readFile38 } from "node:fs/promises";
-import { join as join35, relative as relative9 } from "node:path";
-function isIgnoredKnowledgeMarkdown(name) {
-  return name === "_index.md" || name === "changelog.md";
-}
-async function pushUnsupportedNestedMarkdownIssues(root2, dir, issues, depth = 0) {
-  if (depth > MAX_UNSUPPORTED_NESTED_SCAN_DEPTH) {
-    issues.push({
-      severity: "error",
-      code: "file-layout-unsupported",
-      message: "knowledge node files nested under this directory are too deep to scan safely",
-      path: relative9(root2, dir).replace(/\\/g, "/")
-    });
-    return;
-  }
-  const entries = await readdir14(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const filePath = join35(dir, entry.name);
-    if (entry.isSymbolicLink())
-      continue;
-    if (entry.isDirectory()) {
-      await pushUnsupportedNestedMarkdownIssues(root2, filePath, issues, depth + 1);
-      continue;
-    }
-    if (!entry.isFile() || !entry.name.endsWith(".md") || isIgnoredKnowledgeMarkdown(entry.name))
-      continue;
-    const relativePath = relative9(root2, filePath).replace(/\\/g, "/");
-    issues.push({
-      severity: "error",
-      code: "file-layout-unsupported",
-      message: "knowledge node files must live at knowledge/<type>/<slug>.md or knowledge/<type>/<package>/<slug>.md",
-      path: relativePath
-    });
-  }
-}
-async function readParsedKnowledgeFile(root2, filePath) {
-  const relativePath = relative9(root2, filePath).replace(/\\/g, "/");
-  try {
-    const rootNode = parseNodeMarkdown(await readFile38(filePath, "utf8"));
-    const expectedSlug = slugFromKnowledgeRelativePath(relativePath);
-    if (expectedSlug !== null && expectedSlug.includes("/") && rootNode.node.id === expectedSlug) {
-      const parentSlug = expectedSlug.split("/")[0];
-      if (parentSlug) {
-        const edge2 = {
-          type: "contains",
-          from: parentSlug,
-          to: expectedSlug,
-          grounding: "directory",
-          ...rootNode.node.valid_from !== undefined ? { valid_from: rootNode.node.valid_from } : {},
-          ...rootNode.node.valid_until !== undefined ? { valid_until: rootNode.node.valid_until } : {}
-        };
-        rootNode.containsEdges = [edge2, ...rootNode.containsEdges];
-      }
-    }
-    return { filePath, relativePath, root: rootNode };
-  } catch (error) {
-    return {
-      severity: "error",
-      code: "parse-error",
-      message: error instanceof Error ? error.message : String(error),
-      path: relativePath
-    };
-  }
-}
-async function collectParsedWorkspace(ctxDir) {
-  const files = [];
-  const issues = [];
-  const root2 = knowledgeRoot2(ctxDir);
-  if (existsSync30(root2)) {
-    const entries = await readdir14(root2, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isDirectory() && entry.name === "concept") {
-        issues.push({
-          severity: "error",
-          code: "concept-directory-not-allowed",
-          message: "knowledge/concept is not supported; use knowledge/entity with the term tag for named concepts",
-          path: "knowledge/concept"
-        });
-      }
-    }
-  }
-  for (const type of NODE_TYPES) {
-    const dir = join35(root2, type);
-    if (!existsSync30(dir))
-      continue;
-    const entries = await readdir14(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isFile()) {
-        if (!entry.name.endsWith(".md") || isIgnoredKnowledgeMarkdown(entry.name))
-          continue;
-        const parsed = await readParsedKnowledgeFile(root2, join35(dir, entry.name));
-        if ("root" in parsed)
-          files.push(parsed);
-        else
-          issues.push(parsed);
-        continue;
-      }
-      if (!entry.isDirectory())
-        continue;
-      const nestedDir = join35(dir, entry.name);
-      const nestedEntries = await readdir14(nestedDir, { withFileTypes: true });
-      for (const nestedEntry of nestedEntries) {
-        if (nestedEntry.isDirectory()) {
-          await pushUnsupportedNestedMarkdownIssues(root2, join35(nestedDir, nestedEntry.name), issues);
-          continue;
-        }
-        if (!nestedEntry.isFile() || !nestedEntry.name.endsWith(".md") || isIgnoredKnowledgeMarkdown(nestedEntry.name)) {
-          continue;
-        }
-        const parsed = await readParsedKnowledgeFile(root2, join35(nestedDir, nestedEntry.name));
-        if ("root" in parsed)
-          files.push(parsed);
-        else
-          issues.push(parsed);
-      }
-    }
-  }
-  return { files, issues };
-}
-function collectAllNodes(files) {
-  return flattenWorkspaceNodes(files.map((file) => ({
-    filePath: file.filePath,
-    relativePath: file.relativePath,
-    root: file.root
-  })));
-}
-var MAX_UNSUPPORTED_NESTED_SCAN_DEPTH = 8;
-var init_verifyWorkspaceReader = __esm(() => {
-  init_nodeParser();
-  init_knowledge();
-  init_shared();
-});
-
 // src/mdrive/verify.ts
 function okFromIssues(issues) {
   return issues.every((issue) => issue.severity !== "error");
@@ -44137,6 +44691,7 @@ async function mdriveVerifyWorkspace(input) {
   }
   await detectDanglingGraphEdges(input.ctxDir, new Set(slugMap.keys()), issues);
   await detectExternalDepIssues(input.ctxDir, new Set(slugMap.keys()), issues);
+  await detectRenderBlockIssues(input.ctxDir, files, issues);
   const currentOwnership = await readCurrentSourceOwnership(input.ctxDir);
   const allowedSourcelessSlugs = alignedNoWritePlaceholderSlugs(currentOwnership);
   for (const file of files) {
@@ -44225,6 +44780,7 @@ var init_verify = __esm(() => {
   init_verifyCoverage();
   init_verifyExternalRules();
   init_verifyPromotionCleanup();
+  init_verifyRenderBlocks();
   init_verifyGraphRules();
   init_verifyNodeRules();
   init_verifySchemaRules();
@@ -44254,8 +44810,15 @@ var init_sectionDetail = __esm(() => {
 });
 
 // src/reconcile/sourceSupport.ts
+function orderedListMarkerSpans(text5) {
+  return [...text5.matchAll(ORDERED_LIST_MARKER_RE)].map((match) => ({
+    start: (match.index ?? 0) + match[0].indexOf(match[1]),
+    end: (match.index ?? 0) + match[0].indexOf(match[1]) + match[1].length
+  }));
+}
 function numbersIn(text5) {
-  return text5.match(/\b\d+(?:\.\d+)*\b/gu) ?? [];
+  const markerSpans = orderedListMarkerSpans(text5);
+  return [...text5.matchAll(NUMBER_RE)].filter((match) => !markerSpans.some((span) => (match.index ?? 0) >= span.start && (match.index ?? 0) + match[0].length <= span.end)).map((match) => match[0]);
 }
 function normalizedToken(value) {
   return normalizeMarkdown(value).trim().toLowerCase();
@@ -44745,7 +45308,7 @@ function weakSourceSupportGuidance(action, verdict) {
   }
   return " Key facts match, but this action rewrites or reanchors existing knowledge and requires direct support; choose source_ref/source_refs from the prepared evidence, split the claim, or ask the user before choosing a different final action.";
 }
-var DEFAULT_THRESHOLDS, CJK_ONLY_RE, CJK_CHAR_RE, URL_RE2, TRAILING_URL_PUNCTUATION_RE, TRAILING_HARD_TERM_PUNCTUATION_RE, TRACKING_QUERY_PARAM_RE, EN_URL_REFERENCE_LABEL_RE, CJK_URL_REFERENCE_LABEL_RE, CONSTRAINT_PATTERNS, PLACEHOLDER_ANCHOR_PARTS;
+var NUMBER_RE, ORDERED_LIST_MARKER_RE, DEFAULT_THRESHOLDS, CJK_ONLY_RE, CJK_CHAR_RE, URL_RE2, TRAILING_URL_PUNCTUATION_RE, TRAILING_HARD_TERM_PUNCTUATION_RE, TRACKING_QUERY_PARAM_RE, EN_URL_REFERENCE_LABEL_RE, CJK_URL_REFERENCE_LABEL_RE, CONSTRAINT_PATTERNS, PLACEHOLDER_ANCHOR_PARTS;
 var init_sourceSupport = __esm(() => {
   init_normalize();
   init_sectionDetail();
@@ -44753,6 +45316,8 @@ var init_sourceSupport = __esm(() => {
   init_ref();
   init_rawBlocks();
   init_terms();
+  NUMBER_RE = /\b\d+(?:\.\d+)*\b/gu;
+  ORDERED_LIST_MARKER_RE = /(?:^|\n)[ \t]{0,3}(\d{1,3})(?:[.)]|[、．。])(?=[ \t]+)/gu;
   DEFAULT_THRESHOLDS = { supported: 0.75, weak: 0.5 };
   CJK_ONLY_RE = /^[\u4e00-\u9fff]+$/u;
   CJK_CHAR_RE = /[\u4e00-\u9fff]/gu;
@@ -45011,8 +45576,8 @@ var init_dropSemantic = __esm(() => {
 });
 
 // src/reconcile/evidence.ts
-import { readFile as readFile39 } from "node:fs/promises";
-import { join as join36 } from "node:path";
+import { readFile as readFile40 } from "node:fs/promises";
+import { join as join37 } from "node:path";
 function sourceRefAliasIndex(sourceRef) {
   const match = /^src-(\d+)#/u.exec(sourceRef.trim());
   return match ? Number(match[1]) - 1 : null;
@@ -45112,7 +45677,7 @@ async function evidenceSpansForSnapshotSourceRef(input) {
   if (combinedEvidenceBlockHash(manifestBlocks) !== sourceRefHash) {
     throw new Error(`${input.action} source_ref "${input.sourceRef}" does not match the cited evidence block hash`);
   }
-  const raw = await readFile39(join36(input.ctxDir, input.snapshot.file), "utf8");
+  const raw = await readFile40(join37(input.ctxDir, input.snapshot.file), "utf8");
   const note = input.source.type === "note" ? readNoteMetadata(raw) : undefined;
   const body2 = note !== undefined ? note.body : stripCaptureFrontmatter(raw);
   const spans = extractRawBlocks(body2).flatMap((block) => {
@@ -45152,7 +45717,7 @@ async function evidenceSpansForSnapshotSourceRange(input) {
   if (rangeHash === null) {
     throw new Error(`${input.action} source_ref "${input.sourceRef}" does not overlap a reliable raw block`);
   }
-  const raw = await readFile39(join36(input.ctxDir, input.snapshot.file), "utf8");
+  const raw = await readFile40(join37(input.ctxDir, input.snapshot.file), "utf8");
   const note = input.source.type === "note" ? readNoteMetadata(raw) : undefined;
   const body2 = note !== undefined ? note.body : stripCaptureFrontmatter(raw);
   const minLine = Math.min(...manifestBlocks.map((block) => block.line_start));
@@ -45347,13 +45912,13 @@ var init_evidence = __esm(() => {
 import { existsSync as existsSync31 } from "node:fs";
 import { execFile as execFile2 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
-import { readFile as readFile40 } from "node:fs/promises";
+import { readFile as readFile41 } from "node:fs/promises";
 import { relative as relative10 } from "node:path";
 function changelogPath(ctxDir) {
-  return `${knowledgeRoot2(ctxDir)}/changelog.md`;
+  return `${knowledgeRoot3(ctxDir)}/changelog.md`;
 }
 function indexPath(ctxDir) {
-  return `${knowledgeRoot2(ctxDir)}/_index.md`;
+  return `${knowledgeRoot3(ctxDir)}/_index.md`;
 }
 async function mdriveWorkspaceStats(input) {
   const nodes = flattenWorkspaceNodes(await readWorkspaceNodeFiles(input.ctxDir));
@@ -45422,7 +45987,7 @@ async function mdriveWorkspaceRebuildIndex(input) {
 }
 async function mdriveWorkspaceAppendChangelog(input) {
   const path9 = changelogPath(input.ctxDir);
-  const existing = existsSync31(path9) ? await readFile40(path9, "utf8") : `# Knowledge Changelog
+  const existing = existsSync31(path9) ? await readFile41(path9, "utf8") : `# Knowledge Changelog
 
 `;
   const trimmed = existing.endsWith(`
@@ -45433,7 +45998,7 @@ async function mdriveWorkspaceAppendChangelog(input) {
 }
 async function mdriveWorkspaceRebuildChangelog(input) {
   const workspaceRoot = workspaceRootFromCtxDir(input.ctxDir);
-  const relKnowledgePath = relative10(workspaceRoot, knowledgeRoot2(input.ctxDir));
+  const relKnowledgePath = relative10(workspaceRoot, knowledgeRoot3(input.ctxDir));
   try {
     const { stdout } = await execFileAsync2("git", [
       "-C",
@@ -45461,16 +46026,11 @@ ${entries.join(`
   }
 }
 async function mdriveWorkspaceCompact(input) {
+  await assertNoUnclosedRenderAutoBlocks(input.ctxDir);
   const files = await readWorkspaceNodeFiles(input.ctxDir);
-  const graphEdges = await loadKnowledgeGraphEdges(input.ctxDir);
   const renderContext = await buildRenderWorkspaceContext(input.ctxDir, files);
   for (const file of files) {
-    const relatedLinks = renderContext.relatedLinksByFile.get(file.filePath);
-    await atomicWriteText(file.filePath, renderNodeMarkdown({
-      ...file.root,
-      graphEdges,
-      ...relatedLinks !== undefined ? { relatedLinks } : {}
-    }));
+    await atomicRewriteRootFile(file.filePath, file.root, undefined, renderContext);
   }
 }
 async function canonicalizeSourceRefsInNode(ctxDir, node3, cache) {
@@ -45508,38 +46068,31 @@ async function mdriveWorkspaceCanonicalizeSourceRefs(input) {
   }
   if (updates === 0)
     return 0;
-  const graphEdges = await loadKnowledgeGraphEdges(input.ctxDir);
   const renderContext = await buildRenderWorkspaceContext(input.ctxDir, files);
   for (const file of files) {
     if (!changed.has(file.filePath))
       continue;
-    const relatedLinks = renderContext.relatedLinksByFile.get(file.filePath);
-    await atomicWriteText(file.filePath, renderNodeMarkdown({
-      ...file.root,
-      graphEdges,
-      ...relatedLinks !== undefined ? { relatedLinks } : {}
-    }));
+    await atomicRewriteRootFile(file.filePath, file.root, undefined, renderContext);
   }
   return updates;
 }
 var execFileAsync2;
 var init_workspace = __esm(() => {
   init_normalize();
-  init_nodeRenderer();
   init_workspaceLayout();
   init_ref();
   init_shared();
-  init_graphEdges();
+  init_verifyRenderBlocks();
   execFileAsync2 = promisify3(execFile2);
 });
 
 // src/workflow/workflowOutputPaths.ts
-import { join as join42 } from "node:path";
+import { join as join43 } from "node:path";
 function workflowOutputDir(ctxDir, kind) {
-  return join42(ctxDir, "output", kind);
+  return join43(ctxDir, "output", kind);
 }
 function workflowOutputPath(ctxDir, kind, fileName) {
-  return join42(workflowOutputDir(ctxDir, kind), fileName);
+  return join43(workflowOutputDir(ctxDir, kind), fileName);
 }
 function workflowOutputPathForFile(ctxDir, fileName) {
   return workflowOutputPath(ctxDir, workflowOutputKindForFile(fileName), fileName);
@@ -45586,13 +46139,13 @@ var init_dropPlanPayload = __esm(() => {
 
 // src/workflow/compileKnowledgeState.ts
 import { existsSync as existsSync36 } from "node:fs";
-import { readFile as readFile48 } from "node:fs/promises";
-import { join as join45 } from "node:path";
+import { readFile as readFile49 } from "node:fs/promises";
+import { join as join46 } from "node:path";
 async function readLastCompileAt(ctxDir) {
-  const path9 = join45(ctxDir, "knowledge", "changelog.md");
+  const path9 = join46(ctxDir, "knowledge", "changelog.md");
   if (!existsSync36(path9))
     return null;
-  const lines = (await readFile48(path9, "utf8")).split(`
+  const lines = (await readFile49(path9, "utf8")).split(`
 `).filter((line) => line.includes("[compile]"));
   for (let index2 = lines.length - 1;index2 >= 0; index2 -= 1) {
     const stamp = /@\s*([0-9]{4}-[0-9]{2}-[0-9]{2}(?:T[0-9:.+-]+Z?)?)/u.exec(lines[index2] ?? "")?.[1];
@@ -45909,7 +46462,7 @@ function ignoredLocatorChangeFromDiff(input) {
 }
 
 // src/workflow/compileChangesRaw.ts
-import { readFile as readFile49 } from "node:fs/promises";
+import { readFile as readFile50 } from "node:fs/promises";
 function isRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -45923,7 +46476,7 @@ function isRawBlocksCache2(value) {
   return Object.values(value.snapshots).every((snapshot) => isRecord15(snapshot) && typeof snapshot.source_id === "string" && typeof snapshot.snapshot_file === "string" && typeof snapshot.content_hash === "string" && typeof snapshot.hash_id === "string" && typeof snapshot.structure_hash === "string" && Array.isArray(snapshot.blocks) && snapshot.blocks.every(isRawBlock2));
 }
 async function readJsonFile2(path9) {
-  return JSON.parse(await readFile49(path9, "utf8"));
+  return JSON.parse(await readFile50(path9, "utf8"));
 }
 async function loadRawBlocks2(path9) {
   let parsed;
@@ -46506,10 +47059,10 @@ var init_node2 = __esm(() => {
 // src/workflow/coverage.ts
 import { createHash as createHash8 } from "node:crypto";
 import { existsSync as existsSync37 } from "node:fs";
-import { mkdir as mkdir22, readFile as readFile50 } from "node:fs/promises";
-import { dirname as dirname16, join as join46 } from "node:path";
+import { mkdir as mkdir22, readFile as readFile51 } from "node:fs/promises";
+import { dirname as dirname17, join as join47 } from "node:path";
 function coverageStatePath(ctxDir) {
-  return join46(ctxDir, "output", "workflows", "_coverage", "workspace", "coverage-state.json");
+  return join47(ctxDir, "output", "workflows", "_coverage", "workspace", "coverage-state.json");
 }
 function shortHash3(value) {
   return createHash8("sha256").update(value).digest("hex").slice(0, 16);
@@ -46666,7 +47219,7 @@ async function readCoverageStateFile(ctxDir) {
   if (!existsSync37(path9))
     return emptyState();
   try {
-    const parsed = JSON.parse(await readFile50(path9, "utf8"));
+    const parsed = JSON.parse(await readFile51(path9, "utf8"));
     if (parsed.schema_version !== COVERAGE_STATE_SCHEMA_VERSION || !Array.isArray(parsed.candidates)) {
       throw coverageStateInvalid("coverage state is invalid or uses an unsupported schema version");
     }
@@ -46727,7 +47280,7 @@ function mergeDispositions(existing, incoming) {
 }
 async function writeCoverageStateFile(ctxDir, state) {
   const path9 = coverageStatePath(ctxDir);
-  await mkdir22(dirname16(path9), { recursive: true });
+  await mkdir22(dirname17(path9), { recursive: true });
   await atomicWriteFile(path9, `${JSON.stringify(state, null, 2)}
 `);
 }
@@ -47571,6 +48124,12 @@ async function computeCompileChanges(options) {
   }
   const alignNodes = alignResult.nodes;
   const sourcesFile = await loadSources(options.ctxDir);
+  const inputSummary = await buildWorkspaceInputSummary({ ctxDir: options.ctxDir, workspaceRoot: paths.workspaceRoot, sourcesFile });
+  const cacheRead = await readIncrementalCache({
+    workspaceRoot,
+    ...options.cacheHome !== undefined ? { cacheHome: options.cacheHome } : {},
+    inputSummary
+  });
   const sourcesById = new Map(sourcesFile.sources.map((source2) => [source2.id, source2]));
   const ignoredSources = await compileIgnoredSourceIds({ ctxDir: options.ctxDir, explicit: options.ignoreSourceIds ?? [] });
   const finalizedOwnership = await readCurrentSourceOwnership(options.ctxDir, {
@@ -47619,6 +48178,18 @@ async function computeCompileChanges(options) {
       await writeCompileState({ paths, output: output2, now });
     return output2;
   }
+  const cacheNeedsRebuild = cacheRead.status !== "ready" && cacheRead.status !== "missing";
+  if (options.writeState === false && cacheNeedsRebuild) {
+    const unknown2 = globalUnknownNodes(alignNodes, sourceIdsByNode, cacheRead.reason);
+    return createCompileChangesOutput({
+      now,
+      nodes: unknown2.nodes,
+      sourcesChecked: 0,
+      sourcesUnchanged: 0,
+      sourcesContentChanged: 0,
+      unknownInputs: unknown2.unknownInputs
+    });
+  }
   let rawBlocksResult = await loadRawBlocks2(paths.rawBlocks);
   let fingerprintResult = await loadSectionFingerprints(paths.sectionFingerprints);
   const knowledgeState = await readCompileKnowledgeState(options.ctxDir);
@@ -47638,7 +48209,7 @@ async function computeCompileChanges(options) {
   }
   let noPriorFingerprints = fingerprintResult.status === "unknown-input" && fingerprintResult.reason === "section-fingerprints-missing";
   const needsFingerprints = alignNodes.some((node3) => knowledgeState.state.sectionNodeSlugs.has(node3.slug));
-  if (options.writeState !== false && shouldSelfHealCache({ rawBlocksResult, fingerprintResult, needsFingerprints })) {
+  if (options.writeState !== false && (cacheNeedsRebuild || shouldSelfHealCache({ rawBlocksResult, fingerprintResult, needsFingerprints }))) {
     try {
       await rebuildWorkspaceIncrementalCache({
         ctxDir: options.ctxDir,
@@ -48735,8 +49306,8 @@ var init_fullTextPaging = __esm(() => {
 
 // src/workflow/compileFinalizedContext.ts
 import { existsSync as existsSync44 } from "node:fs";
-import { readFile as readFile55 } from "node:fs/promises";
-import { join as join53 } from "node:path";
+import { readFile as readFile56 } from "node:fs/promises";
+import { join as join54 } from "node:path";
 function finalizedContextSourceIds(ownership, slug) {
   const evidenceSources = new Set;
   const contextSources = new Set;
@@ -48790,11 +49361,11 @@ function entryRole(block, slug) {
   return "unresolved";
 }
 async function rawBody(ctxDir, file, source2) {
-  const path9 = join53(ctxDir, file);
+  const path9 = join54(ctxDir, file);
   if (!existsSync44(path9))
     return null;
   try {
-    const raw = (await readFile55(path9, "utf8")).replace(/\r\n/g, `
+    const raw = (await readFile56(path9, "utf8")).replace(/\r\n/g, `
 `);
     if (source2?.type === "note") {
       const note = readNoteMetadata(raw);
@@ -49382,8 +49953,8 @@ var init_compileRuntimeHints = __esm(() => {
 });
 
 // src/workflow/compileContext.ts
-import { readFile as readFile56 } from "node:fs/promises";
-import { join as join54 } from "node:path";
+import { readFile as readFile57 } from "node:fs/promises";
+import { join as join55 } from "node:path";
 function compileAlignNodeFromKnowledge(node3) {
   return {
     slug: node3.id,
@@ -49586,7 +50157,7 @@ async function readChangedBlockSnippet(ctxDir, block, source2, aliasIndex2) {
   if (file.length === 0)
     return fallback;
   try {
-    const raw = await readFile56(join54(ctxDir, file), "utf8");
+    const raw = await readFile57(join55(ctxDir, file), "utf8");
     let note;
     if (source2?.type === "note") {
       try {
@@ -51028,8 +51599,8 @@ var init_locatedNodeSources = __esm(() => {
 
 // src/reconcile/prepareCompileArchiveCandidates.ts
 import { existsSync as existsSync45 } from "node:fs";
-import { readdir as readdir21, readFile as readFile57 } from "node:fs/promises";
-import { join as join55 } from "node:path";
+import { readdir as readdir21, readFile as readFile58 } from "node:fs/promises";
+import { join as join56 } from "node:path";
 function sourceIdForSection3(nodeSources, sourceRef) {
   const index2 = sourceRefAliasIndex(sourceRef);
   if (index2 === null || index2 < 0)
@@ -51044,7 +51615,7 @@ async function readDropArchiveManifest2(path9) {
   if (!existsSync45(path9))
     return null;
   try {
-    const parsed = import_yaml29.default.parse(await readFile57(path9, "utf8"));
+    const parsed = import_yaml29.default.parse(await readFile58(path9, "utf8"));
     if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && parsed.kind === "source-drop" && typeof parsed.source_id === "string") {
       return parsed;
     }
@@ -51086,31 +51657,31 @@ async function restoredArchiveCandidatesForNode(ctxDir, targetNode) {
   const restoredSourceIds = new Set(sourcesFile.sources.filter((source2) => source2.status === "active" && typeof source2.restored_at === "string").map((source2) => source2.id));
   if (restoredSourceIds.size === 0)
     return [];
-  const sourcesRoot = join55(ctxDir, "archive", "sources");
+  const sourcesRoot = join56(ctxDir, "archive", "sources");
   if (!existsSync45(sourcesRoot))
     return [];
   const out2 = [];
   for (const sourceDir of await readdir21(sourcesRoot, { withFileTypes: true })) {
     if (!sourceDir.isDirectory())
       continue;
-    const sourceRoot = join55(sourcesRoot, sourceDir.name);
+    const sourceRoot = join56(sourcesRoot, sourceDir.name);
     for (const archiveDir of await readdir21(sourceRoot, { withFileTypes: true })) {
       if (!archiveDir.isDirectory())
         continue;
       const archivePath = `archive/sources/${sourceDir.name}/${archiveDir.name}`;
-      const manifest = await readDropArchiveManifest2(join55(ctxDir, archivePath, "manifest.yaml"));
+      const manifest = await readDropArchiveManifest2(join56(ctxDir, archivePath, "manifest.yaml"));
       if (!manifest || !restoredSourceIds.has(manifest.source_id))
         continue;
       const knowledgeBefore = Array.isArray(manifest.knowledge_before) ? manifest.knowledge_before : [];
       for (const relPath of knowledgeBefore) {
         if (!isSafeRelativePath(relPath))
           continue;
-        const absPath = join55(ctxDir, relPath);
+        const absPath = join56(ctxDir, relPath);
         if (!existsSync45(absPath))
           continue;
         let parsed;
         try {
-          parsed = parseNodeMarkdown(await readFile57(absPath, "utf8"));
+          parsed = parseNodeMarkdown(await readFile58(absPath, "utf8"));
         } catch {
           continue;
         }
@@ -51291,7 +51862,7 @@ function defaultDecisionForCompileDraftAction(input) {
 
 // src/mdrive/section.ts
 import { existsSync as existsSync46 } from "node:fs";
-import { join as join56 } from "node:path";
+import { join as join57 } from "node:path";
 function locateNode(ctxDir, nodeSlug) {
   return readWorkspaceNodeFiles(ctxDir).then((files) => findLocatedNode(flattenWorkspaceNodes(files), nodeSlug));
 }
@@ -51519,7 +52090,7 @@ async function resolveSourceRefCandidates(input) {
     const latest = await getLatestSnapshot(input.ctxDir, sourceId);
     if (!latest?.file)
       continue;
-    const fullPath = join56(input.ctxDir, latest.file);
+    const fullPath = join57(input.ctxDir, latest.file);
     if (existsSync46(fullPath))
       candidateFiles.push({ sourceId, path: fullPath });
   }
@@ -52623,9 +53194,11 @@ var init_agentHintRegistry = __esm(() => {
     "align-entity-tag-term-mixed-with-a-b",
     "align-finalize-node-without-citation-evidence",
     "align-finalize-patch-invalid",
+    "align-block-preview-truncated",
     "align-ownership-patch-base-digest-stale",
     "align-ownership-patch-invalid",
     "align-segments-required",
+    "align-segments-source-mapping",
     "align-scope-name-entity-warning",
     "align-structure-decision-invalid",
     "align-workflow-review-pending",
@@ -53123,14 +53696,14 @@ var init_agentHints = __esm(() => {
 // src/workflow/outputArchive.ts
 import { existsSync as existsSync47 } from "node:fs";
 import { copyFile as copyFile3, mkdir as mkdir24, readdir as readdir22, realpath as realpath2, rename as rename5, unlink as unlink4 } from "node:fs/promises";
-import { dirname as dirname20, isAbsolute as isAbsolute6, join as join57, relative as relative13, resolve as resolve12 } from "node:path";
+import { dirname as dirname21, isAbsolute as isAbsolute6, join as join58, relative as relative14, resolve as resolve13 } from "node:path";
 function archiveStamp(now) {
   return now.toISOString().replace(/[:.]/g, "-");
 }
 async function uniqueArchiveDir(ctxDir, category, now) {
-  const archiveRoot = join57(ctxDir, "output", "archive");
+  const archiveRoot = join58(ctxDir, "output", "archive");
   await mkdir24(archiveRoot, { recursive: true });
-  const base = join57(archiveRoot, `${archiveStamp(now)}-${category}`);
+  const base = join58(archiveRoot, `${archiveStamp(now)}-${category}`);
   if (!existsSync47(base))
     return base;
   for (let index2 = 2;; index2 += 1) {
@@ -53147,7 +53720,7 @@ function normalizeOutputRelPath(name) {
   return normalized;
 }
 async function listOutputFiles(outputDir, relDir = "") {
-  const dir = join57(outputDir, relDir);
+  const dir = join58(outputDir, relDir);
   const entries = await readdir22(dir, { withFileTypes: true }).catch(() => []);
   const out2 = [];
   for (const entry of entries) {
@@ -53172,7 +53745,7 @@ function patternMatches(pattern, relPath) {
 async function listMatchingOutputFiles(ctxDir, patterns) {
   if (patterns.length === 0)
     return [];
-  const outputDir = join57(ctxDir, "output");
+  const outputDir = join58(ctxDir, "output");
   return (await listOutputFiles(outputDir)).filter((relPath) => patterns.some((pattern) => patternMatches(pattern, relPath)));
 }
 function uniqueNames(names) {
@@ -53180,7 +53753,7 @@ function uniqueNames(names) {
 }
 async function uniqueExternalCopies(ctxDir, copies) {
   const out2 = new Map;
-  const realCtxDir = await realpath2(ctxDir).catch(() => resolve12(ctxDir));
+  const realCtxDir = await realpath2(ctxDir).catch(() => resolve13(ctxDir));
   for (const copy of copies) {
     const to = normalizeOutputRelPath(copy.to);
     if (to.length === 0 || !existsSync47(copy.from))
@@ -53189,7 +53762,7 @@ async function uniqueExternalCopies(ctxDir, copies) {
       throw new Error(`archive copyExternal.from must be an absolute path: ${copy.from}`);
     }
     const realFrom = await realpath2(copy.from);
-    const rel = relative13(realCtxDir, realFrom);
+    const rel = relative14(realCtxDir, realFrom);
     if (rel === "" || rel.startsWith("..") || isAbsolute6(rel)) {
       throw new Error(`archive copyExternal.from must stay inside the workspace: ${copy.from}`);
     }
@@ -53206,31 +53779,31 @@ async function safeMove(src, dest) {
   }
 }
 async function archiveOutputArtifacts(options) {
-  const outputDir = join57(options.ctxDir, "output");
+  const outputDir = join58(options.ctxDir, "output");
   const move = uniqueNames([
     ...options.move ?? [],
     ...await listMatchingOutputFiles(options.ctxDir, options.movePatterns ?? [])
-  ]).filter((name) => existsSync47(join57(outputDir, name)));
+  ]).filter((name) => existsSync47(join58(outputDir, name)));
   const copy = uniqueNames([
     ...options.copy ?? [],
     ...await listMatchingOutputFiles(options.ctxDir, options.copyPatterns ?? [])
-  ]).filter((name) => existsSync47(join57(outputDir, name)) && !move.includes(name));
+  ]).filter((name) => existsSync47(join58(outputDir, name)) && !move.includes(name));
   const copyExternal = (await uniqueExternalCopies(options.ctxDir, options.copyExternal ?? [])).filter((entry) => !move.includes(entry.to) && !copy.includes(entry.to));
   if (move.length === 0 && copy.length === 0 && copyExternal.length === 0)
     return null;
   const archiveDir = await uniqueArchiveDir(options.ctxDir, options.category, options.now ?? new Date);
   await mkdir24(archiveDir, { recursive: true });
   for (const name of copy) {
-    await mkdir24(dirname20(join57(archiveDir, name)), { recursive: true });
-    await copyFile3(join57(outputDir, name), join57(archiveDir, name));
+    await mkdir24(dirname21(join58(archiveDir, name)), { recursive: true });
+    await copyFile3(join58(outputDir, name), join58(archiveDir, name));
   }
   for (const entry of copyExternal) {
-    await mkdir24(dirname20(join57(archiveDir, entry.to)), { recursive: true });
-    await copyFile3(entry.from, join57(archiveDir, entry.to));
+    await mkdir24(dirname21(join58(archiveDir, entry.to)), { recursive: true });
+    await copyFile3(entry.from, join58(archiveDir, entry.to));
   }
   for (const name of move) {
-    await mkdir24(dirname20(join57(archiveDir, name)), { recursive: true });
-    await safeMove(join57(outputDir, name), join57(archiveDir, name));
+    await mkdir24(dirname21(join58(archiveDir, name)), { recursive: true });
+    await safeMove(join58(outputDir, name), join58(archiveDir, name));
   }
   return { archiveDir, moved: move, copied: [...copy, ...copyExternal.map((entry) => entry.to)] };
 }
@@ -53238,9 +53811,9 @@ var init_outputArchive = () => {};
 
 // src/workflow/compileCloseFinalizedNodes.ts
 import { existsSync as existsSync48 } from "node:fs";
-import { join as join58 } from "node:path";
+import { join as join59 } from "node:path";
 function finalizedNodePath(ctxDir, node3) {
-  return join58(ctxDir, "knowledge", node3.type, `${node3.slug}.md`);
+  return join59(ctxDir, "knowledge", node3.type, `${node3.slug}.md`);
 }
 function noWriteContextSources(node3) {
   return [...new Set([
@@ -53337,8 +53910,8 @@ var init_compileCloseFinalizedNodes = __esm(() => {
 
 // src/workflow/compileCloseDebt.ts
 import { existsSync as existsSync49 } from "node:fs";
-import { readFile as readFile58, readdir as readdir23 } from "node:fs/promises";
-import { join as join59 } from "node:path";
+import { readFile as readFile59, readdir as readdir23 } from "node:fs/promises";
+import { join as join60 } from "node:path";
 function coverageDebtItems(status) {
   return status.candidates.filter((candidate) => candidate.status === "unresolved" && candidate.coverage_type !== "context").map((candidate) => ({
     debt_type: "coverage",
@@ -53419,23 +53992,23 @@ async function orphanKnowledgeDebtItems(ctxDir) {
   return out2;
 }
 async function readWorkflowPayloadFiles(ctxDir, payloadBaseName) {
-  const root2 = join59(ctxDir, "output", "workflows");
+  const root2 = join60(ctxDir, "output", "workflows");
   if (!existsSync49(root2))
     return [];
   const out2 = [];
   for (const workflowEntry of await readdir23(root2, { withFileTypes: true })) {
     if (!workflowEntry.isDirectory())
       continue;
-    const workflowDir = join59(root2, workflowEntry.name);
+    const workflowDir = join60(root2, workflowEntry.name);
     for (const scopeEntry of await readdir23(workflowDir, { withFileTypes: true }).catch(() => [])) {
       if (!scopeEntry.isDirectory())
         continue;
-      const scopeDir = join59(workflowDir, scopeEntry.name);
+      const scopeDir = join60(workflowDir, scopeEntry.name);
       for (const format of ["json", "yaml"]) {
-        const path9 = join59(scopeDir, `${payloadBaseName}.${format}`);
+        const path9 = join60(scopeDir, `${payloadBaseName}.${format}`);
         if (!existsSync49(path9))
           continue;
-        const body2 = await readFile58(path9, "utf8");
+        const body2 = await readFile59(path9, "utf8");
         out2.push(format === "json" ? JSON.parse(body2) : import_yaml30.default.parse(body2));
       }
     }
@@ -53460,7 +54033,7 @@ var init_compileCloseDebt = __esm(() => {
 });
 
 // src/workflow/compileCloseDraftScratch.ts
-import { readFile as readFile59 } from "node:fs/promises";
+import { readFile as readFile60 } from "node:fs/promises";
 async function hasOnlyNoopCompileDraft(input) {
   if (input.draftPaths.length === 0)
     return false;
@@ -53474,7 +54047,7 @@ async function hasOnlyNoopDraftScratch(input) {
   const current = await mdriveNodeShow({ ctxDir: input.ctxDir, slug: input.node }).catch(() => null);
   const sections = new Map((current?.sections ?? []).map((section) => [section.id, section]));
   for (const draftPath of input.draftPaths) {
-    const draft = normalizeCompileDraftInput(import_yaml31.default.parse(await readFile59(draftPath, "utf8")));
+    const draft = normalizeCompileDraftInput(import_yaml31.default.parse(await readFile60(draftPath, "utf8")));
     if (!isRecord21(draft) || !Array.isArray(draft.actions))
       return false;
     for (const action of draft.actions) {
@@ -53531,28 +54104,28 @@ var init_compileCloseDraftScratch = __esm(() => {
 
 // src/workflow/compileClose.ts
 import { existsSync as existsSync50 } from "node:fs";
-import { readFile as readFile60, readdir as readdir24, rm as rm17 } from "node:fs/promises";
-import { join as join60 } from "node:path";
+import { readFile as readFile61, readdir as readdir24, rm as rm17 } from "node:fs/promises";
+import { join as join61 } from "node:path";
 function knowledgePath(ctxDir, name) {
-  return join60(ctxDir, "knowledge", name);
+  return join61(ctxDir, "knowledge", name);
 }
 async function snapshotFile(path9) {
-  return existsSync50(path9) ? { path: path9, content: await readFile60(path9, "utf8") } : { path: path9 };
+  return existsSync50(path9) ? { path: path9, content: await readFile61(path9, "utf8") } : { path: path9 };
 }
 async function snapshotCompileCloseFiles(ctxDir) {
   const paths = new Set([
     knowledgePath(ctxDir, "_index.md"),
     knowledgePath(ctxDir, "changelog.md"),
-    join60(ctxDir, "knowledge", "_edges.yaml")
+    join61(ctxDir, "knowledge", "_edges.yaml")
   ]);
   for (const type of NODE_TYPES) {
-    const dir = join60(ctxDir, "knowledge", type);
+    const dir = join61(ctxDir, "knowledge", type);
     if (!existsSync50(dir))
       continue;
     const entries = await readdir24(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".md")) {
-        paths.add(join60(dir, entry.name));
+        paths.add(join61(dir, entry.name));
       }
     }
   }
@@ -53573,7 +54146,7 @@ async function readLastCompileAt2(ctxDir) {
   const changelog = knowledgePath(ctxDir, "changelog.md");
   if (!existsSync50(changelog))
     return null;
-  const lines = (await readFile60(changelog, "utf8")).split(`
+  const lines = (await readFile61(changelog, "utf8")).split(`
 `).filter((line) => line.includes("[compile]"));
   for (let index2 = lines.length - 1;index2 >= 0; index2 -= 1) {
     const stamp = /@\s*([0-9]{4}-[0-9]{2}-[0-9]{2}(?:T[0-9:.+-]+Z?)?)/u.exec(lines[index2] ?? "")?.[1];
@@ -53617,7 +54190,7 @@ async function compileDraftScratchEntries(ctxDir) {
       continue;
     const match = /^compile\.(.+)\.draft\.(?:json|ya?ml)$/u.exec(entry.name);
     if (match?.[1])
-      out2.push({ slug: match[1], path: join60(outputDir, entry.name) });
+      out2.push({ slug: match[1], path: join61(outputDir, entry.name) });
   }
   return out2;
 }
@@ -53932,6 +54505,7 @@ async function compileCloseInner(options) {
     pendingCompileNodes: beforeCache.state.pending_compile.nodes ?? []
   });
   await assertNoUnownedSourceOwnership(options.ctxDir);
+  await assertNoUnclosedRenderAutoBlocks(options.ctxDir);
   const coverageStatus = await readAndPruneCoverageWorkspaceStatus(options.ctxDir);
   const retractedNodes = await retractRemovedFinalizedNodes(options.ctxDir);
   const createdContainerDomains = await ensureFinalizedContainerDomains(options.ctxDir, now);
@@ -54055,6 +54629,7 @@ var init_compileClose = __esm(() => {
   init_temporal();
   init_workspaceLayout();
   init_verify();
+  init_verifyRenderBlocks();
   init_ledger();
   init_semanticLedgerGc();
   init_workspace();
@@ -56008,7 +56583,7 @@ var init_prepareRefresh = __esm(() => {
 });
 
 // src/reconcile/prepare.ts
-import { readFile as readFile61 } from "node:fs/promises";
+import { readFile as readFile62 } from "node:fs/promises";
 async function ensureRetrievalIndex2(input) {
   const read = await readRetrievalIndex(input);
   if (read.status === "ready" && read.index)
@@ -56042,7 +56617,7 @@ async function prepareRetrieval(input) {
 async function readJsonOrYaml(path9) {
   let raw;
   try {
-    raw = await readFile61(path9, "utf8");
+    raw = await readFile62(path9, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
       throw new ContextError(ExitCode.UserError, `file not found: ${path9}`, {
@@ -56163,7 +56738,7 @@ var init_prepare = __esm(() => {
 
 // src/cli.ts
 import { existsSync as existsSync54, readFileSync as readFileSync3, realpathSync as realpathSync2 } from "node:fs";
-import { dirname as dirname27, join as join69 } from "node:path";
+import { dirname as dirname28, join as join70 } from "node:path";
 import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL3 } from "node:url";
 
 // ../../node_modules/.bun/commander@11.1.0/node_modules/commander/esm.mjs
@@ -57080,6 +57655,7 @@ function verifyIssueAgentView(issue) {
     location: semanticIssueLocation(issue),
     ...issue.slug !== undefined ? { node_slug: issue.slug } : {},
     ...issue.sectionId !== undefined ? { section_id: issue.sectionId } : {},
+    ...issue.line !== undefined ? { line: issue.line } : {},
     ...issue.next_action !== undefined ? { next_action: issue.next_action } : {}
   };
 }
@@ -62132,7 +62708,7 @@ init_exitCode();
 var import_yaml25 = __toESM(require_dist(), 1);
 import { createInterface as createInterface2 } from "node:readline/promises";
 import { mkdir as mkdir21, writeFile as writeFile16 } from "node:fs/promises";
-import { dirname as dirname15, resolve as resolve10 } from "node:path";
+import { dirname as dirname16, resolve as resolve11 } from "node:path";
 
 // src/workflow/dropApply.ts
 init_atomicWrite();
@@ -62143,8 +62719,8 @@ init_graphEdges();
 init_verify();
 init_ledger();
 import { existsSync as existsSync32 } from "node:fs";
-import { cp as cp2, mkdir as mkdir18, readFile as readFile41, rm as rm11 } from "node:fs/promises";
-import { dirname as dirname13, join as join39, relative as relative12 } from "node:path";
+import { cp as cp2, mkdir as mkdir18, readFile as readFile42, rm as rm11 } from "node:fs/promises";
+import { dirname as dirname14, join as join40, relative as relative12 } from "node:path";
 
 // src/reconcile/sectionValidation.ts
 init_sectionMount();
@@ -62226,7 +62802,7 @@ init_workspace();
 init_exitCode();
 var import_yaml21 = __toESM(require_dist(), 1);
 import { writeFile as writeFile14 } from "node:fs/promises";
-import { join as join37 } from "node:path";
+import { join as join38 } from "node:path";
 function nowIso4(now = new Date) {
   return now.toISOString();
 }
@@ -62295,7 +62871,7 @@ async function markSourceDropped(input) {
       ...input.archivePath !== undefined ? { archive_path: input.archivePath } : {}
     } : s)
   };
-  await writeFile14(join37(ctxDir, "raw", "_sources.yaml"), import_yaml21.default.stringify(next), "utf8");
+  await writeFile14(join38(ctxDir, "raw", "_sources.yaml"), import_yaml21.default.stringify(next), "utf8");
   await mdriveWorkspaceAppendChangelog({
     ctxDir,
     entry: `[drop] source=${sourceId} reason=${reason} affected-nodes=${affectedNodes} affected-sections=${affectedSections} @ ${droppedAt}`
@@ -62308,7 +62884,7 @@ init_sectionFingerprints();
 init_errors();
 init_sourceRef();
 var import_yaml22 = __toESM(require_dist(), 1);
-import { isAbsolute as isAbsolute5, join as join38, relative as relative11, resolve as resolve9 } from "node:path";
+import { isAbsolute as isAbsolute5, join as join39, relative as relative11, resolve as resolve10 } from "node:path";
 init_sources();
 init_shared();
 init_graphEdges();
@@ -62360,16 +62936,16 @@ function normalizeSnapshotPath(input) {
   const cwd = input.cwd ?? process.cwd();
   const candidates = new Set;
   const addAbs = (path9) => {
-    const rel = toPosixPath2(relative11(ctxDir, path9));
+    const rel = toPosixPath3(relative11(ctxDir, path9));
     if (!rel.startsWith("../") && rel !== ".." && !isAbsolute5(rel)) {
       candidates.add(rel);
     }
   };
-  addAbs(isAbsolute5(target) ? target : resolve9(cwd, target));
+  addAbs(isAbsolute5(target) ? target : resolve10(cwd, target));
   if (!isAbsolute5(target)) {
-    addAbs(resolve9(ctxDir, target));
+    addAbs(resolve10(ctxDir, target));
     if (target.startsWith(".context/")) {
-      addAbs(resolve9(join38(ctxDir, ".."), target));
+      addAbs(resolve10(join39(ctxDir, ".."), target));
     }
   }
   for (const rel of candidates) {
@@ -62948,7 +63524,7 @@ function buildDropScopeByItem(plan, decisions) {
 async function snapshotTextFile(path9) {
   if (!existsSync32(path9))
     return { path: path9, existed: false };
-  return { path: path9, existed: true, content: await readFile41(path9, "utf8") };
+  return { path: path9, existed: true, content: await readFile42(path9, "utf8") };
 }
 async function restoreTextFile(snapshot) {
   if (!snapshot.existed) {
@@ -62959,21 +63535,21 @@ async function restoreTextFile(snapshot) {
 }
 async function restoreRawEntries(input) {
   for (const entry of input.entries) {
-    const fromAbs = join39(input.ctxDir, entry.to);
-    const toAbs = join39(input.ctxDir, entry.from);
+    const fromAbs = join40(input.ctxDir, entry.to);
+    const toAbs = join40(input.ctxDir, entry.from);
     if (!existsSync32(fromAbs))
       continue;
-    await mkdir18(dirname13(toAbs), { recursive: true });
+    await mkdir18(dirname14(toAbs), { recursive: true });
     await cp2(fromAbs, toAbs, { recursive: entry.kind === "dir", force: true });
   }
 }
 async function restoreKnowledgeBefore(input) {
   for (const filePath of input.touchedKnowledgeFiles) {
     const rel = relative12(input.ctxDir, filePath);
-    const archivedPath = join39(input.ctxDir, input.archivePath, "knowledge", "before", rel);
+    const archivedPath = join40(input.ctxDir, input.archivePath, "knowledge", "before", rel);
     if (!existsSync32(archivedPath))
       continue;
-    await mkdir18(dirname13(filePath), { recursive: true });
+    await mkdir18(dirname14(filePath), { recursive: true });
     await cp2(archivedPath, filePath, { force: true });
   }
 }
@@ -62987,11 +63563,11 @@ async function restoreDropApplyFailure(input) {
   await restoreTextFile(input.sourcesBefore);
   await restoreTextFile(input.changelogBefore);
   await restoreTextFile(input.ledgerBefore);
-  await rm11(join39(input.ctxDir, input.archivePath), { recursive: true, force: true });
+  await rm11(join40(input.ctxDir, input.archivePath), { recursive: true, force: true });
 }
 async function commitDropPlanWrites(input) {
-  const sourcesBefore = await snapshotTextFile(join39(input.ctxDir, "raw", "_sources.yaml"));
-  const changelogBefore = await snapshotTextFile(join39(input.ctxDir, "knowledge", "changelog.md"));
+  const sourcesBefore = await snapshotTextFile(join40(input.ctxDir, "raw", "_sources.yaml"));
+  const changelogBefore = await snapshotTextFile(join40(input.ctxDir, "knowledge", "changelog.md"));
   const ledgerBefore = await snapshotTextFile(semanticLedgerPath2(input.ctxDir));
   const plannedArchivePath = sourceArchiveRelPath(input.source.id, input.droppedAt);
   let archive;
@@ -63181,7 +63757,7 @@ async function applyDropPlan(input) {
   removeDroppedContextSources({ files, sourceId: plan.source_id, deletedFiles, touchedFiles });
   markGraphEdgeNeighborsForArchivedNodes({ plan, nodes, archivedSlugs, deletedFiles, touchedFiles });
   const targetAfterByItem = collectDropTargetSnapshots(nodes, semanticDecisions);
-  const graphEdgesPath2 = join39(input.ctxDir, "knowledge", "_edges.yaml");
+  const graphEdgesPath2 = join40(input.ctxDir, "knowledge", "_edges.yaml");
   const touchedKnowledgeFiles = new Set([...touchedFiles, ...deletedFiles]);
   if (archivedSlugs.size > 0 && existsSync32(graphEdgesPath2)) {
     touchedKnowledgeFiles.add(graphEdgesPath2);
@@ -63219,8 +63795,8 @@ init_verify();
 init_workspace();
 init_exitCode();
 import { existsSync as existsSync34 } from "node:fs";
-import { cp as cp3, mkdir as mkdir19, readFile as readFile45, readdir as readdir15, rm as rm12 } from "node:fs/promises";
-import { dirname as dirname14, join as join41 } from "node:path";
+import { cp as cp3, mkdir as mkdir19, readFile as readFile46, readdir as readdir15, rm as rm12 } from "node:fs/promises";
+import { dirname as dirname15, join as join42 } from "node:path";
 
 // src/code/codeProjectionFreshness.ts
 init_errors();
@@ -63233,11 +63809,13 @@ init_verify();
 init_exitCode();
 
 // src/code/codeProjection.ts
+init_config();
 init_sourceRef();
 init_externalDeps();
 init_graphEdges();
 init_shared();
-import { readFile as readFile44 } from "node:fs/promises";
+import { readFile as readFile45 } from "node:fs/promises";
+import { relative as relative13 } from "node:path";
 
 // src/code/codeProjectionBuild.ts
 init_cliFeedback();
@@ -63254,8 +63832,8 @@ init_sources();
 init_exitCode();
 var import_yaml23 = __toESM(require_dist(), 1);
 import { existsSync as existsSync33 } from "node:fs";
-import { readFile as readFile42 } from "node:fs/promises";
-import { join as join40 } from "node:path";
+import { readFile as readFile43 } from "node:fs/promises";
+import { join as join41 } from "node:path";
 
 // src/code/codeSnapshotVersioning.ts
 init_src();
@@ -63466,15 +64044,15 @@ function snapshotSemanticId3(snapshot) {
 }
 function snapshotDir3(ctxDir, source2, snapshot) {
   if (snapshot.dir)
-    return join40(ctxDir, snapshot.dir);
+    return join41(ctxDir, snapshot.dir);
   const slug = sourceSlugFor2(source2, snapshot);
   const id2 = snapshot.snapshot_id;
   if (!slug || !id2)
     return null;
-  return join40(ctxDir, "raw", "aspect", "code", slug, id2);
+  return join41(ctxDir, "raw", "aspect", "code", slug, id2);
 }
 async function readStructuredFile(path9) {
-  const text5 = await readFile42(path9, "utf8");
+  const text5 = await readFile43(path9, "utf8");
   const parsed = import_yaml23.default.parse(text5);
   return isRecord12(parsed) ? parsed : {};
 }
@@ -63484,7 +64062,7 @@ async function readStructuredFileIfExists(path9) {
   return readStructuredFile(path9);
 }
 async function readJsonl2(path9) {
-  const text5 = await readFile42(path9, "utf8");
+  const text5 = await readFile43(path9, "utf8");
   const rows = [];
   for (const line of text5.split(/\r?\n/u)) {
     if (line.trim().length === 0)
@@ -63510,15 +64088,15 @@ async function loadOneSnapshot(ctxDir, source2, snapshot) {
       source_id: source2.id
     });
   }
-  const files = Object.fromEntries(BETA9_CODE_SNAPSHOT_FILES.flatMap((fileName) => existsSync33(join40(dir, fileName)) ? [[fileName, true]] : []));
-  const sourceFile = await readStructuredFileIfExists(join40(dir, "source.yaml"));
-  const manifest = await readStructuredFileIfExists(join40(dir, "manifest.json"));
-  const meta = await readStructuredFileIfExists(join40(dir, "_meta.yaml"));
-  const digests = await readJsonlIfExists(join40(dir, "digests.jsonl"));
-  const sourceFiles = await readJsonlIfExists(join40(dir, "source-files.jsonl"));
-  const packages = await readJsonlIfExists(join40(dir, "packages.jsonl"));
-  const symbols = await readJsonlIfExists(join40(dir, "symbols.jsonl"));
-  const edges = await readJsonlIfExists(join40(dir, "edges.jsonl"));
+  const files = Object.fromEntries(BETA9_CODE_SNAPSHOT_FILES.flatMap((fileName) => existsSync33(join41(dir, fileName)) ? [[fileName, true]] : []));
+  const sourceFile = await readStructuredFileIfExists(join41(dir, "source.yaml"));
+  const manifest = await readStructuredFileIfExists(join41(dir, "manifest.json"));
+  const meta = await readStructuredFileIfExists(join41(dir, "_meta.yaml"));
+  const digests = await readJsonlIfExists(join41(dir, "digests.jsonl"));
+  const sourceFiles = await readJsonlIfExists(join41(dir, "source-files.jsonl"));
+  const packages = await readJsonlIfExists(join41(dir, "packages.jsonl"));
+  const symbols = await readJsonlIfExists(join41(dir, "symbols.jsonl"));
+  const edges = await readJsonlIfExists(join41(dir, "edges.jsonl"));
   validateCodeSnapshotSchema({
     files,
     ...sourceFile !== undefined ? { source: sourceFile } : {},
@@ -63621,7 +64199,7 @@ init_sourceRef();
 init_sources();
 init_knowledge();
 init_exitCode();
-import { readFile as readFile43 } from "node:fs/promises";
+import { readFile as readFile44 } from "node:fs/promises";
 var SECTION_ORDER = new Map(SECTION_RENDER_ORDER.map((kind, index2) => [kind, index2]));
 function visibleVersion(value) {
   return value === undefined ? undefined : `v${String(value).replace(/^v/u, "")}`;
@@ -63784,7 +64362,7 @@ function assertNoGeneratedDrift(draft, sections) {
 }
 async function renderedNodePlan(draft) {
   const sections = finalizeNodeSections(draft);
-  const current = draft.existingPath ? await readFile43(draft.existingPath, "utf8").catch(() => "") : "";
+  const current = draft.existingPath ? await readFile44(draft.existingPath, "utf8").catch(() => "") : "";
   assertNoGeneratedDrift(draft, sections);
   const input = {
     node: draft.node,
@@ -64285,21 +64863,120 @@ async function buildCodeProjectionDraftState(ctxDir, sourceSlug3) {
 async function buildCodeProjectionPlan(ctxDir, sourceSlug3) {
   return renderCodeProjectionPlanFromState(await buildCodeProjectionDraftState(ctxDir, sourceSlug3));
 }
+function parsedRootFromRenderInput(input, headingLevel = 1) {
+  return {
+    node: input.node,
+    headingLevel,
+    body: input.body ?? "",
+    sections: [...input.sections],
+    children: (input.children ?? []).map((child) => parsedRootFromRenderInput(child, headingLevel + 1)),
+    containsEdges: [],
+    containsList: []
+  };
+}
+function projectedWorkspaceFileFromInput(ctxDir, filePath, input) {
+  const relativePath = toPosixPath3(relative13(knowledgeRoot3(ctxDir), filePath));
+  const root2 = parsedRootFromRenderInput(input);
+  const expectedSlug = slugFromKnowledgeRelativePath(relativePath);
+  if (expectedSlug !== null && expectedSlug.includes("/") && root2.node.id === expectedSlug) {
+    const parentSlug = expectedSlug.split("/")[0];
+    root2.containsEdges = [{
+      type: "contains",
+      from: parentSlug,
+      to: expectedSlug,
+      grounding: "directory",
+      ...root2.node.valid_from !== undefined ? { valid_from: root2.node.valid_from } : {},
+      ...root2.node.valid_until !== undefined ? { valid_until: root2.node.valid_until } : {}
+    }];
+  }
+  return { filePath, relativePath, root: root2 };
+}
+async function projectedWorkspaceFiles(ctxDir, rendered) {
+  const byPath = new Map((await readWorkspaceNodeFiles(ctxDir)).map((file) => [file.filePath, file]));
+  for (const item of rendered.values()) {
+    const filePath = knowledgeFilePath(ctxDir, item.input.node.type, item.input.node.id);
+    byPath.set(filePath, projectedWorkspaceFileFromInput(ctxDir, filePath, item.input));
+  }
+  return [...byPath.values()];
+}
+async function projectedRenderContext(plan) {
+  const [files, currentEdges, currentExternals, renderConfig] = await Promise.all([
+    projectedWorkspaceFiles(plan.state.ctxDir, plan.rendered),
+    loadKnowledgeGraphEdges(plan.state.ctxDir),
+    loadExternalDeps(plan.state.ctxDir),
+    loadRenderConfig(plan.state.ctxDir)
+  ]);
+  const codeGroundings = new Set(plan.source_slugs.map((slug) => `code:${slug}`));
+  const graphEdges = [
+    ...currentEdges.filter((edge2) => !codeGroundings.has(edge2.grounding ?? "")),
+    ...plan.state.edges
+  ];
+  const externalOwners = new Set;
+  for (const node3 of plan.nodes)
+    externalOwners.add(ownerSlugForPackageScopedPath(node3.slug));
+  for (const dep of plan.state.externals)
+    externalOwners.add(ownerSlugForPackageScopedPath(dep.from));
+  const externalDeps = [
+    ...currentExternals.filter((dep) => !externalOwners.has(ownerSlugForPackageScopedPath(dep.from))),
+    ...plan.state.externals
+  ];
+  return buildRenderWorkspaceContextFromData({
+    files,
+    graphEdges,
+    externalDeps,
+    renderOptions: {
+      nodeLinkMode: renderConfig.obsidian_mode ? "wiki" : "md",
+      usedBy: renderConfig.used_by
+    }
+  });
+}
 async function renderCodeProjectionPlanFromState(state) {
   const rendered = new Map;
-  const nodes = [];
+  const pending = [];
   for (const draft of [...state.nodeDrafts.values()].sort((left, right) => left.node.id.localeCompare(right.node.id))) {
     const result = await renderedNodePlan(draft);
-    rendered.set(draft.node.id, { input: result.input, rendered: result.rendered, diff: result.diff });
-    const codeSections = result.input.sections.filter((section) => parseCodeSourceRef(section.source_ref) !== null);
-    nodes.push({
+    const filePath = knowledgeFilePath(state.ctxDir, result.input.node.type, result.input.node.id);
+    pending.push({
       slug: draft.node.id,
-      title: draft.node.title,
-      section_count: result.input.sections.length,
+      input: result.input,
+      current: await readFile45(filePath, "utf8").catch(() => ""),
+      filePath
+    });
+    rendered.set(draft.node.id, { input: result.input, rendered: result.rendered });
+  }
+  const initialPlan = {
+    action: "code-align",
+    sources: [...new Set([...state.nodeDrafts.values()].map((draft) => draft.source.source.id))].sort(),
+    source_slugs: [...new Set([...state.nodeDrafts.values()].map((draft) => draft.source.sourceSlug))].sort(),
+    nodes: pending.map((item) => ({
+      slug: item.input.node.id,
+      title: item.input.node.title,
+      section_count: item.input.sections.length,
+      code_section_count: item.input.sections.filter((section) => parseCodeSourceRef(section.source_ref) !== null).length,
+      diff: "unchanged",
+      ...item.input.node.valid_from !== undefined ? { valid_from: item.input.node.valid_from } : {},
+      ...item.input.node.valid_until !== undefined ? { valid_until: item.input.node.valid_until } : {}
+    })),
+    edge_count: state.edges.length,
+    external_count: state.externals.length,
+    warnings: state.warnings,
+    rendered,
+    state
+  };
+  const renderContext = await projectedRenderContext(initialPlan);
+  const nodes = [];
+  for (const item of pending) {
+    const renderedText = renderNodeInputForFile(item.filePath, item.input, renderContext);
+    rendered.set(item.slug, { input: item.input, rendered: renderedText });
+    const codeSections = item.input.sections.filter((section) => parseCodeSourceRef(section.source_ref) !== null);
+    nodes.push({
+      slug: item.input.node.id,
+      title: item.input.node.title,
+      section_count: item.input.sections.length,
       code_section_count: codeSections.length,
-      diff: result.diff,
-      ...draft.node.valid_from !== undefined ? { valid_from: draft.node.valid_from } : {},
-      ...draft.node.valid_until !== undefined ? { valid_until: draft.node.valid_until } : {}
+      diff: item.current.length === 0 ? "create" : item.current === renderedText ? "unchanged" : "update",
+      ...item.input.node.valid_from !== undefined ? { valid_from: item.input.node.valid_from } : {},
+      ...item.input.node.valid_until !== undefined ? { valid_until: item.input.node.valid_until } : {}
     });
   }
   return {
@@ -64322,7 +64999,7 @@ async function writeProjectedNodes(plan, ctxDir) {
   for (const [slug, rendered] of plan.rendered) {
     const filePath = knowledgeFilePath(ctxDir, rendered.input.node.type, slug);
     await ensureKnowledgeTypeDir(ctxDir, rendered.input.node.type);
-    const current = await readFile44(filePath, "utf8").catch(() => "");
+    const current = await readFile45(filePath, "utf8").catch(() => "");
     if (current === rendered.rendered)
       continue;
     await atomicWriteText(filePath, rendered.rendered);
@@ -64789,35 +65466,35 @@ function applyCodeDropToNode(input) {
 async function snapshotTextFile2(path9) {
   if (!existsSync34(path9))
     return { path: path9, existed: false };
-  return { path: path9, existed: true, content: await readFile45(path9, "utf8") };
+  return { path: path9, existed: true, content: await readFile46(path9, "utf8") };
 }
 async function restoreTextFile2(snapshot) {
   if (!snapshot.existed) {
     await rm12(snapshot.path, { force: true });
     return;
   }
-  await mkdir19(dirname14(snapshot.path), { recursive: true });
+  await mkdir19(dirname15(snapshot.path), { recursive: true });
   await atomicWriteFile(snapshot.path, snapshot.content ?? "");
 }
 async function restoreRawEntries2(ctxDir, entries) {
   for (const entry of entries) {
-    const fromAbs = join41(ctxDir, entry.to);
-    const toAbs = join41(ctxDir, entry.from);
+    const fromAbs = join42(ctxDir, entry.to);
+    const toAbs = join42(ctxDir, entry.from);
     if (!existsSync34(fromAbs))
       continue;
-    await mkdir19(dirname14(toAbs), { recursive: true });
+    await mkdir19(dirname15(toAbs), { recursive: true });
     await cp3(fromAbs, toAbs, { recursive: entry.kind === "dir", force: true });
   }
 }
 async function collectPotentialSideEffectFiles(ctxDir) {
   const paths = new Set([
-    join41(ctxDir, "raw", "_sources.yaml"),
-    join41(ctxDir, "knowledge", "changelog.md"),
-    join41(ctxDir, "knowledge", "_index.md"),
-    join41(ctxDir, "knowledge", "_edges.yaml"),
-    join41(ctxDir, "knowledge", "_external.yaml")
+    join42(ctxDir, "raw", "_sources.yaml"),
+    join42(ctxDir, "knowledge", "changelog.md"),
+    join42(ctxDir, "knowledge", "_index.md"),
+    join42(ctxDir, "knowledge", "_edges.yaml"),
+    join42(ctxDir, "knowledge", "_external.yaml")
   ]);
-  const entityRoot = join41(ctxDir, "knowledge", "entity");
+  const entityRoot = join42(ctxDir, "knowledge", "entity");
   let entries = [];
   try {
     entries = await readdir15(entityRoot, { withFileTypes: true });
@@ -64829,8 +65506,8 @@ async function collectPotentialSideEffectFiles(ctxDir) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    paths.add(join41(entityRoot, entry.name, "_edges.yaml"));
-    paths.add(join41(entityRoot, entry.name, "_external.yaml"));
+    paths.add(join42(entityRoot, entry.name, "_edges.yaml"));
+    paths.add(join42(entityRoot, entry.name, "_external.yaml"));
   }
   return paths;
 }
@@ -64838,7 +65515,7 @@ async function restoreCodeDropFailure(input) {
   for (const snapshot of input.snapshots)
     await restoreTextFile2(snapshot);
   await restoreRawEntries2(input.ctxDir, input.rawEntries);
-  await rm12(join41(input.ctxDir, input.archivePath), { recursive: true, force: true });
+  await rm12(join42(input.ctxDir, input.archivePath), { recursive: true, force: true });
 }
 async function applyCodeSourceDropPlan(input) {
   const plan = parseDropPlan(input.plan);
@@ -64886,7 +65563,7 @@ async function applyCodeSourceDropPlan(input) {
   const sideEffectFiles = await collectPotentialSideEffectFiles(input.ctxDir);
   const snapshotPaths = new Set([...touchedFiles, ...deletedFiles, ...sideEffectFiles]);
   const snapshots = await Promise.all([...snapshotPaths].map((path9) => snapshotTextFile2(path9)));
-  const knowledgeRoot4 = join41(input.ctxDir, "knowledge");
+  const knowledgeRoot4 = join42(input.ctxDir, "knowledge");
   const touchedKnowledgeFiles = [...snapshotPaths].filter((path9) => path9.startsWith(knowledgeRoot4) && existsSync34(path9));
   const plannedArchivePath = sourceArchiveRelPath(source2.id, droppedAt);
   let archive;
@@ -64899,6 +65576,8 @@ async function applyCodeSourceDropPlan(input) {
       touchedKnowledgeFiles,
       plan
     });
+    await replaceCodeGraphEdges(input.ctxDir, `code:${codeSourceSlug(source2)}`, []);
+    await replaceExternalDepsForOwners(input.ctxDir, [], owners);
     const renderContext = touchedFiles.size > 0 ? await buildRenderWorkspaceContext(input.ctxDir, files.filter((file) => !deletedFiles.has(file.filePath))) : undefined;
     for (const filePath of touchedFiles) {
       if (deletedFiles.has(filePath))
@@ -64909,8 +65588,6 @@ async function applyCodeSourceDropPlan(input) {
     }
     for (const filePath of deletedFiles)
       await rm12(filePath, { force: true });
-    await replaceCodeGraphEdges(input.ctxDir, `code:${codeSourceSlug(source2)}`, []);
-    await replaceExternalDepsForOwners(input.ctxDir, [], owners);
     await mdriveWorkspaceRebuildIndex({ ctxDir: input.ctxDir });
     await removeActiveRawEntries(input.ctxDir, archive.rawEntries);
     const dropped = await markSourceDropped({
@@ -64967,8 +65644,8 @@ init_exitCode();
 init_workflowPayloadStore();
 var import_yaml24 = __toESM(require_dist(), 1);
 import { createHash as createHash7 } from "node:crypto";
-import { mkdir as mkdir20, readdir as readdir16, readFile as readFile46, rm as rm13, writeFile as writeFile15 } from "node:fs/promises";
-import { join as join43 } from "node:path";
+import { mkdir as mkdir20, readdir as readdir16, readFile as readFile47, rm as rm13, writeFile as writeFile15 } from "node:fs/promises";
+import { join as join44 } from "node:path";
 var IMMUTABLE_REVIEW_SCHEMA_VERSION = "reconcile.review-artifact.v1";
 function shortHash2(value) {
   return createHash7("sha256").update(value).digest("hex").slice(0, 16);
@@ -64977,7 +65654,7 @@ function deriveReviewId(input) {
   return `rv_${shortHash2(`${input.scopeId}\x00${input.prepareDigest}\x00${input.decisionsDigest}`)}`;
 }
 function reviewArtifactPath(input) {
-  return join43(workflowScopePath(input.ctxDir, input.workflowId, input.scopeId), `review.${input.reviewId}.yaml`);
+  return join44(workflowScopePath(input.ctxDir, input.workflowId, input.scopeId), `review.${input.reviewId}.yaml`);
 }
 function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -65032,12 +65709,12 @@ async function removeSupersededReviewArtifacts(scopeDir, keepFileName) {
       return;
     throw err2;
   }
-  await Promise.all(entries.filter((entry) => /^review\.rv_[a-f0-9]{16}\.ya?ml$/u.test(entry) && entry !== keepFileName).map((entry) => rm13(join43(scopeDir, entry), { force: true })));
+  await Promise.all(entries.filter((entry) => /^review\.rv_[a-f0-9]{16}\.ya?ml$/u.test(entry) && entry !== keepFileName).map((entry) => rm13(join44(scopeDir, entry), { force: true })));
 }
 async function readArtifactFile(path9) {
   let parsed;
   try {
-    parsed = import_yaml24.default.parse(await readFile46(path9, "utf8"));
+    parsed = import_yaml24.default.parse(await readFile47(path9, "utf8"));
   } catch {
     return null;
   }
@@ -65056,7 +65733,7 @@ async function readReadyReviewArtifacts(input) {
   }
   const out2 = [];
   for (const entry of entries.filter((name) => /^review\.rv_[a-f0-9]{16}\.ya?ml$/u.test(name)).sort()) {
-    const path9 = join43(dir, entry);
+    const path9 = join44(dir, entry);
     const artifact = await readArtifactFile(path9);
     if (artifact !== null && artifact.ready_to_apply === true)
       out2.push({ artifact, path: path9 });
@@ -65091,7 +65768,7 @@ function dropPlanOutputPath(ctxDir, plan, format) {
   return workflowOutputPath(ctxDir, "drop", `drop.${safeFilePart(plan.source_id)}.plan.${format === "yaml" ? "yaml" : "json"}`);
 }
 async function saveTextFile(path9, body2) {
-  await mkdir21(dirname15(path9), { recursive: true });
+  await mkdir21(dirname16(path9), { recursive: true });
   await writeFile16(path9, body2, "utf8");
 }
 function assertDropPlanSaveFlags(flags2) {
@@ -65108,7 +65785,7 @@ async function saveDropPlanOutputs(input) {
     await saveTextFile(path9, input.output);
     saved.push(path9);
   } else if (typeof input.saveOutput === "string") {
-    const path9 = resolve10(input.saveOutput);
+    const path9 = resolve11(input.saveOutput);
     await saveTextFile(path9, input.output);
     saved.push(path9);
   }
@@ -65513,8 +66190,8 @@ init_temporal();
 init_knowledge();
 init_archive();
 import { existsSync as existsSync39 } from "node:fs";
-import { readdir as readdir18, readFile as readFile52, stat as stat3 } from "node:fs/promises";
-import { dirname as dirname18, join as join48, resolve as resolve11 } from "node:path";
+import { readdir as readdir18, readFile as readFile53, stat as stat3 } from "node:fs/promises";
+import { dirname as dirname19, join as join49, resolve as resolve12 } from "node:path";
 
 // src/reconcile/status.ts
 init_workspaceCache();
@@ -65527,8 +66204,8 @@ init_noteStatus();
 init_ledger();
 var import_yaml26 = __toESM(require_dist(), 1);
 import { existsSync as existsSync35 } from "node:fs";
-import { readdir as readdir17, readFile as readFile47 } from "node:fs/promises";
-import { join as join44 } from "node:path";
+import { readdir as readdir17, readFile as readFile48 } from "node:fs/promises";
+import { join as join45 } from "node:path";
 
 // src/reconcile/staleDecisions.ts
 init_sectionFingerprints();
@@ -65583,11 +66260,11 @@ async function findStaleSemanticDecisions(ctxDir) {
     latestByTarget.set(`${record.target.node}\x00${record.target.section_id}`, record);
   }
   const stale = [];
-  for (const [targetKey, record] of latestByTarget) {
+  for (const [targetKey2, record] of latestByTarget) {
     const target = record.target;
     if (!target?.node || !target.section_id)
       continue;
-    const currentTargetHash = currentTargetHashes.get(targetKey) ?? null;
+    const currentTargetHash = currentTargetHashes.get(targetKey2) ?? null;
     if (currentTargetHash === null) {
       continue;
     }
@@ -65602,7 +66279,7 @@ async function findStaleSemanticDecisions(ctxDir) {
     });
     if (reuse.kind !== "stale")
       continue;
-    if (await isDeterministicHeadingHousekeeping(ctxDir, record, currentSections.get(targetKey)))
+    if (await isDeterministicHeadingHousekeeping(ctxDir, record, currentSections.get(targetKey2)))
       continue;
     stale.push({
       id: record.id,
@@ -65621,10 +66298,10 @@ function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function parseLastCompile(ctxDir) {
-  const path9 = join44(ctxDir, "knowledge", "changelog.md");
+  const path9 = join45(ctxDir, "knowledge", "changelog.md");
   if (!existsSync35(path9))
     return null;
-  const lines = (await readFile47(path9, "utf8")).split(`
+  const lines = (await readFile48(path9, "utf8")).split(`
 `).filter((line) => line.includes("[compile]"));
   for (let index2 = lines.length - 1;index2 >= 0; index2 -= 1) {
     const stamp = /@\s*([0-9]{4}-[0-9]{2}-[0-9]{2}(?:T[0-9:.+-]+Z?)?)/.exec(lines[index2] ?? "")?.[1];
@@ -65644,13 +66321,13 @@ async function refreshedSourcesPendingCompile(ctxDir) {
   }).map((source2) => source2.id).sort();
 }
 async function pendingQuestionFiles(ctxDir) {
-  const outputDir = join44(ctxDir, "output");
+  const outputDir = join45(ctxDir, "output");
   if (!existsSync35(outputDir))
     return { count: 0, files: [] };
   const files = [];
   let count = 0;
   const visit2 = async (relDir) => {
-    const absDir = join44(outputDir, relDir);
+    const absDir = join45(outputDir, relDir);
     for (const entry of await readdir17(absDir, { withFileTypes: true })) {
       const relPath = relDir.length > 0 ? `${relDir}/${entry.name}` : entry.name;
       if (entry.isDirectory()) {
@@ -65662,7 +66339,7 @@ async function pendingQuestionFiles(ctxDir) {
       if (relDir.length === 0 || !entry.isFile() || !SEMANTIC_REVIEW_OUTPUT_FILE_RE.test(entry.name))
         continue;
       const rel = `output/${relPath}`;
-      const raw = await readFile47(join44(outputDir, relPath), "utf8");
+      const raw = await readFile48(join45(outputDir, relPath), "utf8");
       let parsed;
       try {
         parsed = entry.name.endsWith(".json") ? JSON.parse(raw) : import_yaml26.default.parse(raw);
@@ -65940,11 +66617,11 @@ init_errors();
 init_exitCode();
 var import_yaml27 = __toESM(require_dist(), 1);
 import { existsSync as existsSync38 } from "node:fs";
-import { mkdir as mkdir23, readFile as readFile51 } from "node:fs/promises";
-import { dirname as dirname17, join as join47 } from "node:path";
+import { mkdir as mkdir23, readFile as readFile52 } from "node:fs/promises";
+import { dirname as dirname18, join as join48 } from "node:path";
 var ALIGN_DECISION_LEDGER_SCHEMA_VERSION = "decisions.align.v1";
 function alignDecisionLedgerPath(ctxDir) {
-  return join47(ctxDir, "decisions", "align.yaml");
+  return join48(ctxDir, "decisions", "align.yaml");
 }
 function isRecord16(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -66006,7 +66683,7 @@ async function readAlignDecisionLedger(ctxDir) {
   const path9 = alignDecisionLedgerPath(ctxDir);
   if (!existsSync38(path9))
     return { schema_version: ALIGN_DECISION_LEDGER_SCHEMA_VERSION, decisions: [] };
-  return parseLedger(import_yaml27.default.parse(await readFile51(path9, "utf8")));
+  return parseLedger(import_yaml27.default.parse(await readFile52(path9, "utf8")));
 }
 function recordSupersedeKey(record) {
   return `${record.scope}\x00${record.node_slug}`;
@@ -66056,7 +66733,7 @@ async function appendAlignDecisionLedger(input) {
     ]
   };
   const path9 = alignDecisionLedgerPath(input.ctxDir);
-  await mkdir23(dirname17(path9), { recursive: true });
+  await mkdir23(dirname18(path9), { recursive: true });
   await atomicWriteFile(path9, import_yaml27.default.stringify(next));
   return next;
 }
@@ -66116,7 +66793,7 @@ async function collectKnowledgeFiles(dir, nested) {
   for (const e of entries) {
     if (e.name === "_index.md")
       continue;
-    const full = join48(dir, e.name);
+    const full = join49(dir, e.name);
     if (e.isFile() && e.name.endsWith(".md")) {
       files.push(full);
     } else if (e.isDirectory() && nested) {
@@ -66132,7 +66809,7 @@ async function hasLikelySourceCode(root2, depth = 0) {
   for (const entry of entries) {
     if (entry.name.startsWith(".") && entry.name !== ".github")
       continue;
-    const full = join48(root2, entry.name);
+    const full = join49(root2, entry.name);
     if (entry.isFile() && SOURCE_CODE_EXT_RE.test(entry.name))
       return true;
     if (entry.isDirectory() && !SOURCE_SCAN_SKIP_DIRS.has(entry.name)) {
@@ -66163,9 +66840,9 @@ function isKnowledgeType(v) {
   return KNOWLEDGE_TYPES.includes(v);
 }
 async function parseLastCompileTime(ctxDir) {
-  const path9 = join48(ctxDir, "knowledge", "changelog.md");
+  const path9 = join49(ctxDir, "knowledge", "changelog.md");
   if (existsSync39(path9)) {
-    const body2 = await readFile52(path9, "utf8");
+    const body2 = await readFile53(path9, "utf8");
     const compileLines = body2.split(`
 `).filter((line) => line.includes("[compile]"));
     for (let index2 = compileLines.length - 1;index2 >= 0; index2 -= 1) {
@@ -66228,13 +66905,13 @@ function latestCaptureFromSources(file) {
   return { capture, drop, hasActiveRaw, hasAspectCode, totalSnapshots };
 }
 function detectGitRepo(cwd, ctxDir) {
-  const roots = [resolve11(cwd), workspaceLocationFromCtxDir(ctxDir).workspaceRoot];
+  const roots = [resolve12(cwd), workspaceLocationFromCtxDir(ctxDir).workspaceRoot];
   for (const start2 of roots) {
     let dir = start2;
     while (true) {
-      if (existsSync39(join48(dir, ".git")))
+      if (existsSync39(join49(dir, ".git")))
         return true;
-      const parent = dirname18(dir);
+      const parent = dirname19(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -66261,9 +66938,9 @@ async function collectWorkspaceStats(input) {
   let latestKnowledgeUpdated = null;
   let totalSections = 0;
   for (const root2 of KNOWLEDGE_ROOTS) {
-    const files = await collectKnowledgeFiles(join48(ctxDir, "knowledge", root2.dir), root2.nested);
+    const files = await collectKnowledgeFiles(join49(ctxDir, "knowledge", root2.dir), root2.nested);
     for (const path9 of files) {
-      const text5 = await readFile52(path9, "utf8");
+      const text5 = await readFile53(path9, "utf8");
       const typeField = parseFrontmatterField(text5, "type");
       if (!typeField || !isKnowledgeType(typeField))
         continue;
@@ -66757,12 +67434,12 @@ init_cliFeedback();
 import { existsSync as existsSync42 } from "node:fs";
 import { readdir as readdir19, rm as rm15 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { join as join51 } from "node:path";
+import { join as join52 } from "node:path";
 
 // src/commands/doctorWorkspace.ts
 import { existsSync as existsSync41 } from "node:fs";
-import { readFile as readFile54 } from "node:fs/promises";
-import { join as join50 } from "node:path";
+import { readFile as readFile55 } from "node:fs/promises";
+import { join as join51 } from "node:path";
 init_cliFeedback();
 init_verify();
 
@@ -66776,8 +67453,8 @@ init_sourceSupport();
 init_evidence();
 init_ledger();
 import { existsSync as existsSync40 } from "node:fs";
-import { readFile as readFile53 } from "node:fs/promises";
-import { join as join49 } from "node:path";
+import { readFile as readFile54 } from "node:fs/promises";
+import { join as join50 } from "node:path";
 function numbersIn2(text5) {
   return text5.match(/\b\d+(?:\.\d+)*\b/gu) ?? [];
 }
@@ -66816,10 +67493,10 @@ async function latestSourceRefText(input) {
   const snapshot = findSnapshotByHashPrefix(source2.snapshots, parsedSource.snapshotHash) ?? selectLatestSnapshot(source2.snapshots);
   if (!snapshot?.file)
     return null;
-  const fullPath = join49(input.ctxDir, snapshot.file);
+  const fullPath = join50(input.ctxDir, snapshot.file);
   if (!existsSync40(fullPath))
     return null;
-  const raw = await readFile53(fullPath, "utf8");
+  const raw = await readFile54(fullPath, "utf8");
   if (!sourceRefRangeOverlapsEvidenceBlock(raw, parsed.lineStart, parsed.lineEnd))
     return null;
   return { sourceId, text: sourceRefRangeText(raw, parsed.lineStart, parsed.lineEnd) };
@@ -66927,7 +67604,7 @@ init_cache();
 init_workspaceLayout();
 import { constants as constants3 } from "node:fs";
 import { access as access2, stat as stat4 } from "node:fs/promises";
-import { dirname as dirname19 } from "node:path";
+import { dirname as dirname20 } from "node:path";
 async function assertRetrievalCacheWritable(ctxDir) {
   const workspaceRoot = workspaceRootFromCtxDir(ctxDir);
   const paths = await getIncrementalCachePaths({ workspaceRoot });
@@ -66953,7 +67630,7 @@ async function nearestExistingPath(target) {
       const code3 = typeof err2 === "object" && err2 !== null && "code" in err2 ? String(err2.code) : "";
       if (code3 !== "ENOENT")
         return current;
-      const parent = dirname19(current);
+      const parent = dirname20(current);
       if (parent === current)
         return current;
       current = parent;
@@ -67315,11 +67992,11 @@ function notApplicableIssue2(path9, message) {
   };
 }
 async function hasCompileEntry(ctxDir) {
-  const changelogPath2 = join50(ctxDir, "knowledge", "changelog.md");
+  const changelogPath2 = join51(ctxDir, "knowledge", "changelog.md");
   if (!existsSync41(changelogPath2))
     return false;
   try {
-    return (await readFile54(changelogPath2, "utf8")).split(`
+    return (await readFile55(changelogPath2, "utf8")).split(`
 `).some((line) => line.includes("[compile]"));
   } catch {
     return false;
@@ -67699,19 +68376,19 @@ async function cleanClaudePluginCache(opts = {}) {
   for (const mp of marketplaces) {
     if (!mp.isDirectory())
       continue;
-    const mpDir = join51(cacheRoot, mp.name);
+    const mpDir = join52(cacheRoot, mp.name);
     const plugins = await readdir19(mpDir, { withFileTypes: true });
     for (const pl of plugins) {
       if (!pl.isDirectory())
         continue;
-      const plDir = join51(mpDir, pl.name);
+      const plDir = join52(mpDir, pl.name);
       const versions = await readdir19(plDir, { withFileTypes: true });
       for (const ver of versions) {
         if (!ver.isDirectory())
           continue;
         scanned += 1;
-        const verDir = join51(plDir, ver.name);
-        const markerPath = join51(verDir, ORPHAN_MARKER);
+        const verDir = join52(plDir, ver.name);
+        const markerPath = join52(verDir, ORPHAN_MARKER);
         if (!existsSync42(markerPath))
           continue;
         const label = `${mp.name}/${pl.name}/${ver.name}`;
@@ -67743,7 +68420,7 @@ function resolveClaudePluginCacheRoot(opts) {
   if (explicitRoot)
     return explicitRoot;
   const home = opts.home ?? process.env[CLAUDE_PLUGIN_CACHE_HOME_ENV] ?? homedir2();
-  return join51(home, ".claude", "plugins", "cache");
+  return join52(home, ".claude", "plugins", "cache");
 }
 async function isEmptyDir(dir) {
   try {
@@ -67775,7 +68452,7 @@ init_errors();
 init_cliFeedback();
 import { existsSync as existsSync43 } from "node:fs";
 import { readdir as readdir20, rm as rm16 } from "node:fs/promises";
-import { join as join52 } from "node:path";
+import { join as join53 } from "node:path";
 init_cache();
 init_workspaceCache();
 init_cache2();
@@ -67930,7 +68607,7 @@ async function countFiles2(dir) {
     return 0;
   let count = 0;
   for (const entry of await readdir20(dir, { withFileTypes: true })) {
-    const full = join52(dir, entry.name);
+    const full = join53(dir, entry.name);
     count += entry.isDirectory() ? await countFiles2(full) : 1;
   }
   return count;
@@ -67946,7 +68623,7 @@ async function cleanAllRetrievalCache() {
 }
 async function inspectAllRetrievalCache() {
   const cacheHome = resolveCacheHome();
-  const cacheRoot = join52(cacheHome, "retrieval");
+  const cacheRoot = join53(cacheHome, "retrieval");
   const projectIds = existsSync43(cacheRoot) ? (await readdir20(cacheRoot, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort() : [];
   const files = await countFiles2(cacheRoot);
   return { cacheRoot, projects: projectIds.length, files, projectIds };
@@ -70561,8 +71238,8 @@ function weakSupportWarning(input) {
     item_id: input.decision.item_id,
     severity: "warning",
     code: "weak-source-support",
-    message: `proposed keep_separate is weakly supported by its cited raw text: ${formatSupportDiagnostic(input.diagnostic)}.`,
-    next_action: "Review the cited evidence if the content looks surprising; missing hard facts still remain errors."
+    message: `proposed keep_separate has low lexical source_support but no missing hard facts: ${formatSupportDiagnostic(input.diagnostic)}.`,
+    next_action: "Review the cited evidence if the content looks surprising; semantic judge/user/delegated acceptance may proceed, but missing hard facts remain errors."
   };
 }
 function supportConfirmationQuestion(input) {
@@ -70652,6 +71329,9 @@ function questionPrompt(decision) {
     return "Please confirm how this knowledge should be handled.";
   return "Please confirm the proposed semantic reconciliation.";
 }
+function judgeAcceptsLowLexicalSupport(input) {
+  return input.decision.action === "keep_separate" && input.decision.judge_support_verdict === "supported" && input.changedSourceRef === false && input.diagnostic !== null && input.diagnostic.missingHardTerms.length === 0 && (input.diagnostic.verdict === "weak" || input.diagnostic.verdict === "unsupported");
+}
 function questionFromDecision(decision, index2, summary) {
   return {
     question_id: `q-${String(index2 + 1).padStart(3, "0")}`,
@@ -70957,11 +71637,16 @@ function reviewSemanticDecisions(input) {
   for (const prior of priorResults) {
     const diagnostic = supportDiagnosticFromItem({ decision: prior.decision, item: prior.item });
     const changedSourceRef = sourceRefChangedFromPreparedSupport({ decision: prior.decision, item: prior.item });
+    const judgeAcceptedLowLexical = judgeAcceptsLowLexicalSupport({
+      decision: prior.decision,
+      diagnostic,
+      changedSourceRef
+    });
     const weakAllowed = allowsWeakSourceSupport({
       decision: prior.decision,
       allowDelegatedDecisions: input.allowDelegatedDecisions
-    });
-    if (diagnostic?.verdict === "weak" && prior.decision.action === "keep_separate" && !changedSourceRef && weakAllowed) {
+    }) || judgeAcceptedLowLexical;
+    if (diagnostic !== null && (diagnostic.verdict === "weak" || judgeAcceptedLowLexical) && prior.decision.action === "keep_separate" && !changedSourceRef && weakAllowed) {
       issues.push(weakSupportWarning({
         decision: prior.decision,
         diagnostic
@@ -71138,7 +71823,7 @@ init_ledger();
 import { existsSync as existsSync51 } from "node:fs";
 import { cp as cp4, mkdir as mkdir25, mkdtemp as mkdtemp2, rm as rm18 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { dirname as dirname21, join as join61 } from "node:path";
+import { dirname as dirname22, join as join62 } from "node:path";
 
 // src/reconcile/applyPreflight.ts
 init_sources();
@@ -71461,11 +72146,11 @@ async function propagateOmitCoverageSkips(input) {
   }
 }
 async function createApplyRollbackSnapshot(ctxDir) {
-  const tmpDir = await mkdtemp2(join61(tmpdir2(), "c4a-reconcile-apply-"));
-  const knowledgePath2 = join61(ctxDir, "knowledge");
+  const tmpDir = await mkdtemp2(join62(tmpdir2(), "c4a-reconcile-apply-"));
+  const knowledgePath2 = join62(ctxDir, "knowledge");
   const ledgerPath = semanticLedgerPath2(ctxDir);
-  const knowledgeBackup = join61(tmpDir, "knowledge");
-  const ledgerBackup = join61(tmpDir, "semantic.yaml");
+  const knowledgeBackup = join62(tmpDir, "knowledge");
+  const ledgerBackup = join62(tmpDir, "semantic.yaml");
   const knowledgeExisted = existsSync51(knowledgePath2);
   const ledgerExisted = existsSync51(ledgerPath);
   if (knowledgeExisted)
@@ -71475,7 +72160,7 @@ async function createApplyRollbackSnapshot(ctxDir) {
   return { ctxDir, tmpDir, knowledgeExisted, ledgerExisted, knowledgeBackup, ledgerBackup };
 }
 async function restoreApplyRollbackSnapshot(snapshot) {
-  const knowledgePath2 = join61(snapshot.ctxDir, "knowledge");
+  const knowledgePath2 = join62(snapshot.ctxDir, "knowledge");
   if (snapshot.knowledgeExisted) {
     await rm18(knowledgePath2, { recursive: true, force: true });
     await cp4(snapshot.knowledgeBackup, knowledgePath2, { recursive: true });
@@ -71484,7 +72169,7 @@ async function restoreApplyRollbackSnapshot(snapshot) {
   }
   const ledgerPath = semanticLedgerPath2(snapshot.ctxDir);
   if (snapshot.ledgerExisted) {
-    await mkdir25(dirname21(ledgerPath), { recursive: true });
+    await mkdir25(dirname22(ledgerPath), { recursive: true });
     await cp4(snapshot.ledgerBackup, ledgerPath);
   } else {
     await rm18(ledgerPath, { force: true });
@@ -71865,7 +72550,7 @@ init_compile();
 init_cliFeedback();
 init_errors();
 var import_yaml32 = __toESM(require_dist(), 1);
-import { resolve as resolve13 } from "node:path";
+import { resolve as resolve14 } from "node:path";
 init_structuredInput();
 init_exitCode();
 function isRecord28(value) {
@@ -71946,7 +72631,7 @@ function saveOutputPath(value, flag) {
       flag
     });
   }
-  return resolve13(value);
+  return resolve14(value);
 }
 function requireWorkspace2(ctxDir, command) {
   if (!ctxDir) {
@@ -72338,7 +73023,7 @@ init_exitCode();
 init_currentWorkflow();
 init_workflowOutputPaths();
 import { mkdir as mkdir26, writeFile as writeFile17 } from "node:fs/promises";
-import { dirname as dirname22 } from "node:path";
+import { dirname as dirname23 } from "node:path";
 function familyForReconcileMode(mode) {
   if (mode === "compile")
     return "compile";
@@ -72442,14 +73127,14 @@ function reviewOutputFile(input) {
   return workflowOutputPath(input.ctxDir, input.context.mode, `${input.context.mode}.review.${ext}`);
 }
 async function saveOutput(path9, body2) {
-  await mkdir26(dirname22(path9), { recursive: true });
+  await mkdir26(dirname23(path9), { recursive: true });
   await writeFile17(path9, body2, "utf8");
 }
 
 // src/commands/workflowCommandUtils.ts
 var import_yaml33 = __toESM(require_dist(), 1);
-import { mkdir as mkdir27, readFile as readFile62, writeFile as writeFile18 } from "node:fs/promises";
-import { dirname as dirname23 } from "node:path";
+import { mkdir as mkdir27, readFile as readFile63, writeFile as writeFile18 } from "node:fs/promises";
+import { dirname as dirname24 } from "node:path";
 init_errors();
 init_cliFeedback();
 init_structuredInput();
@@ -72473,7 +73158,7 @@ function writeSchemaOutput(value, format) {
 async function readStructuredInput2(path9) {
   let raw;
   try {
-    raw = path9 === "-" ? await readStdinText() : await readFile62(path9, "utf8");
+    raw = path9 === "-" ? await readStdinText() : await readFile63(path9, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
       throw new ContextError(ExitCode.UserError, `file not found: ${path9}`, {
@@ -72488,7 +73173,7 @@ async function readStructuredInput2(path9) {
 async function writeWorkflowPayload(input) {
   assertWorkflowOutputFileName(input.fileName);
   const outputPath = workflowOutputPathForFile(input.ctxDir, input.fileName);
-  await mkdir27(dirname23(outputPath), { recursive: true });
+  await mkdir27(dirname24(outputPath), { recursive: true });
   const body2 = input.format === "json" ? `${JSON.stringify(input.payload, null, 2)}
 ` : import_yaml33.default.stringify(input.payload);
   await writeFile18(outputPath, body2, "utf8");
@@ -72953,7 +73638,7 @@ function renderReconcileApplyFeedbackBody(result) {
 init_errors();
 init_nodeRenderer();
 var import_yaml34 = __toESM(require_dist(), 1);
-import { readFile as readFile65 } from "node:fs/promises";
+import { readFile as readFile66 } from "node:fs/promises";
 init_knowledge();
 init_exitCode();
 init_edge2();
@@ -72962,8 +73647,8 @@ init_edge2();
 init_knowledge();
 init_nodeParser();
 import { existsSync as existsSync52 } from "node:fs";
-import { readdir as readdir25, readFile as readFile63 } from "node:fs/promises";
-import { join as join62 } from "node:path";
+import { readdir as readdir25, readFile as readFile64 } from "node:fs/promises";
+import { join as join63 } from "node:path";
 function collectGlossaryFromParsedTree(parsed, glossary, allowedTypes) {
   const type = parsed.node.type;
   if (allowedTypes.has(type)) {
@@ -72986,8 +73671,8 @@ function normalizeGlossaryTerm(value) {
   return value.normalize("NFC").trim().toLowerCase();
 }
 function resolveKnowledgeRoot(path9) {
-  if (existsSync52(join62(path9, "knowledge"))) {
-    return join62(path9, "knowledge");
+  if (existsSync52(join63(path9, "knowledge"))) {
+    return join63(path9, "knowledge");
   }
   return path9;
 }
@@ -72995,7 +73680,7 @@ async function readGlossaryFiles(dir) {
   if (!existsSync52(dir))
     return [];
   const entries = await readdir25(dir, { withFileTypes: true });
-  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".md") && entry.name !== "_index.md" && entry.name !== "changelog.md").map((entry) => join62(dir, entry.name));
+  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".md") && entry.name !== "_index.md" && entry.name !== "changelog.md").map((entry) => join63(dir, entry.name));
 }
 async function buildGlossary(path9, options = {}) {
   const knowledgeRoot4 = resolveKnowledgeRoot(path9);
@@ -73003,9 +73688,9 @@ async function buildGlossary(path9, options = {}) {
   const allowedTypes = new Set(targets);
   const glossary = [];
   for (const type of targets) {
-    const files = await readGlossaryFiles(join62(knowledgeRoot4, type));
+    const files = await readGlossaryFiles(join63(knowledgeRoot4, type));
     for (const file of files) {
-      const parsed = parseNodeMarkdown(await readFile63(file, "utf8"));
+      const parsed = parseNodeMarkdown(await readFile64(file, "utf8"));
       if (parsed.node.type !== type)
         continue;
       collectGlossaryFromParsedTree(parsed, glossary, allowedTypes);
@@ -73071,7 +73756,7 @@ init_query();
 // src/commands/mdriveSection.ts
 init_errors();
 init_cliFeedback();
-import { readFile as readFile64 } from "node:fs/promises";
+import { readFile as readFile65 } from "node:fs/promises";
 init_knowledge();
 init_exitCode();
 init_section();
@@ -73084,7 +73769,7 @@ async function readSourceRefText(options) {
       category: ErrorCategory.UserInputInvalid
     });
   }
-  return hasText ? String(options.text) : await readFile64(String(options.textFile), "utf8");
+  return hasText ? String(options.text) : await readFile65(String(options.textFile), "utf8");
 }
 function registerMdriveSectionCommands(mdrive, deps) {
   const section = mdrive.command("section").description("Section primitives");
@@ -73189,7 +73874,7 @@ function optionalChoice(value, choices, label) {
 }
 async function readStructuredInput3(path9, label = "--input") {
   const value = requireString2(path9, label);
-  const raw = value === "-" ? await readStdinText() : await readFile65(value, "utf8");
+  const raw = value === "-" ? await readStdinText() : await readFile66(value, "utf8");
   return import_yaml34.default.parse(raw);
 }
 function asRecord2(input, label) {
@@ -73618,8 +74303,8 @@ init_cliFeedback();
 init_errors();
 var import_yaml35 = __toESM(require_dist(), 1);
 import { existsSync as existsSync53 } from "node:fs";
-import { lstat as lstat2, mkdir as mkdir28, readFile as readFile66, readdir as readdir26, realpath as realpath3, rename as rename6, writeFile as writeFile19 } from "node:fs/promises";
-import { dirname as dirname24, isAbsolute as isAbsolute7, join as join63, relative as relative14 } from "node:path";
+import { lstat as lstat2, mkdir as mkdir28, readFile as readFile67, readdir as readdir26, realpath as realpath3, rename as rename6, writeFile as writeFile19 } from "node:fs/promises";
+import { dirname as dirname25, isAbsolute as isAbsolute7, join as join64, relative as relative15 } from "node:path";
 init_workspaceLayout();
 init_section();
 init_exitCode();
@@ -73675,7 +74360,7 @@ function normalizeWorkspacePath(input) {
 async function assertRealPathInside(ctxDir, targetPath) {
   const rootReal = await realpath3(ctxDir);
   const targetReal = await realpath3(targetPath);
-  const rel = relative14(rootReal, targetReal);
+  const rel = relative15(rootReal, targetReal);
   if (rel === "" || !rel.startsWith("..") && !isAbsolute7(rel))
     return;
   throw new ContextError(ExitCode.UserError, "workspace path resolves outside the context data root", {
@@ -73683,7 +74368,7 @@ async function assertRealPathInside(ctxDir, targetPath) {
   });
 }
 function resolveWorkspacePath(ctxDir, relPath) {
-  return relPath === "." ? ctxDir : join63(ctxDir, relPath);
+  return relPath === "." ? ctxDir : join64(ctxDir, relPath);
 }
 function pathKind2(stats) {
   if (stats.isFile())
@@ -73791,7 +74476,7 @@ async function searchWorkspace(input) {
     if (hits.length >= input.maxResults || entry.kind !== "file")
       continue;
     const abs = resolveWorkspacePath(input.ctxDir, entry.path);
-    const content3 = await readFile66(abs, "utf8");
+    const content3 = await readFile67(abs, "utf8");
     if (!isProbablyText(content3))
       continue;
     const lines = content3.replace(/\r\n/g, `
@@ -73844,7 +74529,7 @@ async function writeWorkspaceFile(input) {
       path: input.relPath
     });
   }
-  await mkdir28(dirname24(destination), { recursive: true });
+  await mkdir28(dirname25(destination), { recursive: true });
   const tmpPath = `${destination}.workspace-tmp-${process.pid}-${Date.now()}`;
   await writeFile19(tmpPath, input.content, "utf8");
   await assertRealPathInside(input.ctxDir, tmpPath);
@@ -73873,11 +74558,11 @@ async function readResolveRefText(ctxDir, options) {
     return String(options.text);
   const file = String(options.textFile);
   try {
-    return await readFile66(file, "utf8");
+    return await readFile67(file, "utf8");
   } catch (error) {
     if (error.code !== "ENOENT" || isAbsolute7(file))
       throw error;
-    return await readFile66(resolveWorkspacePath(ctxDir, normalizeWorkspacePath(file)), "utf8");
+    return await readFile67(resolveWorkspacePath(ctxDir, normalizeWorkspacePath(file)), "utf8");
   }
 }
 function registerWorkspaceCommands(program2) {
@@ -73901,7 +74586,7 @@ function registerWorkspaceCommands(program2) {
         path: relPath
       });
     }
-    const content3 = await readFile66(absPath, "utf8");
+    const content3 = await readFile67(absPath, "utf8");
     const format = assertChoice3(options.format, READ_FORMATS, "--format");
     if (format === "json") {
       process.stdout.write(`${JSON.stringify({
@@ -74450,6 +75135,7 @@ function compactAlignSegments(record, value) {
 }
 var LARGE_WINDOW_BLOCK_THRESHOLD = 12;
 var WINDOW_PREVIEW_LIMIT = 1;
+var FULL_TEXT_METADATA_TOKEN_BUFFER = 100;
 var SOURCE_WINDOW_SELECTOR_RE = /^(src-[1-9]\d*):([1-9]\d*)$/u;
 var ALIGN_BLOCKS_SELECTION_POLICY = {
   id: "align-blocks-v1",
@@ -74484,6 +75170,16 @@ function blockLineRange(block) {
     return;
   return `L${block.line_start}-L${block.line_end}`;
 }
+function normalizedPreviewBasis(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function blockBodyText(block) {
+  return typeof block.body_text === "string" && block.body_text.length > 0 ? block.body_text : undefined;
+}
+function fullTextTokenEstimate(block, bodyText) {
+  const storedEstimate = typeof block.token_estimate === "number" && Number.isFinite(block.token_estimate) ? Math.max(0, block.token_estimate) : 0;
+  return Math.max(storedEstimate, estimateTokenCount(bodyText));
+}
 function alignBlockRows(value) {
   if (!isRecord29(value))
     return [];
@@ -74492,6 +75188,8 @@ function alignBlockRows(value) {
     const locator = isRecord29(block.stable_locator_hint) ? block.stable_locator_hint : {};
     const ordinal = typeof locator.ordinal_in_source === "number" ? locator.ordinal_in_source : index2 + 1;
     const textPreview = previewText2(block.text_preview, 220);
+    const bodyText = blockBodyText(block);
+    const textPreviewTruncated = bodyText !== undefined && textPreview !== undefined ? normalizedPreviewBasis(bodyText).length > textPreview.length : undefined;
     const signals = blockSignalLabels(block, textPreview);
     const lineRange2 = blockLineRange(block);
     return {
@@ -74507,7 +75205,13 @@ function alignBlockRows(value) {
       ordinal_in_source: ordinal,
       signal_labels: signals,
       signal_score: signals.length,
-      ...textPreview !== undefined ? { text_preview: textPreview } : {}
+      ...textPreview !== undefined ? { text_preview: textPreview } : {},
+      ...bodyText !== undefined ? {
+        body_text: bodyText,
+        full_text_available: true,
+        full_text_token_estimate: fullTextTokenEstimate(block, bodyText),
+        text_preview_truncated: textPreviewTruncated === true
+      } : {}
     };
   }));
 }
@@ -74640,7 +75344,7 @@ function blockDetailContext(blocks) {
     ...sameHeadingPath2 ? { heading_path: first.heading_path } : {}
   };
 }
-function blockDetailRow(block, context) {
+function blockDetailRow(block, context, options) {
   return {
     ...context.source === undefined ? { source_alias: block.source_alias, source_id: block.source_id } : {},
     block_id: block.block_id,
@@ -74652,11 +75356,25 @@ function blockDetailRow(block, context) {
     block_locator_id: block.block_locator_id,
     block_ordinal: block.ordinal_in_source,
     ...block.signal_labels.length > 0 ? { signal_labels: block.signal_labels, signal_score: block.signal_score } : {},
-    ...block.text_preview !== undefined ? { text_preview: block.text_preview } : {}
+    ...block.text_preview !== undefined ? { text_preview: block.text_preview } : {},
+    ...block.full_text_available === true ? {
+      full_text_available: true,
+      ...block.full_text_token_estimate !== undefined ? { full_text_token_estimate: block.full_text_token_estimate } : {},
+      text_preview_truncated: block.text_preview_truncated === true
+    } : {},
+    ...options.includeFullText && block.body_text !== undefined ? {
+      body_text: block.body_text,
+      full_text_included: true
+    } : {}
   };
 }
-function blockDetailItems(blocks, context) {
-  return blocks.map((block) => ({ block, row: blockDetailRow(block, context) }));
+function blockDetailItems(blocks, context, options) {
+  const singleBlock = blocks.length === 1 ? blocks[0] : undefined;
+  const includeFullText = singleBlock?.body_text !== undefined && (singleBlock.full_text_token_estimate ?? blockTokenEstimate(singleBlock)) + FULL_TEXT_METADATA_TOKEN_BUFFER <= options.tokenBudget;
+  return blocks.map((block) => ({
+    block,
+    row: blockDetailRow(block, context, { includeFullText: includeFullText && block === singleBlock })
+  }));
 }
 function blockTokenEstimate(block) {
   return typeof block.token_estimate === "number" && Number.isFinite(block.token_estimate) ? Math.max(0, block.token_estimate) : 0;
@@ -74683,6 +75401,27 @@ function alignBlocksHowToExplore(input) {
     ]
   });
 }
+function alignBlockPreviewHints(input) {
+  const truncated = input.items.filter((item) => item.text_preview_truncated === true && typeof item.body_text !== "string");
+  const first = truncated[0];
+  if (first === undefined)
+    return;
+  const ordinal = typeof first.block_ordinal === "number" ? first.block_ordinal : undefined;
+  const estimate = typeof first.full_text_token_estimate === "number" ? first.full_text_token_estimate : input.tokenBudget;
+  return [{
+    code: "align-block-preview-truncated",
+    severity: "warning",
+    message: `${truncated.length} shown block preview(s) are truncated while full block text is available.`,
+    next_action: "Narrow to a single block with --range <ordinal>:<ordinal> so the blocks view can include body_text before drafting decisions.",
+    ...ordinal !== undefined ? {
+      command: alignBlocksCommand(input.record, {
+        ...input.options,
+        range: `${ordinal}:${ordinal}`,
+        tokenBudget: String(Math.max(input.tokenBudget, estimate + FULL_TEXT_METADATA_TOKEN_BUFFER))
+      })
+    } : {}
+  }];
+}
 function compactAlignSegmentBlocks(record, value, options) {
   const windows = alignWindowRows(value);
   const selectedWindow = typeof options.windowId === "string" ? resolveWindowSelector(windows, options.windowId) : undefined;
@@ -74699,8 +75438,8 @@ function compactAlignSegmentBlocks(record, value, options) {
   const range = parseOrdinalRange(options.range);
   const blocks = alignBlockRows(value).filter((block) => (options.sourceId === undefined || block.source_id === options.sourceId) && (windowBlockIds === undefined || typeof block.block_id === "string" && windowBlockIds.has(block.block_id)) && headingMatches(block.heading_path, options.heading) && (range === undefined || block.ordinal_in_source >= range.start && block.ordinal_in_source <= range.end));
   const detailContext = blockDetailContext(blocks);
-  const detailItems = blockDetailItems(blocks, detailContext);
   const tokenBudget = parseTokenBudgetOption(options.tokenBudget);
+  const detailItems = blockDetailItems(blocks, detailContext, { tokenBudget });
   const window2 = buildTokenBudgetWindow({
     entries: detailItems.map((item) => ({
       item: item.row,
@@ -74712,6 +75451,7 @@ function compactAlignSegmentBlocks(record, value, options) {
     howToExplore: alignBlocksHowToExplore({ record, blocks, options, tokenBudget }),
     previewItem: (row) => row
   });
+  const agentHints = alignBlockPreviewHints({ record, items: window2.items, options, tokenBudget });
   return {
     mode: "detail",
     filters: compactFilters(options),
@@ -74731,7 +75471,8 @@ function compactAlignSegmentBlocks(record, value, options) {
     counts: {
       matched_blocks: blocks.length,
       shown_blocks: window2.items.length
-    }
+    },
+    ...agentHints !== undefined ? { agent_hints: agentHints } : {}
   };
 }
 function compactAlignSegmentSourceMapping(value, options) {
@@ -77127,6 +77868,13 @@ function formatDraftPlanHeadline(result) {
 function shellQuote2(value) {
   return `'${value.replace(/'/g, "'\\''")}'`;
 }
+function formatDraftPatchHeadline(result) {
+  const counts = actionCounts(result);
+  return `${counts.total} actions parsed; draft patched; re-prepare required`;
+}
+function compileDraftPrepareCommand(slug) {
+  return `context compile --draft ${shellQuote2(slug)} --plan --prepare --view summary --format json`;
+}
 function draftPlanBody(input) {
   const { ctxDir, slug, saved, hints, draftDigest, result } = input;
   const draftPath = workflowOutputPath(ctxDir, "compile", `compile.${slug}.draft.yaml`);
@@ -77164,7 +77912,7 @@ function draftPlanBody(input) {
   lines.push("- continue: `/context:compile`");
   if (draftDigest !== undefined) {
     lines.push(`- revise: \`context compile --draft-patch ${shellQuote2(slug)} --input - --plan\``);
-    lines.push(`- prepare saved draft: \`context compile --draft ${shellQuote2(slug)} --plan --prepare --view summary --format json\``);
+    lines.push(`- prepare saved draft: \`${compileDraftPrepareCommand(slug)}\``);
     lines.push(`- primitive: \`context reconcile prepare --mode compile --node ${shellQuote2(slug)} --view summary --format json\``);
   } else if (saved) {
     lines.push(`- saved draft: \`${draftPath}\``);
@@ -77478,7 +78226,7 @@ init_generationPolicy();
 var import_yaml38 = __toESM(require_dist(), 1);
 import { createHash as createHash9 } from "node:crypto";
 import { mkdir as mkdir29, writeFile as writeFile20 } from "node:fs/promises";
-import { dirname as dirname25 } from "node:path";
+import { dirname as dirname26 } from "node:path";
 
 // src/workflow/alignCandidates.ts
 init_rawBlocks();
@@ -77779,7 +78527,7 @@ async function writeAlignSegments(options) {
   const payload = await buildAlignSegments(options);
   if (options.dryRun !== true) {
     const outPath = options.outputPath ?? workflowOutputPath(options.ctxDir, "align", "align.segments.yaml");
-    await mkdir29(dirname25(outPath), { recursive: true });
+    await mkdir29(dirname26(outPath), { recursive: true });
     await writeFile20(outPath, import_yaml38.default.stringify(payload), "utf8");
   }
   return payload;
@@ -79320,6 +80068,12 @@ var ALIGN_WORKFLOW_FORBIDDEN_FIELDS = [
 ];
 var termTags = TERM_TAG_VALUES;
 var entityTags = [...ENTITY_TAG_A_VALUES, ...ENTITY_TAG_B_VALUES, ...termTags];
+var entityTagGroups = {
+  tag_a: ENTITY_TAG_A_VALUES,
+  tag_b: ENTITY_TAG_B_VALUES,
+  standalone: termTags,
+  allowed_shapes: ["one tag_a", "one tag_b", "one tag_a plus one tag_b", "standalone only"]
+};
 var TERM_ENTITY_NOTES = [
   "Node type order: action first only when scale plus process evidence both pass; otherwise concrete/term entity; otherwise child-bearing domain; otherwise no Node.",
   "Classify the Node by evidence referent, not by source title or heading. Source title/heading is ordinary evidence and does not automatically become node.title, aliases[], or slug.",
@@ -79569,6 +80323,7 @@ var SCHEMAS = {
     consumer: "CLI ledger reducer",
     role: "One transactional batch of candidate ledger operations.",
     enums: enums(),
+    entity_tag_groups: entityTagGroups,
     required: ["batch_id", "ops"],
     forbidden_fields: ALIGN_WORKFLOW_FORBIDDEN_FIELDS,
     example: {
@@ -79659,6 +80414,7 @@ var SCHEMAS = {
     consumer: "next Discovery batch / CLI aggregate / LLM resolution",
     role: "Current rolling candidate snapshot, not the operation stream.",
     enums: enums(),
+    entity_tag_groups: entityTagGroups,
     required: ["schema_version", "last_batch_id", "candidates", "block_dispositions"],
     forbidden_fields: ALIGN_WORKFLOW_FORBIDDEN_FIELDS,
     example: {
@@ -79749,6 +80505,7 @@ var SCHEMAS = {
     consumer: "CLI finalize",
     role: "Final Node structure, depends_on edges, planned Sections, and block ownership.",
     enums: enums(),
+    entity_tag_groups: entityTagGroups,
     mount_matrix: sectionMountMatrix(),
     required: ["schema_version", "nodes", "sections", "edges", "block_ownership"],
     forbidden_fields: ALIGN_WORKFLOW_FORBIDDEN_FIELDS,
@@ -80778,7 +81535,7 @@ init_sourceOwnership();
 init_workflowOutputPaths();
 var import_yaml39 = __toESM(require_dist(), 1);
 import { mkdir as mkdir30, writeFile as writeFile21 } from "node:fs/promises";
-import { dirname as dirname26 } from "node:path";
+import { dirname as dirname27 } from "node:path";
 function lineRange2(block) {
   return `L${block.line_start}-L${block.line_end}`;
 }
@@ -80838,7 +81595,7 @@ function renderMarkdown2(input) {
 async function renderStructureDecisionProposal(input) {
   const path9 = workflowOutputPath(input.ctxDir, "align", "align.propose.md");
   const debugPath = workflowOutputPath(input.ctxDir, "align", "align.propose.yaml");
-  await mkdir30(dirname26(path9), { recursive: true });
+  await mkdir30(dirname27(path9), { recursive: true });
   await writeFile21(path9, renderMarkdown2(input), "utf8");
   await writeFile21(debugPath, import_yaml39.default.stringify({
     schema_version: input.decision.schema_version,
@@ -83314,7 +84071,7 @@ async function runDraftPatch(input) {
     scopeId: nodeRunIdForSlug(input.slug),
     draft: normalizedDraft
   });
-  const revisionCommand = compileDraftRevisionHints(result.slug, nextPayload.digest)[0].command ?? `context compile --draft-patch ${result.slug} --input - --plan`;
+  const prepareCommand = compileDraftPrepareCommand(result.slug);
   const outputHints = [...patch.agent_hints ?? [], ...result.agent_hints ?? []];
   if (compileChangesFormat(input.options.format) === "json") {
     writeJson3({
@@ -83331,7 +84088,7 @@ async function runDraftPatch(input) {
       },
       action_counts: draftActionCounts(normalizedDraft),
       agent_hints: outputHints,
-      next_command: revisionCommand
+      next_command: prepareCommand
     });
     return;
   }
@@ -83339,7 +84096,7 @@ async function runDraftPatch(input) {
     symbol: outputHints.some((hint) => hint.severity === "warning" || hint.severity === "error") ? "⚠" : "✓",
     action: "patched",
     subject: input.slug,
-    headline: formatDraftPlanHeadline(result),
+    headline: formatDraftPatchHeadline(result),
     body: [
       workflowSummaryLine(current),
       ...draftPlanBody({
@@ -83351,7 +84108,7 @@ async function runDraftPatch(input) {
         result
       })
     ],
-    next: revisionCommand
+    next: prepareCommand
   }));
 }
 async function draftFromSavedSession(input) {
@@ -84124,7 +84881,7 @@ function registerWorkflowCommands(program2) {
 init_cliFeedback();
 init_errors();
 import { lstat as lstat3, readdir as readdir27 } from "node:fs/promises";
-import { isAbsolute as isAbsolute8, join as join64, relative as relative15, resolve as resolve14 } from "node:path";
+import { isAbsolute as isAbsolute8, join as join65, relative as relative16, resolve as resolve15 } from "node:path";
 
 // src/lib/pathFreeAgentHintWorkflowInventory.ts
 var AGENT_HINT_EMITTER_WORKFLOW_INVENTORY = [
@@ -84881,6 +85638,13 @@ var AGENT_HINT_EMITTER_INVENTORY = [
     handles: ["edge_owner", "node_slug", "issue_code"],
     notes: "Graph verify next actions route to compile close, compile --code, or edge repair."
   },
+  {
+    source: "src/mdrive/verifyRenderBlocks.ts",
+    family: "mdrive render-block verify",
+    policy: "semantic",
+    handles: ["node_slug", "issue_code", "line"],
+    notes: "Render-block verify next actions route to compile close or target Node repair without storage probing."
+  },
   {
     source: "src/mdrive/verifySourceRules.ts",
     family: "mdrive source verify",
@@ -84895,6 +85659,13 @@ var AGENT_HINT_EMITTER_INVENTORY = [
     handles: ["issue_code", "next_action"],
     notes: "Verify issue type exposes next_action as a semantic repair field."
   },
+  {
+    source: "src/mdrive/verifyWorkspaceReader.ts",
+    family: "mdrive workspace reader verify",
+    policy: "semantic",
+    handles: ["node_slug", "issue_code", "line"],
+    notes: "Reader-surfaced render-block issues use semantic Node and line handles."
+  },
   {
     source: "src/reconcile/prepare.ts",
     family: "reconcile prepare",
@@ -84974,9 +85745,9 @@ function writeJson4(value) {
 `);
 }
 function workspacePath(ctxDir, relPath, label) {
-  const base = resolve14(ctxDir);
-  const path9 = resolve14(base, relPath);
-  const pathRelativeToBase = relative15(base, path9);
+  const base = resolve15(ctxDir);
+  const path9 = resolve15(base, relPath);
+  const pathRelativeToBase = relative16(base, path9);
   if (pathRelativeToBase.startsWith("..") || isAbsolute8(pathRelativeToBase)) {
     throw new ContextError(ExitCode.UserError, "debug path resolved outside the context workspace", {
       category: ErrorCategory.UserInputInvalid,
@@ -85112,11 +85883,11 @@ async function debugSourceRawPath(ctx, options) {
 function workspaceStorageRoots(ctxDir) {
   return {
     ctxDir,
-    raw: join64(ctxDir, "raw"),
-    knowledge: join64(ctxDir, "knowledge"),
-    output: join64(ctxDir, "output"),
-    archive: join64(ctxDir, "archive"),
-    decisions: join64(ctxDir, "decisions"),
+    raw: join65(ctxDir, "raw"),
+    knowledge: join65(ctxDir, "knowledge"),
+    output: join65(ctxDir, "output"),
+    archive: join65(ctxDir, "archive"),
+    decisions: join65(ctxDir, "decisions"),
     user_cache: workspaceUserCacheRoot(ctxDir)
   };
 }
@@ -85207,7 +85978,7 @@ async function knowledgeNodeTypeDirs(ctxDir) {
 async function inspectNodeObject(ctxDir, slug) {
   const typeDirs = await knowledgeNodeTypeDirs(ctxDir);
   const candidates = await Promise.all(typeDirs.map((type) => {
-    const relPath = join64("knowledge", type, `${slug}.md`);
+    const relPath = join65("knowledge", type, `${slug}.md`);
     return inspectWorkspacePath(ctxDir, relPath, relPath);
   }));
   return {
@@ -85223,7 +85994,7 @@ function safeArchiveSourceSegment(value) {
 async function inspectArchiveObject(ctx, archiveId) {
   const ctxDir = requireContext2(ctx, "debug storage inspect");
   const source2 = (ctx.sources?.sources ?? []).find((entry) => entry.id === archiveId);
-  const directRel = join64("archive", "sources", safeArchiveSourceSegment(archiveId));
+  const directRel = join65("archive", "sources", safeArchiveSourceSegment(archiveId));
   const paths = [
     ...source2?.archive_path !== undefined ? [await inspectWorkspacePath(ctxDir, source2.archive_path, "source.archive_path")] : [],
     await inspectWorkspacePath(ctxDir, directRel, directRel)
@@ -85271,7 +86042,7 @@ async function walkForFileName(root2, fileName, out2 = []) {
     throw error;
   }
   for (const entry of entries) {
-    const child = join64(root2, entry.name);
+    const child = join65(root2, entry.name);
     if (entry.isDirectory()) {
       await walkForFileName(child, fileName, out2);
     } else if (entry.isFile() && entry.name === fileName) {
@@ -85281,7 +86052,7 @@ async function walkForFileName(root2, fileName, out2 = []) {
   return out2;
 }
 async function inspectReviewObject(ctxDir, reviewId) {
-  const matches = await walkForFileName(join64(ctxDir, "output", "workflows"), `review.${reviewId}.yaml`);
+  const matches = await walkForFileName(join65(ctxDir, "output", "workflows"), `review.${reviewId}.yaml`);
   return {
     object: `review:${reviewId}`,
     kind: "review",
@@ -85291,7 +86062,7 @@ async function inspectReviewObject(ctxDir, reviewId) {
 }
 async function inspectWorkflowObject(ctxDir, workflowId) {
   const current = await readCurrentWorkflow(ctxDir);
-  const workflowRoot = workspacePath(ctxDir, join64("output", "workflows", safePathSegment2(workflowId)), "workflow output root");
+  const workflowRoot = workspacePath(ctxDir, join65("output", "workflows", safePathSegment2(workflowId)), "workflow output root");
   const currentMatches = current.status === "ready" && current.state.workflow_id === workflowId;
   return {
     object: `workflow:${workflowId}`,
@@ -85445,10 +86216,10 @@ async function buildDebugSnapshot(ctx) {
       manifest: cache.manifest
     },
     counts: {
-      raw_entries: await countDirectEntries(join64(ctxDir, "raw")),
-      knowledge_entries: await countDirectEntries(join64(ctxDir, "knowledge")),
-      output_entries: await countDirectEntries(join64(ctxDir, "output")),
-      archive_entries: await countDirectEntries(join64(ctxDir, "archive"))
+      raw_entries: await countDirectEntries(join65(ctxDir, "raw")),
+      knowledge_entries: await countDirectEntries(join65(ctxDir, "knowledge")),
+      output_entries: await countDirectEntries(join65(ctxDir, "output")),
+      archive_entries: await countDirectEntries(join65(ctxDir, "archive"))
     }
   };
 }
@@ -85522,11 +86293,11 @@ init_errors();
 init_cliFeedback();
 init_config();
 init_errors();
-import { join as join68 } from "node:path";
+import { join as join69 } from "node:path";
 
 // src/build/llms.ts
 import { writeFile as writeFile22 } from "node:fs/promises";
-import { join as join66 } from "node:path";
+import { join as join67 } from "node:path";
 
 // src/build/renderKnowledge.ts
 init_nodeRenderer();
@@ -85609,7 +86380,7 @@ init_nodeRenderer();
 init_exitCode();
 init_knowledge();
 import { mkdir as mkdir31 } from "node:fs/promises";
-import { join as join65 } from "node:path";
+import { join as join66 } from "node:path";
 var MAX_TIMESTAMP_COLLISION_ATTEMPTS = 60;
 var SUMMARY_MAX_LENGTH = 160;
 var NODE_TYPE_ORDER = [NodeType2.domain, NodeType2.entity, NodeType2.action];
@@ -85636,11 +86407,11 @@ function isFsCode(error, code3) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code3;
 }
 async function createTimestampedPackageDir(outputRoot, packageName2, now) {
-  const packageRoot = join65(outputRoot, packageName2);
+  const packageRoot = join66(outputRoot, packageName2);
   await mkdir31(packageRoot, { recursive: true });
   for (let offsetSeconds = 0;offsetSeconds < MAX_TIMESTAMP_COLLISION_ATTEMPTS; offsetSeconds += 1) {
     const candidateTime = new Date(now.getTime() + offsetSeconds * 1000);
-    const candidate = join65(packageRoot, formatBuildTimestamp(candidateTime));
+    const candidate = join66(packageRoot, formatBuildTimestamp(candidateTime));
     try {
       await mkdir31(candidate);
       return candidate;
@@ -85716,10 +86487,10 @@ function renderLlmsIndex(input) {
 }
 async function writeLlmsPackage(input) {
   const packageDir = await createTimestampedPackageDir(input.outputRoot, "llms-pkg", input.now);
-  await writeFile22(join66(packageDir, "llms.txt"), renderLlmsIndex(input), "utf8");
+  await writeFile22(join67(packageDir, "llms.txt"), renderLlmsIndex(input), "utf8");
   await Promise.all(input.nodes.map(async (node3) => {
     const parsed = node3.located.parsed.node;
-    await writeFile22(join66(packageDir, buildNodeFileName(parsed)), renderExportNodeMarkdown({ node: parsed, sections: node3.activeSections }), "utf8");
+    await writeFile22(join67(packageDir, buildNodeFileName(parsed)), renderExportNodeMarkdown({ node: parsed, sections: node3.activeSections }), "utf8");
   }));
   return {
     packageDir,
@@ -85729,7 +86500,7 @@ async function writeLlmsPackage(input) {
 
 // src/build/skillsPack.ts
 import { mkdir as mkdir32, writeFile as writeFile23 } from "node:fs/promises";
-import { join as join67 } from "node:path";
+import { join as join68 } from "node:path";
 var KNOWLEDGE_QUERY_PROCEDURE = [
   "1. For a named topic, read the matching wiki file directly from `wikis/`.",
   "2. For a broad question, grep `wikis/` with relevant keywords, then read the matching wiki files.",
@@ -85790,23 +86561,23 @@ function renderKnowledgeQuerySkill() {
 }
 async function writeSkillsPack(input) {
   const packageDir = await createTimestampedPackageDir(input.outputRoot, "skills-pkg", input.now);
-  const guidesDir = join67(packageDir, "guides");
-  const skillsDir = join67(packageDir, "skills");
-  const wikisDir = join67(packageDir, "wikis");
+  const guidesDir = join68(packageDir, "guides");
+  const skillsDir = join68(packageDir, "skills");
+  const wikisDir = join68(packageDir, "wikis");
   await Promise.all([
     mkdir32(guidesDir, { recursive: true }),
     mkdir32(skillsDir, { recursive: true }),
     mkdir32(wikisDir, { recursive: true }),
-    mkdir32(join67(packageDir, "rules"), { recursive: true }),
-    mkdir32(join67(packageDir, "integrations"), { recursive: true })
+    mkdir32(join68(packageDir, "rules"), { recursive: true }),
+    mkdir32(join68(packageDir, "integrations"), { recursive: true })
   ]);
   await Promise.all([
-    writeFile23(join67(guidesDir, "AGENTS.md"), renderAgentsGuide2(input), "utf8"),
-    writeFile23(join67(skillsDir, "knowledge-query.md"), renderKnowledgeQuerySkill(), "utf8")
+    writeFile23(join68(guidesDir, "AGENTS.md"), renderAgentsGuide2(input), "utf8"),
+    writeFile23(join68(skillsDir, "knowledge-query.md"), renderKnowledgeQuerySkill(), "utf8")
   ]);
   await Promise.all(input.nodes.map(async (node3) => {
     const parsed = node3.located.parsed.node;
-    await writeFile23(join67(wikisDir, buildNodeFileName(parsed)), renderExportNodeMarkdown({ node: parsed, sections: node3.activeSections }), "utf8");
+    await writeFile23(join68(wikisDir, buildNodeFileName(parsed)), renderExportNodeMarkdown({ node: parsed, sections: node3.activeSections }), "utf8");
   }));
   return {
     packageDir,
@@ -85888,7 +86659,7 @@ async function collectExportNodes(ctxDir) {
   return {
     config,
     nodes,
-    outputRoot: join68(ctxDir, "output")
+    outputRoot: join69(ctxDir, "output")
   };
 }
 async function buildKnowledgePackage(input) {
@@ -86049,7 +86820,7 @@ function cmdVerifyWorkspace(opts = {}) {
         subject: "knowledge",
         headline: `${result.issues.length} issues (${errors3} error, ${warnings} warning)`,
         body: [
-          ...result.issues.map((issue2) => `[${issue2.severity}] ${issue2.code}${issue2.slug ? ` node=${issue2.slug}` : ""}${issue2.sectionId ? ` section=${issue2.sectionId}` : ""}: ${issue2.message}`),
+          ...result.issues.map((issue2) => `[${issue2.severity}] ${issue2.code}${issue2.slug ? ` node=${issue2.slug}` : ""}${issue2.sectionId ? ` section=${issue2.sectionId}` : ""}${issue2.line ? ` line=${issue2.line}` : ""}: ${issue2.message}`),
           ...verifyHintLines(result)
         ]
       }));
@@ -86676,14 +87447,14 @@ function inferErrorCategory(message) {
 }
 function readPackageVersion() {
   try {
-    let dir = dirname27(fileURLToPath5(import.meta.url));
+    let dir = dirname28(fileURLToPath5(import.meta.url));
     for (let i = 0;i < 8; i++) {
-      const pkg = join69(dir, "package.json");
+      const pkg = join70(dir, "package.json");
       if (existsSync54(pkg)) {
         const parsed = JSON.parse(readFileSync3(pkg, "utf8"));
         return parsed.version ?? "unknown";
       }
-      const parent = dirname27(dir);
+      const parent = dirname28(dir);
       if (parent === dir)
         break;
       dir = parent;