@c4a/context-cli 0.5.35-alpha.3 → 0.5.35-beta.1

package/cli.js

@@ -45002,6 +45002,17 @@ function hasCitedFencedDetail(detail, basisTexts) {
     return false;
   return fencedBlocksIn(detail).some((block) => cited.includes(block));
 }
+function fencedPayloadLines(block) {
+  return block.split(/\r?\n/u).filter((line) => !/^\s*(?:```|~~~)/u.test(line)).map((line) => line.trim()).filter((line) => line.length > 0);
+}
+function citedFencedDetailSupportsExcerpt(detail, basisTexts) {
+  const citedBlocks = fencedBlocksIn(basisText(basisTexts));
+  const detailBlocks = fencedBlocksIn(detail);
+  return detailBlocks.length > 0 && detailBlocks.every((block) => citedBlocks.some((cited) => cited.includes(block) || fencedPayloadLines(block).every((line) => cited.includes(line))));
+}
+function stripFencedBlocks(value) {
+  return value.replace(FENCED_DETAIL_BLOCK_RE, " ");
+}
 var FENCED_DETAIL_BLOCK_RE;
 var init_sectionDetail = __esm(() => {
   init_normalize();
@@ -45235,13 +45246,18 @@ function sourceTextSupportDiagnostic(content3, citedText, thresholds = DEFAULT_T
 function sourceSectionSupportDiagnostic(input) {
   const detail = typeof input.detail === "string" ? input.detail.trim() : "";
   const content3 = input.content;
+  const thresholds = thresholdsForKind(input.kind);
   if (detail.length === 0) {
-    return {
-      ...sourceTextSupportDiagnostic(content3, input.citedText, thresholdsForKind(input.kind)),
-      checkedFields: ["content"]
-    };
+    const diagnostic = sourceTextSupportDiagnostic(content3, input.citedText, thresholds);
+    if (input.kind === "example" && diagnostic.verdict === "unsupported" && citedFencedDetailSupportsExcerpt(content3, input.citedText)) {
+      const prose = stripFencedBlocks(content3).trim();
+      const proseDiagnostic = prose.length === 0 ? { ...diagnostic, verdict: "supported", missingContentTerms: [], missingHardTerms: [] } : sourceTextSupportDiagnostic(prose, stripFencedBlocks(input.citedText), thresholds);
+      if (prose.length === 0 || proseDiagnostic.verdict !== "unsupported" && proseDiagnostic.missingHardTerms.length === 0) {
+        return { ...proseDiagnostic, checkedFields: ["content"] };
+      }
+    }
+    return { ...diagnostic, checkedFields: ["content"] };
   }
-  const thresholds = thresholdsForKind(input.kind);
   const contentDiagnostic = sourceTextSupportDiagnostic(content3, input.citedText, thresholds);
   const detailDiagnostic = sourceTextSupportDiagnostic(detail, input.citedText, thresholds);
   const combined = sourceTextSupportDiagnostic(`${content3}
@@ -46456,10 +46472,13 @@ function createCompileChangesOutput(input) {
   let nodesChanged = 0;
   let nonBlockingBlocksChanged = 0;
   let nonBlockingNodesChanged = 0;
+  const firstCompileSlugs = [];
   for (const node3 of input.nodes) {
     const actionableBlocks = blockingChangedBlocksForNode(node3);
     const nonBlockingBlocks = nonBlockingChangedBlocksForNode(node3);
     const locatorOnlyChanges = node3.locator_only_changes ?? [];
+    if (node3.reason === "first-compile")
+      firstCompileSlugs.push(node3.slug);
     if (node3.reason === "first-compile" || actionableBlocks.length > 0 || locatorOnlyChanges.length > 0)
       nodesChanged += 1;
     if (nonBlockingBlocks.length > 0)
@@ -46475,6 +46494,7 @@ function createCompileChangesOutput(input) {
         sectionsChanged.add(`${node3.slug}:${section}`);
     }
   }
+  firstCompileSlugs.sort((left, right) => left.localeCompare(right));
   const status = input.unknownInputs.length > 0 ? "unknown-input" : "ready";
   return {
     schema_version: INCREMENTAL_SCHEMA_VERSION,
@@ -46496,6 +46516,14 @@ function createCompileChangesOutput(input) {
       unknown_inputs: input.unknownInputs.length,
       partial: input.unknownInputs.length > 0
     },
+    ...firstCompileSlugs.length > 0 ? {
+      first_compile_pending: {
+        remaining: firstCompileSlugs.length,
+        remaining_slugs: firstCompileSlugs,
+        commands: firstCompileSlugs.map((slug) => `context compile --context ${slug}`),
+        next_action: "Compile each remaining first-compile Node before running context compile --close."
+      }
+    } : {},
     nodes: input.nodes,
     ...input.ignoredLocatorChanges !== undefined && input.ignoredLocatorChanges.length > 0 ? { ignored_locator_changes: input.ignoredLocatorChanges } : {},
     unknown_inputs: input.unknownInputs
@@ -46561,35 +46589,35 @@ var init_compileIgnoredSources = __esm(() => {
 });
 
 // src/workflow/compileChangesInputs.ts
+function alignNodeFromOwnership(node3) {
+  return {
+    slug: node3.slug,
+    type: node3.type,
+    sources: [...node3.sources],
+    contextSources: [...node3.context_sources ?? []],
+    hasExplicitSources: true,
+    plannedSections: [...node3.planned_sections ?? []]
+  };
+}
 async function readAlignNodes(ctxDir) {
   try {
-    const nodes = await scanWorkspaceNodes(ctxDir);
-    if (nodes.length === 0) {
-      const ownership = await readCurrentSourceOwnership(ctxDir);
-      if (ownership?.nodes !== undefined && ownership.nodes.length > 0) {
-        return {
-          status: "ready",
-          nodes: ownership.nodes.map((node3) => ({
-            slug: node3.slug,
-            type: node3.type,
-            sources: [...node3.sources],
-            contextSources: [...node3.context_sources ?? []],
-            hasExplicitSources: true,
-            plannedSections: [...node3.planned_sections ?? []]
-          }))
-        };
-      }
+    const locatedNodes = await scanWorkspaceNodes(ctxDir);
+    const nodes = new Map(locatedNodes.map((located) => [located.parsed.node.id, {
+      slug: located.parsed.node.id,
+      type: located.parsed.node.type,
+      sources: [...located.parsed.node.sources],
+      contextSources: [...located.parsed.node.context_sources ?? []],
+      hasExplicitSources: true,
+      plannedSections: [...located.parsed.node.planned_sections ?? []]
+    }]));
+    const ownership = await readCurrentSourceOwnership(ctxDir);
+    for (const node3 of ownership?.nodes ?? []) {
+      if (!nodes.has(node3.slug))
+        nodes.set(node3.slug, alignNodeFromOwnership(node3));
     }
     return {
       status: "ready",
-      nodes: nodes.map((located) => ({
-        slug: located.parsed.node.id,
-        type: located.parsed.node.type,
-        sources: [...located.parsed.node.sources],
-        contextSources: [...located.parsed.node.context_sources ?? []],
-        hasExplicitSources: true,
-        plannedSections: [...located.parsed.node.planned_sections ?? []]
-      }))
+      nodes: [...nodes.values()]
     };
   } catch {
     return { status: "unknown-input", reason: "knowledge-scan-failed" };
@@ -49453,7 +49481,7 @@ function lineRangeText(range) {
   return `${range.start}:${range.end}`;
 }
 function requestFullTextPageCommand(slug, blockId, range) {
-  return `context compile --context ${slug} --request-full-text ${blockId} --request-full-text-range ${range} --format json`;
+  return `context compile --context ${slug} --request-full-text ${blockId} --request-full-text-range ${range} --view text --format json`;
 }
 function isFenceLine(line) {
   return /^\s*(```|~~~)/u.test(line);
@@ -49828,7 +49856,7 @@ function requestableFullTextBlockIds(ownership, slug) {
 }
 function requestFullTextCommand(slug, blockIds) {
   const flags2 = blockIds.length > 0 ? blockIds.map((blockId) => ` --request-full-text ${blockId}`).join("") : " --request-full-text <block_id>";
-  return `context compile --context ${slug}${flags2}`;
+  return `context compile --context ${slug}${flags2} --view text --format json`;
 }
 function requestFullTextError(input) {
   const hint = {
@@ -50033,7 +50061,7 @@ async function appendFinalizedBlock(input) {
       request_full_text: {
         available: true,
         block_id: blockId,
-        command_hint: `context compile --context ${input.nodeSlug} --request-full-text ${blockId}`
+        command_hint: `context compile --context ${input.nodeSlug} --request-full-text ${blockId} --view text --format json`
       }
     } : {}
   };
@@ -50254,7 +50282,7 @@ function compileContextRuntimeHints(context) {
       message: `${expandableSecondaryBlockIds.length} secondary shared block(s) are compacted and not citation-eligible.`,
       target_node: context.node.slug,
       next_action: "Request full text only when you need to inspect background. Expanded secondary text still cannot support Section source_refs.",
-      command: `context compile --context ${context.node.slug}${flags2}`,
+      command: `context compile --context ${context.node.slug}${flags2} --view text --format json`,
       available_block_ids: expandableSecondaryBlockIds
     });
   }
@@ -52747,6 +52775,23 @@ function nearbyCitationEligibleSourceRefs(input) {
   })).filter((item) => item.distance <= 3).sort((left, right) => left.distance - right.distance || left.range.start - right.range.start);
   return refs.slice(0, 8).map((item) => item.sourceRef);
 }
+function suggestedSplitDraftActions(diagnostics) {
+  const selectedBlocks = [...diagnostics.selected_blocks ?? []].sort((left, right) => left.manifest_index - right.manifest_index || left.source_ref.localeCompare(right.source_ref));
+  if (selectedBlocks.length === 0) {
+    return diagnostics.source_refs.map((sourceRef) => ({ op: "add", source_refs: [sourceRef] }));
+  }
+  const runs = [];
+  for (const block of selectedBlocks) {
+    const current = runs.at(-1);
+    const previous3 = current?.at(-1);
+    if (current === undefined || previous3 === undefined || block.manifest_index !== previous3.manifest_index + 1) {
+      runs.push([block]);
+    } else {
+      current.push(block);
+    }
+  }
+  return runs.map((run2) => ({ op: "add", source_refs: run2.map((block) => block.source_ref) }));
+}
 function normalizedForRawCompare2(value) {
   return normalizeMarkdown(value).trim();
 }
@@ -52783,11 +52828,17 @@ async function assertResolvedSourceRefs(ctxDir, sourceRefs2, slug, context, labe
         }
       });
     }
+    const suggestedSplitActions = suggestedSplitDraftActions(diagnostics);
     throw draftError(slug, context, `${label} could not be resolved to one contiguous source_ref; split the action or include every intervening citation-eligible source_ref`, {
       path: label,
       reasonCode: "source-refs-not-contiguous",
       currentValue: sourceRefs2,
-      diagnostics
+      diagnostics: {
+        ...diagnostics,
+        repair_options: ["split_by_contiguous_runs", "include_missing_intervening_source_refs"],
+        ...suggestedSplitActions.length > 1 ? { suggested_split_actions: suggestedSplitActions } : {},
+        next_action: "Use suggested_split_actions as separate draft actions, or include every missing_intervening_blocks[].source_ref if one Section truly covers that intervening evidence."
+      }
     });
   }
 }
@@ -57303,7 +57354,7 @@ async function pathExistsNoFollow(path3) {
 }
 function displayLanguage(language) {
   if (!language || language.trim().length === 0)
-    return "not set";
+    return "English (default)";
   const normalized = language.trim().toLowerCase();
   if (["zh", "zh-cn", "chinese", "中文", "汉语"].includes(normalized))
     return "Chinese";
@@ -57316,56 +57367,47 @@ function renderAgentsGuide(input) {
   const projectRoot = location.layout === "embedded" ? ".." : ".";
   return `# C4A Workspace Instructions
 
-This directory is the C4A data root for a knowledge workspace.
-
-- Workspace name: ${input.workspaceName}
-- Workspace layout: ${location.layout}
-- Project root relative to this file: \`${projectRoot}\`
-- C4A data root relative to this file: \`.\`
-- Default user-facing language: ${displayLanguage(input.language)}
-
-## Agent Rules
-
-- Treat this data root as CLI-owned by default. Agents and users should not directly edit managed files unless a command or skill explicitly asks for a structured input file.
-- Generated knowledge titles, summaries, and user-facing workflow reports follow this workspace language unless a CLI payload returns a more specific \`generation_policy\`. Keep \`node.summary\` concise: target under 15 tokens and never over 30 tokens. Source-bound Section content should stay close to the cited source language when it differs from the workspace language; add \`section.summary\` for long content as one plain paragraph. Preserve product names, code identifiers, command flags, slugs, \`block_id\` / \`source_ref\` tokens, and exact quoted evidence as printed when it is active user-facing knowledge.
-- Keep Agent prompts and handoff payloads stable: fixed protocol/schema rules first, existing knowledge lookup second, source-shared context third, and the current task-specific candidate/Node/question last. Do not add current timestamps, random ids, scratch paths, host absolute paths, or reordered JSON fields to Agent-authored payloads or reports unless a \`context\` command explicitly returned them as semantic workspace facts.
-- Existing \`knowledge/\` Nodes are the lookup registry. Use \`context mdrive glossary list|match\`, \`context mdrive node list\`, \`context mdrive query\`, or \`context query\` to reuse term, service, system, action, and domain handles. Do not create a separate dynamic registry file, and do not read \`knowledge/**\` directly just to decide whether a name already exists. When \`context mdrive glossary match <name>\` returns \`match.kind\`, \`match.matched\`, and \`match.rank\`, treat those as stable lookup hints; exact title/slug/alias hits should usually reuse the existing Node.
-- Naming surfaces are separate: \`/context:*\` names user slash commands, \`context ...\` names CLI primitives, and \`context:skill-*\` names packaged skills/procedures invoked by slash workflows. Do not invent \`/context:compile-draft\`, \`/context:skill-*\`, or call a packaged skill a user command.
-- Do not directly read, search, or list workspace files with generic file tools or shell commands such as Read, Glob, Grep, \`ls\`, \`find\`, \`tree\`, \`rg\`, \`cat\`, or \`sed\`. Use higher-level \`context\` commands instead — \`context status\`, \`context source list|get\`, \`context workflow show|status\`, \`context compile --context\`, \`context mdrive node|section|edge|query\`, and \`context query\` cover normal production reads. \`context workspace read/list/search\` is a developer/debug surface only; do not use it as a production agent next step, including ad-hoc browsing of \`raw/\`, \`knowledge/\`, \`archive/\`, \`decisions/\`, or cache internals.
-- Do not directly write workspace files with generic file tools, shell redirection, patch tools, or scripts. Use higher-level \`context\` commands for managed data and workflow artifacts. Agent workflow handoffs should go through stdin and CLI-owned workflow payloads, not ad-hoc scratch files; \`output/\` root must not contain direct files.
-- Do not run state-changing \`context\` commands in parallel against the same workspace. Commands such as \`context reconcile apply\`, \`context compile --close\`, \`context align --finalize\`, \`context capture\`, \`context drop\`, \`context purge\`, and \`context mdrive ... add|update|delete|supersede|deprecate\` must run sequentially so rollback, ledger, cache, and index updates stay coherent.
-- Do not write or run ad-hoc Python, Node.js, shell, or other scripts to inspect, transform, filter, summarize, or bulk-read \`.context/**\`, this data root, \`output/**\`, \`decisions/**\`, raw snapshots, knowledge markdown, cache files, archives, or \`/tmp\` files produced by C4A commands. If a step needs structured data, use the relevant \`context ... --format json\` command or skill output and pass that output directly to the next \`context\` command or workflow.
-- Do not pipe or wrap \`context ... --format json\` output through \`python3\`, \`node\`, \`jq\`, \`sed\`, \`cat\`, \`2>&1\`, \`|| echo\`, or similar shell helpers. Run the \`context\` command directly and consume its complete stdout.
-- Workflow payload exploration follows one query protocol: \`--view\` selects the semantic view, \`--token-budget <n>\` controls the context window size, and \`--source\`, \`--heading\`, \`--node\`, \`--type\`, \`--status\`, \`--candidate-id\`, or \`--item-id\` only narrow the view. Start with purpose-built views such as \`context compile --context <slug> --view source-refs --token-budget 2000 --format json\`, \`context workflow show --payload node-context --view source-refs --token-budget 2000 --unwrap --format json\`, \`context workflow show --payload coverage-candidates --view coverage-summary --token-budget 2000 --unwrap --format json\`, \`context workflow show --payload coverage-candidates --view coverage --type <issue-type> --token-budget 2000 --unwrap --format json\`, and \`context workflow show --payload align-segments --view blocks --source <source-id> --token-budget 2000 --unwrap --format json\`.
-- Budgeted views return \`token_budget\`, \`token_used\`, \`shown_count\`, \`total\`, \`omitted_count\`, \`truncated\`, \`selection_policy\`, \`item_id_field\`, and \`how_to_explore[]\`. If \`truncated: true\`, follow \`how_to_explore[]\` rather than slicing stdout yourself; prefer narrowing the view before increasing the budget. \`context_items[]\` are background-only entries, and \`context_omitted_count\` means additional background exists outside the current budget.
-- Schema discovery must also go through direct \`context\` commands. Schema commands support \`--format text|json|yaml\`; use readable YAML/text while drafting and JSON when a caller needs machine parsing. Inspect the schema \`enums\` field for allowed tags/actions instead of inventing labels such as \`platform\` or \`tool\`.
-- When passing large JSON / YAML / Markdown bodies to the CLI, feed stdin directly into the \`context\` command with a heredoc, for example \`context align --finalize - <<'JSON'\`. Do not pipe a heredoc through another command, and never redirect heredocs to workspace files.
-- For large \`context align --finalize\` payloads, use \`block_ownership_defaults[]\` as a compact source-level ownership rule instead of generating temporary JSON files or enumerating hundreds of block rows. Defaults must still declare an explicit \`source_id\`, \`ownership_role\`, owner/visibility fields, and reason when needed; use \`block_ownership[]\` for block-level exceptions. Defaults are a compression mechanism, not permission to assign mixed-source evidence to one owner without review.
-- In Claude Code, direct heredoc commands such as \`context compile --draft <slug> --input - --plan <<'JSON'\` may still prompt for permission when only subcommand-specific allow rules are configured. If that happens, ask the user before adding the scoped allow rule \`Bash(context:*)\` to the project \`.claude/settings.local.json\`; do not enable \`bypassPermissions\`.
-- Never hand-edit \`raw/\`, \`raw/_sources.yaml\`, \`archive/\`, \`knowledge/\`, \`knowledge/_index.md\`, or \`knowledge/changelog.md\`. Maintain them through \`context\` CLI commands and \`/context:*\` workflows.
-- \`decisions/\` stores CLI-managed semantic reconciliation decisions. Do not directly read, search, or write \`decisions/semantic.yaml\`; use \`context reconcile prepare|review|apply|record\`.
-- \`archive/\` stores dropped-but-restorable source and knowledge artifacts. Do not edit it directly; use \`context drop\`, \`context capture\` restore flow, or \`context purge\`.
-- Use \`context source list|get\` for source registry metadata; do not inspect \`raw/_sources.yaml\` directly.
-- Use \`/context:capture\` or \`context capture\` for documents, and \`/context:capture --code\` / \`context capture --code\` for code snapshots. Do not write files directly under \`raw/\`. If code capture fails because a runner or plugin dependency is missing, surface the CLI's structured agent hint list exactly as returned; do not run hand-written \`node -e\`, \`require.resolve\`, or package-probing preflight snippets.
-- Code snapshots are raw inputs until projected. After \`context capture --code\`, run \`context compile --code <source-slug>\` to materialize package/category/symbol knowledge Nodes, then run \`context compile --close\` when the CLI asks for close. Do not use prose \`/context:align\` or draft/reconcile compile to hand-build code knowledge.
-- Code projection uses package/category/symbol layout: package roots such as \`pkg\` and category Nodes such as \`pkg/components\` are navigation surfaces, while concrete symbol Nodes such as \`pkg/symbol/button\` carry API Sections and code frontmatter. Use Node slugs, \`code_package\`, \`symbol_kind\`, and \`code_symbols[]\` as semantic handles; do not infer ownership, category, or identity from source file paths, directory names, line numbers, or \`module_path\`.
-- Mixed code/doc knowledge is code-first. Materialize code symbol Nodes before aligning manuals, examples, notes, or on-call prose that mention APIs. When prose mentions an existing symbol through text, JSX tags, imports, or code spans, reuse the concrete symbol Node; if the same API name exists in multiple packages, ask for selection or leave it unresolved instead of creating a duplicate API Node.
-- Use \`/context:align\` for structural planning. Read the current align workflow schemas, inspect \`align-segments\` through \`context workflow show --payload align-segments --view blocks --token-budget <n> --unwrap --format json\` plus semantic filters, build candidate ledger outputs, and finalize with \`context align --finalize -\`. Align workflow payload submissions must go through stdin; do not write scratch YAML/JSON files for coarse-read, candidate ops, or structure decision. Finalize consumes only the structure-decision payload and finalized block ownership; it does not read raw directly or accept old patch inputs.
-- Use \`/context:compile\` for synthesis into \`knowledge/\`. Prepare NodeContext with \`context compile --context <slug> --format json\`, then inspect citation handles with \`context compile --context <slug> --view source-refs --token-budget 2000 --format json\` or \`context workflow show --payload node-context --view source-refs --token-budget 2000 --unwrap --format json\`; source-refs is a projection of \`NodeContext.raw_snippets[]\`, not a separate source. Use \`how_to_explore[]\` and semantic filters before expanding the durable NodeContext for the draft procedure. Pass drafts to \`context compile --draft <slug> --input - --plan --prepare\`; the CLI stores workflow payloads for review/apply. Use \`--save-input\` only when an explicit draft debug copy is needed. For precise manual knowledge edits, use \`context mdrive ...\`; do not bypass the CLI for article markdown, indexes, or changelog entries.
-- \`/context:compile\` may process a workset, but each Node must complete its own context → draft → prepare → review → apply loop before the agent applies another Node. Do not run multiple Node reconcile/apply chains in parallel, hide several Node failures inside one batch command, or move to the next Node while the current Node has unresolved review questions, schema errors, unsupported evidence, or coverage warnings.
-- Use \`context query\` for mixed code/doc consumption. \`context query --intent node_lookup --query "<name>"\` disambiguates same-name symbols with full slug and \`code_package\`; \`context query --intent node_view --scope <slug>\` opens a known Node; \`context query --intent section_search --scope <slug> --query "<terms>" --evidence code|prose|all\` filters code-owned versus doc-owned Sections. Query metadata such as \`source_id\`, \`source_type\`, \`evidence_kind\`, \`source_ref\`, \`version_applicability\`, and \`code_projection_status\` is authoritative; do not guess evidence kind from \`code_package\` or inspect rendered markdown to recover provenance.
-- Dropping or refreshing code sources is ownership-aware. Use \`context drop <source-id> --plan\` / \`context drop --apply-plan\` and \`context capture --code\` refresh rather than deleting files. Code-owned Sections, code-owned graph edges, and external deps can be removed while doc-owned Sections on the same symbol Node are preserved with \`code_projection_status=dropped\` or \`detached\`; use the query/status repair hints to reattach.
-- Treat compile \`source_support\` as a lexical diagnostic, not a target to game. Do not copy raw text merely to raise matched-term counts or show evidence; \`source_ref\` already provides traceability. Keep Section \`content\` as the user-facing wording, preserving cited raw prose when it is already clear and only cleaning formatting, typos, casing, entity names, aliases, or grammar without changing meaning.
-- When \`context compile --draft <slug> --plan\` or \`context reconcile prepare --mode compile\` returns \`compact-source-low-coverage\` or \`dense-source-low-coverage\`, treat it as a required coverage progress warning. Check \`coverage is <covered>/<total>\` and \`remaining <N> snippet(s)\`, then return to the same draft and add actions for uncovered, source-backed, orthogonal facts before review/apply. If \`context verify\` or \`context doctor\` reports \`compact-source-evidence-undercovered\` or \`dense-source-evidence-undercovered\`, review the reported uncovered raw blocks before declaring the source complete. CLI success for one action only proves that action is supported; it does not prove the Node is complete.
-- Users may intentionally edit \`config.yaml\` and \`aspects/*/prompt.md\`; after doing so, run \`context doctor\` or \`context status\`.
-- Use \`context doctor\`, \`context verify\`, and \`context status\` to inspect workspace health instead of inferring state from partial files.
-- \`context status\` is local-only and must be run from the workspace root. When an agent starts in a child directory, run \`context status\` from the project root or have the user reposition the shell; \`context workspace locate\` is a developer/debug fallback, not a normal production handoff.
-- Aspect prompts live under \`aspects/\` and are long-lived workspace files.
-
-## Layout Notes
-
-- \`embedded\` layout keeps this data root under the project \`.context/\` directory and is intended for normal code repositories.
-- \`root\` layout uses the current directory as the C4A data root. It is intended only for dedicated knowledge repositories; keep product source code outside this root unless you intentionally want C4A commands to treat it as part of the knowledge workspace.
+This directory is the C4A data root.
+
+- Workspace: ${input.workspaceName}
+- Layout: ${location.layout}
+- Project root: \`${projectRoot}\` (relative to this file)
+- Language: ${displayLanguage(input.language)} (used for generated titles, summaries, and workflow reports)
+
+## TL;DR — Non-negotiables
+
+- **The CLI owns this data root.** All reads and writes go through \`context ...\` commands. Never use generic tools (\`Read\`, \`Glob\`, \`Grep\`, \`ls\`, \`find\`, \`cat\`, \`rg\`, \`head\`, \`tail\`, \`jq\`, \`sed\`, \`python3\`, \`node\`, shell pipes) against \`.context/**\`, \`output/**\`, \`archive/**\`, \`decisions/**\`, or \`/tmp\` files produced by C4A.
+- **Consume \`context ... --format json\` stdout directly.** Don't pipe it through \`jq\`, \`sed\`, \`cat\`, \`2>&1\`, or any wrapper.
+- **State-changing commands run sequentially.** Never run \`reconcile apply\`, \`compile --close\`, \`align --finalize\`, \`capture\`, \`drop\`, \`purge\`, or \`mdrive ... add|update|delete|supersede|deprecate\` in parallel against this workspace.
+- **Names are distinct.** \`/context:*\` = user slash command, \`context ...\` = CLI primitive, \`context:skill-*\` = packaged skill. Don't invent \`/context:skill-*\` or \`/context:compile-draft\`.
+
+## Managed directories
+
+These paths are CLI-owned. Hand-editing breaks the ledger, index, or cache.
+
+| Path | Use this instead |
+|---|---|
+| \`raw/\`, \`raw/_sources.yaml\` | \`context capture\`, \`context capture --code\`, \`context source list|get\` |
+| \`knowledge/\`, \`knowledge/_index.md\`, \`knowledge/changelog.md\` | \`/context:compile\`, \`context mdrive ...\` |
+| \`decisions/semantic.yaml\` | \`context reconcile prepare|review|apply\` |
+| \`archive/\` | \`context drop\`, \`context purge\`, \`context capture\` restore |
+| \`config.yaml\`, \`aspects/*/prompt.md\` | hand-editing OK; run \`context doctor\` or \`context status\` afterward |
+
+Workflow input goes through stdin (e.g. \`context align --finalize - <<'JSON'\`). Do not write scratch files under \`output/\` root or pipe heredocs through other commands.
+
+## Discovery — trust the CLI, not this file
+
+This file describes the workspace, not the workflows. For align / compile / drop procedures, follow the relevant \`/context:*\` slash command or \`context:skill-*\` skill. Command flags, view names, and schemas may evolve; ask the CLI:
+
+- \`context status\` — current workspace state (run from project root)
+- \`context doctor\`, \`context verify\` — health checks
+- \`context schema <name>\` — input schemas with allowed enums and examples
+- \`context <cmd> --help\` — command flags and view options
+
+## Layout
+
+- **embedded** — data root lives at \`.context/\` under the project root. Normal code repositories.
+- **root** — data root is the current directory itself. Use only for dedicated knowledge repositories; keep product source code outside this root.
 `;
 }
 async function writeAgentsGuide(input) {
@@ -57382,8 +57424,19 @@ async function writeAgentsGuide(input) {
   }
   let claudeLinkCreated = false;
   if (!await pathExistsNoFollow(claudePath)) {
-    await symlink("AGENTS.md", claudePath);
-    claudeLinkCreated = true;
+    try {
+      await symlink("AGENTS.md", claudePath);
+      claudeLinkCreated = true;
+    } catch (err2) {
+      const code3 = err2.code;
+      if (code3 === "EPERM" || code3 === "EINVAL" || code3 === "ENOSYS") {
+        await writeFile4(claudePath, `# See [AGENTS.md](./AGENTS.md)
+`, "utf8");
+        claudeLinkCreated = true;
+      } else {
+        throw err2;
+      }
+    }
   }
   return { agentsPath, agentsWritten, claudePath, claudeLinkCreated };
 }
@@ -66579,13 +66632,87 @@ function removeDroppedContextSources2(input) {
 function shouldArchiveNode2(node3) {
   return node3.sections.length === 0 && node3.children.length === 0 && node3.containsList.length === 0 && node3.body.trim().length === 0;
 }
+function shouldArchiveDroppedCodeNavigationNode(node3, sourceSlug3) {
+  return node3.node.code_package === sourceSlug3 && (node3.node.code_symbols?.length ?? 0) === 0 && node3.sections.length === 0 && node3.children.length === 0 && node3.body.trim().length === 0;
+}
+function archiveLocatedNode(input) {
+  if (input.archivedSlugs.has(input.located.parsed.node.id))
+    return;
+  if (input.located.path.length === 0) {
+    input.deletedFiles.add(input.located.filePath);
+  } else {
+    detachNodeAtPath(input.located.root, input.located.path);
+    input.touchedFiles.add(input.located.filePath);
+  }
+  input.archivedSlugs.add(input.located.parsed.node.id);
+}
+function archiveEmptyAffectedNodes(input) {
+  let changed = false;
+  for (const located of input.nodes) {
+    if (!input.affectedSlugs.has(located.parsed.node.id))
+      continue;
+    if (input.archivedSlugs.has(located.parsed.node.id))
+      continue;
+    if (!shouldArchiveNode2(located.parsed))
+      continue;
+    archiveLocatedNode({
+      located,
+      deletedFiles: input.deletedFiles,
+      touchedFiles: input.touchedFiles,
+      archivedSlugs: input.archivedSlugs
+    });
+    changed = true;
+  }
+  return changed;
+}
+function archiveDroppedCodeNavigationNodes(input) {
+  let changed = false;
+  for (const located of input.nodes) {
+    if (input.archivedSlugs.has(located.parsed.node.id))
+      continue;
+    if (!shouldArchiveDroppedCodeNavigationNode(located.parsed, input.sourceSlug))
+      continue;
+    archiveLocatedNode({
+      located,
+      deletedFiles: input.deletedFiles,
+      touchedFiles: input.touchedFiles,
+      archivedSlugs: input.archivedSlugs
+    });
+    changed = true;
+  }
+  return changed;
+}
+function containsEntryTargetSlug(parentSlug, entry) {
+  const href = entry.href.split(/[?#]/u)[0]?.replace(/^\.\//u, "").replace(/\.md$/u, "") ?? "";
+  if (href.length === 0 || /^[a-z][a-z0-9+.-]*:/iu.test(href))
+    return entry.slug.length > 0 ? entry.slug : null;
+  const parentParts = parentSlug.split("/").filter((part) => part.length > 0);
+  const rootSlug = parentParts[0] ?? "";
+  if (href === rootSlug || href.startsWith(`${rootSlug}/`))
+    return href;
+  if (rootSlug.length > 0 && href.startsWith("symbol/"))
+    return `${rootSlug}/${href}`;
+  if (parentParts.length > 1)
+    return `${parentParts.slice(0, -1).join("/")}/${href}`;
+  return rootSlug.length > 0 ? `${rootSlug}/${href}` : href;
+}
+function containsEntryMatchesArchivedSlug(parentSlug, entry, archivedSlug) {
+  if (entry.slug === archivedSlug)
+    return true;
+  return containsEntryTargetSlug(parentSlug, entry) === archivedSlug;
+}
 function removeReferencesToArchivedNodes2(input) {
   if (input.archivedSlugs.size === 0)
     return;
   const visit2 = (filePath, node3) => {
     const beforeContains = node3.containsList.length;
-    for (const slug of input.archivedSlugs)
-      node3.containsList = removeContainsEntry(node3.containsList, slug);
+    node3.containsList = node3.containsList.filter((entry) => {
+      for (const slug of input.archivedSlugs) {
+        if (containsEntryMatchesArchivedSlug(node3.node.id, entry, slug))
+          return false;
+      }
+      return true;
+    });
     if (node3.containsList.length !== beforeContains)
       input.touchedFiles.add(filePath);
     for (const section of node3.sections) {
@@ -66717,6 +66844,8 @@ async function applyCodeSourceDropPlan(input) {
   const touchedFiles = new Set;
   const deletedFiles = new Set;
   const archivedSlugs = new Set;
+  const affectedSlugs = new Set(plan.affected_nodes.map((node3) => node3.slug));
+  const sourceSlug3 = codeSourceSlug(source2);
   let removedSections = 0;
   let reindexedSections = 0;
   for (const planNode of plan.affected_nodes) {
@@ -66727,17 +66856,32 @@ async function applyCodeSourceDropPlan(input) {
     removedSections += result.removedSections;
     reindexedSections += result.reindexedSections;
     if (result.archiveNode && located.path.length === 0) {
-      deletedFiles.add(located.filePath);
-      archivedSlugs.add(located.parsed.node.id);
+      archiveLocatedNode({ located, deletedFiles, touchedFiles, archivedSlugs });
     } else if (result.archiveNode) {
-      detachNodeAtPath(located.root, located.path);
-      touchedFiles.add(located.filePath);
-      archivedSlugs.add(located.parsed.node.id);
+      archiveLocatedNode({ located, deletedFiles, touchedFiles, archivedSlugs });
     } else if (result.removedSections > 0 || result.reindexedSections > 0) {
       touchedFiles.add(located.filePath);
     }
   }
-  removeReferencesToArchivedNodes2({ files, archivedSlugs, touchedFiles });
+  while (true) {
+    removeReferencesToArchivedNodes2({ files, archivedSlugs, touchedFiles });
+    const changed = archiveEmptyAffectedNodes({
+      nodes,
+      affectedSlugs,
+      deletedFiles,
+      touchedFiles,
+      archivedSlugs
+    });
+    const changedNavigation = archiveDroppedCodeNavigationNodes({
+      nodes,
+      sourceSlug: sourceSlug3,
+      deletedFiles,
+      touchedFiles,
+      archivedSlugs
+    });
+    if (!changed && !changedNavigation)
+      break;
+  }
   removeDroppedContextSources2({ files, sourceId: source2.id, deletedFiles, touchedFiles });
   const owners = new Set;
   for (const node3 of plan.affected_nodes)
@@ -66758,7 +66902,7 @@ async function applyCodeSourceDropPlan(input) {
       touchedKnowledgeFiles,
       plan
     });
-    await replaceCodeGraphEdges(input.ctxDir, `code:${codeSourceSlug(source2)}`, []);
+    await replaceCodeGraphEdges(input.ctxDir, `code:${sourceSlug3}`, []);
     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) {
@@ -77458,7 +77602,7 @@ function nodeContextSourceRefRows(value) {
       citation_eligible: snippet.citation_eligible === true,
       context_only: snippet.context_only === true,
       ...quotePreview !== undefined ? { quote_preview: quotePreview } : {},
-      ...node3 !== undefined && blockId !== undefined && canRequestFullTextForSnippet(snippet) ? { request_full_text_command: `context compile --context ${shellQuote(node3)} --request-full-text ${shellQuote(blockId)} --format json` } : {}
+      ...node3 !== undefined && blockId !== undefined && canRequestFullTextForSnippet(snippet) ? { request_full_text_command: `context compile --context ${shellQuote(node3)} --request-full-text ${shellQuote(blockId)} --view text --format json` } : {}
     };
   });
 }
@@ -84551,10 +84695,115 @@ function plannedSectionSourceRefGroups(context, rows) {
         source_refs: run2.map((row) => row.source_ref)
       })),
       draft_action_templates: templates,
-      draft_action_template: templates[0] ?? draftActionTemplate(plan.section_kind, [])
+      ...status === "ready_with_splits" ? {} : { draft_action_template: templates[0] ?? draftActionTemplate(plan.section_kind, []) }
+    };
+  });
+}
+
+// src/commands/compileSourceRefsCodeText.ts
+function recordArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "object" && item !== null && !Array.isArray(item)) : [];
+}
+function exampleSourceRefs(sectionGroups) {
+  const refs = new Set;
+  for (const group of sectionGroups) {
+    if (group.section_kind !== "example")
+      continue;
+    for (const sourceRef of Array.isArray(group.source_refs) ? group.source_refs : []) {
+      if (typeof sourceRef === "string")
+        refs.add(sourceRef);
+    }
+  }
+  return refs;
+}
+function fencedCodeTextBySourceRef(context) {
+  const out2 = new Map;
+  for (const snippet of context.raw_snippets) {
+    if (typeof snippet.source_ref !== "string" || typeof snippet.quote !== "string")
+      continue;
+    if (!/```[\s\S]*```/u.test(snippet.quote))
+      continue;
+    out2.set(snippet.source_ref, snippet.quote);
+  }
+  return out2;
+}
+function enrichRows(rows, exampleRefs, fullTextBySourceRef) {
+  return recordArray(rows).map((row) => {
+    const sourceRef = typeof row.source_ref === "string" ? row.source_ref : undefined;
+    const fullText = sourceRef !== undefined && exampleRefs.has(sourceRef) ? fullTextBySourceRef.get(sourceRef) : undefined;
+    if (fullText === undefined)
+      return row;
+    return {
+      ...row,
+      quote_full_text: fullText,
+      quote_full_text_reason: "example-code-block",
+      quote_full_text_field: "items[].quote_full_text"
     };
   });
 }
+function withExampleCodeFullText(input) {
+  const exampleRefs = exampleSourceRefs(input.sectionGroups);
+  if (exampleRefs.size === 0)
+    return input.projected;
+  const fullTextBySourceRef = fencedCodeTextBySourceRef(input.context);
+  if (fullTextBySourceRef.size === 0)
+    return input.projected;
+  return {
+    ...input.projected,
+    items: enrichRows(input.projected.items, exampleRefs, fullTextBySourceRef),
+    context_items: enrichRows(input.projected.context_items, exampleRefs, fullTextBySourceRef)
+  };
+}
+
+// src/commands/compileSourceRefsScaffold.ts
+init_compile();
+function recordArray2(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "object" && item !== null && !Array.isArray(item)) : [];
+}
+function stringArray7(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function defaultScaffoldSectionKind(context) {
+  return context.node.planned_sections?.[0] ?? "description";
+}
+function plannedTemplateActions(sectionGroups) {
+  return sectionGroups.filter((group) => group.status === "ready" || group.status === "ready_with_splits").flatMap((group) => recordArray2(group.draft_action_templates));
+}
+function sourceRefsDraftScaffold(input) {
+  const requested = new Set(input.requestedBlockIds ?? []);
+  const plannedActions = requested.size === 0 ? plannedTemplateActions(input.sectionGroups) : [];
+  if (plannedActions.length > 0) {
+    return {
+      schema_version: COMPILE_DRAFT_SCHEMA_VERSION,
+      target_node: input.context.node.slug,
+      selection: {
+        mode: "planned_section_groups",
+        selected_action_count: plannedActions.length,
+        planned_section_groups: input.sectionGroups.filter((group) => group.status === "ready" || group.status === "ready_with_splits").map((group) => group.section_id).filter((sectionId) => typeof sectionId === "string")
+      },
+      usage: "Fill each action.content, adjust kind when needed, then submit the actions with context compile --draft <node> --input - --plan.",
+      actions: plannedActions.map((action) => ({ ...action }))
+    };
+  }
+  const selectedRows = input.rows.filter((row) => row.citation_eligible === true && typeof row.source_ref === "string" && (requested.size === 0 || typeof row.block_id === "string" && requested.has(row.block_id)));
+  const kind = defaultScaffoldSectionKind(input.context);
+  return {
+    schema_version: COMPILE_DRAFT_SCHEMA_VERSION,
+    target_node: input.context.node.slug,
+    selection: {
+      mode: requested.size > 0 ? "requested_block_ids" : "visible_citation_eligible_source_refs",
+      selected_action_count: selectedRows.length,
+      ...requested.size > 0 ? { requested_block_ids: [...requested] } : {}
+    },
+    usage: "Fill each action.content, adjust kind when needed, then submit the actions with context compile --draft <node> --input - --plan.",
+    actions: selectedRows.map((row) => ({
+      op: "add",
+      kind,
+      content: "",
+      source_refs: stringArray7([row.source_ref])
+    }))
+  };
+}
 
 // src/commands/compileWorkflowViews.ts
 function compileChangesFormat(value) {
@@ -84576,12 +84825,17 @@ function compileOutputView(value) {
     return "source-refs";
   if (value === "issues")
     return "issues";
-  throw new ContextError(ExitCode.UserError, "--view must be full, summary, source-refs, or issues", {
+  if (value === "text")
+    return "text";
+  throw new ContextError(ExitCode.UserError, "--view must be full, summary, source-refs, issues, or text", {
     category: ErrorCategory.UserInputInvalid,
     flag: "--view"
   });
 }
 function compileChangesNextHint(changes) {
+  if (changes.first_compile_pending !== undefined && changes.first_compile_pending.remaining > 0) {
+    return `${changes.first_compile_pending.remaining} first-compile node(s) remain; run first_compile_pending.commands[] before context compile --close`;
+  }
   if (changes.reason === "no-changed-nodes") {
     if ((changes.stats.non_blocking_blocks_changed ?? 0) > 0) {
       return "only non-blocking context/source changes were detected; compile draft can stop";
@@ -84610,6 +84864,11 @@ function compileChangesNextHint(changes) {
 }
 function compileChangesNext(changes) {
   const reason = compileChangesNextHint(changes);
+  if (changes.first_compile_pending !== undefined && changes.first_compile_pending.commands.length > 0) {
+    const command = changes.first_compile_pending.commands[0];
+    if (command !== undefined)
+      return { command, reason };
+  }
   if (changes.reason === "no-changed-nodes")
     return { reason };
   if (changes.status === "unknown-input") {
@@ -84659,6 +84918,7 @@ function compactCompileChanges(changes) {
       unknown_input_count: node3.unknown_inputs.length,
       source_ids: [...new Set(node3.changed_blocks.map((block) => block.source_id))]
     })),
+    ...changes.first_compile_pending !== undefined ? { first_compile_pending: changes.first_compile_pending } : {},
     ignored_locator_change_count: changes.ignored_locator_changes?.length ?? 0,
     unknown_inputs: changes.unknown_inputs
   };
@@ -84826,14 +85086,14 @@ function writeCompileContextSummary(input) {
   }
   writeCompileContextTextSummary(input, coverageRepairRound, coverageScopeHint);
 }
-function recordArray(value) {
+function recordArray3(value) {
   return Array.isArray(value) ? value.filter((item) => typeof item === "object" && item !== null && !Array.isArray(item)) : [];
 }
 function objectRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
 }
 function projectedSourceRefRows(value) {
-  return recordArray(value.items).concat(recordArray(value.context_items)).filter((row) => typeof row.source_ref === "string" && typeof row.block_id === "string" && typeof row.citation_eligible === "boolean");
+  return recordArray3(value.items).concat(recordArray3(value.context_items)).filter((row) => typeof row.source_ref === "string" && typeof row.block_id === "string" && typeof row.citation_eligible === "boolean");
 }
 function compileSourceRefsBaseCommand(slug) {
   return `context compile --context ${shellQuote(slug)} --view source-refs --format json`;
@@ -84849,30 +85109,6 @@ function sourceRefsDraftScaffoldCommand(slug, options = {}) {
     "--format json"
   ].join(" ");
 }
-function defaultScaffoldSectionKind(context) {
-  return context.node.planned_sections?.[0] ?? "description";
-}
-function sourceRefsDraftScaffold(input) {
-  const requested = new Set(input.requestedBlockIds ?? []);
-  const selectedRows = input.rows.filter((row) => row.citation_eligible === true && typeof row.source_ref === "string" && (requested.size === 0 || typeof row.block_id === "string" && requested.has(row.block_id)));
-  const kind = defaultScaffoldSectionKind(input.context);
-  return {
-    schema_version: COMPILE_DRAFT_SCHEMA_VERSION,
-    target_node: input.context.node.slug,
-    selection: {
-      mode: requested.size > 0 ? "requested_block_ids" : "visible_citation_eligible_source_refs",
-      selected_action_count: selectedRows.length,
-      ...requested.size > 0 ? { requested_block_ids: [...requested] } : {}
-    },
-    usage: "Fill each action.content, adjust kind when needed, then submit the actions with context compile --draft <node> --input - --plan.",
-    actions: selectedRows.map((row) => ({
-      op: "add",
-      kind,
-      content: "",
-      source_refs: [row.source_ref]
-    }))
-  };
-}
 function sourceRefsSectionGroupHint(sectionGroups) {
   if (sectionGroups.length === 0)
     return [];
@@ -84918,16 +85154,18 @@ function sourceRefsViewHints(input) {
 }
 function writeCompileSourceRefs(context, format, options = {}) {
   const projected = projectNodeContextSourceRefs(context, options, compileSourceRefsBaseCommand(context.node.slug));
-  const projectedHints = recordArray(projected.agent_hints);
+  const projectedHints = recordArray3(projected.agent_hints);
   const projectedCounts = objectRecord(projected.counts);
-  const windowRows = recordArray(projected.items).concat(recordArray(projected.context_items));
+  const windowRows = recordArray3(projected.items).concat(recordArray3(projected.context_items));
   const sectionGroups = plannedSectionSourceRefGroups(context, projectedSourceRefRows(projected));
+  const projectedForOutput = withExampleCodeFullText({ projected, context, sectionGroups });
   const draftScaffoldCommand = sourceRefsDraftScaffoldCommand(context.node.slug, options);
   const requestedScaffoldBlockIds = options.draftScaffoldBlockIds ?? [];
-  const scaffoldRows = requestedScaffoldBlockIds.length > 0 ? recordArray(context.raw_snippets) : windowRows;
+  const scaffoldRows = requestedScaffoldBlockIds.length > 0 ? recordArray3(context.raw_snippets) : windowRows;
   const draftScaffold = options.draftScaffold === true ? sourceRefsDraftScaffold({
     context,
     rows: scaffoldRows,
+    sectionGroups,
     ...requestedScaffoldBlockIds.length > 0 ? { requestedBlockIds: requestedScaffoldBlockIds } : {}
   }) : undefined;
   const scaffoldHint = {
@@ -84940,7 +85178,7 @@ function writeCompileSourceRefs(context, format, options = {}) {
   const viewHints = sourceRefsViewHints({ projectedHints, sectionGroups, scaffoldHint });
   if (format === "json") {
     writeJson3({
-      ...projected,
+      ...projectedForOutput,
       ...sectionGroups.length > 0 ? { planned_section_groups: sectionGroups } : {},
       draft_scaffold_command: draftScaffoldCommand,
       ...draftScaffold !== undefined ? { draft_scaffold: draftScaffold } : {},
@@ -84949,7 +85187,7 @@ function writeCompileSourceRefs(context, format, options = {}) {
         planned_section_groups: sectionGroups.length,
         planned_section_groups_ready: sectionGroups.filter((group) => group.status === "ready" || group.status === "ready_with_splits").length,
         planned_section_groups_split: sectionGroups.filter((group) => group.status === "ready_with_splits").length,
-        ...draftScaffold !== undefined ? { draft_scaffold_actions: recordArray(draftScaffold.actions).length } : {}
+        ...draftScaffold !== undefined ? { draft_scaffold_actions: recordArray3(draftScaffold.actions).length } : {}
       },
       agent_hints: viewHints
     });
@@ -85041,7 +85279,7 @@ function writeCompileDraftStatus(input) {
 function claimIdForActionIndex(index2) {
   return `claim-${String(index2 + 1).padStart(3, "0")}`;
 }
-function stringArray7(value) {
+function stringArray8(value) {
   return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
 }
 function sourceRefNarrowingByActionIndex(hints) {
@@ -85050,9 +85288,9 @@ function sourceRefNarrowingByActionIndex(hints) {
     if (hint.code !== "compile-source-refs-narrowing-suggested" || typeof hint.op_index !== "number")
       continue;
     const diagnostics = hint.diagnostics ?? {};
-    const original = stringArray7(diagnostics.original_source_refs);
-    const narrowed = stringArray7(diagnostics.narrowed_source_refs);
-    const removed = stringArray7(diagnostics.removed_source_refs);
+    const original = stringArray8(diagnostics.original_source_refs);
+    const narrowed = stringArray8(diagnostics.narrowed_source_refs);
+    const removed = stringArray8(diagnostics.removed_source_refs);
     if (original.length === 0 || narrowed.length === 0 || removed.length === 0)
       continue;
     byIndex.set(hint.op_index, {
@@ -85070,8 +85308,8 @@ function sourceRefNarrowingByActionIndex(hints) {
 function sourceSupportDiagnostics(support) {
   if (support?.verdict === undefined || support.verdict === "supported")
     return;
-  const missingHardTerms = stringArray7(support.missing_hard_terms);
-  const missingContentTerms = stringArray7(support.missing_content_terms);
+  const missingHardTerms = stringArray8(support.missing_hard_terms);
+  const missingContentTerms = stringArray8(support.missing_content_terms);
   const contextOnlyMatches = Array.isArray(support.context_only_hard_term_matches) ? support.context_only_hard_term_matches.slice(0, 12).map((match) => ({
     ...typeof match.term === "string" ? { term: match.term } : {},
     ...typeof match.line_range === "string" ? { line_range: match.line_range } : {},
@@ -85163,11 +85401,11 @@ function withPayloadMeta2(value, payload) {
     })
   };
 }
-function stringArray8(value) {
+function stringArray9(value) {
   return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
 }
 function narrowingSuggestionRemovedCount(context) {
-  return (context.agent_hints ?? []).filter((hint) => hint.code === "compile-source-refs-narrowing-suggested").reduce((sum, hint) => sum + stringArray8(hint.diagnostics?.removed_source_refs).length, 0);
+  return (context.agent_hints ?? []).filter((hint) => hint.code === "compile-source-refs-narrowing-suggested").reduce((sum, hint) => sum + stringArray9(hint.diagnostics?.removed_source_refs).length, 0);
 }
 function prepareViewFromCompileView(view, viewWasExplicit) {
   if (view === "source-refs") {
@@ -85342,7 +85580,7 @@ async function writeCompileDraftChallengePayloads2(input) {
     });
   }
 }
-function stringArray9(value) {
+function stringArray10(value) {
   return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
 }
 function preparedSourceSupportStatus(value) {
@@ -85350,8 +85588,8 @@ function preparedSourceSupportStatus(value) {
     return;
   if (value.verdict === "supported")
     return { verdict: value.verdict };
-  const missingHardTerms = stringArray9(value.missing_hard_terms);
-  const missingContentTerms = stringArray9(value.missing_content_terms);
+  const missingHardTerms = stringArray10(value.missing_hard_terms);
+  const missingContentTerms = stringArray10(value.missing_content_terms);
   return {
     verdict: value.verdict,
     ...missingHardTerms.length > 0 ? { missing_hard_terms: missingHardTerms } : {},
@@ -85666,6 +85904,78 @@ async function runCompileDraftCommand(input) {
   return false;
 }
 
+// src/commands/compileRequestFullTextView.ts
+function textViewNextCommand(command) {
+  if (command === undefined)
+    return;
+  if (command.includes("--view text"))
+    return command;
+  if (command.includes("--format json"))
+    return command.replace("--format json", "--view text --format json");
+  return `${command} --view text`;
+}
+function pageItem(context, page) {
+  const snippet = context.raw_snippets[page.raw_snippet_index];
+  const nextCommand2 = textViewNextCommand(page.next_command);
+  return {
+    block_id: snippet?.block_id ?? context.request_full_text?.requested_block_ids[0] ?? "<unknown>",
+    raw_snippet_index: page.raw_snippet_index,
+    ...page.source_ref !== undefined || snippet?.source_ref !== undefined ? { source_ref: page.source_ref ?? snippet?.source_ref } : {},
+    line_range: page.line_range,
+    line_start: page.line_start,
+    line_end: page.line_end,
+    text: page.text,
+    text_field: "items[].text",
+    ...page.next_range !== undefined ? { next_range: page.next_range } : {},
+    ...nextCommand2 !== undefined ? { next_command: nextCommand2 } : {}
+  };
+}
+function tokenEstimate4(items) {
+  const chars = items.reduce((sum, item) => sum + (typeof item.text === "string" ? item.text.length : 0), 0);
+  return Math.ceil(chars / 4);
+}
+function writeCompileRequestFullTextView(context, format) {
+  const pages = context.request_full_text?.pages ?? [];
+  const items = pages.map((page) => pageItem(context, page));
+  if (format === "json") {
+    writeJson3({
+      schema_version: "compile.request_full_text.view.v1",
+      view: "text",
+      view_of: "NodeContext.request_full_text.pages",
+      node: context.node.slug,
+      text_field: "items[].text",
+      requested_block_ids: context.request_full_text?.requested_block_ids ?? [],
+      item_id_field: "block_id",
+      token_budget: "request-full-text-page",
+      token_used: tokenEstimate4(items),
+      shown_count: items.length,
+      total: items.length,
+      omitted_count: 0,
+      truncated: items.some((item) => item.next_range !== undefined),
+      selection_policy: {
+        id: "request-full-text-v1",
+        order: [{ field: "requested_block_ids", direction: "input" }]
+      },
+      items,
+      how_to_explore: items.filter((item) => typeof item.next_command === "string").map((item) => ({
+        level: "next_page",
+        block_id: item.block_id,
+        command: item.next_command,
+        reason: "continue reading this full-text block page"
+      }))
+    });
+    return;
+  }
+  const lines = [`Request full text for ${context.node.slug}`];
+  for (const item of items) {
+    lines.push("", `### ${String(item.block_id)} ${String(item.line_range)}`, String(item.text ?? ""));
+    if (typeof item.next_command === "string")
+      lines.push(`next: ${item.next_command}`);
+  }
+  process.stdout.write(lines.join(`
+`));
+}
+
 // src/commands/workflowCompileHelpers.ts
 init_cliFeedback();
 init_errors();
@@ -85837,7 +86147,7 @@ function compileScopeForOptions(options) {
 
 // src/commands/workflowCompileCommand.ts
 function registerCompileWorkflowCommand(program2) {
-  program2.command("compile").description("Workflow helpers for /context:compile").option("--code [slug]", "compile deterministic code projection for an active aspect:code source").option("--scan-changes", "print incremental compile workset without creating a workflow lock").addOption(new Option("--scan", "removed; use --scan-changes").hideHelp()).option("--format <format>", "with --scan-changes/--context, output format: json | table", "table").option("--view <view>", "compact output view: full | summary | source-refs | issues").option("--ignore-source <source-id>", "with --scan-changes or --context, ignore refresh-applied source ids", collectIgnoredSource, []).option("--context <slug>", "prepare NodeContext payload for one align node and print summary/digests").option("--source <source-id>", "with --context --view source-refs, narrow source refs to one source id").option("--heading <heading-prefix>", "with --context --view source-refs, narrow source refs to a heading path prefix or heading text").option("--token-budget <n>", "with --context --view source-refs, limit output by approximate token budget").option("--draft-scaffold", "with --context --view source-refs, include a compile-draft skeleton for visible citation refs").option("--cover-uncovered-only", "with --context, return only unresolved coverage candidates for a targeted repair round").option("--request-full-text <block-id>", "with --context, expand one visible finalized evidence block", collectRequestedBlock, []).option("--request-full-text-range <start:end>", "with --request-full-text, read a block-relative line page").option("--node-cycle <slug>", "validate one node draft, prepare reconcile, review safe defaults, and apply in one command").option("--delegated", "with a new compile workflow, record user-authorized delegated mode for low-risk review decisions").option("--draft <slug>", "validate a compile draft JSON/YAML document from stdin, or with --prepare reuse the saved draft").option("--prepare", "with --draft --plan, also prepare the semantic reconcile payload").option("--draft-status <slug>", "print the current compile draft session summary").option("--draft-patch <slug>", "apply a compile draft patch for one node").option("--input <stdin>", "compile draft JSON/YAML document used with --draft; use '-' for stdin").option("--accept-safe-defaults", "with --node-cycle, accept mechanically safe defaults and stop if anything needs judgment").option("--coverage-disposition <stdin>", "coverage disposition patch JSON/YAML document; use '-' for stdin").option("--coverage-skip <candidate-id>", "skip one coverage candidate without writing a disposition file").option("--coverage-skip-unresolved", "skip every unresolved coverage candidate in the node payload").option("--coverage-disposition-node <slug>", "node slug for --coverage-disposition").option("--coverage-disposition-replace", "replace existing dispositions for the patched coverage candidates").option("--payload-digest <digest>", "optional workflow payload digest stale guard for write commands").option("--reason <text>", "reason for coverage skip shortcuts").option("--plan", "validate the draft without writing knowledge").option("--close", "run compile close: compact, rebuild index, append changelog, verify").option("--save-input", "with --draft, save the consumed draft under output/compile/compile.<slug>.draft.yaml").action(async (options) => {
+  program2.command("compile").description("Workflow helpers for /context:compile").option("--code [slug]", "compile deterministic code projection for an active aspect:code source").option("--scan-changes", "print incremental compile workset without creating a workflow lock").addOption(new Option("--scan", "removed; use --scan-changes").hideHelp()).option("--format <format>", "with --scan-changes/--context, output format: json | table", "table").option("--view <view>", "compact output view: full | summary | source-refs | issues | text").option("--ignore-source <source-id>", "with --scan-changes or --context, ignore refresh-applied source ids", collectIgnoredSource, []).option("--context <slug>", "prepare NodeContext payload for one align node and print summary/digests").option("--source <source-id>", "with --context --view source-refs, narrow source refs to one source id").option("--heading <heading-prefix>", "with --context --view source-refs, narrow source refs to a heading path prefix or heading text").option("--token-budget <n>", "with --context --view source-refs, limit output by approximate token budget").option("--draft-scaffold", "with --context --view source-refs, include a compile-draft skeleton for visible citation refs").option("--cover-uncovered-only", "with --context, return only unresolved coverage candidates for a targeted repair round").option("--request-full-text <block-id>", "with --context, expand one visible finalized evidence block", collectRequestedBlock, []).option("--request-full-text-range <start:end>", "with --request-full-text, read a block-relative line page").option("--node-cycle <slug>", "validate one node draft, prepare reconcile, review safe defaults, and apply in one command").option("--delegated", "with a new compile workflow, record user-authorized delegated mode for low-risk review decisions").option("--draft <slug>", "validate a compile draft JSON/YAML document from stdin, or with --prepare reuse the saved draft").option("--prepare", "with --draft --plan, also prepare the semantic reconcile payload").option("--draft-status <slug>", "print the current compile draft session summary").option("--draft-patch <slug>", "apply a compile draft patch for one node").option("--input <stdin>", "compile draft JSON/YAML document used with --draft; use '-' for stdin").option("--accept-safe-defaults", "with --node-cycle, accept mechanically safe defaults and stop if anything needs judgment").option("--coverage-disposition <stdin>", "coverage disposition patch JSON/YAML document; use '-' for stdin").option("--coverage-skip <candidate-id>", "skip one coverage candidate without writing a disposition file").option("--coverage-skip-unresolved", "skip every unresolved coverage candidate in the node payload").option("--coverage-disposition-node <slug>", "node slug for --coverage-disposition").option("--coverage-disposition-replace", "replace existing dispositions for the patched coverage candidates").option("--payload-digest <digest>", "optional workflow payload digest stale guard for write commands").option("--reason <text>", "reason for coverage skip shortcuts").option("--plan", "validate the draft without writing knowledge").option("--close", "run compile close: compact, rebuild index, append changelog, verify").option("--save-input", "with --draft, save the consumed draft under output/compile/compile.<slug>.draft.yaml").action(async (options) => {
     if (options.scan === true) {
       throw new ContextError(ExitCode.UserError, "context compile --scan was removed; use context compile --scan-changes", {
         category: ErrorCategory.UserInputInvalid,
@@ -85854,7 +86164,7 @@ function registerCompileWorkflowCommand(program2) {
     const wantsChanges = options.scanChanges === true;
     const actionCount = countActions(wantsCode, wantsChanges, typeof options.context === "string", typeof options.nodeCycle === "string", typeof options.draft === "string", typeof options.draftStatus === "string", typeof options.draftPatch === "string", typeof options.coverageDisposition === "string", typeof options.coverageSkip === "string", options.coverageSkipUnresolved === true, options.close === true);
     if (actionCount !== 1) {
-      throw new ContextError(ExitCode.UserError, "usage: context compile --code [slug] | --scan-changes [--delegated] | --context <slug> [--view source-refs] [--source <source-id>] [--heading <heading-prefix>] [--token-budget <n>] [--draft-scaffold] [--request-full-text <block-id> [--request-full-text-range <start:end>]] [--delegated] | --node-cycle <slug> --input - --accept-safe-defaults [--delegated] | --draft <slug> --input - --plan [--prepare] [--delegated] | --draft <slug> --plan --prepare | --draft-status <slug> | --draft-patch <slug> --input - --plan [--payload-digest <digest>] | --coverage-disposition - --coverage-disposition-node <slug> [--payload-digest <digest>] | --coverage-skip <candidate-id> --coverage-disposition-node <slug> --reason <text> | --coverage-skip-unresolved --coverage-disposition-node <slug> --reason <text> | --close. Code sources are not processed by bare context compile; use context compile --code.", {
+      throw new ContextError(ExitCode.UserError, "usage: context compile --code [slug] | --scan-changes [--delegated] | --context <slug> [--view source-refs|text] [--source <source-id>] [--heading <heading-prefix>] [--token-budget <n>] [--draft-scaffold] [--request-full-text <block-id> [--request-full-text-range <start:end>]] [--delegated] | --node-cycle <slug> --input - --accept-safe-defaults [--delegated] | --draft <slug> --input - --plan [--prepare] [--delegated] | --draft <slug> --plan --prepare | --draft-status <slug> | --draft-patch <slug> --input - --plan [--payload-digest <digest>] | --coverage-disposition - --coverage-disposition-node <slug> [--payload-digest <digest>] | --coverage-skip <candidate-id> --coverage-disposition-node <slug> --reason <text> | --coverage-skip-unresolved --coverage-disposition-node <slug> --reason <text> | --close. Code sources are not processed by bare context compile; use context compile --code.", {
         category: ErrorCategory.UserInputInvalid,
         agent_hints: [{
           code: "compile-code-explicit-required",
@@ -85868,14 +86178,15 @@ function registerCompileWorkflowCommand(program2) {
     const viewWasExplicit = typeof options.view === "string";
     const view = compileOutputView(options.view);
     const wantsDraftPrepare = typeof options.draft === "string" && options.prepare === true;
+    const requestFullTextBlockIds = ignoredSourceIds(options.requestFullText);
     if (view !== "full") {
       if (!wantsChanges && typeof options.context !== "string" && !wantsDraftPrepare) {
         throw new ContextError(ExitCode.UserError, "--view is only valid with --scan-changes, --context, or --draft --prepare", {
           category: ErrorCategory.UserInputInvalid
         });
       }
-      if (wantsChanges && view === "source-refs") {
-        throw new ContextError(ExitCode.UserError, "--view source-refs is only valid with --context", {
+      if (wantsChanges && (view === "source-refs" || view === "text")) {
+        throw new ContextError(ExitCode.UserError, `--view ${view} is only valid with --context`, {
           category: ErrorCategory.UserInputInvalid
         });
       }
@@ -85889,8 +86200,12 @@ function registerCompileWorkflowCommand(program2) {
           category: ErrorCategory.UserInputInvalid
         });
       }
+      if (view === "text" && (typeof options.context !== "string" || requestFullTextBlockIds.length === 0)) {
+        throw new ContextError(ExitCode.UserError, "--view text requires --context <slug> --request-full-text <block-id>", {
+          category: ErrorCategory.UserInputInvalid
+        });
+      }
     }
-    const requestFullTextBlockIds = ignoredSourceIds(options.requestFullText);
     const requestFullTextRange = parseRequestFullTextRange(options.requestFullTextRange);
     const coverUncoveredOnly = options.coverUncoveredOnly === true;
     const draftScaffold = options.draftScaffold === true;
@@ -86098,11 +86413,15 @@ function registerCompileWorkflowCommand(program2) {
         }
         if (typeof options.context === "string") {
           let context = await getNodeContext(ctx.ctxDir, options.context, {
-            ...view !== "source-refs" && !coverUncoveredOnly ? { mode: "changed-only" } : {},
+            ...view !== "source-refs" && view !== "text" && requestFullTextBlockIds.length === 0 && !coverUncoveredOnly ? { mode: "changed-only" } : {},
             ...ignoreSourceIds.length > 0 ? { ignoreSourceIds } : {},
             ...requestFullTextBlockIds.length > 0 ? { requestFullTextBlockIds } : {},
             ...requestFullTextRange !== undefined ? { requestFullTextRange } : {}
           });
+          if (view === "text") {
+            writeCompileRequestFullTextView(context, compileChangesFormat(options.format));
+            return;
+          }
           const sourceFinalize = await readCurrentSourceOwnershipRecord(ctx.ctxDir).then((record) => record === null ? undefined : publishedSourceOwnershipSummary(record));
           const selectedCoverageStatus = coverUncoveredOnly ? await readCoverageWorkspaceStatus(ctx.ctxDir) : undefined;
           const selectedCoverageCandidates = selectedCoverageStatus?.candidates.filter((candidate) => candidate.node_slug === context.node.slug && candidate.status === "unresolved");
@@ -86425,6 +86744,20 @@ var AGENT_HINT_EMITTER_WORKFLOW_INVENTORY = [
     handles: ["node_slug", "section_id", "source_ref"],
     notes: "Compile applies semantic draft actions."
   },
+  {
+    source: "src/workflow/compileChangesOutput.ts",
+    family: "compile changes output",
+    policy: "semantic",
+    handles: ["node_slug", "first_compile_pending", "next_action"],
+    notes: "Incremental compile output routes agents through remaining Node slugs and compile commands instead of cache probing."
+  },
+  {
+    source: "src/workflow/compileChangesTypes.ts",
+    family: "compile changes contract",
+    policy: "semantic",
+    handles: ["node_slug", "first_compile_pending", "next_action"],
+    notes: "Compile changes types define semantic pending-work handles and next actions for Agent views."
+  },
   {
     source: "src/workflow/compileClose.ts",
     family: "compile close",
@@ -86453,6 +86786,13 @@ var AGENT_HINT_EMITTER_WORKFLOW_INVENTORY = [
     handles: ["draft_digest", "action_id", "node_slug"],
     notes: "Draft patch hints use session digest and action ids."
   },
+  {
+    source: "src/workflow/compileDraftSourceRefs.ts",
+    family: "compile draft source refs",
+    policy: "semantic",
+    handles: ["source_ref", "block_id", "node_slug"],
+    notes: "Source_ref diagnostics provide nearby refs, split actions, and citation handles rather than storage inspection steps."
+  },
   {
     source: "src/workflow/compileDraftTypes.ts",
     family: "compile draft types",
@@ -86743,6 +87083,20 @@ var AGENT_HINT_EMITTER_INVENTORY = [
     handles: ["project_id", "cache_status", "pending_compile"],
     notes: "Next commands are cache/status commands, not physical cache inspection."
   },
+  {
+    source: "src/commands/captureCodeInputHints.ts",
+    family: "code capture input hints",
+    policy: "semantic",
+    handles: ["target_path", "module_path", "received_targets"],
+    notes: "Code capture input errors route agents through plan and module capture commands rather than package probing."
+  },
+  {
+    source: "src/commands/captureCommand.ts",
+    family: "capture command output",
+    policy: "semantic",
+    handles: ["source_id", "capture_mode", "agent_hints"],
+    notes: "Capture output serializes structured hints from mode-specific handlers."
+  },
   {
     source: "src/commands/captureNote.ts",
     family: "note capture code anchors",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c4a/context-cli",
-  "version": "0.5.35-alpha.3",
+  "version": "0.5.35-beta.1",
   "type": "module",
   "bin": {
     "context": "./cli.js"

package/plugin/commands/align.md

@@ -30,6 +30,7 @@ Keep the prompt shape stable: read fixed schema/protocol first, then existing kn
    - `--unwrap` only removes the workflow metadata envelope. It does not turn a summary view into detail output.
 3. Reuse existing knowledge before inventing candidates. For named terms or entities, prefer `context mdrive glossary match <name>` and `context mdrive node list --format json` over direct file reads. Treat `match.kind`, `match.matched`, and `match.rank` as stable lookup hints: exact title/slug/alias hits should usually reuse the existing Node instead of creating another one.
    - Apply packaged `context:skill-align-workflow` Node classification gates before candidate ops and again before finalize: Action requires scale plus process evidence; Entity requires a concrete A/B tag or pure `term`; Domain requires child Nodes; fake Entities need at least two suspicious signals before downgrade. Scope/process words in a source title, such as "方案", "架构", "流程", "策略", or "演练", are review signals for the title/type choice, not proof that the Node is an Entity.
+   - Code projection Nodes are reusable knowledge handles. When prose evidence should attach to an existing code symbol Node, reuse the code slug (for example `pkg/symbol/button`) instead of creating a parallel document Node. If that code slug is not already in finalized prose ownership, declare it in the current `nodes[]` with the same node type and compatible tags/title, add the desired `planned_sections`, and point `sections[].owner` plus `block_ownership[].owners` at that slug. Do not cite `aspect:code:*` source refs from prose Sections; prose Sections cite only the current document evidence.
 4. Submit generated workflow payloads directly through stdin, preferably as JSON. Use YAML schemas only for reading examples when helpful; generated artifacts should avoid YAML quoting/indentation failure loops. Do not create `/tmp` or workspace scratch files for align payloads. The CLI owns ids, reducer validation, workflow payload storage, and mechanical aggregate. You own semantic discovery, Node type/tag decisions, structure decisions, and user-facing questions.
    - Save coarse-read with `context align --coarse-read - --format json`.
      The latest `align-coarse-read` payload is only the most recent checkpoint; durable multi-source reading notes are stored under `align-candidate-ledger.source_readings`.
@@ -80,6 +81,8 @@ Submit it with `context align --ownership-patch - --format json`. Keep `base_dig
 
 If `align-segments.incremental.mode` is `incremental`, the finalize step is a delta merge: submit only the Nodes and block ownership supported by the current scanned sources, and reference previous finalized Nodes when they are parents, dependencies, domain children, owners, or visibility targets. Absence of an old Node or edge is not a delete signal. Do not redeclare an old parent/domain just to attach a new child. `sections[].owner` must be a Node declared in the current payload; previous finalized Nodes can be referenced structurally but do not receive new section plans from this incremental payload. Existing or previously removed Node slugs cannot change `node_type`; `context align --scan --full` does not bypass that guard. Use a new slug for a different type, or retire the old slug through `context drop` or explicit structure correction before re-aligning.
 
+For code-projection Nodes, distinguish "reuse the existing knowledge file" from "previous finalized prose ownership". A freshly projected code Node may exist in `knowledge/` but not yet appear in finalized ownership. To attach current prose evidence to it, declare that same slug in the current finalize payload and plan only prose-owned Sections for the current evidence; the compile step will merge the prose source and Sections into the existing code Node while preserving code metadata and code-owned Sections.
+
 `nodes[].planned_sections` is the distinct set of Section kinds planned for that Node. List each kind at most once; do not copy `sections[].section_kind` one-for-one when a Node has multiple Sections of the same kind.
 
 For large finalize decisions, use `block_ownership_defaults[]` instead of enumerating every block. Each default names a `source_id` plus the same ownership fields as a block-level entry except `block_id`; the CLI expands it across that source's coverable blocks. Put only exceptions in `block_ownership[]`, which override defaults for their `block_id`. Keep the payload on stdin; do not generate temp JSON files just to list hundreds of ownership rows.

package/plugin/skills/skill-align-workflow/SKILL.md

@@ -18,6 +18,7 @@ Run the align workflow through the CLI-owned beta.8 payload chain: scan segments
 - Finalized structure is represented by `align-structure-decision`.
 - Retired payloads include candidate tables, decision patches, and full-tree finalize documents.
 - Existing knowledge is the lookup registry. Use `context mdrive glossary match <name>` / `context mdrive node list --format json` for term/entity reuse; do not read `knowledge/**` and do not create a separate registry file.
+- Code projection Nodes are existing knowledge handles. When document evidence belongs on a code symbol, reuse the code slug instead of creating a parallel document Node. If the slug exists only as projected code knowledge and is not yet in finalized prose ownership, declare that same slug in the current `nodes[]`, add the prose `planned_sections`, and route `sections[].owner` plus `block_ownership[].owners` to it.
 - Keep cache-friendly prompt order: fixed protocol and schemas first, existing knowledge lookup second, source-shared payload views third, current candidate batch last. Preserve CLI JSON order and do not add timestamps, random ids, scratch paths, or host paths to generated payloads.
 - `align-segments.generation_policy` is the workspace language contract for generated Node titles, summaries, rationale prose, and planned Section wording. Source-bound Section wording should stay close to the cited source language when it differs from the workspace language. Preserve product names, code identifiers, slugs, flags, `block_id` handles, and `source_ref` tokens exactly when needed.
 - Source titles and headings are ordinary evidence, not structural authority. Do not automatically copy them into Node titles or aliases; classify the evidence referent first, then generate a title that fits the final Node type.
@@ -43,6 +44,8 @@ Use this only inside `/context:align`.
 
    If `align-segments.incremental.mode` is `incremental`, finalize is a delta merge. Submit only the Nodes and ownership supported by the current scanned sources; reference previous finalized Nodes when they are parents, dependencies, domain children, owners, or visibility targets. Absence of an old Node or edge is not a delete signal. Do not redeclare an old parent/domain just to attach a new child. `sections[].owner` must be a Node declared in the current payload; previous finalized Nodes can be referenced structurally but do not receive new section plans from this incremental payload. Existing or previously removed Node slugs cannot change `node_type`; `context align --scan --full` does not bypass that guard. Use a new slug for a different type, or retire the old slug through `context drop` or explicit structure correction before re-aligning.
 
+   For code-projection Nodes, "existing knowledge file" and "previous finalized prose ownership" are different states. A freshly projected code Node can be reused by declaring the same slug in the current finalize payload and planning only prose-owned Sections for the current evidence. Compile merges the prose source and Sections into the existing code Node while preserving code metadata and code-owned Sections. Prose Sections must cite document evidence, not `aspect:code:*` source refs.
+
    `nodes[].planned_sections` is the distinct set of Section kinds planned for that Node. List each kind at most once; do not copy `sections[].section_kind` one-for-one when a Node has multiple Sections of the same kind.
 
    For large finalize decisions, use `block_ownership_defaults[]` instead of enumerating every block. Each default names a `source_id` plus the same ownership fields as a block-level entry except `block_id`; the CLI expands it across that source's coverable blocks. Put only exceptions in `block_ownership[]`, which override defaults for their `block_id`. Keep the payload on stdin; do not generate temp JSON files just to list hundreds of ownership rows.