archctx 0.7.0 → 0.7.2

package/bin/archctx.mjs

@@ -167,6 +167,65 @@ var init_architecture = __esm(() => {
   ];
 });
 
+// packages/contracts/src/docs-anchors.ts
+function docsAnchorsReportIssues(report) {
+  const issues = [];
+  const ids = report.nodes.map((node) => node.nodeId);
+  const sorted = [...new Set(ids)].sort();
+  if (sorted.length !== ids.length || sorted.some((id, index) => id !== ids[index]))
+    issues.push("nodes.nodeId must be sorted and unique");
+  const findings = report.nodes.flatMap((node) => node.findings);
+  const unchecked = report.nodes.flatMap((node) => node.unchecked);
+  if (report.summary.citations !== report.nodes.reduce((total, node) => total + node.citationCount, 0))
+    issues.push("summary.citations must equal the sum of nodes[].citationCount");
+  if (report.summary.findings !== findings.length)
+    issues.push("summary.findings must equal the number of findings");
+  if (report.summary.unchecked !== unchecked.length)
+    issues.push("summary.unchecked must equal the number of unchecked citations");
+  for (const kind of DOCS_ANCHOR_FINDING_KINDS) {
+    if (report.summary.byKind[kind] !== findings.filter((finding) => finding.kind === kind).length)
+      issues.push(`summary.byKind.${kind} must equal the number of ${kind} findings`);
+  }
+  for (const [index, node] of report.nodes.entries()) {
+    if (node.citationCount === 0)
+      issues.push(`nodes[${index}] must have at least one citation`);
+    for (const [findingIndex, finding] of node.findings.entries()) {
+      issues.push(...docsAnchorFindingIssues(finding, `nodes[${index}].findings[${findingIndex}]`));
+    }
+  }
+  if (report.codeGraph.availability === "ready" && unchecked.some((entry) => entry.reasonCode === "codegraph-unavailable")) {
+    issues.push("codegraph-unavailable is reported only when codeGraph.availability is unavailable");
+  }
+  return issues;
+}
+function docsAnchorFindingIssues(finding, prefix) {
+  const issues = [];
+  const { citation } = finding;
+  if (finding.kind === "missing-path" && citation.path === undefined)
+    issues.push(`${prefix} missing-path must name citation.path`);
+  if (finding.kind === "missing-symbol" && citation.symbol === undefined)
+    issues.push(`${prefix} missing-symbol must name citation.symbol`);
+  if (finding.kind === "line-out-of-range" && (citation.line === undefined || finding.lineCount === undefined)) {
+    issues.push(`${prefix} line-out-of-range must name citation.line and lineCount`);
+  }
+  if (finding.lineCount !== undefined !== (finding.kind === "line-out-of-range"))
+    issues.push(`${prefix}.lineCount is present only on line-out-of-range`);
+  if (finding.kind === "line-moved") {
+    const lines = finding.currentLines ?? [];
+    if (citation.line === undefined || citation.symbol === undefined)
+      issues.push(`${prefix} line-moved must name citation.line and citation.symbol`);
+    if (lines.length === 0 || lines.some((line, index) => index > 0 && line <= lines[index - 1]))
+      issues.push(`${prefix}.currentLines must be non-empty, sorted and unique`);
+  } else if (finding.currentLines !== undefined) {
+    issues.push(`${prefix}.currentLines is present only on line-moved`);
+  }
+  return issues;
+}
+var DOCS_ANCHORS_REPORT_SCHEMA_VERSION = "archcontext.docs-anchors/v1", DOCS_ANCHOR_FINDING_KINDS;
+var init_docs_anchors = __esm(() => {
+  DOCS_ANCHOR_FINDING_KINDS = ["line-moved", "line-out-of-range", "missing-path", "missing-symbol"];
+});
+
 // packages/contracts/src/external-docs.ts
 var EXTERNAL_DOCUMENTATION_RESOURCE_SCHEMA_VERSION = "archcontext.external-document/v1", CONTEXT7_LOCKFILE_SCHEMA_VERSION = "archcontext.context7-lock/v1";
 
@@ -674,6 +733,9 @@ var init_ledger = __esm(() => {
   ];
 });
 
+// packages/contracts/src/ownership-dependencies.ts
+var CHANGESET_OWNERSHIP_DELTA_SCHEMA_VERSION = "archcontext.changeset-ownership-delta/v1", CHANGESET_OWNERSHIP_DELTA_PATH_LIMIT = 50, CAPABILITY_DEPENDENCIES_SCHEMA_VERSION = "archcontext.capability-dependencies/v1", CAPABILITY_DEPENDENCIES_EDGE_LIMIT = 200, CAPABILITY_DEPENDENCIES_CALLS_UNAVAILABLE_REASON = "call-edges-not-exposed";
+
 // packages/contracts/src/ports.ts
 function baseModelBlockingErrors(result) {
   if (result.valid)
@@ -1407,7 +1469,7 @@ function sortedUniqueIssues(label, values) {
   const expected = [...new Set(values)].sort();
   return expected.length === values.length && expected.every((value, index) => value === values[index]) ? [] : [`${label} must be sorted and unique`];
 }
-var PROJECTION_REQUEST_SCHEMA_VERSION = "archcontext.projection-request/v1", PROJECTION_RESULT_SCHEMA_VERSION = "archcontext.projection-result/v2", PROJECTION_APPLY_IDENTITY_SCHEMA_VERSION = "archcontext.projection-apply-identity/v1", PROJECTION_APPLY_RECEIPT_SCHEMA_VERSION = "archcontext.projection-apply-receipt/v1", PROJECTION_APPLY_RECOVERY_BINDING_SCHEMA_VERSION = "archcontext.projection-apply-recovery-binding/v1", PROJECTION_APPLY_RECOVERY_INTENT_SCHEMA_VERSION = "archcontext.projection-apply-recovery-intent/v1", PROJECTION_APPLY_RECOVERY_PROOF_SCHEMA_VERSION = "archcontext.projection-apply-recovery-proof/v1", PROJECTION_APPLY_RECOVERY_RESULT_SCHEMA_VERSION = "archcontext.projection-apply-recovery-result/v1", PROJECTION_APPLY_READBACK_RESULT_SCHEMA_VERSION = "archcontext.projection-apply-readback-result/v1", ARCHITECTURE_REFRESH_SIGNAL_SCHEMA_VERSION = "archcontext.architecture-refresh-signal/v1", ARCHCTX_CAPABILITIES_SCHEMA_VERSION = "archcontext.capabilities/v1", ARCHITECTURE_DOCS_RENDERER_VERSION = "archcontext.docs-renderer/v5", AGENT_CONTEXT_RENDERER_VERSION = "archcontext.agent-context-renderer/v1", PROJECTION_MODES, PROJECTION_PRIOR_COMMITTED_APPLY_OPERATIONS, PROJECTION_TARGETS, PROJECTION_HUMAN_ACTION_REASON_CODES, ARCHITECTURE_MAJOR_CHANGE_REASON_CODES, ARCHCTX_FEATURES, ARCHITECTURE_SEMANTIC_FACETS, ARCHITECTURE_PROOF_P1_STATUSES, ARCHITECTURE_PROOF_P2_STATUSES, PROJECTION_FILE_PREVIEW_MAX_BYTES = 65536, PROJECTION_PREVIEW_TOTAL_MAX_BYTES = 1048576, PROJECTION_FRESHNESS_REASON_CODES, UTF8, SHA256_DIGEST, ISO_INSTANT;
+var PROJECTION_REQUEST_SCHEMA_VERSION = "archcontext.projection-request/v1", PROJECTION_RESULT_SCHEMA_VERSION = "archcontext.projection-result/v2", PROJECTION_APPLY_IDENTITY_SCHEMA_VERSION = "archcontext.projection-apply-identity/v1", PROJECTION_APPLY_RECEIPT_SCHEMA_VERSION = "archcontext.projection-apply-receipt/v1", PROJECTION_APPLY_RECOVERY_BINDING_SCHEMA_VERSION = "archcontext.projection-apply-recovery-binding/v1", PROJECTION_APPLY_RECOVERY_INTENT_SCHEMA_VERSION = "archcontext.projection-apply-recovery-intent/v1", PROJECTION_APPLY_RECOVERY_PROOF_SCHEMA_VERSION = "archcontext.projection-apply-recovery-proof/v1", PROJECTION_APPLY_RECOVERY_RESULT_SCHEMA_VERSION = "archcontext.projection-apply-recovery-result/v1", PROJECTION_APPLY_READBACK_RESULT_SCHEMA_VERSION = "archcontext.projection-apply-readback-result/v1", ARCHITECTURE_REFRESH_SIGNAL_SCHEMA_VERSION = "archcontext.architecture-refresh-signal/v1", ARCHCTX_CAPABILITIES_SCHEMA_VERSION = "archcontext.capabilities/v1", ARCHITECTURE_DOCS_RENDERER_VERSION = "archcontext.docs-renderer/v5", AGENT_CONTEXT_RENDERER_VERSION = "archcontext.agent-context-renderer/v1", PROJECTION_MODES, PROJECTION_PRIOR_COMMITTED_APPLY_OPERATIONS, PROJECTION_TARGETS, PROJECTION_HUMAN_ACTION_REASON_CODES, ARCHITECTURE_MAJOR_CHANGE_REASON_CODES, ARCHCTX_FEATURES, ARCHITECTURE_SEMANTIC_FACETS, ARCHITECTURE_PROOF_P1_STATUSES, ARCHITECTURE_PROOF_P2_STATUSES, ARCHITECTURE_FLOW_SELECTOR_CHECK_SCHEMA_VERSION = "archcontext.flow-selector-check/v1", PROJECTION_FILE_PREVIEW_MAX_BYTES = 65536, PROJECTION_PREVIEW_TOTAL_MAX_BYTES = 1048576, PROJECTION_FRESHNESS_REASON_CODES, UTF8, SHA256_DIGEST, ISO_INSTANT;
 var init_projection = __esm(() => {
   init_schema();
   PROJECTION_MODES = ["check", "plan", "apply", "adopt"];
@@ -1440,8 +1502,12 @@ var init_projection = __esm(() => {
     "architecture-change-capabilities-v1",
     "architecture-docs-renderer-v2",
     "architecture-refresh-signal-v1",
+    "capability-dependencies-v1",
     "changeset-entity-operations-v1",
+    "changeset-ownership-delta-v1",
     "code-facts-unavailable-error-v1",
+    "docs-anchors-v1",
+    "flow-selector-check-v1",
     "module-statistics-v1",
     "projection-apply-readback-v1",
     "projection-apply-receipt-v1",
@@ -1459,7 +1525,8 @@ var init_projection = __esm(() => {
     "refactor-assessment-v1",
     "refactor-observation-evidence-v1",
     "refactor-resolution-v1",
-    "refactor-scan-limits-v1"
+    "refactor-scan-limits-v1",
+    "refactor-scan-untracked-count-v1"
   ];
   ARCHITECTURE_SEMANTIC_FACETS = [
     "constraints",
@@ -1802,7 +1869,7 @@ function productVersionManifest() {
     }
   };
 }
-var ARCHCONTEXT_PRODUCT_NAME = "archctx", ARCHCONTEXT_PRODUCT_VERSION = "0.7.0", ARCHCONTEXT_PACKAGE_MANAGER = "bun@1.4.3", ARCHCONTEXT_NODE_RANGE = ">=22.22 <26", LOCAL_RUNTIME_RPC_SCHEMA_VERSION = "archcontext.runtime-rpc/v1", ARCHCONTEXT_SCHEMA_SET_VERSION = "2026-07-11.explorer-view-v2";
+var ARCHCONTEXT_PRODUCT_NAME = "archctx", ARCHCONTEXT_PRODUCT_VERSION = "0.7.2", ARCHCONTEXT_PACKAGE_MANAGER = "bun@1.4.3", ARCHCONTEXT_NODE_RANGE = ">=22.22 <26", LOCAL_RUNTIME_RPC_SCHEMA_VERSION = "archcontext.runtime-rpc/v1", ARCHCONTEXT_SCHEMA_SET_VERSION = "2026-07-11.explorer-view-v2";
 
 // packages/contracts/src/refactor.ts
 function refactorProposalDigest(proposal) {
@@ -1919,6 +1986,9 @@ function refactorRequestInvariantIssues(request, prefix = "request") {
   }
   if (request.proposal)
     issues.push(...refactorProposalInvariantIssues(request.proposal, `${prefix}.proposal`));
+  if (request.importNodeLimit !== undefined && !(Number.isInteger(request.importNodeLimit) && request.importNodeLimit >= 1)) {
+    issues.push(`${prefix}.importNodeLimit must be a positive integer`);
+  }
   return issues;
 }
 function refactorVerificationRequestInvariantIssues(request, prefix = "request") {
@@ -1937,6 +2007,9 @@ function refactorVerificationRequestInvariantIssues(request, prefix = "request")
   if (request.expectedWorktreeDigest !== undefined) {
     issues.push(...digestIssues(`${prefix}.expectedWorktreeDigest`, request.expectedWorktreeDigest));
   }
+  if (request.importNodeLimit !== undefined && !(Number.isInteger(request.importNodeLimit) && request.importNodeLimit >= 1)) {
+    issues.push(`${prefix}.importNodeLimit must be a positive integer`);
+  }
   if (request.executionEvidenceRefs !== undefined) {
     if (!Array.isArray(request.executionEvidenceRefs)) {
       issues.push(`${prefix}.executionEvidenceRefs must be an array`);
@@ -2013,6 +2086,16 @@ function moduleStatisticsSnapshotInvariantIssues(snapshot, prefix = "snapshot")
     }
   }
   issues.push(...nonNegativeIntegerIssues(`${prefix}.codeFacts.edgeLimit`, snapshot.codeFacts.edgeLimit));
+  const importNodeCount = snapshot.codeFacts.importNodeCount ?? null;
+  issues.push(...nonNegativeIntegerIssues(`${prefix}.codeFacts.importNodeCount`, importNodeCount));
+  if (snapshot.codeFacts.reasonCodes.includes("code-facts-import-limit")) {
+    const { edgeLimit } = snapshot.codeFacts;
+    if (snapshot.codeFacts.coverage !== "partial")
+      issues.push(`${prefix}.codeFacts.coverage must be partial when the import limit was reached`);
+    if (edgeLimit === null || importNodeCount !== null && importNodeCount <= edgeLimit) {
+      issues.push(`${prefix}.codeFacts.importNodeCount must exceed edgeLimit when the import limit was reached`);
+    }
+  }
   for (const [field, value] of Object.entries(snapshot.repositorySummary)) {
     issues.push(...nonNegativeIntegerIssues(`${prefix}.repositorySummary.${field}`, value));
   }
@@ -2467,6 +2550,7 @@ var init_refactor = __esm(() => {
     "executionEvidenceRefs",
     "expectedHeadSha",
     "expectedWorktreeDigest",
+    "importNodeLimit",
     "recommendationId",
     "schemaVersion"
   ];
@@ -2479,6 +2563,7 @@ var init_refactor = __esm(() => {
   ];
   REFACTOR_SCALE_REASON_CODES = [
     "caller-coverage-unknown",
+    "code-facts-import-limit",
     "code-facts-missing",
     "code-facts-truncated",
     "major-change-detected",
@@ -2712,6 +2797,7 @@ var init_validator = __esm(() => {
 var init_src = __esm(() => {
   init_control_plane_routes();
   init_architecture();
+  init_docs_anchors();
   init_github_governance();
   init_ledger();
   init_ports();
@@ -13366,14 +13452,18 @@ function sanitizeGithubDeveloperReviewState(state, statePath) {
   assertNoReviewSecrets(data, []);
   return data;
 }
+function isStandardBase64Value(token) {
+  return token.length % 4 === 0 && /^[A-Za-z0-9+/]+={0,2}$/.test(token) && /[A-Za-z0-9+]{20}/.test(token);
+}
 function assertNoCliSecretMaterial(value) {
   const serialized = typeof value === "string" ? value : JSON.stringify(value);
   if (!serialized)
     return;
   if (/-----BEGIN [A-Z ]*PRIVATE KEY-----/.test(serialized))
     throw new Error("device-private-key-material-forbidden");
-  if (/(^|["'\s])(?:file:\/\/|\/|\.\/|\.\.\/|~\/)[^"'\s]*(?:private|device|key)[^"'\s]*/i.test(serialized)) {
-    throw new Error("device-private-key-file-ref-forbidden");
+  for (const [, token] of serialized.matchAll(/(?:^|["'\s])((?:file:\/\/|\.{0,2}\/|~\/)[^"'\s]*)/gi)) {
+    if (/private|device|key/i.test(token) && !isStandardBase64Value(token))
+      throw new Error("device-private-key-file-ref-forbidden");
   }
   if (/(access|refresh|token)_[A-Za-z0-9_-]+/.test(serialized))
     throw new Error("github-token-material-forbidden");
@@ -15017,7 +15107,7 @@ function parseScalar(value) {
 
 // packages/local-runtime/git-adapter/src/index.ts
 import { execFileSync as execFileSync2, spawnSync } from "node:child_process";
-import { existsSync as existsSync6, lstatSync as lstatSync3, mkdirSync as mkdirSync4, mkdtempSync, readFileSync as readFileSync7, rmSync as rmSync4 } from "node:fs";
+import { existsSync as existsSync6, lstatSync as lstatSync3, mkdirSync as mkdirSync4, mkdtempSync, readdirSync as readdirSync4, readFileSync as readFileSync7, rmSync as rmSync4 } from "node:fs";
 import { dirname as dirname4, join as join4, resolve as resolve8 } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -16363,29 +16453,86 @@ function validateStep(input) {
     input.diagnostics.push({ code: "selector-declaration-ambiguous", flowId: input.flowId, stepId: input.step.id, detail: selectorKey });
     return;
   }
-  const evidence = input.evidence.filter((entry) => evidenceSelectorKey(entry) === selectorKey && entry.nodeId === declarations[0].nodeId);
-  if (evidence.length === 0) {
-    input.diagnostics.push({ code: "selector-evidence-missing", flowId: input.flowId, stepId: input.step.id, detail: selectorKey });
-    return;
-  }
-  if (evidence.length > 1) {
-    input.diagnostics.push({ code: "selector-evidence-ambiguous", flowId: input.flowId, stepId: input.step.id, detail: selectorKey });
-    return;
-  }
-  if (evidence[0].ambiguous) {
-    input.diagnostics.push({ code: "selector-evidence-ambiguous", flowId: input.flowId, stepId: input.step.id, detail: selectorKey });
-    return;
-  }
-  if (evidence[0].truncated) {
-    input.diagnostics.push({ code: "selector-evidence-truncated", flowId: input.flowId, stepId: input.step.id, detail: selectorKey });
-    return;
-  }
-  if (!evidence[0].matched || evidence[0].callSites.length === 0) {
-    input.diagnostics.push({ code: "selector-evidence-unmatched", flowId: input.flowId, stepId: input.step.id, detail: selectorKey });
+  const status = architectureSelectorProofStatus(input.evidence.filter((entry) => evidenceSelectorKey(entry) === selectorKey && entry.nodeId === declarations[0].nodeId));
+  if (status !== "proven") {
+    input.diagnostics.push({ code: SELECTOR_STATUS_DIAGNOSTICS[status], flowId: input.flowId, stepId: input.step.id, detail: selectorKey });
     return;
   }
   input.provenSelectorKeys.add(selectorKey);
 }
+var SELECTOR_STATUS_DIAGNOSTICS = {
+  "ambiguous-symbol": "selector-evidence-ambiguous",
+  "evidence-missing": "selector-evidence-missing",
+  "evidence-truncated": "selector-evidence-truncated",
+  "false-builtin-call": "selector-evidence-unmatched",
+  "no-direct-call": "selector-evidence-unmatched",
+  "only-references": "selector-evidence-unmatched"
+};
+function architectureSelectorProofStatus(evidence) {
+  if (evidence.length === 0)
+    return "evidence-missing";
+  if (evidence.length > 1 || evidence[0].ambiguous)
+    return "ambiguous-symbol";
+  if (evidence[0].truncated)
+    return "evidence-truncated";
+  if (evidence[0].matched && evidence[0].callSites.length > 0)
+    return "proven";
+  if ((evidence[0].rejectedBuiltinCallSites ?? []).length > 0)
+    return "false-builtin-call";
+  if ((evidence[0].referenceSites ?? []).length > 0)
+    return "only-references";
+  return "no-direct-call";
+}
+function checkSemanticFlowSelectors(input) {
+  const stepsByKey = new Map;
+  for (const flow of [...input.flows].sort((left, right) => left.id.localeCompare(right.id))) {
+    if (flow.applicability !== "required")
+      continue;
+    for (const step of [...flow.steps, ...flow.outcomes.flatMap((outcome) => outcome.steps)]) {
+      const key = evidenceSelectorKey(step.evidence);
+      stepsByKey.set(key, [...stepsByKey.get(key) ?? [], { flowId: flow.id, stepId: step.id }]);
+    }
+  }
+  const selectors = input.nodes.flatMap((node) => (node.source?.entrypoints ?? []).flatMap((entrypoint) => entrypoint.symbols.flatMap((source) => source.sinks.map((sink) => {
+    const key = evidenceSelectorKey({ entrypointId: entrypoint.id, sourceSymbol: source.name, sinkId: sink.id });
+    const evidence = input.evidence.filter((entry) => evidenceSelectorKey(entry) === key && entry.nodeId === node.id);
+    const single = evidence.length === 1 ? evidence[0] : undefined;
+    return {
+      nodeId: node.id,
+      entrypointId: entrypoint.id,
+      sourcePath: entrypoint.path,
+      sourceSymbol: source.name,
+      sinkId: sink.id,
+      sinkPath: sink.path,
+      sinkSymbol: sink.symbol,
+      status: architectureSelectorProofStatus(evidence),
+      callSites: single?.callSites ?? [],
+      referenceSites: single?.referenceSites ?? [],
+      rejectedBuiltinCallSites: single?.rejectedBuiltinCallSites ?? [],
+      flowSteps: stepsByKey.get(key) ?? []
+    };
+  })))).sort((left, right) => compareStrings(left.nodeId, right.nodeId) || compareStrings(left.entrypointId, right.entrypointId) || compareStrings(left.sourceSymbol, right.sourceSymbol) || compareStrings(left.sinkId, right.sinkId));
+  const capabilityIds = [...new Set(input.flows.map((flow) => flow.capabilityId))].sort(compareStrings);
+  const capabilities = capabilityIds.map((capabilityId) => {
+    const { p2 } = compileSemanticCapabilityDiagrams({ capabilityId, nodes: input.nodes, relations: input.relations, flows: input.flows, evidence: input.evidence });
+    return { capabilityId, p2Status: p2.status, diagnostics: p2.diagnostics };
+  });
+  const unproven = selectors.filter((selector) => selector.status !== "proven");
+  return {
+    ok: capabilities.every((capability) => capability.p2Status !== "unprovable"),
+    summary: {
+      selectors: selectors.length,
+      proven: selectors.length - unproven.length,
+      unproven: unproven.length,
+      usedUnproven: unproven.filter((selector) => selector.flowSteps.length > 0).length
+    },
+    selectors,
+    capabilities
+  };
+}
+function compareStrings(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
 function proofRelevantSelectorEvidence(evidence) {
   return evidence.map((entry) => ({
     nodeId: entry.nodeId,
@@ -16486,7 +16633,7 @@ function mermaidStableId(prefix, value) {
   return `${prefix}_${slug}_${digestJson(value).slice(7, 15)}`;
 }
 function escapeMermaidLabel(value) {
-  return value.replace(/["#;,]/g, (character) => ({ '"': "'", "#": "＃", ";": "；", ",": "，" })[character]);
+  return value.replace(/["#;,]/g, (character) => ({ '"': "#quot;", "#": "#35;", ";": "#59;", ",": "#44;" })[character]);
 }
 
 // packages/core/projection-engine/src/major-change.ts
@@ -17142,6 +17289,374 @@ function diffHunks(ops) {
   }
   return hunks;
 }
+// packages/core/projection-engine/src/prose-anchors.ts
+init_src();
+var IDENTIFIER = "[A-Za-z_][A-Za-z0-9_$]*";
+var QUALIFIED_IDENTIFIER = `${IDENTIFIER}(?:\\.${IDENTIFIER})*`;
+var IDENTIFIER_PATTERN = new RegExp(`^${IDENTIFIER}$`);
+var QUALIFIED_PATTERN = new RegExp(`^${QUALIFIED_IDENTIFIER}$`);
+var CALL_PATTERN = new RegExp(`^(${QUALIFIED_IDENTIFIER})\\(\\)$`);
+var PATH_PATTERN = /^[A-Za-z0-9_.@+\-/]+$/;
+var LINE_FRAGMENT = /^L(\d+)(?:-L?(\d+))?$/;
+var LINE_SUFFIX = /^(.*?):(\d+)(?:-(\d+))?$/;
+var FILE_EXTENSION = /\.[A-Za-z0-9]+$/;
+var BINDING_GAP = /^\s*[([,:–—-]?\s*$/;
+var GENERATED_BEGIN = /<!-- BEGIN ARCHCONTEXT:generated target="([^"]+)"[^>]*-->/;
+function checkProseAnchors(input) {
+  const nodes = [];
+  let documents = 0;
+  for (const node of [...input.nodes].sort((left, right) => left.nodeId < right.nodeId ? -1 : left.nodeId > right.nodeId ? 1 : 0)) {
+    if (node.document)
+      documents += 1;
+    const result = checkNode(node, input);
+    if (result.citationCount > 0)
+      nodes.push(result);
+  }
+  const findings = nodes.flatMap((node) => node.findings);
+  const byKind = Object.fromEntries(DOCS_ANCHOR_FINDING_KINDS.map((kind) => [kind, findings.filter((finding) => finding.kind === kind).length]));
+  return {
+    schemaVersion: DOCS_ANCHORS_REPORT_SCHEMA_VERSION,
+    profile: input.profile,
+    codeGraph: input.codeGraph.availability === "ready" ? { availability: "ready" } : { availability: "unavailable", reasonCode: input.codeGraph.reasonCode },
+    summary: {
+      nodes: input.nodes.length,
+      documents,
+      citations: nodes.reduce((total, node) => total + node.citationCount, 0),
+      findings: findings.length,
+      unchecked: nodes.reduce((total, node) => total + node.unchecked.length, 0),
+      byKind
+    },
+    nodes
+  };
+}
+function extractNodeProseCitations(node) {
+  const located = [];
+  if (typeof node.summary === "string") {
+    for (const line of node.summary.split(/\r?\n/)) {
+      located.push(...parseLineCitations(line).map((parsed) => ({ origin: { kind: "node-summary" }, parsed })));
+    }
+  }
+  for (const [index, responsibility] of (node.responsibilities ?? []).entries()) {
+    if (typeof responsibility !== "string")
+      continue;
+    for (const line of responsibility.split(/\r?\n/)) {
+      located.push(...parseLineCitations(line).map((parsed) => ({ origin: { kind: "node-responsibility", index }, parsed })));
+    }
+  }
+  if (node.document) {
+    for (const { line, text } of humanOwnedMarkdownLines(node.document.body)) {
+      located.push(...parseLineCitations(text).map((parsed) => ({ origin: { kind: "document", path: node.document.path, line }, parsed })));
+    }
+  }
+  return located;
+}
+function humanOwnedMarkdownLines(body) {
+  const lines = [];
+  let generatedEnd;
+  let fence;
+  let inComment = false;
+  for (const [index, raw] of body.split(/\r?\n/).entries()) {
+    if (generatedEnd !== undefined) {
+      if (raw.includes(generatedEnd))
+        generatedEnd = undefined;
+      continue;
+    }
+    const begin = GENERATED_BEGIN.exec(raw);
+    if (begin) {
+      const end = `<!-- END ARCHCONTEXT:generated target="${begin[1]}" -->`;
+      if (!raw.slice(begin.index + begin[0].length).includes(end))
+        generatedEnd = end;
+      continue;
+    }
+    if (fence) {
+      const close = /^ {0,3}(`{3,}|~{3,})\s*$/.exec(raw);
+      if (close && close[1][0] === fence.char && close[1].length >= fence.length)
+        fence = undefined;
+      continue;
+    }
+    const open = /^ {0,3}(`{3,}|~{3,})/.exec(raw);
+    if (open && !inComment) {
+      fence = { char: open[1][0], length: open[1].length };
+      continue;
+    }
+    const stripped = stripHtmlComments(raw, inComment);
+    inComment = stripped.inComment;
+    if (stripped.text.trim() !== "")
+      lines.push({ line: index + 1, text: stripped.text });
+  }
+  return lines;
+}
+function stripHtmlComments(raw, inComment) {
+  let text = "";
+  let rest = raw;
+  let open = inComment;
+  while (rest.length > 0) {
+    if (open) {
+      const close = rest.indexOf("-->");
+      if (close < 0)
+        return { text, inComment: true };
+      rest = rest.slice(close + 3);
+      open = false;
+      continue;
+    }
+    const start = rest.indexOf("<!--");
+    if (start < 0)
+      return { text: text + rest, inComment: false };
+    text += rest.slice(0, start);
+    rest = rest.slice(start + 4);
+    open = true;
+  }
+  return { text, inComment: open };
+}
+function inlineCodeSpans(text) {
+  const spans = [];
+  let index = 0;
+  while (index < text.length) {
+    if (text[index] !== "`") {
+      index += 1;
+      continue;
+    }
+    if (precedingBackslashes(text, index) % 2 === 1) {
+      index += 1;
+      continue;
+    }
+    let runEnd = index;
+    while (text[runEnd] === "`")
+      runEnd += 1;
+    const ticks = runEnd - index;
+    let cursor = runEnd;
+    let close = -1;
+    while (cursor < text.length) {
+      if (text[cursor] !== "`") {
+        cursor += 1;
+        continue;
+      }
+      let closeEnd = cursor;
+      while (text[closeEnd] === "`")
+        closeEnd += 1;
+      if (closeEnd - cursor === ticks) {
+        close = cursor;
+        break;
+      }
+      cursor = closeEnd;
+    }
+    if (close < 0) {
+      index = runEnd;
+      continue;
+    }
+    let content = text.slice(runEnd, close);
+    if (content.length > 2 && content.startsWith(" ") && content.endsWith(" "))
+      content = content.slice(1, -1);
+    spans.push({ content, start: index, end: close + ticks });
+    index = close + ticks;
+  }
+  return spans;
+}
+function precedingBackslashes(text, index) {
+  let count = 0;
+  while (index - count - 1 >= 0 && text[index - count - 1] === "\\")
+    count += 1;
+  return count;
+}
+function parseLineCitations(text) {
+  const spans = inlineCodeSpans(text);
+  const parsed = spans.map((span) => parseCitationText(span.content));
+  const consumed = new Set;
+  for (const [index, citation] of parsed.entries()) {
+    if (citation?.form !== "path" || citation.line === undefined || citation.symbol !== undefined)
+      continue;
+    const bind = (other, gap) => {
+      const candidate = parsed[other];
+      if (consumed.has(other) || !candidate || candidate.form === "path" || !BINDING_GAP.test(gap))
+        return false;
+      citation.symbol = candidate.symbol;
+      consumed.add(other);
+      return true;
+    };
+    if (index + 1 < spans.length && bind(index + 1, text.slice(spans[index].end, spans[index + 1].start)))
+      continue;
+    if (index > 0)
+      bind(index - 1, text.slice(spans[index - 1].end, spans[index].start));
+  }
+  return parsed.flatMap((citation, index) => citation && !consumed.has(index) ? [citation] : []);
+}
+function parseCitationText(raw) {
+  const text = raw.trim();
+  if (text === "" || /\s/.test(text))
+    return;
+  const call = CALL_PATTERN.exec(text);
+  if (call)
+    return { form: "call", text, symbol: call[1] };
+  if (IDENTIFIER_PATTERN.test(text))
+    return { form: "identifier", text, symbol: text };
+  let rest = text;
+  let line;
+  let endLine;
+  let symbol;
+  let explicit = false;
+  const hash = rest.indexOf("#");
+  if (hash >= 0) {
+    const fragment = rest.slice(hash + 1);
+    rest = rest.slice(0, hash);
+    const lineFragment = LINE_FRAGMENT.exec(fragment);
+    if (lineFragment) {
+      line = Number(lineFragment[1]);
+      endLine = lineFragment[2] === undefined ? undefined : Number(lineFragment[2]);
+    } else if (QUALIFIED_PATTERN.test(fragment)) {
+      symbol = fragment;
+    } else {
+      return;
+    }
+    explicit = true;
+  }
+  const lineSuffix = LINE_SUFFIX.exec(rest);
+  if (lineSuffix) {
+    if (line !== undefined)
+      return;
+    rest = lineSuffix[1];
+    line = Number(lineSuffix[2]);
+    endLine = lineSuffix[3] === undefined ? undefined : Number(lineSuffix[3]);
+    explicit = true;
+  }
+  if (line !== undefined && (line < 1 || endLine !== undefined && endLine < line))
+    return;
+  const written = rest.replace(/^\.\//, "");
+  if (!PATH_PATTERN.test(written) || written.startsWith("/"))
+    return;
+  const directory = written.endsWith("/");
+  const path = directory ? written.slice(0, -1) : written;
+  const segments = path.split("/");
+  if (path === "" || segments.some((segment) => segment === "" || /^\.+$/.test(segment)))
+    return;
+  if (!explicit && segments.length < 2)
+    return;
+  if (explicit && segments.length < 2 && !FILE_EXTENSION.test(path))
+    return;
+  return {
+    form: "path",
+    text,
+    path,
+    directory,
+    explicit,
+    ...line === undefined ? {} : { line },
+    ...endLine === undefined ? {} : { endLine },
+    ...symbol === undefined ? {} : { symbol }
+  };
+}
+function checkNode(node, input) {
+  const findings = [];
+  const unchecked = [];
+  let citationCount = 0;
+  for (const { origin, parsed } of extractNodeProseCitations(node)) {
+    const outcome = parsed.form === "path" ? checkPathCitation(parsed, node, input) : checkSymbolCitation(parsed, input.codeGraph);
+    if (!outcome.counted)
+      continue;
+    citationCount += 1;
+    for (const finding of outcome.findings)
+      findings.push({ ...finding, origin, citation: outcome.citation });
+    for (const reasonCode of outcome.unchecked)
+      unchecked.push({ reasonCode, origin, citation: outcome.citation });
+  }
+  return {
+    nodeId: node.nodeId,
+    ...node.document ? { documentPath: node.document.path } : {},
+    citationCount,
+    findings,
+    unchecked
+  };
+}
+function checkSymbolCitation(parsed, codeGraph) {
+  const citation = { text: parsed.text, symbol: parsed.symbol };
+  if (codeGraph.availability !== "ready") {
+    return parsed.form === "call" ? { counted: true, citation, findings: [], unchecked: ["codegraph-unavailable"] } : { counted: false, citation, findings: [], unchecked: [] };
+  }
+  const { name, container } = splitSymbol(parsed.symbol);
+  const declared = matchingDeclarations(codeGraph.symbols.declarationsNamed(name), container).length > 0;
+  if (parsed.form === "identifier")
+    return { counted: declared, citation, findings: [], unchecked: [] };
+  const missing = !codeGraph.symbols.appearsInSource(name);
+  return { counted: true, citation, findings: missing ? [{ kind: "missing-symbol" }] : [], unchecked: [] };
+}
+function checkPathCitation(parsed, node, input) {
+  const citation = {
+    text: parsed.text,
+    path: parsed.path,
+    ...parsed.line === undefined ? {} : { line: parsed.line },
+    ...parsed.endLine === undefined ? {} : { endLine: parsed.endLine },
+    ...parsed.symbol === undefined ? {} : { symbol: parsed.symbol }
+  };
+  const resolution = resolveCitedPath(parsed, node, input.tree);
+  if (resolution.status === "ignored")
+    return { counted: false, citation, findings: [], unchecked: [] };
+  if (resolution.status === "ambiguous")
+    return { counted: true, citation, findings: [], unchecked: ["path-ambiguous"] };
+  const needsFile = parsed.line !== undefined || parsed.symbol !== undefined;
+  if (resolution.status === "missing" || needsFile && resolution.kind !== "file") {
+    return { counted: true, citation, findings: [{ kind: "missing-path" }], unchecked: [] };
+  }
+  const resolved = resolution;
+  if (resolved.path !== parsed.path)
+    citation.resolvedPath = resolved.path;
+  if (!needsFile)
+    return { counted: true, citation, findings: [], unchecked: [] };
+  const lineFinding = () => {
+    if (parsed.line === undefined)
+      return [];
+    const lineCount = input.tree.lineCount(resolved.path);
+    return (parsed.endLine ?? parsed.line) > lineCount ? [{ kind: "line-out-of-range", lineCount }] : [];
+  };
+  if (parsed.symbol === undefined)
+    return { counted: true, citation, findings: lineFinding(), unchecked: [] };
+  if (input.codeGraph.availability !== "ready") {
+    return { counted: true, citation, findings: lineFinding(), unchecked: ["codegraph-unavailable"] };
+  }
+  const symbols = input.codeGraph.symbols;
+  if (!symbols.supportsPath(resolved.path)) {
+    return { counted: true, citation, findings: lineFinding(), unchecked: ["language-unsupported"] };
+  }
+  const { name, container } = splitSymbol(parsed.symbol);
+  const declarations = matchingDeclarations(symbols.declarationsInFile(resolved.path, name), container);
+  if (declarations.length === 0)
+    return { counted: true, citation, findings: [{ kind: "missing-symbol" }], unchecked: [] };
+  const line = parsed.line;
+  if (line === undefined || declarations.some((declaration) => declaration.startLine <= line && line <= declaration.endLine)) {
+    return { counted: true, citation, findings: [], unchecked: [] };
+  }
+  const currentLines = [...new Set(declarations.map((declaration) => declaration.startLine))].sort((left, right) => left - right);
+  return { counted: true, citation, findings: [{ kind: "line-moved", currentLines }], unchecked: [] };
+}
+function resolveCitedPath(parsed, node, tree) {
+  const direct = tree.kind(parsed.path);
+  if (direct && !(parsed.directory && direct === "file"))
+    return { status: "resolved", path: parsed.path, kind: direct };
+  const missing = () => tree.isIgnored(parsed.path) ? { status: "ignored" } : { status: "missing" };
+  const anchored = parsed.path.includes("/") && tree.hasTopLevelEntry(parsed.path.split("/")[0]);
+  if (anchored)
+    return missing();
+  if (!parsed.explicit)
+    return { status: "ignored" };
+  let matches = tree.filesEndingWith(parsed.path);
+  if (matches.length > 1 && node.footprint) {
+    const footprint = new Set(node.footprint);
+    const inFootprint = matches.filter((path) => footprint.has(path));
+    if (inFootprint.length === 1)
+      matches = inFootprint;
+  }
+  if (matches.length === 0)
+    return missing();
+  if (matches.length > 1)
+    return { status: "ambiguous" };
+  return { status: "resolved", path: matches[0], kind: "file" };
+}
+function splitSymbol(symbol) {
+  const segments = symbol.split(".");
+  return segments.length > 1 ? { name: segments[segments.length - 1], container: segments[segments.length - 2] } : { name: symbol };
+}
+function matchingDeclarations(declarations, container) {
+  if (container === undefined)
+    return declarations;
+  return declarations.filter((declaration) => declaration.qualifiedName.split(/::|\.|#|\//).includes(container));
+}
 
 // packages/core/projection-engine/src/index.ts
 function nativeNodeSource(node) {
@@ -17164,15 +17679,10 @@ function renderArchitectureDocumentationProjection(input) {
   const generatedAt = input.generatedAt ?? "1970-01-01T00:00:00.000Z";
   const scaleSignalsByNodeId = new Map((input.sourceScaleSignals ?? []).map((signal) => [signal.nodeId, signal]));
   const scaleByNodeId = new Map([...scaleSignalsByNodeId].map(([nodeId, signal]) => [nodeId, architectureCapabilityScale(signal)]));
+  const semanticNodes = semanticArchitectureNodes(model);
   const semanticCompilationsByNodeId = new Map(model.nodes.map((node) => [node.id, compileSemanticCapabilityDiagrams({
     capabilityId: node.id,
-    nodes: model.nodes.map((entry) => ({
-      id: entry.id,
-      kind: entry.kind,
-      name: entry.name,
-      ...entry.parent ? { parent: entry.parent } : {},
-      ...nativeNodeSource(entry) ? { source: nativeNodeSource(entry) } : {}
-    })),
+    nodes: semanticNodes,
     relations: model.relations,
     flows: model.flows ?? [],
     evidence: input.selectorEvidence
@@ -17187,7 +17697,8 @@ function renderArchitectureDocumentationProjection(input) {
     resulting: semanticState,
     acceptedChange: input.refreshContext?.acceptedChange
   });
-  const targetDrafts = architectureDocumentationTargetDrafts(model, layout2);
+  const docsLanguage = input.docsLanguage === undefined ? undefined : assertArchitectureDocsLanguage(input.docsLanguage);
+  const targetDrafts = architectureDocumentationTargetDrafts(model, layout2, docsLanguage);
   const stampedNodeIds = new Set(architectureProjectionStampedNodeIds(model, layout2.profile));
   const footprintDigestByNodeId = new Map(input.sourceFootprints.map((entry) => [entry.nodeId, entry.digest]));
   const rendered = targetDrafts.map((draft) => {
@@ -17426,7 +17937,8 @@ function loadArchitectureDocumentationInputs(root, profile = "default") {
   return {
     model,
     decisions: loadArchitectureDecisionRecords(root),
-    existingFiles: loadArchitectureFilesForLayout(root, layout2)
+    existingFiles: loadArchitectureFilesForLayout(root, layout2),
+    docsLanguage: loadArchitectureDocumentationLanguage(root)
   };
 }
 function loadCapabilitySourceScaleSignals(root, model, sourceFiles) {
@@ -17514,6 +18026,28 @@ function loadArchitectureDocumentationProfile(root) {
   }
   return manifest.profile;
 }
+var ARCHITECTURE_DOCS_LANGUAGES = ["zh-Hant", "zh-Hans", "en"];
+var ARCHCONTEXT_MANIFEST_PATH = ".archcontext/manifest.yaml";
+function loadArchitectureDocumentationLanguage(root) {
+  const path = resolve7(root, ARCHCONTEXT_MANIFEST_PATH);
+  if (!existsSync5(path))
+    return;
+  let manifest;
+  try {
+    manifest = parseJsonOrStableYaml(readFileSync6(path, "utf8"), ARCHCONTEXT_MANIFEST_PATH);
+  } catch {
+    return;
+  }
+  const docs = manifest && typeof manifest === "object" && !Array.isArray(manifest) ? manifest.docs : undefined;
+  const language = docs && typeof docs === "object" && !Array.isArray(docs) ? docs.language : undefined;
+  return language === undefined ? undefined : assertArchitectureDocsLanguage(language);
+}
+function assertArchitectureDocsLanguage(value) {
+  if (!ARCHITECTURE_DOCS_LANGUAGES.includes(value)) {
+    throw new Error(`architecture-docs-language-invalid: docs.language must be one of ${ARCHITECTURE_DOCS_LANGUAGES.join(", ")} (got ${JSON.stringify(value)})`);
+  }
+  return value;
+}
 function loadArchitectureDecisionRecords(root) {
   const dir = resolve7(root, "docs/adr");
   if (!existsSync5(dir))
@@ -17663,6 +18197,28 @@ function loadArchitectureProjectionManifestStamps(root) {
     ...isV3Provenance ? { provenance } : {}
   };
 }
+function semanticArchitectureNodes(model) {
+  return model.nodes.map((entry) => ({
+    id: entry.id,
+    kind: entry.kind,
+    name: entry.name,
+    ...entry.parent ? { parent: entry.parent } : {},
+    ...nativeNodeSource(entry) ? { source: nativeNodeSource(entry) } : {}
+  }));
+}
+function checkArchitectureFlowSelectors(input) {
+  const model = normalizeNativeModel(input.model);
+  return {
+    schemaVersion: ARCHITECTURE_FLOW_SELECTOR_CHECK_SCHEMA_VERSION,
+    codeGraph: input.codeGraph,
+    ...checkSemanticFlowSelectors({
+      nodes: semanticArchitectureNodes(model),
+      relations: model.relations,
+      flows: model.flows ?? [],
+      evidence: input.selectorEvidence
+    })
+  };
+}
 function normalizeNativeModel(model) {
   return {
     nodes: [...model.nodes].sort((a, b) => a.id.localeCompare(b.id)),
@@ -17903,8 +18459,8 @@ function readYamlObjects(dir) {
 function escapeMermaid(value) {
   return value.replace(/"/g, "'");
 }
-function architectureDocumentationTargetDrafts(model, layout2) {
-  return layout2.targets.map((target) => target.type === "entity-summary" ? { ...target, skeleton: entitySummarySkeleton(model.nodes.find((node) => node.id === target.scope.id)) } : target);
+function architectureDocumentationTargetDrafts(model, layout2, docsLanguage) {
+  return layout2.targets.map((target) => target.type === "entity-summary" ? { ...target, skeleton: entitySummarySkeleton(model.nodes.find((node) => node.id === target.scope.id), docsLanguage) } : target);
 }
 function projectionTarget(input) {
   return {
@@ -17932,6 +18488,7 @@ function renderTargetGeneratedBody(target, model, input) {
     return renderEntitySummary(node, model, {
       scaleSignal: input.scaleSignalsByNodeId.get(node.id),
       scale: input.scaleByNodeId.get(node.id),
+      scaleByNodeId: input.scaleByNodeId,
       semanticCompilation: input.semanticCompilationsByNodeId.get(node.id)
     });
   }
@@ -17992,6 +18549,7 @@ function renderEntitySummary(node, model, input) {
   const incoming = model.relations.filter((relation) => relation.target === node.id);
   const outgoing = model.relations.filter((relation) => relation.source === node.id);
   const localContracts = contractFilesForNode(node);
+  const components = model.nodes.filter((entry) => entry.parent === node.id && entry.kind === "component");
   const lines = [
     `> **狀態**:${node.status ? `\`${node.status}\`` : "未宣告(`status` 缺失)"}`,
     `> **Capability ID**:\`${node.id}\`(kind \`${node.kind}\`)`,
@@ -18013,6 +18571,7 @@ function renderEntitySummary(node, model, input) {
       "| --- | --- | --- |",
       ...entrypoints.flatMap((entry) => entry.symbols.map((symbol) => `| \`${entry.id}\` | \`${entry.path}#${symbol.name}\` | ${symbol.sinks.map((sink) => `\`${sink.id}\` → \`${sink.path}#${sink.symbol}\``).join("、")} |`))
     ] : ["- 未宣告 `source.entrypoints`,入口清單無法從架構模型推導。"],
+    ...renderComponentEntrypoints(components),
     "",
     "### 1.3 規模信號",
     "",
@@ -18032,6 +18591,8 @@ function renderEntitySummary(node, model, input) {
     "入向關係:",
     "",
     ...incoming.length === 0 ? ["- 無。"] : incoming.map((relation) => `- \`${relation.kind}\` ← \`${relation.source}\` — ${relation.intent}`),
+    ...renderComponentOutboundRelations(components, model.relations),
+    ...renderComponentTable(components, input.scaleByNodeId),
     "",
     "## 2. P2:端到端數據流",
     "",
@@ -18041,6 +18602,56 @@ function renderEntitySummary(node, model, input) {
 `)}
 `;
 }
+function renderComponentEntrypoints(components) {
+  if (components.length === 0)
+    return [];
+  const rows = components.flatMap((component) => (nativeNodeSource(component)?.entrypoints ?? []).flatMap((entry) => entry.symbols.map((symbol) => `| \`${component.id}\` | \`${entry.id}\` | \`${entry.path}#${symbol.name}\` | ${symbol.sinks.map((sink) => `\`${sink.id}\` → \`${sink.path}#${sink.symbol}\``).join("、")} |`)));
+  return [
+    "",
+    "組件入口:",
+    "",
+    ...rows.length > 0 ? ["| 組件 | 宣告入口 | 錨點 | 職責 |", "| --- | --- | --- | --- |", ...rows] : ["- 組件均未宣告 `source.entrypoints`。"]
+  ];
+}
+function renderComponentOutboundRelations(components, relations) {
+  if (components.length === 0)
+    return [];
+  return [
+    "",
+    "組件出向關係:",
+    "",
+    ...components.flatMap((component) => {
+      const outgoing = relations.filter((relation) => relation.source === component.id);
+      return [
+        `- \`${component.id}\`:`,
+        ...outgoing.length === 0 ? ["  - 無。"] : outgoing.map((relation) => `  - \`${relation.kind}\` → \`${relation.target}\` — ${relation.intent}`)
+      ];
+    })
+  ];
+}
+function renderComponentTable(components, scaleByNodeId) {
+  if (components.length === 0)
+    return [];
+  return [
+    "",
+    "### 1.5 組件結構",
+    "",
+    "| 組件 | 名稱 | 規模量級 | 宣告入口 |",
+    "| --- | --- | --- | --- |",
+    ...components.map((component) => {
+      const source = nativeNodeSource(component);
+      let scaleCell = "未宣告 `source.include`";
+      if ((source?.include ?? []).length > 0) {
+        const scale = scaleByNodeId.get(component.id);
+        if (!scale)
+          throw new Error(`architecture-docs-projection-scale-signal-missing: ${component.id}`);
+        scaleCell = `\`${scaleMagnitudeBucketLabel(scale.fileCountBucket)}\` 個文件 / \`${scaleMagnitudeBucketLabel(scale.lineCountBucket)}\` 行`;
+      }
+      const entrypointIds = (source?.entrypoints ?? []).map((entry) => `\`${entry.id}\``);
+      return `| \`${component.id}\` | ${component.name.replaceAll("|", "\\|")} | ${scaleCell} | ${entrypointIds.length > 0 ? entrypointIds.join("、") : "未宣告"} |`;
+    })
+  ];
+}
 function renderSemanticP1Section(compilation) {
   if (compilation.p1.status === "proven") {
     return [
@@ -18081,16 +18692,23 @@ function entitySummaryTitle(node) {
   const segments = node.id.replace(/^capability\./, "").split(".").filter((segment) => segment !== "");
   return segments.length > 0 ? segments.join("/") : node.id;
 }
-function entitySummarySkeleton(node) {
+var ENTITY_SUMMARY_SKELETON_TEXT = {
+  legacy: { titleSuffix: " 架構文檔", p3: "## 3. P3:設計決策與不變量", history: "## 4. 歷史決策記錄(append-only)" },
+  "zh-Hant": { titleSuffix: " 架構文檔", p3: "## 3. P3：設計決策與不變量", history: "## 4. 歷史決策記錄（append-only）" },
+  "zh-Hans": { titleSuffix: " 架构文档", p3: "## 3. P3：设计决策与不变量", history: "## 4. 历史决策记录（append-only）" },
+  en: { titleSuffix: " Architecture", p3: "## 3. P3: Design Decisions and Invariants", history: "## 4. Decision History (append-only)" }
+};
+function entitySummarySkeleton(node, docsLanguage) {
+  const text = ENTITY_SUMMARY_SKELETON_TEXT[docsLanguage ?? "legacy"];
   return {
-    prefix: `# ${entitySummaryTitle(node)} 架構文檔
+    prefix: `# ${entitySummaryTitle(node)}${text.titleSuffix}
 
 `,
     suffix: [
       "",
-      "## 3. P3:設計決策與不變量",
+      text.p3,
       "",
-      "## 4. 歷史決策記錄(append-only)",
+      text.history,
       "",
       "## Optimization Backlog",
       ""
@@ -18098,6 +18716,9 @@ function entitySummarySkeleton(node) {
 `)
   };
 }
+function entitySummarySkeletonVariants(node) {
+  return [undefined, ...ARCHITECTURE_DOCS_LANGUAGES].map((language) => entitySummarySkeleton(node, language));
+}
 function renderRelationSummary(relation, model) {
   const source = model.nodes.find((node) => node.id === relation.source);
   const target = model.nodes.find((node) => node.id === relation.target);
@@ -18263,7 +18884,7 @@ function architectureDocumentationProjectionDrift(input) {
         path: existing.path,
         targetId: region.targetId,
         actualDigest,
-        disposition: orphanHoldsOnlyIntactGeneratedRegion(existing.body, region.targetId, orphanSkeleton(committedEntityTargets, existing.path, region.targetId)) ? "delete" : "human-review"
+        disposition: orphanHoldsOnlyIntactGeneratedRegion(existing.body, region.targetId, orphanSkeletons(committedEntityTargets, existing.path, region.targetId)) ? "delete" : "human-review"
       });
     }
   }
@@ -18299,17 +18920,17 @@ function committedEntitySummaryTargets(manifestBody) {
   }
   return targets;
 }
-function orphanSkeleton(committedEntityTargets, path, targetId) {
+function orphanSkeletons(committedEntityTargets, path, targetId) {
   const committed = committedEntityTargets.get(targetId);
-  return committed && committed.path === path ? entitySummarySkeleton({ id: committed.nodeId }) : undefined;
+  return committed && committed.path === path ? entitySummarySkeletonVariants({ id: committed.nodeId }) : [];
 }
-function orphanHoldsOnlyIntactGeneratedRegion(body, targetId, skeleton) {
+function orphanHoldsOnlyIntactGeneratedRegion(body, targetId, skeletons) {
   const region = findGeneratedRegion(body, targetId);
   if (!region)
     return false;
   const before = body.slice(0, region.start);
   const after = body.slice(region.end);
-  const generatedOnly = `${before}${after}`.trim() === "" || skeleton !== undefined && before === skeleton.prefix && after === skeleton.suffix;
+  const generatedOnly = `${before}${after}`.trim() === "" || skeletons.some((skeleton) => before === skeleton.prefix && after === skeleton.suffix);
   if (!generatedOnly)
     return false;
   const metadata = parseGeneratedRegionMetadata(region.startMarker);
@@ -18545,26 +19166,78 @@ function findAgentContextRegion(body, nodeId) {
   };
 }
 function resolveArchitectureOwnerForPath(nodes, path) {
-  const candidates = [];
-  for (const node of nodes) {
+  return resolveArchitectureOwnersForPaths(nodes, [path])[0];
+}
+function resolveArchitectureOwnersForPaths(nodes, paths) {
+  const declaring = nodes.flatMap((node) => {
     const source = nativeNodeSource(node);
     const include = source?.include ?? [];
     if (include.length === 0)
-      continue;
-    const excluded = (source?.exclude ?? []).some((pattern) => matchesGlob(path, pattern));
-    if (excluded)
-      continue;
-    const specificity = include.filter((pattern) => matchesGlob(path, pattern)).reduce((max, pattern) => Math.max(max, globLiteralPrefixLength(pattern)), -1);
-    if (specificity >= 0)
-      candidates.push({ node, specificity });
+      return [];
+    return [{
+      node,
+      include: include.map((pattern) => ({ regex: globToRegExp(pattern), specificity: globLiteralPrefixLength(pattern) })),
+      exclude: (source?.exclude ?? []).map(globToRegExp)
+    }];
+  });
+  const parents = new Map(nodes.map((node) => [node.id, node.parent]));
+  const kinds = new Map(nodes.map((node) => [node.id, node.kind]));
+  const owningCapabilityOf = (id) => {
+    for (const ancestor of ancestorChain(id, parents))
+      if (kinds.get(ancestor) === "capability")
+        return ancestor;
+    return null;
+  };
+  return paths.map((path) => {
+    const candidates = [];
+    for (const entry of declaring) {
+      if (entry.exclude.some((regex) => regex.test(path)))
+        continue;
+      const specificity = entry.include.filter((pattern) => pattern.regex.test(path)).reduce((max, pattern) => Math.max(max, pattern.specificity), -1);
+      if (specificity >= 0)
+        candidates.push({ node: entry.node, specificity });
+    }
+    if (candidates.length === 0)
+      return { status: "no-match", owningCapabilityId: null };
+    const chainOwner = deepestOnOneParentChain(candidates.map((candidate) => candidate.node.id), parents);
+    if (chainOwner !== undefined) {
+      const node = candidates.find((candidate) => candidate.node.id === chainOwner).node;
+      return { status: "matched", node, owningCapabilityId: owningCapabilityOf(node.id) };
+    }
+    const chains = new Map(candidates.map((candidate) => [candidate.node.id, ancestorChain(candidate.node.id, parents)]));
+    const isStrictAncestorOf = (ancestor, descendant) => ancestor !== descendant && chains.get(descendant).has(ancestor) && !chains.get(ancestor).has(descendant);
+    const leaves = candidates.filter((candidate) => !candidates.some((other) => isStrictAncestorOf(candidate.node.id, other.node.id)));
+    const contenders = leaves.length > 0 ? leaves : candidates;
+    const maxSpecificity = contenders.reduce((max, candidate) => Math.max(max, candidate.specificity), -1);
+    const winners = contenders.filter((candidate) => candidate.specificity === maxSpecificity).map((candidate) => candidate.node);
+    if (winners.length === 1)
+      return { status: "matched", node: winners[0], owningCapabilityId: owningCapabilityOf(winners[0].id) };
+    const capabilities = new Set(winners.map((node) => owningCapabilityOf(node.id)));
+    return { status: "ambiguous", candidates: winners, owningCapabilityId: capabilities.size === 1 ? [...capabilities][0] : null };
+  });
+}
+function deepestOnOneParentChain(candidateIds, parents) {
+  if (candidateIds.length === 0)
+    return;
+  const depthOf = (id) => ancestorChain(id, parents).size - 1;
+  const deepest = candidateIds.reduce((best, id) => {
+    const bestDepth = depthOf(best);
+    const depth = depthOf(id);
+    if (depth !== bestDepth)
+      return depth > bestDepth ? id : best;
+    return id < best ? id : best;
+  });
+  const chain = ancestorChain(deepest, parents);
+  return candidateIds.every((id) => chain.has(id)) ? deepest : undefined;
+}
+function ancestorChain(id, parents) {
+  const chain = new Set;
+  let current = id;
+  while (current !== undefined && parents.has(current) && !chain.has(current)) {
+    chain.add(current);
+    current = parents.get(current);
   }
-  if (candidates.length === 0)
-    return { status: "no-match" };
-  const maxSpecificity = candidates.reduce((max, candidate) => Math.max(max, candidate.specificity), -1);
-  const winners = candidates.filter((candidate) => candidate.specificity === maxSpecificity).map((candidate) => candidate.node);
-  if (winners.length > 1)
-    return { status: "ambiguous", candidates: winners };
-  return { status: "matched", node: winners[0] };
+  return chain;
 }
 function matchesGlob(path, pattern) {
   return globToRegExp(pattern).test(path);
@@ -18752,12 +19425,23 @@ function readTrackedSourceFiles(root, options = {}) {
 }
 function readWorkspacePackages(root) {
   const manifest = JSON.parse(readFileSync7(join4(root, "package.json"), "utf8"));
-  return (manifest.workspaces ?? []).map((directory) => {
+  return (manifest.workspaces ?? []).flatMap((entry) => expandWorkspaceEntry(root, entry)).map((directory) => {
     const path = join4(root, ...directory.split("/"), "package.json");
     const packageManifest = JSON.parse(readFileSync7(path, "utf8"));
     return { name: packageManifest.name, root: directory, exports: packageManifest.exports ?? {} };
   }).sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
 }
+function expandWorkspaceEntry(root, entry) {
+  if (!entry.includes("*"))
+    return [entry];
+  const base = entry.slice(0, -2);
+  if (!entry.endsWith("/*") || base.includes("*"))
+    throw new Error(`workspace-glob-unsupported: ${entry}`);
+  const directory = join4(root, ...base.split("/"));
+  if (!existsSync6(directory))
+    return [];
+  return readdirSync4(directory, { withFileTypes: true }).filter((child) => child.isDirectory() && existsSync6(join4(directory, child.name, "package.json"))).map((child) => `${base}/${child.name}`).sort();
+}
 function isDetachedHead(root) {
   return runGit(root, ["rev-parse", "--abbrev-ref", "HEAD"]).trim() === "HEAD";
 }
@@ -18991,7 +19675,8 @@ var CODEGRAPH_TELEMETRY_ENV = "DO_NOT_TRACK";
 var CODEGRAPH_TELEMETRY_DISABLED_VALUE = "1";
 var DEFAULT_CODEGRAPH_BINARY = "codegraph";
 var requireFromAdapter = createRequire2(import.meta.url);
-var { CodeGraph } = requireFromAdapter(REQUIRED_CODEGRAPH_PACKAGE);
+var codeGraphSdk = requireFromAdapter(REQUIRED_CODEGRAPH_PACKAGE);
+var { CodeGraph } = codeGraphSdk;
 var CODEGRAPH_OUTPUT_MAX_BYTES = 32 * 1024 * 1024;
 var CODEGRAPH_QUERY_TIMEOUT_MS = 30000;
 function disableCodeGraphTelemetryByDefault(env = process.env) {
@@ -19502,7 +20187,8 @@ function architectureDeltaTask(git) {
     ...git.paths.flatMap((change) => [change.path, change.previousPath ?? ""])
   ].filter(Boolean)).join(" ");
 }
-var CODEGRAPH_IMPORT_NODE_QUERY_LIMIT = 5000;
+var CODEGRAPH_IMPORT_NODE_READ_LIMIT = 50000;
+var CODEGRAPH_IMPORT_NODE_OUTPUT_BYTES = 4 * 1024;
 function prepareArchitectureDocumentationProjectionSnapshot(root, model, options = {}) {
   const baseHeadSha = readProjectionHeadSha(root);
   const sourceFiles = listProjectionSourceFiles(root);
@@ -19567,7 +20253,7 @@ function assertProjectionCodeFactsAvailable(root, prepared) {
 function prepareProjectionCodeFacts(root, model, options) {
   const invocation = options.binary ? codeGraphCliInvocation(options.binary, root, "") : packagedCodeGraphCliInvocation();
   const binaryPath = invocation.argsPrefix[0] ?? invocation.command;
-  const actualVersion = runProjectionCodeGraph(invocation, root, ["--version"], options.timeouts?.versionMs ?? 5000).trim();
+  const actualVersion = runProjectionCodeGraph(invocation, root, ["--version"], options.timeouts?.versionMs ?? 1e4).trim();
   if (actualVersion !== REQUIRED_CODEGRAPH_VERSION) {
     throw new Error(`CodeGraph ${REQUIRED_CODEGRAPH_VERSION} required, got actual binary ${actualVersion || "unknown"}`);
   }
@@ -19608,7 +20294,9 @@ function prepareProjectionCodeFacts(root, model, options) {
   const inputs = loadCapabilityCodeGraphProjectionInputs(root, model, {
     ...options.sourceFiles ? { sourceFiles: options.sourceFiles } : {},
     binary: binaryPath,
-    importNodeLimit: options.importNodeLimit
+    importNodeLimit: options.importNodeLimit,
+    importNodeCount: statusImportNodeCount(postStatus),
+    ...options.importGraphs === false ? { importGraphs: false } : {}
   });
   const finalStatus = readProjectionCodeGraphStatus(invocation, root, statusTimeout);
   assertProjectionCodeGraphStatus(finalStatus, root, "post-query");
@@ -19743,8 +20431,36 @@ function digestFile(path) {
 function codeGraphIndexAvailable(workspaceRoot) {
   return existsSync7(join5(workspaceRoot, ".codegraph"));
 }
+var NON_DECLARATION_KINDS = new Set(["file", "import", "export", "parameter"]);
+function openCodeGraphSymbolReader(workspaceRoot, openIndex = (root, options) => CodeGraph.openSync(root, options)) {
+  if (!codeGraphIndexAvailable(workspaceRoot))
+    return { availability: "unavailable", reasonCode: "index-missing" };
+  disableCodeGraphTelemetryByDefault();
+  let graph;
+  try {
+    graph = openIndex(workspaceRoot, { readOnly: true });
+  } catch {
+    return { availability: "unavailable", reasonCode: "index-open-failed" };
+  }
+  const declarations = (nodes) => nodes.filter((node) => !NON_DECLARATION_KINDS.has(node.kind)).map((node) => ({ name: node.name, qualifiedName: node.qualifiedName, startLine: node.startLine, endLine: node.endLine })).sort((left, right) => left.startLine - right.startLine || left.qualifiedName.localeCompare(right.qualifiedName));
+  return {
+    availability: "ready",
+    reader: {
+      supportsPath: (path) => codeGraphSdk.isLanguageSupported(codeGraphSdk.detectLanguage(path)),
+      declarationsInSource: (path, content) => {
+        try {
+          return declarations(graph.extractFromSource(path, content).nodes);
+        } catch {
+          return;
+        }
+      },
+      declarationsNamed: (name) => declarations(graph.getNodesByName(name).filter((node) => node.name === name)),
+      close: () => graph.close()
+    }
+  };
+}
 function loadCapabilityCodeGraphProjectionInputs(root, model, options = {}) {
-  const declaresFootprint = model.nodes.some((node) => (nativeNodeSource(node)?.include ?? []).length > 0);
+  const declaresFootprint = options.importGraphs !== false && model.nodes.some((node) => (nativeNodeSource(node)?.include ?? []).length > 0);
   const footprints = declaresFootprint ? loadCapabilitySourceFootprints(root, model, options.sourceFiles ?? listProjectionSourceFiles(root)) : [];
   const entrypointNodes = model.nodes.map((node) => ({ nodeId: node.id, entrypoints: nativeNodeSource(node)?.entrypoints ?? [] })).filter((entry) => entry.entrypoints.length > 0).sort((left, right) => left.nodeId.localeCompare(right.nodeId));
   if (footprints.length === 0 && entrypointNodes.length === 0)
@@ -19753,11 +20469,11 @@ function loadCapabilityCodeGraphProjectionInputs(root, model, options = {}) {
     return { importGraphs: [], selectorEvidence: [] };
   disableCodeGraphTelemetryByDefault();
   const binary = options.binary ?? DEFAULT_CODEGRAPH_BINARY;
-  const importGraphs = footprints.length > 0 ? capabilityImportGraphs(root, binary, footprints, options.importNodeLimit ?? CODEGRAPH_IMPORT_NODE_QUERY_LIMIT) : [];
+  const importGraphs = footprints.length > 0 ? capabilityImportGraphs(root, binary, footprints, options.importNodeLimit ?? CODEGRAPH_IMPORT_NODE_READ_LIMIT, options.importNodeCount ?? null) : [];
   const selectorIndex = entrypointNodes.length > 0 ? options.selectorIndexFactory?.(root) ?? CodeGraph.openSync(root) : undefined;
   let selectorEvidence;
   try {
-    selectorEvidence = entrypointNodes.flatMap((entry) => entry.entrypoints.flatMap((entrypoint) => entrypoint.symbols.flatMap((source) => source.sinks.map((sink) => exactSelectorEvidence(selectorIndex, {
+    selectorEvidence = entrypointNodes.flatMap((entry) => entry.entrypoints.flatMap((entrypoint) => entrypoint.symbols.flatMap((source) => source.sinks.map((sink) => exactSelectorEvidence(root, selectorIndex, {
       nodeId: entry.nodeId,
       entrypointId: entrypoint.id,
       sourcePath: entrypoint.path,
@@ -19772,10 +20488,21 @@ function loadCapabilityCodeGraphProjectionInputs(root, model, options = {}) {
   return { importGraphs, selectorEvidence };
 }
 function repositoryImportPairs(root, binary, limit, worktreeDigest) {
+  if (!Number.isInteger(limit) || limit < 1)
+    throw new Error(`import node limit must be a positive integer, got ${limit}`);
   if (!codeGraphIndexAvailable(root)) {
-    return { pairs: [], truncated: true, availability: "unavailable", indexedWorktreeDigest: null };
+    return {
+      pairs: [],
+      truncated: true,
+      availability: "unavailable",
+      indexedWorktreeDigest: null,
+      importNodeCount: null,
+      importNodeLimit: limit,
+      importNodeLimitExceeded: false
+    };
   }
-  const nodes = codeGraphImportNodes(root, binary, limit);
+  const status = readProjectionCodeGraphStatus(codeGraphCliInvocation(binary, root, ""), root, CODEGRAPH_QUERY_TIMEOUT_MS);
+  const nodes = codeGraphImportPopulation(root, binary, limit, statusImportNodeCount(status));
   const pairs = new Map;
   for (const node of nodes.imports) {
     if (node.kind !== "import")
@@ -19787,18 +20514,43 @@ function repositoryImportPairs(root, binary, limit, worktreeDigest) {
     const firstLine = line === undefined ? previousLine : previousLine === undefined ? line : Math.min(line, previousLine);
     pairs.set(key, { from: node.filePath, specifier: node.name, to, ...firstLine === undefined ? {} : { line: firstLine } });
   }
-  const status = readProjectionCodeGraphStatus(codeGraphCliInvocation(binary, root, ""), root, CODEGRAPH_QUERY_TIMEOUT_MS);
   const pending = status.pendingChanges;
   const clean = status.initialized && pending !== undefined && pending.added === 0 && pending.modified === 0 && pending.removed === 0;
   return {
     pairs: [...pairs.keys()].sort().map((key) => pairs.get(key)),
     truncated: nodes.truncated,
     availability: clean ? "ready" : "unavailable",
-    indexedWorktreeDigest: clean ? worktreeDigest : null
+    indexedWorktreeDigest: clean ? worktreeDigest : null,
+    importNodeCount: nodes.count,
+    importNodeLimit: limit,
+    importNodeLimitExceeded: nodes.limitExceeded
   };
 }
-function capabilityImportGraphs(root, binary, footprints, limit) {
-  const nodes = codeGraphImportNodes(root, binary, limit);
+function statusImportNodeCount(status) {
+  if (!status.nodesByKind || typeof status.nodesByKind !== "object")
+    return null;
+  const count = status.nodesByKind.import;
+  return Number.isInteger(count) && count >= 0 ? count : null;
+}
+function codeGraphImportPopulation(root, binary, limit, reportedCount) {
+  const queryLimit = Math.min(reportedCount ?? limit, limit) + 1;
+  const output = runCodeGraphCli(binary, root, ["query", "-p", root, "-j", "-l", String(queryLimit), "-k", "import", "import"], Math.max(CODEGRAPH_OUTPUT_MAX_BYTES, queryLimit * CODEGRAPH_IMPORT_NODE_OUTPUT_BYTES));
+  const imports = JSON.parse(output).map(({ node }) => node);
+  const limitExceeded = (reportedCount ?? imports.length) > limit;
+  if (limitExceeded) {
+    return { imports: imports.slice(0, limit), count: reportedCount, truncated: imports.length < limit, limitExceeded };
+  }
+  return {
+    imports,
+    count: reportedCount ?? imports.length,
+    truncated: reportedCount !== null && imports.length !== reportedCount,
+    limitExceeded
+  };
+}
+function capabilityImportGraphs(root, binary, footprints, limit, reportedCount) {
+  if (!Number.isInteger(limit) || limit < 1)
+    throw new Error(`import node limit must be a positive integer, got ${limit}`);
+  const nodes = codeGraphImportPopulation(root, binary, limit, reportedCount);
   const pairs = resolvedImportPairs(root, nodes.imports);
   return footprints.map((footprint) => {
     const scope = new Set(footprint.files);
@@ -19812,39 +20564,147 @@ function capabilityImportGraphs(root, binary, footprints, limit) {
       nodeId: footprint.nodeId,
       files: footprint.files,
       edges: [...edges.values()].sort((left, right) => left.from.localeCompare(right.from) || left.to.localeCompare(right.to)),
-      truncated: nodes.truncated
+      truncated: nodes.truncated,
+      ...nodes.limitExceeded ? { importNodeLimitExceeded: true } : {}
     };
   });
 }
-function codeGraphImportNodes(root, binary, limit) {
-  const output = runCodeGraphCli(binary, root, ["query", "-p", root, "-j", "-l", String(limit), "-k", "import", "import"]);
-  const parsed = JSON.parse(output);
-  return { imports: parsed.map(({ node }) => node), truncated: parsed.length >= limit };
-}
-function exactSelectorEvidence(index, selector) {
-  const sources = index.getNodesByName(selector.sourceSymbol).filter((node) => normalizedIndexPath(node.filePath) === normalizedIndexPath(selector.sourcePath));
-  const exactCalls = sources.flatMap((source) => index.getOutgoingEdges(source.id).filter((edge) => edge.kind === "calls").flatMap((edge) => {
+var RUNTIME_BUILTIN_CALL_NAMES = new Set([
+  "basename",
+  "dirname",
+  "extname",
+  "format",
+  "isAbsolute",
+  "join",
+  "normalize",
+  "parse",
+  "relative",
+  "resolve",
+  "toNamespacedPath",
+  "access",
+  "accessSync",
+  "appendFile",
+  "appendFileSync",
+  "chmod",
+  "chmodSync",
+  "close",
+  "closeSync",
+  "copyFile",
+  "copyFileSync",
+  "cp",
+  "cpSync",
+  "createReadStream",
+  "createWriteStream",
+  "exists",
+  "existsSync",
+  "fsync",
+  "fsyncSync",
+  "lstat",
+  "lstatSync",
+  "mkdir",
+  "mkdirSync",
+  "mkdtemp",
+  "mkdtempSync",
+  "open",
+  "openSync",
+  "opendir",
+  "opendirSync",
+  "read",
+  "readFile",
+  "readFileSync",
+  "readSync",
+  "readdir",
+  "readdirSync",
+  "readlink",
+  "readlinkSync",
+  "realpath",
+  "realpathSync",
+  "rename",
+  "renameSync",
+  "rm",
+  "rmSync",
+  "rmdir",
+  "rmdirSync",
+  "stat",
+  "statSync",
+  "symlink",
+  "symlinkSync",
+  "unlink",
+  "unlinkSync",
+  "watch",
+  "write",
+  "writeFile",
+  "writeFileSync",
+  "writeSync",
+  "exec",
+  "execFile",
+  "execFileSync",
+  "execSync",
+  "fork",
+  "spawn",
+  "spawnSync",
+  "homedir",
+  "hostname",
+  "platform",
+  "tmpdir",
+  "fileURLToPath",
+  "pathToFileURL",
+  "createHash",
+  "randomBytes",
+  "randomUUID",
+  "clearInterval",
+  "clearTimeout",
+  "fetch",
+  "queueMicrotask",
+  "setInterval",
+  "setTimeout",
+  "structuredClone"
+]);
+function exactSelectorEvidence(root, index, selector) {
+  const sources = indexedSymbolsAt(index, selector.sourceSymbol, selector.sourcePath);
+  const sinkDeclarations = indexedSymbolsAt(index, selector.sinkSymbol, selector.sinkPath);
+  const exactEdges = sources.flatMap((source) => index.getOutgoingEdges(source.id).filter((edge) => edge.kind === "calls" || edge.kind === "references").flatMap((edge) => {
     const target = index.getNode(edge.target);
     return target && target.name === selector.sinkSymbol && normalizedIndexPath(target.filePath) === normalizedIndexPath(selector.sinkPath) ? [{ edge, target }] : [];
   }));
+  const calls = exactEdges.filter(({ edge }) => edge.kind === "calls");
+  const falseBuiltinCalls = calls.length > 0 && isFalseBuiltinCall(root, index, sources[0].filePath, selector);
+  const exactCalls = falseBuiltinCalls ? [] : calls;
+  const references = exactCalls.length === 0 ? exactEdges.filter(({ edge }) => edge.kind === "references") : [];
   const sinkIdentities = new Set(exactCalls.map(({ target }) => target.id));
-  const ambiguous = sources.length > 1 || sinkIdentities.size > 1;
-  const callSites = [...new Map(exactCalls.map(({ edge }) => {
-    const callSite = { path: selector.sourcePath, ...edge.line === undefined ? {} : { line: edge.line } };
-    return [`${callSite.path}\x00${callSite.line ?? ""}`, callSite];
-  })).values()].sort((left, right) => left.path.localeCompare(right.path) || (left.line ?? 0) - (right.line ?? 0));
+  const ambiguous = sources.length > 1 || sinkDeclarations.length > 1 || sinkIdentities.size > 1;
   return {
     ...selector,
     matched: !ambiguous && sinkIdentities.size === 1,
     ambiguous,
     truncated: false,
-    callSites
+    callSites: edgeSites(selector.sourcePath, exactCalls),
+    ...falseBuiltinCalls ? { rejectedBuiltinCallSites: edgeSites(selector.sourcePath, calls) } : {},
+    ...references.length > 0 ? { referenceSites: edgeSites(selector.sourcePath, references) } : {}
   };
 }
+function indexedSymbolsAt(index, name, path) {
+  return index.getNodesByName(name).filter((node) => normalizedIndexPath(node.filePath) === normalizedIndexPath(path));
+}
+function edgeSites(sourcePath, edges) {
+  return [...new Map(edges.map(({ edge }) => {
+    const site = { path: sourcePath, ...edge.line === undefined ? {} : { line: edge.line } };
+    return [`${site.path}\x00${site.line ?? ""}`, site];
+  })).values()].sort((left, right) => left.path.localeCompare(right.path) || (left.line ?? 0) - (right.line ?? 0));
+}
+function isFalseBuiltinCall(root, index, indexedSourcePath, selector) {
+  if (!RUNTIME_BUILTIN_CALL_NAMES.has(selector.sinkSymbol))
+    return false;
+  const sourcePath = normalizedIndexPath(selector.sourcePath);
+  const sinkPath = normalizedIndexPath(selector.sinkPath);
+  if (sourcePath === sinkPath)
+    return false;
+  return !index.getNodesInFile(indexedSourcePath).some((node) => node.kind === "import" && [node.name, node.name.replace(/\.[cm]?js$/, "")].some((specifier) => resolveImportTarget(root, sourcePath, specifier) === sinkPath));
+}
 function normalizedIndexPath(path) {
   return path.replaceAll("\\", "/").replace(/^\.\//, "");
 }
-function runCodeGraphCli(binary, workspaceRoot, args) {
+function runCodeGraphCli(binary, workspaceRoot, args, maxBuffer = CODEGRAPH_OUTPUT_MAX_BYTES) {
   disableCodeGraphTelemetryByDefault();
   const invocation = codeGraphCliInvocation(binary, workspaceRoot);
   try {
@@ -19852,7 +20712,7 @@ function runCodeGraphCli(binary, workspaceRoot, args) {
       cwd: workspaceRoot,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"],
-      maxBuffer: CODEGRAPH_OUTPUT_MAX_BYTES,
+      maxBuffer,
       timeout: CODEGRAPH_QUERY_TIMEOUT_MS
     });
   } catch (error) {
@@ -20464,14 +21324,15 @@ function localEgressStatus(env = process.env, live = {}) {
 }
 
 // packages/surfaces/cli/src/main.ts
-import { spawn as spawn2, spawnSync as spawnSync3 } from "child_process";
-import { accessSync as accessSync2, closeSync as closeSync10, constants as constants2, existsSync as existsSync27, mkdirSync as mkdirSync13, openSync as openSync10, readFileSync as readFileSync27, rmSync as rmSync16, statSync as statSync10 } from "fs";
-import { dirname as dirname15, join as join18, resolve as resolve28 } from "path";
+import { spawn as spawn2, spawnSync as spawnSync4 } from "child_process";
+import { accessSync as accessSync2, closeSync as closeSync10, constants as constants2, existsSync as existsSync28, mkdirSync as mkdirSync13, openSync as openSync10, readFileSync as readFileSync28, rmSync as rmSync15, statSync as statSync10 } from "fs";
+import { dirname as dirname15, join as join18, resolve as resolve29 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // packages/contracts/src/index.ts
 init_control_plane_routes();
 init_architecture();
+init_docs_anchors();
 init_github_governance();
 init_ledger();
 init_ports();
@@ -20597,7 +21458,7 @@ function assertAllowedArchContextPath2(root, relativePath, scope) {
 // packages/core/architecture-domain/src/index.ts
 init_src();
 import { createHash as createHash6 } from "node:crypto";
-import { readdirSync as readdirSync4, readFileSync as readFileSync10, realpathSync as realpathSync6, statSync as statSync4 } from "node:fs";
+import { readdirSync as readdirSync5, readFileSync as readFileSync10, realpathSync as realpathSync6, statSync as statSync4 } from "node:fs";
 import { relative as relative7, resolve as resolve12, sep as sep6 } from "node:path";
 var DEFAULT_IGNORES2 = new Set([
   ".git",
@@ -20658,7 +21519,7 @@ function listRepoFiles2(root, ignore = DEFAULT_IGNORES2) {
   walk(resolve12(root));
   return out.sort();
   function walk(dir) {
-    for (const entry of readdirSync4(dir, { withFileTypes: true })) {
+    for (const entry of readdirSync5(dir, { withFileTypes: true })) {
       const absolute = resolve12(dir, entry.name);
       const rel = relative7(root, absolute).split(sep6).join("/");
       if (!rel || shouldIgnorePath2(entry.name, rel, ignore))
@@ -22792,7 +23653,7 @@ var UNTRUSTED_TOOL_ESCAPE_KEYS = new Set([
 ]);
 
 // packages/cloud/hardening/src/index.ts
-import { readdirSync as readdirSync5, readFileSync as readFileSync11, statSync as statSync5 } from "node:fs";
+import { readdirSync as readdirSync6, readFileSync as readFileSync11, statSync as statSync5 } from "node:fs";
 import { resolve as resolve13 } from "node:path";
 init_src2();
 init_src();
@@ -22888,7 +23749,7 @@ function listFiles(root) {
   walk(".");
   return out;
   function walk(relativeDir) {
-    for (const entry of readdirSync5(resolve13(root, relativeDir), { withFileTypes: true })) {
+    for (const entry of readdirSync6(resolve13(root, relativeDir), { withFileTypes: true })) {
       if ([".git", "node_modules", "coverage"].includes(entry.name))
         continue;
       const child = relativeDir === "." ? entry.name : `${relativeDir}/${entry.name}`;
@@ -22905,6 +23766,11 @@ function listFiles(root) {
 import { execFileSync as execFileSync4 } from "node:child_process";
 import { closeSync as closeSync5, constants, existsSync as existsSync10, fstatSync as fstatSync2, openSync as openSync5, readFileSync as readFileSync12, rmSync as rmSync6, writeFileSync as writeFileSync5 } from "node:fs";
 import { join as join6 } from "node:path";
+import { setTimeout as sleep } from "node:timers/promises";
+var WINDOWS_CREATE_TIMEOUT_MS = 60000;
+var WINDOWS_READ_TIMEOUT_MS = 1e4;
+var REMOVE_HANDLE_RELEASE_MARGIN_MS = 2000;
+var REMOVE_RETRY_DELAY_MS = 25;
 var WINDOWS_CONTROL_FILE_SCRIPT = String.raw`
 $ErrorActionPreference = 'Stop'
 # A pwsh -> Node/Bun -> powershell.exe launch inherits incompatible PS7 module paths.
@@ -22982,7 +23848,7 @@ function windowsControlFile(operation, path, body) {
       encoding: "utf8",
       windowsHide: true,
       stdio: ["pipe", "pipe", "pipe"],
-      timeout: operation === "create" ? 30000 : 1e4,
+      timeout: operation === "create" ? WINDOWS_CREATE_TIMEOUT_MS : WINDOWS_READ_TIMEOUT_MS,
       maxBuffer: 1024 * 1024
     });
   } catch (error) {
@@ -23041,6 +23907,21 @@ function readPrivateControlFile(path) {
     return;
   }
 }
+async function removePrivateControlFile(path) {
+  const deadline = Date.now() + WINDOWS_READ_TIMEOUT_MS + REMOVE_HANDLE_RELEASE_MARGIN_MS;
+  for (;; ) {
+    try {
+      rmSync6(path, { force: true });
+      return;
+    } catch (error) {
+      const code = error.code;
+      const sharingFailure = process.platform === "win32" && (code === "EBUSY" || code === "EPERM" || code === "EACCES");
+      if (!sharingFailure || Date.now() >= deadline)
+        throw error;
+    }
+    await sleep(REMOVE_RETRY_DELAY_MS);
+  }
+}
 
 // packages/local-runtime/process-liveness/src/index.ts
 function isProcessAlive(pid) {
@@ -25871,7 +26752,7 @@ function isIgnorableDirectoryFsyncError2(error) {
 
 // packages/local-runtime/git-adapter/src/index.ts
 import { execFileSync as execFileSync5, spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync12, lstatSync as lstatSync6, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync2, readFileSync as readFileSync14, rmSync as rmSync8 } from "node:fs";
+import { existsSync as existsSync12, lstatSync as lstatSync6, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync2, readdirSync as readdirSync7, readFileSync as readFileSync14, rmSync as rmSync8 } from "node:fs";
 import { dirname as dirname8, join as join8, resolve as resolve15 } from "node:path";
 init_src();
 var GIT_CAT_FILE_MAX_BYTES2 = 512 * 1024 * 1024;
@@ -27427,7 +28308,7 @@ function unresolvedChangeSetJournalSummary(journals) {
 }
 
 // packages/local-runtime/runtime-daemon/src/external-documentation.ts
-import { existsSync as existsSync15, readdirSync as readdirSync8, readFileSync as readFileSync17, statSync as statSync7 } from "node:fs";
+import { existsSync as existsSync15, readdirSync as readdirSync10, readFileSync as readFileSync17, statSync as statSync7 } from "node:fs";
 import { resolve as resolve18 } from "node:path";
 
 // packages/core/context-compiler/src/index.ts
@@ -27435,7 +28316,7 @@ init_src();
 
 // packages/core/practice-catalog/src/index.ts
 init_src();
-import { existsSync as existsSync13, lstatSync as lstatSync7, readdirSync as readdirSync6, readFileSync as readFileSync15, realpathSync as realpathSync8 } from "node:fs";
+import { existsSync as existsSync13, lstatSync as lstatSync7, readdirSync as readdirSync8, readFileSync as readFileSync15, realpathSync as realpathSync8 } from "node:fs";
 import { dirname as dirname9, relative as relative9, resolve as resolve16, sep as sep7 } from "node:path";
 import { fileURLToPath } from "node:url";
 var PRACTICE_CATALOG_VERSION = "2026.06.0";
@@ -28046,7 +28927,7 @@ function listDataFiles(dir, allowedRoot, errors) {
       return;
     }
     if (stat.isDirectory()) {
-      for (const entry of readdirSync6(current, { withFileTypes: true }))
+      for (const entry of readdirSync8(current, { withFileTypes: true }))
         walk(resolve16(current, entry.name));
       return;
     }
@@ -28660,7 +29541,7 @@ function checkResult(input, result) {
 }
 // packages/core/practice-engine/src/enforcement.ts
 init_src();
-import { existsSync as existsSync14, lstatSync as lstatSync8, readdirSync as readdirSync7, readFileSync as readFileSync16 } from "node:fs";
+import { existsSync as existsSync14, lstatSync as lstatSync8, readdirSync as readdirSync9, readFileSync as readFileSync16 } from "node:fs";
 import { basename as basename4, join as join9, relative as relative10, resolve as resolve17, sep as sep8 } from "node:path";
 var ENFORCEMENT_RANK = { advisory: 0, checkpoint: 1, complete: 2 };
 var POLICY_MODES = new Set(["advisory", "active", "fail-open", "fail-closed"]);
@@ -28702,7 +29583,7 @@ function loadPracticeWaivers(root) {
     throw new Error("practice-waiver-path-not-directory");
   const waivers = [];
   const ownerRegistry = loadPracticeWaiverOwnerRegistry(root);
-  for (const entry of readdirSync7(dir, { withFileTypes: true })) {
+  for (const entry of readdirSync9(dir, { withFileTypes: true })) {
     if (!entry.isFile() || !/\.(?:ya?ml|json)$/.test(entry.name))
       continue;
     const path = join9(dir, entry.name);
@@ -29005,7 +29886,7 @@ function parseJsonYamlFile(path) {
 function collectFiles(root, relativeDir) {
   const dir = resolve17(root, relativeDir);
   const out = [];
-  for (const entry of readdirSync7(dir, { withFileTypes: true })) {
+  for (const entry of readdirSync9(dir, { withFileTypes: true })) {
     const child = `${relativeDir}/${entry.name}`;
     if (entry.isDirectory())
       out.push(...collectFiles(root, child));
@@ -30571,7 +31452,7 @@ function expandWorkspacePackageJson(root, pattern) {
   const base = resolve18(root, pattern.slice(0, -2));
   if (!existsSync15(base) || !statSync7(base).isDirectory())
     return [];
-  return readdirSync8(base, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => resolve18(base, entry.name, "package.json")).filter((path) => existsSync15(path));
+  return readdirSync10(base, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => resolve18(base, entry.name, "package.json")).filter((path) => existsSync15(path));
 }
 function exactVersionFromManifest(manifest, packageName) {
   if (!manifest || typeof manifest !== "object" || Array.isArray(manifest))
@@ -31349,7 +32230,7 @@ function parsePracticeCheckpointBaselineState(state, repositoryId, taskSessionId
 // packages/local-runtime/runtime-daemon/src/developer-review-run.ts
 init_src();
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { chmodSync as chmodSync6, existsSync as existsSync18, lstatSync as lstatSync9, mkdirSync as mkdirSync8, mkdtempSync as mkdtempSync3, readdirSync as readdirSync9, readFileSync as readFileSync18, rmSync as rmSync10, writeFileSync as writeFileSync7 } from "node:fs";
+import { chmodSync as chmodSync6, existsSync as existsSync18, lstatSync as lstatSync9, mkdirSync as mkdirSync8, mkdtempSync as mkdtempSync3, readdirSync as readdirSync11, readFileSync as readFileSync18, rmSync as rmSync10, writeFileSync as writeFileSync7 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import { basename as basename5, dirname as dirname10, join as join11, resolve as resolve20, sep as sep9 } from "node:path";
 // packages/local-runtime/runtime-daemon/src/rpc-protocol.ts
@@ -31911,6 +32792,17 @@ function acquireDaemonLock(lockPath, root) {
     throw new Error(`archctxd already running for ${root}; lock=${lockPath}`);
   }
 }
+function liveDaemonLockOwnerPid(root = process.cwd()) {
+  try {
+    const body = readPrivateControlFile(defaultDaemonLockPath(root));
+    if (body === undefined)
+      return;
+    const pid = JSON.parse(body).pid;
+    return typeof pid === "number" && pid > 0 && isProcessAlive(pid) ? pid : undefined;
+  } catch {
+    return;
+  }
+}
 function isValidRuntimeRpcConnection(value) {
   return value.schemaVersion === RUNTIME_RPC_VERSION && value.protocol === "http-loopback" && value.version === 1 && typeof value.url === "string" && value.url.startsWith("http://127.0.0.1:") && typeof value.token === "string" && value.token.length > 0 && typeof value.pid === "number" && typeof value.connectionPath === "string" && typeof value.lockPath === "string";
 }
@@ -32120,7 +33012,7 @@ class DeveloperReviewRunService {
     };
     if (!existsSync18(stateDir))
       return recovery;
-    for (const entry of readdirSync9(stateDir).sort()) {
+    for (const entry of readdirSync11(stateDir).sort()) {
       if (!entry.endsWith(".json"))
         continue;
       const manifestPath = join11(stateDir, entry);
@@ -32148,7 +33040,7 @@ class DeveloperReviewRunService {
         recovery.rejected.push(`${entry}: ${error instanceof Error ? error.message : String(error)}`);
       }
     }
-    for (const entry of readdirSync9(stateDir).sort()) {
+    for (const entry of readdirSync11(stateDir).sort()) {
       if (!entry.endsWith(".lock"))
         continue;
       const lockPath = join11(stateDir, entry);
@@ -33344,7 +34236,7 @@ init_src();
 
 // packages/local-runtime/model-store-yaml/src/index.ts
 init_src();
-import { existsSync as existsSync19, lstatSync as lstatSync10, mkdirSync as mkdirSync9, readdirSync as readdirSync10, readFileSync as readFileSync19, rmSync as rmSync11 } from "node:fs";
+import { existsSync as existsSync19, lstatSync as lstatSync10, mkdirSync as mkdirSync9, readdirSync as readdirSync12, readFileSync as readFileSync19, rmSync as rmSync11 } from "node:fs";
 import { dirname as dirname11, resolve as resolve21 } from "node:path";
 var GENERATED_ARCHITECTURE_PATH = ".archcontext/generated/ARCHITECTURE.md";
 var GENERATED_ARCHITECTURE_BODY = [
@@ -33569,7 +34461,7 @@ function collectGeneratedProjectionFiles(root) {
   const generatedRoot = ".archcontext/generated";
   if (!existsSync19(resolve21(root, generatedRoot)))
     return [];
-  const walk = (relativeDir) => readdirSync10(resolve21(root, relativeDir), { withFileTypes: true }).flatMap((entry) => {
+  const walk = (relativeDir) => readdirSync12(resolve21(root, relativeDir), { withFileTypes: true }).flatMap((entry) => {
     const child = `${relativeDir}/${entry.name}`;
     if (entry.isDirectory())
       return walk(child);
@@ -33664,7 +34556,7 @@ function collectArchContextFiles(root, entries) {
   function walk(relativeDir) {
     const out = [];
     const dir = resolve21(root, relativeDir);
-    for (const entry of readdirSync10(dir, { withFileTypes: true })) {
+    for (const entry of readdirSync12(dir, { withFileTypes: true })) {
       const child = `${relativeDir}/${entry.name}`;
       if (entry.isDirectory())
         out.push(...walk(child));
@@ -33681,7 +34573,7 @@ function isCollectableModelFile(path) {
 }
 function readdirOrFile(path) {
   try {
-    readdirSync10(path);
+    readdirSync12(path);
     return "directory";
   } catch {
     return "file";
@@ -41814,6 +42706,9 @@ function runNodeInvestigationTransport(input, options) {
     child.once("exit", (code) => {
       settleResolve(unwrapClaudeCodeEnvelope(code ?? 1, stdout, stderr));
     });
+    child.stdin?.on("error", () => {
+      return;
+    });
     child.stdin?.end(input.stdin);
   });
 }
@@ -42854,6 +43749,7 @@ function buildArchitectureDocsProjection(_host, root, generatedAt, profile = "de
     profile,
     decisions: loaded.decisions,
     existingFiles: loaded.existingFiles,
+    docsLanguage: loaded.docsLanguage,
     sourceFootprints,
     sourceScaleSignals: loadCapabilitySourceScaleSignals(root, loaded.model, codeGraphInputs.sourceFiles),
     importGraphs: codeGraphInputs.importGraphs,
@@ -43954,6 +44850,7 @@ function buildRuntimeProjectionRecoveryFixedPoint(root) {
     profile: REPO_HARNESS_PROJECTION_PROFILE,
     decisions: loaded.decisions,
     existingFiles: loaded.existingFiles,
+    docsLanguage: loaded.docsLanguage,
     sourceFootprints: loadCapabilitySourceFootprintDigests(root, loaded.model, codeGraphInputs.sourceFiles),
     sourceScaleSignals: loadCapabilitySourceScaleSignals(root, loaded.model, codeGraphInputs.sourceFiles),
     importGraphs: codeGraphInputs.importGraphs,
@@ -44068,12 +44965,123 @@ function runtimeProjectionOwnedOutputDigest(projection) {
     files: projection.files.map((file) => ({ path: file.path, body: file.body })).sort((left, right) => left.path.localeCompare(right.path))
   });
 }
-// packages/core/recommendation-engine/src/index.ts
-init_src();
-
-// packages/core/refactor-assessment/src/index.ts
+// packages/local-runtime/runtime-daemon/src/docs-anchors.ts
 init_src();
-
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { readFileSync as readFileSync24 } from "node:fs";
+import { resolve as resolve25 } from "node:path";
+function runDocsAnchorsCommand(cwd, options = {}) {
+  let opened;
+  try {
+    const root = findRepositoryRoot(cwd);
+    const profile = options.profile ?? committedArchitectureDocsProfile(root);
+    const model = loadNativeModelFromArchContext(root);
+    const layout = resolveArchitectureDocumentationLayout({ nodes: model.nodes, relations: model.relations, profile });
+    const documents = new Map(loadArchitectureFilesForLayout(root, layout).map((file) => [file.path, file.body]));
+    const files = listProjectionSourceFiles(root);
+    const footprints = new Map(loadCapabilitySourceFootprints(root, model, files).map((footprint) => [footprint.nodeId, footprint.files]));
+    const contents = fileContentReader(root);
+    const tree = gitVisibleTree(root, files, contents);
+    opened = openCodeGraphSymbolReader(root);
+    const codeGraph = opened.availability === "ready" ? { availability: "ready", symbols: proseAnchorSymbols(opened.reader, files, contents) } : { availability: "unavailable", reasonCode: opened.reasonCode };
+    const report = checkProseAnchors({
+      profile,
+      codeGraph,
+      tree,
+      nodes: model.nodes.map((node) => {
+        const documentPath = layout.entityPathByNodeId.get(node.id);
+        const body = documentPath === undefined ? undefined : documents.get(documentPath);
+        const responsibilities = Array.isArray(node.responsibilities) ? node.responsibilities.filter((entry) => typeof entry === "string") : undefined;
+        return {
+          nodeId: node.id,
+          ...typeof node.summary === "string" ? { summary: node.summary } : {},
+          ...responsibilities ? { responsibilities } : {},
+          ...footprints.has(node.id) ? { footprint: footprints.get(node.id) } : {},
+          ...documentPath !== undefined && body !== undefined ? { document: { path: documentPath, body } } : {}
+        };
+      })
+    });
+    const issues = docsAnchorsReportIssues(report);
+    if (issues.length > 0)
+      throw new Error(`docs-anchors-report-invalid: ${issues.join("; ")}`);
+    return okEnvelope("docs.anchors", report);
+  } catch (error) {
+    return projectionFailureEnvelope("docs.anchors", error);
+  } finally {
+    if (opened?.availability === "ready")
+      opened.reader.close();
+  }
+}
+function fileContentReader(root) {
+  const cache = new Map;
+  return (path) => {
+    let content = cache.get(path);
+    if (content === undefined) {
+      content = readFileSync24(resolve25(root, path), "utf8").replace(/\r\n/g, `
+`);
+      cache.set(path, content);
+    }
+    return content;
+  };
+}
+function gitVisibleTree(root, files, contents) {
+  const fileSet = new Set(files);
+  const directories = new Set;
+  const topLevel = new Set;
+  const ignored = new Map;
+  for (const file of files) {
+    const segments = file.split("/");
+    topLevel.add(segments[0]);
+    for (let index = 1;index < segments.length; index += 1)
+      directories.add(segments.slice(0, index).join("/"));
+  }
+  return {
+    kind: (path) => fileSet.has(path) ? "file" : directories.has(path) ? "directory" : undefined,
+    hasTopLevelEntry: (segment) => topLevel.has(segment),
+    filesEndingWith: (suffix) => files.filter((file) => file === suffix || file.endsWith(`/${suffix}`)),
+    lineCount: (path) => {
+      const content = contents(path);
+      if (content === "")
+        return 0;
+      return content.split(`
+`).length - (content.endsWith(`
+`) ? 1 : 0);
+    },
+    isIgnored: (path) => {
+      let found = ignored.get(path);
+      if (found === undefined) {
+        found = spawnSync3("git", ["check-ignore", "--", path, `${path}/`], { cwd: root, stdio: "ignore" }).status === 0;
+        ignored.set(path, found);
+      }
+      return found;
+    }
+  };
+}
+var SOURCE_SEARCH_EXCLUDED_PREFIXES = [".archcontext/"];
+function proseAnchorSymbols(reader, files, contents) {
+  const sourceFiles = files.filter((file) => !SOURCE_SEARCH_EXCLUDED_PREFIXES.some((prefix) => file.startsWith(prefix)) && reader.supportsPath(file));
+  const appears = new Map;
+  const parsed = new Map;
+  const declarationsIn = (path) => {
+    if (!parsed.has(path))
+      parsed.set(path, reader.supportsPath(path) ? reader.declarationsInSource(path, contents(path)) : undefined);
+    return parsed.get(path);
+  };
+  return {
+    supportsPath: (path) => declarationsIn(path) !== undefined,
+    declarationsInFile: (path, name) => (declarationsIn(path) ?? []).filter((declaration) => declaration.name === name),
+    declarationsNamed: (name) => reader.declarationsNamed(name),
+    appearsInSource: (name) => {
+      let found = appears.get(name);
+      if (found === undefined) {
+        const word = new RegExp(`(?<![A-Za-z0-9_$])${name.replace(/[$]/g, "\\$")}(?![A-Za-z0-9_$])`);
+        found = sourceFiles.some((file) => word.test(contents(file)));
+        appears.set(name, found);
+      }
+      return found;
+    }
+  };
+}
 // packages/core/module-statistics/src/index.ts
 init_src();
 
@@ -44221,10 +45229,10 @@ function tarjanComponents(nodeIds, successors) {
 }
 
 // packages/core/module-statistics/src/ownership.ts
+init_src();
 function resolveOwnership(nodes, paths) {
   const declaring = nodes.filter((node) => (nativeNodeSource(node)?.include ?? []).length > 0);
   const parents = new Map(nodes.map((node) => [node.id, node.parent]));
-  const depths = new Map(nodes.map((node) => [node.id, depthOf(node.id, parents)]));
   const roots = declaredSourceRoots(declaring);
   const excludes = declaring.flatMap((node) => nativeNodeSource(node)?.exclude ?? []);
   const byPath = new Map;
@@ -44243,7 +45251,7 @@ function resolveOwnership(nodes, paths) {
       byPath.set(path, { owners: [], ambiguous: false });
       continue;
     }
-    const resolution = resolveCandidates(candidates, parents, depths);
+    const resolution = resolveCandidates(candidates, parents);
     ownedFileCount += 1;
     if (resolution.ambiguous)
       multiplyOwnedFileCount += 1;
@@ -44290,38 +45298,90 @@ function claims(node, path) {
     return false;
   return include.some((pattern) => matchesGlob(path, pattern));
 }
-function resolveCandidates(candidates, parents, depths) {
-  if (candidates.length === 1)
-    return { owners: [candidates[0].id], ambiguous: false };
-  const deepest = candidates.reduce((best, node) => {
-    const bestDepth = depths.get(best.id) ?? 0;
-    const nodeDepth = depths.get(node.id) ?? 0;
-    if (nodeDepth !== bestDepth)
-      return nodeDepth > bestDepth ? node : best;
-    return node.id < best.id ? node : best;
-  });
-  const chain = ancestorChain(deepest.id, parents);
-  if (candidates.every((node) => chain.has(node.id)))
-    return { owners: [deepest.id], ambiguous: false };
-  return { owners: candidates.map((node) => node.id).sort(), ambiguous: true };
-}
-function ancestorChain(id, parents) {
-  const chain = new Set;
-  let current = id;
-  while (current !== undefined && parents.has(current) && !chain.has(current)) {
-    chain.add(current);
-    current = parents.get(current);
-  }
-  return chain;
+function resolveCandidates(candidates, parents) {
+  const ids = candidates.map((node) => node.id);
+  const owner = deepestOnOneParentChain(ids, parents);
+  if (owner !== undefined)
+    return { owners: [owner], ambiguous: false };
+  return { owners: ids.sort(), ambiguous: true };
+}
+function ownershipDelta(before, after, paths, pathLimit = CHANGESET_OWNERSHIP_DELTA_PATH_LIMIT) {
+  const changedNodeIds = ownershipRelevantChanges(before, after);
+  const beforeIndex = resolveOwnership(before, paths);
+  const afterIndex = changedNodeIds.length === 0 ? beforeIndex : resolveOwnership(after, paths);
+  const categories = {
+    becameOwned: [],
+    becameContested: [],
+    ownerChanged: [],
+    becameUnowned: []
+  };
+  for (const path of [...paths].sort()) {
+    const was = beforeIndex.byPath.get(path) ?? { owners: [], ambiguous: false };
+    const now = afterIndex.byPath.get(path) ?? { owners: [], ambiguous: false };
+    if (sameOwners(was.owners, now.owners))
+      continue;
+    const file = { path, before: [...was.owners].sort(), after: [...now.owners].sort() };
+    if (now.ambiguous && !was.ambiguous)
+      categories.becameContested.push(file);
+    else if (was.owners.length === 0)
+      categories.becameOwned.push(file);
+    else if (now.owners.length === 0)
+      categories.becameUnowned.push(file);
+    else
+      categories.ownerChanged.push(file);
+  }
+  const summary = (index) => ({
+    ownedFileCount: index.ownedFileCount,
+    multiplyOwnedFileCount: index.multiplyOwnedFileCount,
+    unownedFileCount: index.unownedFileCount
+  });
+  const bounded = (files) => {
+    const listed = files.slice(0, pathLimit);
+    return { count: files.length, files: listed, omittedCount: files.length - listed.length };
+  };
+  return {
+    schemaVersion: CHANGESET_OWNERSHIP_DELTA_SCHEMA_VERSION,
+    status: "computed",
+    ownershipRule: "parent-chain",
+    fileUniverse: "head-tracked-files",
+    trackedFileCount: paths.length,
+    changedNodeIds,
+    pathLimit,
+    before: summary(beforeIndex),
+    after: summary(afterIndex),
+    becameOwned: bounded(categories.becameOwned),
+    becameContested: bounded(categories.becameContested),
+    ownerChanged: bounded(categories.ownerChanged),
+    becameUnowned: bounded(categories.becameUnowned)
+  };
+}
+function ownershipRelevantChanges(before, after) {
+  const key = (node) => {
+    if (node === undefined)
+      return "absent";
+    const source = nativeNodeSource(node);
+    return digestJson({
+      include: source?.include ?? [],
+      exclude: source?.exclude ?? [],
+      parent: node.parent ?? null
+    });
+  };
+  const beforeById = new Map(before.map((node) => [node.id, node]));
+  const afterById = new Map(after.map((node) => [node.id, node]));
+  const ids = new Set([...beforeById.keys(), ...afterById.keys()]);
+  return [...ids].filter((id) => key(beforeById.get(id)) !== key(afterById.get(id))).sort();
 }
-function depthOf(id, parents) {
-  return ancestorChain(id, parents).size - 1;
+function sameOwners(left, right) {
+  if (left.length !== right.length)
+    return false;
+  const sortedRight = [...right].sort();
+  return [...left].sort().every((owner, index) => owner === sortedRight[index]);
 }
 
 // packages/core/module-statistics/src/index.ts
 function evaluateDependencyConstraints(input) {
   const constraints = [...input.constraints].sort((left, right) => compare(left.id, right.id));
-  const certification = certifyCodeFacts(input.codeFacts, input.worktreeDigest, input.truncated);
+  const certification = certifyCodeFacts(input.codeFacts, input.worktreeDigest, input.truncated, input.importNodeLimitExceeded ?? false);
   if (constraints.length === 0) {
     return {
       schemaVersion: "archcontext.dependency-constraint-evaluation/v1",
@@ -44389,7 +45449,87 @@ function evaluateDependencyConstraints(input) {
     violations: sortedViolations
   };
 }
-function certifyCodeFacts(codeFacts, worktreeDigest, truncated) {
+function measureCapabilityDependencies(input) {
+  const certification = certifyCodeFacts(input.codeFacts, input.worktreeDigest, input.truncated, input.importNodeLimitExceeded);
+  const paths = new Set(input.files);
+  const edges = (certification.measurable ? resolveEdges(input.importEdges, input.workspacePackages, paths) : []).filter((edge) => paths.has(edge.from) && (edge.to === null || paths.has(edge.to)));
+  const ownership = resolveOwnership(input.nodes, [...paths].sort());
+  const parents = new Map(input.nodes.map((node) => [node.id, node.parent]));
+  const kinds = new Map(input.nodes.map((node) => [node.id, node.kind]));
+  const capabilityOf = (owner) => {
+    for (const ancestor of ancestorChain(owner, parents))
+      if (kinds.get(ancestor) === "capability")
+        return ancestor;
+    return null;
+  };
+  const ownersOf = (path) => ownership.byPath.get(path)?.owners ?? [];
+  const within = (path, nodeId) => nodeId === undefined || ownersOf(path).some((owner) => ancestorChain(owner, parents).has(nodeId));
+  const attribute = (path) => {
+    const owners = ownersOf(path);
+    if (owners.length === 0)
+      return { gap: "unownedEndpoint" };
+    const capabilities = new Set(owners.map(capabilityOf));
+    if (capabilities.size > 1)
+      return { gap: "contestedEndpoint" };
+    const [capability] = capabilities;
+    return capability === null ? { gap: "noCapabilityEndpoint" } : { capability };
+  };
+  const unattributed = { unownedEndpoint: 0, contestedEndpoint: 0, noCapabilityEndpoint: 0 };
+  const cells = new Map;
+  const attributedEdges = [];
+  const seen = new Set;
+  let unresolvedCount = 0;
+  for (const edge of edges) {
+    if (!within(edge.from, input.from))
+      continue;
+    if (edge.to === null) {
+      if (input.into === undefined && isRepositoryLocalSpecifier(edge.specifier, input.workspacePackages))
+        unresolvedCount += 1;
+      continue;
+    }
+    if (edge.to === edge.from || !within(edge.to, input.into))
+      continue;
+    const key = JSON.stringify([edge.from, edge.to]);
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    const from = attribute(edge.from);
+    const to = attribute(edge.to);
+    if ("gap" in from || "gap" in to) {
+      unattributed["gap" in from ? from.gap : to.gap] += 1;
+      continue;
+    }
+    const cellKey = JSON.stringify([from.capability, to.capability]);
+    const cell = cells.get(cellKey) ?? { from: from.capability, to: to.capability, imports: 0, calls: null };
+    cell.imports += 1;
+    cells.set(cellKey, cell);
+    attributedEdges.push({ fromPath: edge.from, toPath: edge.to, fromCapability: from.capability, toCapability: to.capability });
+  }
+  const edgeLimit = input.edgeLimit ?? CAPABILITY_DEPENDENCIES_EDGE_LIMIT;
+  attributedEdges.sort((left, right) => compare(left.fromPath, right.fromPath) || compare(left.toPath, right.toPath));
+  const listed = attributedEdges.slice(0, edgeLimit);
+  return {
+    schemaVersion: CAPABILITY_DEPENDENCIES_SCHEMA_VERSION,
+    ownershipRule: "parent-chain",
+    filter: { from: input.from ?? null, into: input.into ?? null },
+    capabilities: input.nodes.filter((node) => node.kind === "capability").map((node) => node.id).sort(compare),
+    matrix: [...cells.values()].sort((left, right) => compare(left.from, right.from) || compare(left.to, right.to)),
+    imports: {
+      coverage: certification.coverage,
+      reasonCodes: [...certification.reasonCodes].sort(),
+      truncated: input.truncated,
+      importNodeCount: input.importNodeCount,
+      importNodeLimit: input.importNodeLimit,
+      importNodeLimitExceeded: input.importNodeLimitExceeded,
+      edgeCount: seen.size,
+      unresolvedCount,
+      unattributed
+    },
+    calls: { coverage: "unknown", reasonCodes: [CAPABILITY_DEPENDENCIES_CALLS_UNAVAILABLE_REASON] },
+    edges: { limit: edgeLimit, count: attributedEdges.length, omittedCount: attributedEdges.length - listed.length, items: listed }
+  };
+}
+function certifyCodeFacts(codeFacts, worktreeDigest, truncated, importNodeLimitExceeded) {
   const attested = codeFacts.indexedWorktreeDigest !== null && codeFacts.indexedWorktreeDigest === worktreeDigest;
   const measurable = codeFacts.availability === "ready" && attested;
   const reasonCodes = [];
@@ -44397,9 +45537,12 @@ function certifyCodeFacts(codeFacts, worktreeDigest, truncated) {
     reasonCodes.push("code-facts-unavailable");
   else if (!attested)
     reasonCodes.push("code-facts-stale");
+  if (measurable && importNodeLimitExceeded)
+    reasonCodes.push("code-facts-import-limit");
   if (measurable && truncated)
     reasonCodes.push("code-facts-truncated");
-  return { measurable, coverage: !measurable ? "unknown" : truncated ? "partial" : "complete", reasonCodes };
+  const partial = truncated || importNodeLimitExceeded;
+  return { measurable, coverage: !measurable ? "unknown" : partial ? "partial" : "complete", reasonCodes };
 }
 function isRepositoryLocalSpecifier(specifier, workspacePackages) {
   if (specifier === "." || specifier === ".." || specifier.startsWith("./") || specifier.startsWith("../"))
@@ -44414,7 +45557,8 @@ function measureModuleStatistics(input) {
   const trackedFiles = [...input.trackedFiles].sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
   const linesByPath = new Map(trackedFiles.map((file) => [file.path, file.lineCount]));
   const ownership = resolveOwnership(nodes, trackedFiles.map((file) => file.path));
-  const { measurable, coverage } = certifyCodeFacts(input.codeFacts, input.worktree.worktreeDigest, input.truncated);
+  const importNodeLimitExceeded = input.importNodeLimitExceeded ?? false;
+  const { measurable, coverage } = certifyCodeFacts(input.codeFacts, input.worktree.worktreeDigest, input.truncated, importNodeLimitExceeded);
   const edges = measurable ? resolveEdges(input.importEdges, input.workspacePackages, new Set(linesByPath.keys())) : [];
   const constraints = input.constraints ?? [];
   const directionEvaluation = constraints.length === 0 ? undefined : evaluateDependencyConstraints({
@@ -44425,6 +45569,7 @@ function measureModuleStatistics(input) {
     importEdges: input.importEdges,
     workspacePackages: input.workspacePackages,
     truncated: input.truncated,
+    importNodeLimitExceeded,
     codeFacts: input.codeFacts
   });
   const directionViolations = directionEvaluation === undefined ? undefined : countViolationsByNode(directionEvaluation);
@@ -44447,7 +45592,8 @@ function measureModuleStatistics(input) {
     coverage,
     truncated: coverage === "unknown" ? true : input.truncated,
     edgeLimit: input.edgeLimit,
-    reasonCodes: reasonCodes({ coverage, truncated: input.truncated, measurable, modules, ownership })
+    ...input.importNodeCount === undefined ? {} : { importNodeCount: input.importNodeCount },
+    reasonCodes: reasonCodes({ coverage, truncated: input.truncated, importNodeLimitExceeded, measurable, modules, ownership })
   };
   const draft = {
     schemaVersion: MODULE_STATISTICS_SCHEMA_VERSION,
@@ -44557,6 +45703,8 @@ function reasonCodes(context) {
     codes.add("code-facts-missing");
   if (context.truncated || context.coverage === "unknown")
     codes.add("code-facts-truncated");
+  if (context.measurable && context.importNodeLimitExceeded)
+    codes.add("code-facts-import-limit");
   if (context.modules.some((module) => !module.footprintDeclared))
     codes.add("node-footprint-undeclared");
   if (context.ownership.multiplyOwnedFileCount > 0)
@@ -44566,6 +45714,16 @@ function reasonCodes(context) {
   return [...codes].sort();
 }
 
+// packages/local-runtime/runtime-daemon/src/refactor-scan.ts
+init_src();
+import { execFileSync as execFileSync9 } from "node:child_process";
+import { createHash as createHash10 } from "node:crypto";
+import { existsSync as existsSync24, readdirSync as readdirSync13, readFileSync as readFileSync25 } from "node:fs";
+import { join as join16 } from "node:path";
+
+// packages/core/refactor-assessment/src/index.ts
+init_src();
+
 // packages/core/refactor-assessment/src/evidence.ts
 init_src();
 class ObservationEvidenceBuilder {
@@ -45320,7 +46478,8 @@ function buildObservations(snapshot, structure, model) {
       subjectSelectorId: repositorySubject,
       metrics: {
         unresolvedImportCount: snapshot.repositorySummary.unresolvedImportCount,
-        edgeLimit: snapshot.codeFacts.edgeLimit
+        edgeLimit: snapshot.codeFacts.edgeLimit,
+        ...snapshot.codeFacts.importNodeCount === undefined ? {} : { importNodeCount: snapshot.codeFacts.importNodeCount }
       },
       evidence: evidence.evidenceGap()
     });
@@ -45359,8 +46518,12 @@ function classifyProposal(context) {
     codes.add("node-footprint-undeclared");
   if (coverage === "unknown")
     codes.add("code-facts-missing");
-  if (coverage === "partial")
-    codes.add("code-facts-truncated");
+  if (coverage === "partial") {
+    const limited = context.snapshot.codeFacts.reasonCodes.includes("code-facts-import-limit");
+    codes.add(limited ? "code-facts-import-limit" : "code-facts-truncated");
+    if (limited && context.snapshot.codeFacts.truncated)
+      codes.add("code-facts-truncated");
+  }
   if (scopeOwnership.contested.length > 0)
     codes.add("ownership-ambiguous");
   if (derivation.unresolvedTargets.length > 0)
@@ -45502,7 +46665,11 @@ function isPresent2(value) {
   return value !== undefined;
 }
 
+// packages/local-runtime/runtime-daemon/src/refactor-recording.ts
+init_src();
+
 // packages/core/recommendation-engine/src/index.ts
+init_src();
 var RECOMMENDATION_SCHEDULER_ENGINE_VERSION = "archcontext.recommendation-scheduler/v1";
 var ACTIVE_RECOMMENDATION_STATUSES = new Set(["open", "acknowledged", "deferred"]);
 var REFACTOR_ACTIVE_RECOMMENDATION_STATUSES = new Set([
@@ -46176,11 +47343,16 @@ function observationExplanation(observation, affectedNodeIds) {
       const examples = evidence.unresolvedImports.slice(0, EXPLANATION_EXAMPLE_LIMIT);
       return [
         `Code facts coverage is ${evidence.coverage} (${evidence.reasonCodes.join(", ")}), so structural metrics${affectedNodeIds.length > 0 ? ` for ${affectedNodeIds.join(", ")}` : ""} are incomplete.`,
+        ...evidence.reasonCodes.includes("code-facts-import-limit") ? [importLimitText(observation.metrics)] : [],
         ...evidence.totalCount === 0 ? [] : [`${evidence.totalCount} import specifier(s) did not resolve to a tracked file.`, ...examples.map((entry) => `${locationText(entry.fromPath, entry.fromLine)} imports ${entry.specifier}.`), ...more(examples.length)]
       ];
     }
   }
 }
+function importLimitText(metrics) {
+  const count = typeof metrics.importNodeCount === "number" ? `${metrics.importNodeCount} import nodes` : "more import nodes";
+  return `The index holds ${count}, more than the scan import node limit of ${metrics.edgeLimit ?? "unknown"}. Run archctx refactor scan --import-node-limit <n> with a larger limit; a new CodeGraph index does not change this.`;
+}
 function evidenceLength(evidence) {
   switch (evidence.kind) {
     case "cycle":
@@ -46365,7 +47537,6 @@ function latestRecommendationV3ByFingerprint(previous) {
 }
 
 // packages/local-runtime/runtime-daemon/src/refactor-recording.ts
-init_src();
 var REFACTOR_ASSESSMENT_REGISTRY_CAPACITY = 8;
 var REFACTOR_CLASSIFIER_RULESET_SCHEMA_VERSION = "archcontext.refactor-classifier-ruleset/v1";
 var REFACTOR_SCAN_EVENT_TYPE = "architecture.refactor.scan";
@@ -46606,17 +47777,15 @@ function digestSuffix4(digest) {
 }
 
 // packages/local-runtime/runtime-daemon/src/refactor-scan.ts
-init_src();
-import { execFileSync as execFileSync9 } from "node:child_process";
-import { createHash as createHash10 } from "node:crypto";
-import { existsSync as existsSync24, readdirSync as readdirSync11, readFileSync as readFileSync24 } from "node:fs";
-import { join as join16 } from "node:path";
 var CODEGRAPH_BINARY = "codegraph";
 var CODEGRAPH_VERSION_TIMEOUT_MS = 15000;
 var REPOSITORY_REFACTOR_REQUEST = {
   schemaVersion: REFACTOR_REQUEST_SCHEMA_VERSION,
   scope: { kind: "repository" }
 };
+function repositoryRefactorRequest(importNodeLimit) {
+  return importNodeLimit === undefined ? REPOSITORY_REFACTOR_REQUEST : { ...REPOSITORY_REFACTOR_REQUEST, importNodeLimit };
+}
 
 class RefactorScanError extends Error {
   code;
@@ -46640,7 +47809,7 @@ function runRefactorScan(input) {
   const constraints = readDependencyConstraints(listModelFiles(input.root)).constraints;
   const createdAt = readHeadCommitterDate(input.root);
   const requestId = refactorRequestId(input.request);
-  const edgeLimit = input.edgeLimit ?? CODEGRAPH_IMPORT_NODE_QUERY_LIMIT;
+  const edgeLimit = input.request.importNodeLimit ?? CODEGRAPH_IMPORT_NODE_READ_LIMIT;
   const trackedFiles = readTrackedSourceFiles(input.root);
   const codeFacts = readCodeFacts(input.root, input.worktree.worktreeDigest, edgeLimit);
   const { snapshot, structure } = measureModuleStatistics({
@@ -46652,6 +47821,8 @@ function runRefactorScan(input) {
     workspacePackages: declaredWorkspacePackages(input.root),
     truncated: codeFacts.truncated,
     edgeLimit,
+    importNodeCount: codeFacts.importNodeCount,
+    importNodeLimitExceeded: codeFacts.importNodeLimitExceeded,
     codeFacts: {
       version: codeFacts.version,
       binaryDigest: codeFacts.binaryDigest,
@@ -46707,7 +47878,8 @@ function runRefactorScan(input) {
       maxEvidenceSampleLimit: REFACTOR_OBSERVATION_EVIDENCE_LIMIT,
       ...plan.candidateBudget
     },
-    trackedFileCount: trackedFiles.length
+    trackedFileCount: trackedFiles.length,
+    untrackedExcludedCount: countFilesOutsideHead(input.root)
   };
 }
 function evaluateReviewDependencyConstraints(input) {
@@ -46723,11 +47895,20 @@ function evaluateReviewDependencyConstraints(input) {
       codeFacts: { availability: "unavailable", indexedWorktreeDigest: null }
     });
   }
+  const edgeLimit = input.edgeLimit ?? CODEGRAPH_IMPORT_NODE_READ_LIMIT;
   let imports;
   try {
-    imports = repositoryImportPairs(input.root, CODEGRAPH_BINARY, input.edgeLimit ?? CODEGRAPH_IMPORT_NODE_QUERY_LIMIT, input.worktreeDigest);
+    imports = repositoryImportPairs(input.root, CODEGRAPH_BINARY, edgeLimit, input.worktreeDigest);
   } catch {
-    imports = { pairs: [], truncated: true, availability: "unavailable", indexedWorktreeDigest: null };
+    imports = {
+      pairs: [],
+      truncated: true,
+      availability: "unavailable",
+      indexedWorktreeDigest: null,
+      importNodeCount: null,
+      importNodeLimit: edgeLimit,
+      importNodeLimitExceeded: false
+    };
   }
   const workspaces = reviewWorkspacePackages(input.root);
   return evaluateDependencyConstraints({
@@ -46737,6 +47918,7 @@ function evaluateReviewDependencyConstraints(input) {
     workspacePackages: workspaces.packages,
     workspacePackagesResolved: workspaces.resolved,
     truncated: imports.truncated,
+    importNodeLimitExceeded: imports.importNodeLimitExceeded,
     codeFacts: { availability: imports.availability, indexedWorktreeDigest: imports.indexedWorktreeDigest }
   });
 }
@@ -46744,7 +47926,7 @@ function reviewWorkspacePackages(root) {
   if (!existsSync24(join16(root, "package.json")))
     return { packages: [], resolved: true };
   try {
-    const manifest = JSON.parse(readFileSync24(join16(root, "package.json"), "utf8"));
+    const manifest = JSON.parse(readFileSync25(join16(root, "package.json"), "utf8"));
     const declared = Array.isArray(manifest.workspaces) ? manifest.workspaces : manifest.workspaces?.packages ?? [];
     if (!Array.isArray(declared))
       throw new Error("workspaces must be a list");
@@ -46757,10 +47939,10 @@ function reviewWorkspacePackages(root) {
       const parent = /^([^*?[\]{}!]+)\/\*$/.exec(pattern)?.[1];
       if (parent === undefined)
         throw new Error(`unsupported workspace pattern: ${entry}`);
-      return readdirSync11(join16(root, parent), { withFileTypes: true }).filter((child) => child.isDirectory() && existsSync24(join16(root, parent, child.name, "package.json"))).map((child) => `${parent}/${child.name}`);
+      return readdirSync13(join16(root, parent), { withFileTypes: true }).filter((child) => child.isDirectory() && existsSync24(join16(root, parent, child.name, "package.json"))).map((child) => `${parent}/${child.name}`);
     });
     const packages = directories.flatMap((directory) => {
-      const packageManifest = JSON.parse(readFileSync24(join16(root, ...directory.split("/"), "package.json"), "utf8"));
+      const packageManifest = JSON.parse(readFileSync25(join16(root, ...directory.split("/"), "package.json"), "utf8"));
       if (typeof packageManifest.name !== "string")
         return [];
       const exports = typeof packageManifest.exports === "string" ? { ".": packageManifest.exports } : Object.fromEntries(Object.entries(packageManifest.exports ?? {}).filter((entry) => typeof entry[1] === "string"));
@@ -46797,6 +47979,10 @@ function readWorktreeFiles(root) {
   }
   return [...new Set(output.split("\x00").filter(Boolean))].sort();
 }
+function countFilesOutsideHead(root) {
+  const head = new Set(readTrackedTreeEntries(root).map((entry) => entry.path));
+  return readWorktreeFiles(root).filter((path) => !head.has(path)).length;
+}
 function declaredWorkspacePackages(root) {
   return existsSync24(join16(root, "package.json")) ? readWorkspacePackages(root) : [];
 }
@@ -46827,6 +48013,8 @@ function readCodeFacts(root, worktreeDigest, edgeLimit) {
   return {
     pairs: imports.pairs,
     truncated: imports.truncated,
+    importNodeCount: imports.importNodeCount,
+    importNodeLimitExceeded: imports.importNodeLimitExceeded,
     availability: imports.availability,
     indexedWorktreeDigest: imports.indexedWorktreeDigest,
     ...attestation
@@ -46843,10 +48031,108 @@ function attestCodeGraphBinary(root) {
   const binaryPath = invocation.argsPrefix[0] ?? invocation.command;
   return {
     version,
-    binaryDigest: `sha256:${createHash10("sha256").update(readFileSync24(binaryPath)).digest("hex")}`
+    binaryDigest: `sha256:${createHash10("sha256").update(readFileSync25(binaryPath)).digest("hex")}`
   };
 }
 
+// packages/local-runtime/runtime-daemon/src/capability-dependencies.ts
+var CODEGRAPH_BINARY2 = "codegraph";
+
+class CapabilityDependenciesError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "CapabilityDependenciesError";
+  }
+}
+function readCapabilityDependencies(root, request = {}) {
+  const importNodeLimit = request.importNodeLimit ?? CODEGRAPH_IMPORT_NODE_READ_LIMIT;
+  for (const [name, value] of [["importNodeLimit", request.importNodeLimit], ["edgeLimit", request.edgeLimit]]) {
+    if (value !== undefined && (!Number.isInteger(value) || value < (name === "edgeLimit" ? 0 : 1))) {
+      throw new CapabilityDependenciesError("AC_SCHEMA_INVALID", `${name} must be a ${name === "edgeLimit" ? "non-negative" : "positive"} integer, got ${value}`);
+    }
+  }
+  const model = loadModel2(root);
+  const nodeIds = new Set(model.nodes.map((node) => node.id));
+  for (const [flag, nodeId] of [["--from", request.from], ["--into", request.into]]) {
+    if (nodeId !== undefined && !nodeIds.has(nodeId)) {
+      throw new CapabilityDependenciesError("AC_SCHEMA_INVALID", `deps ${flag} names no node in the model: ${nodeId}`);
+    }
+  }
+  const headSha = readHeadSha(root);
+  const worktreeDigest = computeWorktreeDigest(root);
+  const files = readTrackedTreeEntries(root).filter((entry) => entry.type === "blob").map((entry) => entry.path);
+  const imports = readImports(root, importNodeLimit, worktreeDigest);
+  const matrix = measureCapabilityDependencies({
+    nodes: model.nodes,
+    worktreeDigest,
+    files,
+    importEdges: imports.pairs,
+    workspacePackages: readWorkspaces(root),
+    truncated: imports.truncated,
+    importNodeCount: imports.importNodeCount,
+    importNodeLimit: imports.importNodeLimit,
+    importNodeLimitExceeded: imports.importNodeLimitExceeded,
+    codeFacts: { availability: imports.availability, indexedWorktreeDigest: imports.indexedWorktreeDigest },
+    ...request.from === undefined ? {} : { from: request.from },
+    ...request.into === undefined ? {} : { into: request.into },
+    ...request.edgeLimit === undefined ? {} : { edgeLimit: request.edgeLimit }
+  });
+  return { ...matrix, worktree: { headSha, worktreeDigest }, privacy: { writes: "none" } };
+}
+function readWorkspaces(root) {
+  try {
+    return declaredWorkspacePackages(root);
+  } catch (error) {
+    throw new CapabilityDependenciesError("AC_SCHEMA_INVALID", `workspace packages are unreadable: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function loadModel2(root) {
+  try {
+    return loadNativeModelFromArchContext(root);
+  } catch (error) {
+    throw new CapabilityDependenciesError("AC_MODEL_ADOPTION_REQUIRED", `architecture model is unreadable: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function readImports(root, limit, worktreeDigest) {
+  try {
+    return repositoryImportPairs(root, CODEGRAPH_BINARY2, limit, worktreeDigest);
+  } catch {
+    return {
+      pairs: [],
+      truncated: true,
+      availability: "unavailable",
+      indexedWorktreeDigest: null,
+      importNodeCount: null,
+      importNodeLimit: limit,
+      importNodeLimitExceeded: false
+    };
+  }
+}
+// packages/local-runtime/runtime-daemon/src/flow-selector-check.ts
+init_src();
+function runFlowSelectorCheckCommand(cwd, options = {}) {
+  try {
+    const root = findRepositoryRoot(cwd);
+    const model = loadNativeModelFromArchContext(root);
+    const sourceFiles = listProjectionSourceFiles(root);
+    const prepared = prepareProjectionCodeFacts(root, model, {
+      sourceTreeDigest: architectureDocumentationSourceTreeDigest(root, model, sourceFiles),
+      sourceFiles,
+      importGraphs: false,
+      ...options.binary ? { binary: options.binary } : {}
+    });
+    assertProjectionCodeFactsAvailable(root, prepared);
+    return okEnvelope("flows.check", checkArchitectureFlowSelectors({
+      model,
+      selectorEvidence: prepared.selectorEvidence,
+      codeGraph: { availability: prepared.handshake.availability, version: prepared.handshake.actualVersion }
+    }));
+  } catch (error) {
+    return projectionFailureEnvelope("flows.check", error);
+  }
+}
 // packages/local-runtime/runtime-daemon/src/refactor-verify.ts
 init_src();
 var REFACTOR_RESOLUTION_EVENT_TYPE = "architecture.refactor.resolution";
@@ -46993,6 +48279,12 @@ function baselineSnapshotForRecommendation(evidenceState, recommendationId) {
   }
   return;
 }
+function baselineImportNodeLimit(snapshot) {
+  if (snapshot === undefined || snapshot.codeFacts.importNodeCount === undefined)
+    return;
+  const { edgeLimit } = snapshot.codeFacts;
+  return edgeLimit === null || edgeLimit === CODEGRAPH_IMPORT_NODE_READ_LIMIT ? undefined : edgeLimit;
+}
 function refactorVerifyIngressIssues(recommendation) {
   if (recommendation.category === "practice") {
     return [`recommendation ${recommendation.recommendationId} is a practice recommendation and carries no refactor outcome`];
@@ -47087,6 +48379,9 @@ class RecommendationsService {
         }
       });
     };
+    if (input.importNodeLimit !== undefined && !(Number.isInteger(input.importNodeLimit) && input.importNodeLimit >= 1)) {
+      return errorEnvelope(`recommendations.${command}`, "AC_SCHEMA_INVALID", `recommendations ${command} importNodeLimit must be a positive integer`);
+    }
     if (command === "metrics")
       return readMetrics();
     if (command === "list")
@@ -47094,7 +48389,7 @@ class RecommendationsService {
     if (command === "show") {
       if (!input.recommendationId)
         return errorEnvelope("recommendations.show", "AC_SCHEMA_INVALID", "recommendations show requires --id");
-      return this.showRecommendation(repositoryRoot, input.recommendationId);
+      return this.showRecommendation(repositoryRoot, input.recommendationId, input.importNodeLimit);
     }
     if (!isRecommendationLifecycleCliAction(command)) {
       return errorEnvelope("recommendations", "AC_SCHEMA_INVALID", "recommendations requires acknowledge|accept|reject|defer|waive|resolve|metrics|show|list");
@@ -47158,7 +48453,7 @@ class RecommendationsService {
   async decideScanCandidate(root, repositoryRoot, input, command, now) {
     const surface = `recommendations.${command}`;
     const recommendationId = input.recommendationId;
-    const measured = await this.measureRepository(repositoryRoot, REPOSITORY_REFACTOR_REQUEST, `recommendations ${command}`);
+    const measured = await this.measureRepository(repositoryRoot, repositoryRefactorRequest(input.importNodeLimit), `recommendations ${command}`);
     if (!measured.ok) {
       return errorEnvelope(surface, measured.code, `recommendation ${recommendationId} is not recorded and the current refactor scan could not run: ${measured.message}`, measured.reasonCode);
     }
@@ -47239,7 +48534,7 @@ class RecommendationsService {
       }
     });
   }
-  async showRecommendation(repositoryRoot, recommendationId) {
+  async showRecommendation(repositoryRoot, recommendationId, importNodeLimit) {
     const scope = await this.context.architectureLedgerScope(repositoryRoot);
     const replay = await this.context.localStore.replayArchitectureLedger({ ...scope, mode: "genesis" });
     const artifacts = recommendationArtifactsFromEvents(replay.events);
@@ -47257,7 +48552,7 @@ class RecommendationsService {
         worktree: null
       });
     }
-    const measured = await this.measureRepository(repositoryRoot, REPOSITORY_REFACTOR_REQUEST, "recommendations show");
+    const measured = await this.measureRepository(repositoryRoot, repositoryRefactorRequest(importNodeLimit), "recommendations show");
     if (!measured.ok) {
       return errorEnvelope("recommendations.show", measured.code, `recommendation ${recommendationId} is not recorded and the current refactor scan could not run: ${measured.message}`, measured.reasonCode);
     }
@@ -47446,6 +48741,7 @@ class RecommendationsService {
       requestId: result.requestId,
       request,
       trackedFileCount: result.trackedFileCount,
+      untrackedExcludedCount: result.untrackedExcludedCount,
       snapshot: result.snapshot,
       assessment: result.assessment,
       ...result.proposal ? { proposal: result.proposal } : {},
@@ -47612,11 +48908,13 @@ class RecommendationsService {
           graphDigest: replay.graphDigest
         });
       }
+      const baseline = baselineSnapshotForRecommendation(replay.evidenceState, recommendation.recommendationId);
+      const importNodeLimit = input.importNodeLimit ?? baselineImportNodeLimit(baseline?.snapshot);
       let scan;
       try {
         scan = runRefactorScan({
           root: repositoryRoot,
-          request: REPOSITORY_REFACTOR_REQUEST,
+          request: repositoryRefactorRequest(importNodeLimit),
           repository: gitScope.repository,
           worktree: gitScope.worktree,
           previousRecommendations: artifacts.recommendations,
@@ -47627,7 +48925,6 @@ class RecommendationsService {
           return errorEnvelope("refactor.verify", error.code, error.message, error.reasonCode);
         return errorEnvelope("refactor.verify", "AC_SCHEMA_INVALID", error instanceof Error ? error.message : String(error));
       }
-      const baseline = baselineSnapshotForRecommendation(replay.evidenceState, recommendation.recommendationId);
       let plan;
       try {
         plan = runRefactorVerify({
@@ -47764,11 +49061,15 @@ function decodeRuntimeRefactorVerifyInput(value) {
       throw new RuntimeRefactorInputError(`refactor verify ${field} must be a non-empty string`);
     }
   }
+  if (input.importNodeLimit !== undefined && typeof input.importNodeLimit !== "number") {
+    throw new RuntimeRefactorInputError("refactor verify importNodeLimit must be a positive integer");
+  }
   const request = {
     schemaVersion: REFACTOR_VERIFICATION_REQUEST_SCHEMA_VERSION,
     recommendationId: input.recommendationId,
     ...typeof input.expectedHeadSha === "string" ? { expectedHeadSha: input.expectedHeadSha } : {},
     ...typeof input.expectedWorktreeDigest === "string" ? { expectedWorktreeDigest: input.expectedWorktreeDigest } : {},
+    ...typeof input.importNodeLimit === "number" ? { importNodeLimit: input.importNodeLimit } : {},
     ...input.executionEvidenceRefs === undefined ? {} : { executionEvidenceRefs: decodeRuntimeExecutionEvidenceRefs(input.executionEvidenceRefs) }
   };
   if (input.schemaVersion !== REFACTOR_VERIFICATION_REQUEST_SCHEMA_VERSION) {
@@ -47966,14 +49267,14 @@ function recommendationActorKind(input) {
 }
 
 // packages/local-runtime/runtime-daemon/src/changeset-authority.ts
-import { existsSync as existsSync25, readFileSync as readFileSync26 } from "node:fs";
-import { resolve as resolve26 } from "node:path";
+import { existsSync as existsSync25, readFileSync as readFileSync27 } from "node:fs";
+import { resolve as resolve27 } from "node:path";
 init_src();
 
 // packages/local-runtime/runtime-daemon/src/committed-change-acceptance.ts
 import { execFileSync as execFileSync10 } from "node:child_process";
-import { closeSync as closeSync8, constants as fsConstants3, fstatSync as fstatSync3, lstatSync as lstatSync13, openSync as openSync9, readdirSync as readdirSync12, readFileSync as readFileSync25 } from "node:fs";
-import { resolve as resolve25 } from "node:path";
+import { closeSync as closeSync8, constants as fsConstants3, fstatSync as fstatSync3, lstatSync as lstatSync13, openSync as openSync9, readdirSync as readdirSync14, readFileSync as readFileSync26 } from "node:fs";
+import { resolve as resolve26 } from "node:path";
 init_src();
 var SEMANTIC_MODEL_DIRECTORIES = ["nodes", "relations", "flows"];
 var SEMANTIC_MODEL_PATH = /^\.archcontext\/model\/(nodes|relations|flows)\/[^/]+\.ya?ml$/;
@@ -48030,7 +49331,7 @@ function readSemanticModelSnapshot(root, readEntry) {
     try {
       if (!lstatSync13(absolute).isDirectory())
         throw new Error(`semantic-model-directory-invalid: ${relativeDirectory}`);
-      entries = readdirSync12(absolute);
+      entries = readdirSync14(absolute);
     } catch (error) {
       if (error.code === "ENOENT")
         continue;
@@ -48038,7 +49339,7 @@ function readSemanticModelSnapshot(root, readEntry) {
     }
     for (const entry of entries.filter((name) => /\.ya?ml$/.test(name)).sort()) {
       const path = `${relativeDirectory}/${entry}`;
-      bodies.set(path, strictUtf8(readEntry(resolve25(absolute, entry), path), path));
+      bodies.set(path, strictUtf8(readEntry(resolve26(absolute, entry), path), path));
     }
   }
   const hashes = new Map([...bodies].map(([path, body]) => [path, digestJson({ body })]));
@@ -48051,7 +49352,7 @@ function readRegularFileBytes(absolute, path) {
   try {
     if (!fstatSync3(fd).isFile())
       throw new Error(`semantic-model-entry-not-regular: ${path}`);
-    return readFileSync25(fd);
+    return readFileSync26(fd);
   } finally {
     closeSync8(fd);
   }
@@ -48401,6 +49702,40 @@ function sameStrings(left, right) {
   return left.length === right.length && left.every((value, index) => value === right[index]);
 }
 
+// packages/local-runtime/runtime-daemon/src/ownership-delta-preview.ts
+init_src();
+var NODE_DIRECTORY = ".archcontext/model/nodes/";
+var NODE_FILE_OPERATIONS = new Set(["create_entity", "update_entity_fields", "delete_entity"]);
+function planOwnershipDelta(root, draft) {
+  const nodeOperations = draft.operations.filter((operation) => NODE_FILE_OPERATIONS.has(operation.op) && operation.path !== undefined && isNodeFile(operation.path));
+  if (nodeOperations.length === 0)
+    return;
+  try {
+    const current = new Map(listModelFiles(root).filter((file) => isNodeFile(file.path)).map((file) => [file.path, file.body]));
+    const planned = new Map(current);
+    for (const operation of nodeOperations) {
+      if (operation.op === "delete_entity")
+        planned.delete(operation.path);
+      else
+        planned.set(operation.path, operation.body ?? "");
+    }
+    const paths = readTrackedTreeEntries(root).filter((entry) => entry.type === "blob").map((entry) => entry.path);
+    return ownershipDelta(loadNativeModelFromModelFiles(current).nodes, loadNativeModelFromModelFiles(planned).nodes, paths);
+  } catch (error) {
+    return {
+      schemaVersion: CHANGESET_OWNERSHIP_DELTA_SCHEMA_VERSION,
+      status: "unavailable",
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function isNodeFile(path) {
+  if (!path.startsWith(NODE_DIRECTORY))
+    return false;
+  const name = path.slice(NODE_DIRECTORY.length);
+  return !name.includes("/") && /\.ya?ml$/.test(name);
+}
+
 // packages/local-runtime/runtime-daemon/src/changeset-authority.ts
 class RuntimeUpdateInputError extends Error {
 }
@@ -48516,10 +49851,10 @@ class ChangeSetAuthorityService {
       return errorEnvelope("practices.waive", "AC_SCHEMA_INVALID", error instanceof Error ? error.message : String(error));
     }
     const path = `.archcontext/waivers/${waiverId}.json`;
-    const absolute = resolve26(session.workspace.root, path);
+    const absolute = resolve27(session.workspace.root, path);
     const body = `${JSON.stringify(waiver, null, 2)}
 `;
-    const expectedHash = existsSync25(absolute) ? digestJson({ body: readFileSync26(absolute, "utf8") }) : "missing";
+    const expectedHash = existsSync25(absolute) ? digestJson({ body: readFileSync27(absolute, "utf8") }) : "missing";
     const draft = this.changeSetEngine.plan({
       id: input.id ?? `changeset.practice-waiver-${waiverId.replace(/[^A-Za-z0-9_-]/g, "-")}`,
       base: {
@@ -48574,10 +49909,14 @@ class ChangeSetAuthorityService {
     this.changesets.set(draft.id, draft);
     this.changeSetRoots.set(draft.id, canonicalRepositoryRoot(root));
     this.changeSetWorktreeDigestProfiles.set(draft.id, worktreeDigestProfile);
+    const ownershipDelta = planOwnershipDelta(root, draft);
     return okEnvelope("plan_update", {
       draft,
       changeSetDigest: digestJson(draft),
-      preview: this.changeSetEngine.preview(root, draft)
+      preview: {
+        ...this.changeSetEngine.preview(root, draft),
+        ...ownershipDelta === undefined ? {} : { ownershipDelta }
+      }
     });
   }
   async mcpProjection(root, input, approved) {
@@ -48876,7 +50215,7 @@ function architectureLedgerWriteAppendsEvents(mode) {
 // packages/local-runtime/runtime-daemon/src/rpc-server.ts
 init_src();
 import { createServer as createServer2 } from "node:http";
-import { closeSync as closeSync9, mkdirSync as mkdirSync12, rmSync as rmSync15 } from "node:fs";
+import { closeSync as closeSync9, existsSync as existsSync26, mkdirSync as mkdirSync12 } from "node:fs";
 import { dirname as dirname14 } from "node:path";
 import { randomBytes as randomBytes5 } from "node:crypto";
 var DEFAULT_DAEMON_IDLE_TIMEOUT_MS = 30 * 60000;
@@ -48904,6 +50243,8 @@ class ArchctxRuntimeRpcServer {
   idleTimeoutMs;
   idleTimer;
   inFlightRpcRequests = 0;
+  authorizedRequests = 0;
+  idleExitPending = false;
   constructor(daemon, options = {}) {
     this.daemon = daemon;
     this.options = options;
@@ -48930,11 +50271,11 @@ class ArchctxRuntimeRpcServer {
     if (server)
       await new Promise((resolveClose) => server.close(() => resolveClose()));
     if (connection)
-      rmSync15(connection.connectionPath, { force: true });
+      await removePrivateControlFile(connection.connectionPath);
     if (this.lockFd !== undefined) {
       closeSync9(this.lockFd);
       this.lockFd = undefined;
-      rmSync15(this.options.lockPath ?? defaultDaemonLockPath(this.options.root ?? process.cwd()), { force: true });
+      await removePrivateControlFile(this.options.lockPath ?? defaultDaemonLockPath(this.options.root ?? process.cwd()));
     }
     if (startedDaemon)
       await this.daemon.stop().catch(() => {
@@ -48992,13 +50333,16 @@ class ArchctxRuntimeRpcServer {
       });
     }
     await this.daemon.stop();
+    try {
+      if (connection)
+        await removePrivateControlFile(connection.connectionPath);
+    } finally {
+      if (this.lockFd !== undefined)
+        closeSync9(this.lockFd);
+      this.lockFd = undefined;
+    }
     if (connection)
-      rmSync15(connection.connectionPath, { force: true });
-    if (this.lockFd !== undefined)
-      closeSync9(this.lockFd);
-    this.lockFd = undefined;
-    if (connection)
-      rmSync15(connection.lockPath, { force: true });
+      await removePrivateControlFile(connection.lockPath);
     this.options.onStop?.();
   }
   armIdleTimer() {
@@ -49015,21 +50359,44 @@ class ArchctxRuntimeRpcServer {
     this.idleTimer = undefined;
   }
   async checkIdleAndMaybeExit() {
-    if (!this.server || !this.connection)
+    if (!this.server || !this.connection || this.idleExitPending)
       return;
     if (this.inFlightRpcRequests > 0) {
       this.armIdleTimer();
       return;
     }
+    this.idleExitPending = true;
     const hasActiveWork = await this.daemon.hasActiveBackgroundWork().catch(() => true);
     if (hasActiveWork || this.inFlightRpcRequests > 0 || !this.connection) {
+      this.idleExitPending = false;
       this.armIdleTimer();
       return;
     }
-    rmSync15(this.connection.connectionPath, { force: true });
+    const connection = this.connection;
+    const requestsBeforeRemoval = this.authorizedRequests;
+    let cleanupError;
+    await removePrivateControlFile(connection.connectionPath).catch((error) => {
+      cleanupError = error;
+    });
+    if (this.server && this.connection && (this.inFlightRpcRequests > 0 || this.authorizedRequests !== requestsBeforeRemoval)) {
+      try {
+        if (!existsSync26(connection.connectionPath))
+          createPrivateControlFile(connection.connectionPath, JSON.stringify(connection, null, 2));
+        this.idleExitPending = false;
+        this.armIdleTimer();
+        return;
+      } catch (error) {
+        cleanupError ??= error;
+      }
+    }
     try {
       await this.stop();
+    } catch (error) {
+      cleanupError ??= error;
     } finally {
+      if (cleanupError)
+        process.stderr.write(`archctxd idle exit cleanup failed: ${cleanupError.code ?? "unknown"}
+`);
       (this.options.exit ?? process.exit)(0);
     }
   }
@@ -49059,6 +50426,7 @@ class ArchctxRuntimeRpcServer {
         writeJson(response, 401, { schemaVersion: RUNTIME_RPC_VERSION, ok: false, error: "runtime RPC token required" });
         return;
       }
+      this.authorizedRequests += 1;
       const changeSetRecovery = this.daemon.status().changeSetRecovery;
       writeJson(response, 200, {
         schemaVersion: RUNTIME_RPC_VERSION,
@@ -49082,6 +50450,7 @@ class ArchctxRuntimeRpcServer {
       return;
     }
     this.inFlightRpcRequests += 1;
+    this.authorizedRequests += 1;
     try {
       const read = await readRpcRequestBody(request, {
         maxBytes: this.options.maxRequestBodyBytes ?? RUNTIME_RPC_MAX_REQUEST_BODY_BYTES,
@@ -49111,8 +50480,12 @@ class ArchctxRuntimeRpcServer {
         throw error;
       });
       writeJson(response, 200, result);
-      if (body.method === "shutdown")
-        setTimeout(() => void this.stop(), 0);
+      if (body.method === "shutdown") {
+        setTimeout(() => void this.stop().catch((error) => {
+          process.stderr.write(`archctxd shutdown cleanup failed: ${error.code ?? "unknown"}
+`);
+        }), 0);
+      }
     } finally {
       this.inFlightRpcRequests -= 1;
       this.armIdleTimer();
@@ -49214,8 +50587,8 @@ async function readRpcRequestBody(request, limits) {
 }
 
 // packages/local-runtime/runtime-daemon/src/index.ts
-import { existsSync as existsSync26 } from "node:fs";
-import { resolve as resolve27 } from "node:path";
+import { existsSync as existsSync27 } from "node:fs";
+import { resolve as resolve28 } from "node:path";
 init_src();
 
 // packages/local-runtime/runtime-daemon/src/egress.ts
@@ -50154,7 +51527,7 @@ class ArchctxDaemon {
   }
   async restoreRepositorySessions() {
     for (const record of await this.localStore.listRepositorySessions()) {
-      if (!record.root || !existsSync26(record.root))
+      if (!record.root || !existsSync27(record.root))
         continue;
       if (repositoryFingerprint(record.root) !== record.repositoryId)
         continue;
@@ -50419,7 +51792,7 @@ function blockedProductionInjections(deps) {
   ].filter((key) => (key in deps));
 }
 function completeTaskProjectionDrift(root) {
-  if (!existsSync26(resolve27(root, "docs/architecture/.projection-manifest.json")))
+  if (!existsSync27(resolve28(root, "docs/architecture/.projection-manifest.json")))
     return;
   const profile = loadArchitectureDocumentationProfile(root);
   const loaded = loadArchitectureDocumentationInputs(root, profile);
@@ -50436,6 +51809,7 @@ function completeTaskProjectionDrift(root) {
     profile,
     decisions: loaded.decisions,
     existingFiles: loaded.existingFiles,
+    docsLanguage: loaded.docsLanguage,
     sourceFootprints: loadCapabilitySourceFootprintDigests(root, loaded.model, codeGraphInputs.sourceFiles),
     sourceScaleSignals: loadCapabilitySourceScaleSignals(root, loaded.model, codeGraphInputs.sourceFiles),
     importGraphs: codeGraphInputs.importGraphs,
@@ -50470,7 +51844,6 @@ function completeTaskProjectionFreshness(root) {
     currentSourceTreeDigest: architectureDocumentationSourceTreeDigest(root, model, sourceFiles)
   });
 }
-
 // packages/surfaces/adapter-likec4/src/index.ts
 init_src();
 function exportLikeC4Model(model) {
@@ -50691,7 +52064,7 @@ var LOCAL_MCP_TOOLS = [
   {
     name: "archcontext_plan_update",
     inputSchema: MCP_TOOL_INPUT_SCHEMAS.archcontext_plan_update,
-    description: "Create a ChangeSet draft and preview for architecture model updates. Does not write files.",
+    description: "Create a ChangeSet draft and preview for architecture model updates. When the plan writes a node file, preview.ownershipDelta lists the files that become owned, change owner, become contested or become unowned. Does not write files.",
     annotations: { safety: "idempotent", requiresConfirmation: false }
   },
   {
@@ -51134,6 +52507,9 @@ class RuntimeVersionUnsupportedError extends Error {
 
 class RefactorFlagError extends Error {
 }
+
+class CliUsageError extends Error {
+}
 var AUDIT_RUN_STATUSES = ["pending", "issuing", "issued", "failed"];
 var AUDIT_GLOBAL_VALUE_FLAGS = ["--format"];
 var AUDIT_GLOBAL_BOOLEAN_FLAGS = ["--json"];
@@ -51141,6 +52517,17 @@ var AUDIT_RUN_VALUE_FLAGS = ["--task-session-id", "--reason", "--risk", "--uncer
 var AUDIT_RUN_BOOLEAN_FLAGS = ["--no-wait", ...AUDIT_GLOBAL_BOOLEAN_FLAGS];
 var AUDIT_APPROVE_VALUE_FLAGS = ["--run-id", "--confirm-public-repo", ...AUDIT_GLOBAL_VALUE_FLAGS];
 var AUDIT_APPROVE_BOOLEAN_FLAGS = ["--resume", ...AUDIT_GLOBAL_BOOLEAN_FLAGS];
+var CLI_DOCS_ANCHORS_HELP = {
+  usage: "archctx docs anchors [--profile default|repo-harness/v1] [--json]",
+  description: "Read-only check of citations in human-owned module document regions and node summary/responsibilities. It reports missing-path, missing-symbol, line-out-of-range and line-moved per node. It is a signal, not a gate: the result stays ok when it has findings.",
+  options: {
+    "--profile <profile>": "Layout whose module documents are read (default: the committed manifest profile; default without a manifest).",
+    "--json": "Accepted for symmetry; output is always JSON.",
+    "--help, -h": "Show help without reading the repository."
+  },
+  writes: "none; no daemon, no local store. Without a CodeGraph index, path and line checks still run and symbol checks are reported as unchecked (codegraph-unavailable).",
+  capability: "docs-anchors-v1"
+};
 function refactorFlagValue(args, flag) {
   const index = args.indexOf(flag);
   if (index === -1)
@@ -51153,39 +52540,6 @@ function refactorFlagValueAt(args, index, flag) {
     throw new RefactorFlagError(`refactor ${flag} requires a value`);
   return value;
 }
-if (__require.main == __require.module) {
-  if (command === "capabilities") {
-    const result = await runCli(command, args, process.cwd());
-    if ("ok" in result) {
-      process.stdout.write(`${renderResult(result, "json")}
-`);
-      if (result.ok === false)
-        process.exitCode = 1;
-    } else {
-      process.stdout.write(`${JSON.stringify(result, null, 2)}
-`);
-    }
-  } else if (command === "mcp" && args.length === 0) {
-    await runStdioMcpLoop(stdinLines(), (line) => process.stdout.write(`${line}
-`), (line) => process.stderr.write(`${line}
-`), { runtimeResolver: (root) => createOrStartRuntimeRpcClient(root) });
-  } else if (command === "daemon" && args[0] === "start" && args.includes("--foreground")) {
-    await runForegroundDaemon(process.cwd(), args).catch((error) => {
-      const message = error instanceof Error ? error.message : String(error);
-      process.stderr.write(`${message}
-`);
-      process.exitCode = isDaemonOwnedElsewhereError(message) ? DAEMON_OWNED_ELSEWHERE_EXIT_CODE : 1;
-    });
-  } else {
-    const result = await runCli(command, args, process.cwd()).catch((error) => errorEnvelope("cli", "AC_RUNTIME_UNAVAILABLE", error instanceof Error ? error.message : String(error)));
-    process.stdout.write(`${renderResult(result, readFlag(args, "--format") ?? "json")}
-`);
-    if (result.ok === false)
-      process.exitCode = 1;
-    if (command === "resolve")
-      process.exitCode = resolveCommandExitCode(result);
-  }
-}
 async function* stdinLines() {
   let buffer = "";
   for await (const chunk of process.stdin) {
@@ -51271,11 +52625,13 @@ async function runCliUnchecked(command = "help", args = [], cwd, deps = {}) {
         return (await runtime()).runtimeStatus(cwd);
       case "projection":
         return await runProjectionProtocolCommand2(args, cwd, runtime);
+      case "flows":
+        return runFlowsCommand(args, cwd);
       case "repo": {
         const subcommand = args[0] ?? "list";
         if (subcommand === "add") {
           const root = readFlag(args, "--root") ?? cwd;
-          if (resolve28(root) !== resolve28(cwd)) {
+          if (resolve29(root) !== resolve29(cwd)) {
             return errorEnvelope("repo.add", "AC_CAPABILITY_UNSUPPORTED", "Multi-repo architecture context is outside the Local Core MVP; run archctx inside one Git repository.");
           }
           const daemon = await runtime();
@@ -51359,6 +52715,8 @@ async function runCliUnchecked(command = "help", args = [], cwd, deps = {}) {
         return result.ok ? { ...result, data: paginate(result.data, args) } : result;
       }
       case "docs":
+        if (args[0] === "anchors")
+          return runDocsAnchorsCliCommand(args.slice(1), cwd);
         return await runDocsCommand(args, cwd, await runtime());
       case "agent-context":
         return await runAgentContextProjectionCommand2(args, cwd, await runtime());
@@ -51517,36 +52875,30 @@ async function runCliUnchecked(command = "help", args = [], cwd, deps = {}) {
             revocation: "archctx tunnel --revoke"
           }
         };
+      case "deps":
+        return runDepsCommand(args, cwd);
       case "resolve": {
+        if (args.includes("--help") || args.includes("-h"))
+          return okEnvelope("resolve", CLI_RESOLVE_HELP);
+        if (args.includes("--path") && args.includes("--paths-from")) {
+          return errorEnvelope("resolve", "AC_SCHEMA_INVALID", "resolve accepts exactly one of --path or --paths-from");
+        }
+        if (args.includes("--paths-from")) {
+          const read = await readResolvePathsFrom(args, cwd, deps);
+          if ("problem" in read)
+            return errorEnvelope("resolve", "AC_SCHEMA_INVALID", read.problem);
+          const model = loadNativeModelFromArchContext(cwd);
+          const outcomes = resolveArchitectureOwnersForPaths(model.nodes, read.paths);
+          return okEnvelope("resolve", { results: outcomes.map((outcome, index) => resolveResultData(read.paths[index], outcome)) });
+        }
         const path = readFlag(args, "--path");
         if (!path)
-          return errorEnvelope("resolve", "AC_SCHEMA_INVALID", "resolve requires --path");
+          return errorEnvelope("resolve", "AC_SCHEMA_INVALID", "resolve requires --path or --paths-from");
         if (!isRepoRelativePosixPath(path)) {
           return errorEnvelope("resolve", "AC_SCHEMA_INVALID", "resolve --path must be a repository-relative POSIX path");
         }
         const model = loadNativeModelFromArchContext(cwd);
-        const outcome = resolveArchitectureOwnerForPath(model.nodes, path);
-        if (outcome.status === "matched") {
-          const node = outcome.node;
-          return okEnvelope("resolve", {
-            matched: true,
-            ambiguous: false,
-            stableId: node.id,
-            kind: node.kind,
-            name: node.name,
-            ...node.source ? { source: node.source } : {},
-            ...node.extensions ? { extensions: node.extensions } : {}
-          });
-        }
-        if (outcome.status === "ambiguous") {
-          return okEnvelope("resolve", {
-            matched: false,
-            ambiguous: true,
-            path,
-            candidates: outcome.candidates.map((node) => node.id)
-          });
-        }
-        return okEnvelope("resolve", { matched: false, ambiguous: false, path });
+        return okEnvelope("resolve", resolveResultData(path, resolveArchitectureOwnerForPath(model.nodes, path)));
       }
       case "help":
       default:
@@ -51555,8 +52907,8 @@ async function runCliUnchecked(command = "help", args = [], cwd, deps = {}) {
           ok: true,
           requestId: "help",
           data: {
-            commands: ["capabilities", "projection", "init", "sync", "validate", "context", "status", "daemon", "state", "repo", "landscape", "ledger", "book", "recommendations", "refactor", "explore", "prepare", "practices", "checkpoint", "hook", "hooks", "investigate", "agents", "jobs", "audit", "plan", "apply", "hash", "review", "complete", "github", "manifest", "config", "mcp", "install", "uninstall", "doctor", "update", "paths", "privacy-audit", "export", "import", "resolve", "tunnel"],
-            examples: ["archctx init --name MyApp", "archctx projection run --request-json '{...}'", "archctx plan --id changeset.<id> --op update_entity_fields --path .archcontext/model/nodes/<node>.yaml --expected-hash sha256:<64-hex> --body '<complete YAML>'", "archctx plan --id changeset.<id> --op delete_entity --path .archcontext/model/flows/<flow>.yaml --expected-hash sha256:<64-hex>", "archctx hash --path .archcontext/model/nodes/<node>.yaml", "archctx plan --id changeset.<id> --operations-file <operations.json>", "archctx plan --id changeset.<id> --op update_entity_fields --path .archcontext/model/nodes/<node>.yaml --expected-hash sha256:<64-hex> --body-file <entity.yaml>", "archctx apply --id changeset.<id> --approved --expected-worktree-digest <draft.base.worktreeDigest>", "archctx state recover --from-git", "archctx ledger migrate --from-yaml --dry-run", "archctx ledger promote --mode authoritative --preflight --rollback-plan", "archctx book recommendations --open --explain", "archctx recommendations accept --id recommendation.<id> --reason 'Accepted after local readback.'", "archctx recommendations metrics", "archctx recommendations list --status rejected", "archctx refactor scan --json", "archctx refactor verify --request-json '{...}' --json", "archctx practices validate --strict", "archctx practices list --json", "archctx practices waivers", "archctx practices waive --practice-id modularity.no-new-cycle --owner team-architecture --reason 'External migration window requires this edge until cutover.' --review-at 2026-07-10T00:00:00.000Z --expires-at 2026-07-24T00:00:00.000Z --evidence-digest sha256:<64-hex> --subject module.a->module.b", "archctx checkpoint --task-session-id task_cli", "archctx investigate --runner-port codex", "archctx agents status --status queued,running", "archctx agents budget", "archctx hook enqueue --event post-edit --path src/app.ts", "archctx jobs list --status queued", "archctx audit consent", "archctx audit consent --revoke", "archctx audit run --reason 'quarterly architecture audit'", "archctx audit run --no-wait", "archctx audit list --status pending", "archctx audit show audit_run.<id>", "archctx audit approve audit_run.<id>", "archctx audit approve audit_run.<id> --confirm-public-repo public:<host>/<owner>/<repo>:<baseSha>:<runId>", "archctx audit approve audit_run.<id> --resume", "archctx hooks install --host codex", "archctx paths", "archctx update --check", "archctx doctor --check-updates", "archctx github connect", "archctx github status", "archctx daemon start", "archctx explore start --foreground", "archctx export likec4", "archctx import structurizr --content '<json>'", "archctx resolve --path packages/core/projection-engine/src/index.ts", "archctx tunnel"]
+            commands: ["capabilities", "projection", "init", "sync", "validate", "context", "status", "daemon", "state", "repo", "landscape", "ledger", "book", "recommendations", "refactor", "explore", "prepare", "practices", "checkpoint", "hook", "hooks", "investigate", "agents", "jobs", "audit", "plan", "apply", "hash", "review", "complete", "github", "manifest", "config", "mcp", "install", "uninstall", "doctor", "update", "paths", "privacy-audit", "export", "import", "resolve", "tunnel", "flows", "deps"],
+            examples: ["archctx init --name MyApp", "archctx projection run --request-json '{...}'", "archctx plan --id changeset.<id> --op update_entity_fields --path .archcontext/model/nodes/<node>.yaml --expected-hash sha256:<64-hex> --body '<complete YAML>'", "archctx plan --id changeset.<id> --op delete_entity --path .archcontext/model/flows/<flow>.yaml --expected-hash sha256:<64-hex>", "archctx hash --path .archcontext/model/nodes/<node>.yaml", "archctx plan --id changeset.<id> --operations-file <operations.json>", "archctx plan --id changeset.<id> --op update_entity_fields --path .archcontext/model/nodes/<node>.yaml --expected-hash sha256:<64-hex> --body-file <entity.yaml>", "archctx apply --id changeset.<id> --approved --expected-worktree-digest <draft.base.worktreeDigest>", "archctx state recover --from-git", "archctx ledger migrate --from-yaml --dry-run", "archctx ledger promote --mode authoritative --preflight --rollback-plan", "archctx book recommendations --open --explain", "archctx recommendations accept --id recommendation.<id> --reason 'Accepted after local readback.'", "archctx recommendations metrics", "archctx recommendations list --status rejected", "archctx refactor scan --json", "archctx refactor verify --request-json '{...}' --json", "archctx practices validate --strict", "archctx practices list --json", "archctx practices waivers", "archctx practices waive --practice-id modularity.no-new-cycle --owner team-architecture --reason 'External migration window requires this edge until cutover.' --review-at 2026-07-10T00:00:00.000Z --expires-at 2026-07-24T00:00:00.000Z --evidence-digest sha256:<64-hex> --subject module.a->module.b", "archctx checkpoint --task-session-id task_cli", "archctx investigate --runner-port codex", "archctx agents status --status queued,running", "archctx agents budget", "archctx hook enqueue --event post-edit --path src/app.ts", "archctx jobs list --status queued", "archctx audit consent", "archctx audit consent --revoke", "archctx audit run --reason 'quarterly architecture audit'", "archctx audit run --no-wait", "archctx audit list --status pending", "archctx audit show audit_run.<id>", "archctx audit approve audit_run.<id>", "archctx audit approve audit_run.<id> --confirm-public-repo public:<host>/<owner>/<repo>:<baseSha>:<runId>", "archctx audit approve audit_run.<id> --resume", "archctx hooks install --host codex", "archctx paths", "archctx update --check", "archctx doctor --check-updates", "archctx github connect", "archctx github status", "archctx daemon start", "archctx explore start --foreground", "archctx docs anchors --json", "archctx export likec4", "archctx import structurizr --content '<json>'", "archctx resolve --path packages/core/projection-engine/src/index.ts", "archctx tunnel", "archctx refactor scan --import-node-limit 100000 --json", "archctx resolve --paths-from changed-paths.txt", "archctx flows check --json", "archctx recommendations defer --id recommendation.<id> --import-node-limit 100000 --reason 'Scanned with the same limit.'", "archctx deps --json", "archctx deps --into capability.<id> --json"]
           }
         };
     }
@@ -51965,7 +53317,10 @@ async function runRecommendationsCommand(args, cwd, daemon) {
     if (!recommendationId || recommendationId.startsWith("--")) {
       return errorEnvelope("recommendations.show", "AC_SCHEMA_INVALID", "recommendations show requires --id");
     }
-    return daemon.recommendations(cwd, { command: "show", recommendationId });
+    const importNodeLimit = recommendationsImportNodeLimit(args);
+    if (importNodeLimit === null)
+      return recommendationsImportNodeLimitError("show");
+    return daemon.recommendations(cwd, { command: "show", recommendationId, ...importNodeLimit === undefined ? {} : { importNodeLimit } });
   }
   if (subcommand === "list") {
     const status = readFlag(args, "--status");
@@ -51981,6 +53336,9 @@ async function runRecommendationsCommand(args, cwd, daemon) {
   const reason = readFlag(args, "--reason");
   if (!reason)
     return errorEnvelope(`recommendations.${subcommand}`, "AC_SCHEMA_INVALID", `recommendations ${subcommand} requires --reason`);
+  const importNodeLimit = recommendationsImportNodeLimit(args);
+  if (importNodeLimit === null)
+    return recommendationsImportNodeLimitError(subcommand);
   const input = {
     command: subcommand,
     recommendationId,
@@ -51990,11 +53348,25 @@ async function runRecommendationsCommand(args, cwd, daemon) {
     ...readFlag(args, "--source") === undefined ? {} : { source: readFlag(args, "--source") },
     ...readFlag(args, "--expected-worktree-digest") === undefined ? {} : { expectedWorktreeDigest: readFlag(args, "--expected-worktree-digest") },
     ...readFlag(args, "--evidence-digest") === undefined ? {} : { evidenceDigest: readFlag(args, "--evidence-digest") },
+    ...importNodeLimit === undefined ? {} : { importNodeLimit },
     ...readFlag(args, "--agent-job-id") === undefined ? {} : { agentJobId: readFlag(args, "--agent-job-id") },
     ...readFlag(args, "--now") === undefined ? {} : { now: readFlag(args, "--now") }
   };
   return daemon.recommendations(cwd, input);
 }
+function recommendationsImportNodeLimit(args) {
+  const index = args.indexOf("--import-node-limit");
+  if (index === -1)
+    return;
+  const raw = args[index + 1];
+  return raw === undefined ? null : importNodeLimitValue(raw) ?? null;
+}
+function recommendationsImportNodeLimitError(subcommand) {
+  return errorEnvelope(`recommendations.${subcommand}`, "AC_SCHEMA_INVALID", `recommendations ${subcommand} --import-node-limit must be a positive integer`);
+}
+function importNodeLimitValue(raw) {
+  return /^[0-9]+$/.test(raw) && Number(raw) >= 1 ? Number(raw) : undefined;
+}
 async function runRefactorCommand(args, cwd, runtime) {
   const subcommand = args[0] ?? "scan";
   if (subcommand !== "scan" && subcommand !== "record" && subcommand !== "verify") {
@@ -52004,17 +53376,27 @@ async function runRefactorCommand(args, cwd, runtime) {
   try {
     if (subcommand === "scan") {
       const raw = refactorFlagValue(args, "--request-json");
-      if (raw === undefined)
+      const limitRaw = refactorFlagValue(args, "--import-node-limit");
+      if (raw === undefined && limitRaw === undefined)
         return (await runtime()).refactorScan(cwd, {});
-      let request;
-      try {
-        request = JSON.parse(raw);
-      } catch (error) {
-        return errorEnvelope(surface, "AC_SCHEMA_INVALID", `refactor scan --request-json is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+      let request = { schemaVersion: REFACTOR_REQUEST_SCHEMA_VERSION, scope: { kind: "repository" } };
+      if (raw !== undefined) {
+        try {
+          request = JSON.parse(raw);
+        } catch (error) {
+          return errorEnvelope(surface, "AC_SCHEMA_INVALID", `refactor scan --request-json is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+        }
       }
       if (typeof request !== "object" || request === null || Array.isArray(request)) {
         return errorEnvelope(surface, "AC_SCHEMA_INVALID", "refactor scan --request-json must be a RefactorRequestV1 object");
       }
+      if (limitRaw !== undefined) {
+        const importNodeLimit = importNodeLimitValue(limitRaw);
+        if (importNodeLimit === undefined) {
+          return errorEnvelope(surface, "AC_SCHEMA_INVALID", "refactor scan --import-node-limit must be a positive integer");
+        }
+        request = { ...request, importNodeLimit };
+      }
       const issues = refactorRequestInvariantIssues(request);
       if (issues.length > 0)
         return errorEnvelope(surface, "AC_SCHEMA_INVALID", issues.join("; "));
@@ -52034,6 +53416,14 @@ async function runRefactorCommand(args, cwd, runtime) {
       if (typeof request !== "object" || request === null || Array.isArray(request)) {
         return errorEnvelope(surface, "AC_SCHEMA_INVALID", "refactor verify --request-json must be a RefactorVerificationRequestV1 object");
       }
+      const limitRaw = refactorFlagValue(args, "--import-node-limit");
+      if (limitRaw !== undefined) {
+        const importNodeLimit = importNodeLimitValue(limitRaw);
+        if (importNodeLimit === undefined) {
+          return errorEnvelope(surface, "AC_SCHEMA_INVALID", "refactor verify --import-node-limit must be a positive integer");
+        }
+        request = { ...request, importNodeLimit };
+      }
       const issues = refactorVerificationRequestInvariantIssues(request);
       if (issues.length > 0)
         return errorEnvelope(surface, "AC_SCHEMA_INVALID", issues.join("; "));
@@ -52060,7 +53450,7 @@ async function runDocsCommand(args, cwd, daemon) {
     return runArchitectureDocsProjectionCommand2(args, cwd, daemon);
   }
   if (!["status", "resolve", "pin", "fetch", "purge"].includes(subcommand)) {
-    return errorEnvelope("docs", "AC_SCHEMA_INVALID", "docs requires status|resolve|pin|fetch|purge|plan|apply|adopt|drift|clean");
+    return errorEnvelope("docs", "AC_SCHEMA_INVALID", "docs requires status|resolve|pin|fetch|purge|plan|apply|adopt|drift|clean|anchors");
   }
   if (subcommand === "status") {
     return daemon.docs(cwd, { command: "status", provider: "context7" });
@@ -52101,6 +53491,27 @@ async function runDocsCommand(args, cwd, daemon) {
     all: args.includes("--all")
   });
 }
+function runDocsAnchorsCliCommand(args, cwd) {
+  if (args.includes("--help") || args.includes("-h"))
+    return okEnvelope("help", CLI_DOCS_ANCHORS_HELP);
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--json")
+      continue;
+    if (arg === "--profile" && args[index + 1] !== undefined && !args[index + 1].startsWith("--")) {
+      index += 1;
+      continue;
+    }
+    return errorEnvelope("docs.anchors", "AC_SCHEMA_INVALID", `docs anchors does not accept ${arg}; use --help`);
+  }
+  let profile;
+  try {
+    profile = architectureProjectionProfile(args);
+  } catch (error) {
+    return errorEnvelope("docs.anchors", "AC_SCHEMA_INVALID", error instanceof Error ? error.message : String(error));
+  }
+  return runDocsAnchorsCommand(cwd, profile ? { profile } : {});
+}
 async function runArchitectureDocsProjectionCommand2(args, cwd, daemon) {
   const action = args[0] ?? "plan";
   try {
@@ -52146,6 +53557,21 @@ async function runProjectionProtocolCommand2(args, cwd, runtime) {
   }
   return (await runtime()).projection(findRepositoryRoot2(cwd), { action, request });
 }
+function runFlowsCommand(args, cwd) {
+  if (args.includes("--help") || args.includes("-h"))
+    return okEnvelope("flows", {
+      command: "archctx flows check [--json]",
+      description: "Check every declared flow selector against the CodeGraph index without rendering a projection.",
+      statuses: "Each selector reports proven, no-direct-call, only-references, false-builtin-call, ambiguous-symbol, evidence-missing or evidence-truncated. Only proven binds a flow step.",
+      writes: "none; runs in-process with no daemon, local store or task session. Like projection check, it runs codegraph sync first."
+    });
+  const formatAt = args.indexOf("--format");
+  const unexpected = args.slice(1).filter((arg, index) => arg !== "--json" && (formatAt < 0 || index + 1 !== formatAt && index !== formatAt));
+  if (args[0] !== "check" || unexpected.length > 0) {
+    return errorEnvelope("flows", "AC_SCHEMA_INVALID", "flows requires check [--json]; use --help");
+  }
+  return runFlowSelectorCheckCommand(cwd);
+}
 function acceptedArchitectureChange(args) {
   const changeSetId = readFlag(args, "--accepted-change-set-id");
   const eventId = readFlag(args, "--accepted-event-id");
@@ -52520,12 +53946,12 @@ function auditManifestGateRoot(cwd) {
   }
 }
 function auditGithubIssuesEnabled(cwd) {
-  const manifestPath = resolve28(auditManifestGateRoot(cwd), ".archcontext/manifest.yaml");
-  if (!existsSync27(manifestPath))
+  const manifestPath = resolve29(auditManifestGateRoot(cwd), ".archcontext/manifest.yaml");
+  if (!existsSync28(manifestPath))
     return false;
   let raw;
   try {
-    raw = readFileSync27(manifestPath, "utf8");
+    raw = readFileSync28(manifestPath, "utf8");
   } catch {
     return false;
   }
@@ -52768,7 +54194,7 @@ async function runAuditCommand(args, cwd, runtime) {
     const elapsedSeconds = Math.round((Date.now() - (deadline - pollTimeoutMs)) / 1000);
     process.stderr.write(`archctx audit run: ${jobId} is still running (${elapsedSeconds}s elapsed)...
 `);
-    await sleep(pollIntervalMs);
+    await sleep2(pollIntervalMs);
   }
   return errorEnvelope("audit.run", "AC_PRECONDITION_FAILED", `archctx audit run: job ${jobId} has not reached a terminal status after ${Math.round(pollTimeoutMs / 1000)}s; this is not a failure, the daemon may still be running it \u2014 check later with: archctx audit list`);
 }
@@ -52907,8 +54333,8 @@ async function runGithubCommand(args, cwd, deps) {
   }
   if (subcommand === "disconnect") {
     const connection = await deps.githubConnectionReader?.readVerifiedConnection({ repositoryRoot: cwd });
-    const localRecordRemoved = existsSync27(connectionPath);
-    rmSync16(connectionPath, { force: true });
+    const localRecordRemoved = existsSync28(connectionPath);
+    rmSync15(connectionPath, { force: true });
     return okEnvelope("github.disconnect", {
       connected: connection !== undefined,
       localRecordRemoved,
@@ -53187,7 +54613,7 @@ function readPullRequestNumber(args) {
     return;
   const value = Number(raw);
   if (!Number.isInteger(value) || value < 1)
-    throw new Error("--pr must be a positive integer");
+    throw new CliUsageError("--pr must be a positive integer");
   return value;
 }
 async function digestReviewChallenge(challenge) {
@@ -53219,7 +54645,7 @@ async function readReviewChallengeV2Arg(args, cwd, commandName = "github verify-
   if (!inline && !challengePath)
     return { ok: false, message: `${commandName} requires --challenge-json or --challenge-path` };
   try {
-    const raw = inline ?? readFileSync27(resolve28(cwd, challengePath), "utf8");
+    const raw = inline ?? readFileSync28(resolve29(cwd, challengePath), "utf8");
     const parsed = JSON.parse(raw);
     const attestation = await Promise.resolve().then(() => (init_src6(), {}));
     const assertReviewChallengeV2 = assertReviewChallengeV22;
@@ -53600,7 +55026,7 @@ function readLatestPackageVersion(env) {
   if (env[LATEST_VERSION_ENV]) {
     return { source: "env", version: env[LATEST_VERSION_ENV] };
   }
-  const result = withLocalEgress("npm-update-check", () => spawnSync3("npm", ["view", RELEASE_PACKAGE_NAME, "version", "--json"], {
+  const result = withLocalEgress("npm-update-check", () => spawnSync4("npm", ["view", RELEASE_PACKAGE_NAME, "version", "--json"], {
     encoding: "utf8",
     timeout: NPM_VIEW_TIMEOUT_MS,
     shell: false
@@ -53694,10 +55120,10 @@ function doctorSqlite(cwd) {
   const legacyLocalStore = inspectLegacyLocalStoreMigration(cwd);
   return {
     path,
-    exists: existsSync27(path),
+    exists: existsSync28(path),
     migrations: productVersionManifest().runtime.sqliteMigrations,
     legacyPath: paths.legacyLocalStorePath,
-    legacyExists: existsSync27(paths.legacyLocalStorePath),
+    legacyExists: existsSync28(paths.legacyLocalStorePath),
     legacyLocalStore
   };
 }
@@ -53728,7 +55154,7 @@ function runtimePathsReport(cwd) {
   };
 }
 function pathAccess(path) {
-  const exists = existsSync27(path);
+  const exists = existsSync28(path);
   return {
     path,
     exists,
@@ -53789,14 +55215,14 @@ async function createOrStartRuntimeRpcClient(cwd) {
     throw new RuntimeVersionUnsupportedError(fileIssue);
   const client = createRuntimeRpcClientFromConnectionFile(cwd);
   if (client) {
-    const health = await client.health().catch(() => {
-      return;
-    });
+    const { health, unresponsivePid } = await probeDaemonHealth(client);
     const healthIssue = runtimeRpcCompatibilityIssueFromHealth(cwd, client, health);
     if (healthIssue)
       throw new RuntimeVersionUnsupportedError(healthIssue);
     if (health?.ok === true)
       return client;
+    if (unresponsivePid !== undefined)
+      throw new Error(unresponsiveDaemonMessage(unresponsivePid));
     recoverStaleDaemonControlFiles(cwd, { removeUnhealthyConnection: true });
   } else {
     recoverStaleDaemonControlFiles(cwd);
@@ -53878,16 +55304,16 @@ async function runDaemonCommand(args, cwd) {
         return okEnvelope("daemon.status", incompatibleDaemonStatus(compatibilityIssue));
       }
       const recovery = recoverStaleDaemonControlFiles(cwd);
+      const lockOwnerPid = liveDaemonLockOwnerPid(cwd);
       return okEnvelope("daemon.status", {
         running: false,
         protocol: "http-loopback",
         connectionPath: defaultDaemonConnectionPath(cwd),
+        ...lockOwnerPid === undefined ? {} : { lockOwnerPid, action: orphanedDaemonMessage(lockOwnerPid) },
         ...recoveryData(recovery)
       });
     }
-    const health = await client.health().catch(() => {
-      return;
-    });
+    const { health, unresponsivePid } = await probeDaemonHealth(client);
     const healthIssue = runtimeRpcCompatibilityIssueFromHealth(cwd, client, health);
     if (healthIssue) {
       return okEnvelope("daemon.status", incompatibleDaemonStatus(healthIssue));
@@ -53906,6 +55332,16 @@ async function runDaemonCommand(args, cwd) {
         token: "stored-in-connection-file"
       });
     }
+    if (unresponsivePid !== undefined) {
+      return okEnvelope("daemon.status", {
+        running: true,
+        responding: false,
+        pid: unresponsivePid,
+        protocol: "http-loopback",
+        connectionPath: client.connectionInfo().connectionPath,
+        action: unresponsiveDaemonMessage(unresponsivePid)
+      });
+    }
     const recovery = recoverStaleDaemonControlFiles(cwd, { removeUnhealthyConnection: true });
     return okEnvelope("daemon.status", {
       running: false,
@@ -53945,6 +55381,9 @@ async function startBackgroundDaemon(args, cwd) {
   if (discovered.compatibilityIssue?.pidAlive) {
     return errorEnvelope("daemon.start", "AC_RUNTIME_VERSION_UNSUPPORTED", runtimeVersionUnsupportedMessage(discovered.compatibilityIssue));
   }
+  if (discovered.unresponsivePid !== undefined) {
+    return errorEnvelope("daemon.start", "AC_RUNTIME_UNAVAILABLE", unresponsiveDaemonMessage(discovered.unresponsivePid));
+  }
   if (discovered.info) {
     return okEnvelope("daemon.start", {
       running: true,
@@ -53986,7 +55425,7 @@ async function startBackgroundDaemon(args, cwd) {
     child.unref();
     const ready = await waitForDaemonReady(cwd, daemonStartTimeoutMs(args), () => childError !== undefined || childExit !== undefined && childExit.code !== DAEMON_OWNED_ELSEWHERE_EXIT_CODE);
     if (!ready) {
-      return errorEnvelope("daemon.start", "AC_RUNTIME_UNAVAILABLE", daemonStartFailureMessage(logPath, childExit, childError));
+      return errorEnvelope("daemon.start", "AC_RUNTIME_UNAVAILABLE", daemonStartFailureMessage(cwd, logPath, child.pid, childExit, childError));
     }
     return okEnvelope("daemon.start", {
       running: true,
@@ -54056,9 +55495,7 @@ async function discoverRunningDaemonInfo(cwd, options = {}) {
       recovery: options.recoverStale ? recoverStaleDaemonControlFiles(cwd) : emptyRecovery(cwd)
     };
   }
-  const health = await client.health().catch(() => {
-    return;
-  });
+  const { health, unresponsivePid } = await probeDaemonHealth(client);
   const compatibilityIssue = runtimeRpcCompatibilityIssueFromHealth(cwd, client, health) ?? cliEntryStalenessIssue(cwd);
   if (compatibilityIssue) {
     return {
@@ -54070,6 +55507,9 @@ async function discoverRunningDaemonInfo(cwd, options = {}) {
   if (health?.ok === true) {
     return { info: client.connectionInfo(), compatibilityIssue: undefined, recovery: emptyRecovery(cwd) };
   }
+  if (unresponsivePid !== undefined) {
+    return { info: undefined, compatibilityIssue: undefined, unresponsivePid, recovery: emptyRecovery(cwd) };
+  }
   return {
     info: undefined,
     compatibilityIssue: undefined,
@@ -54135,12 +55575,30 @@ function runtimeVersionUnsupportedMessage(issue) {
   }
   return `archctxd RPC version ${issue.received} is incompatible with this CLI (${issue.expected}); run ${issue.upgradeCommand} to replace the local daemon.`;
 }
+async function probeDaemonHealth(client) {
+  try {
+    return { health: await client.health() };
+  } catch (error) {
+    const pid = client.connectionInfo().pid;
+    const busy = error instanceof RuntimeRpcTransportError && error.code === "RPC_TIMEOUT" && typeof pid === "number" && isPidAlive(pid);
+    return { health: undefined, ...busy ? { unresponsivePid: pid } : {} };
+  }
+}
+function stopProcessCommand(pid) {
+  return process.platform === "win32" ? `taskkill /PID ${pid}` : `kill -TERM ${pid}`;
+}
+function unresponsiveDaemonMessage(pid) {
+  return `archctxd pid ${pid} is alive but did not answer its health check in time; it is likely busy, so its connection file was kept. Retry later, or stop it with \`${stopProcessCommand(pid)}\` and run the command again.`;
+}
+function orphanedDaemonMessage(pid) {
+  return `the daemon lock names live pid ${pid}, but no connection file points to it; stop it with \`${stopProcessCommand(pid)}\`, then run the command again.`;
+}
 async function waitForPidExit(pid, timeoutMs) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     if (!isPidAlive(pid))
       return true;
-    await sleep(50);
+    await sleep2(50);
   }
   return !isPidAlive(pid);
 }
@@ -54169,9 +55627,11 @@ function daemonStartTimeoutMs(args) {
   const parsed = Number(configured);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : DAEMON_START_TIMEOUT_MS;
 }
-function daemonStartFailureMessage(logPath, childExit, childError) {
+function daemonStartFailureMessage(cwd, logPath, childPid, childExit, childError) {
   const childState = childError ? `childError=${childError.message}` : childExit ? `childExit=${childExit.code ?? "null"}/${childExit.signal ?? "none"}` : "childState=still-running";
-  return `archctxd did not become ready; ${childState}; log=${logPath}; logTail=${readFileTail(logPath)}`;
+  const lockOwnerPid = existsSync28(defaultDaemonConnectionPath(cwd)) ? undefined : liveDaemonLockOwnerPid(cwd);
+  const owner = lockOwnerPid === undefined || lockOwnerPid === childPid ? "" : `; ${orphanedDaemonMessage(lockOwnerPid)}`;
+  return `archctxd did not become ready; ${childState}${owner}; log=${logPath}; logTail=${readFileTail(logPath)}`;
 }
 async function waitForDaemonReady(cwd, timeoutMs, shouldStop) {
   const deadline = Date.now() + timeoutMs;
@@ -54181,16 +55641,16 @@ async function waitForDaemonReady(cwd, timeoutMs, shouldStop) {
       return ready;
     if (shouldStop?.())
       return;
-    await sleep(50);
+    await sleep2(50);
   }
   return;
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function readFileTail(path, maxBytes = 4096) {
   try {
-    const content = readFileSync27(path, "utf8");
+    const content = readFileSync28(path, "utf8");
     return content.slice(Math.max(0, content.length - maxBytes)).replace(/\s+/g, " ").trim();
   } catch {
     return "<unavailable>";
@@ -54254,19 +55714,109 @@ function resolveCommandExitCode(result) {
   if (!result || result.ok !== true)
     return 1;
   const data = result.data;
+  if (Array.isArray(data?.results))
+    return data.results.some((entry) => entry.ambiguous === true) ? 2 : 0;
   if (data?.matched === true)
     return 0;
   if (data?.ambiguous === true)
     return 2;
   return 1;
 }
+var CLI_RESOLVE_HELP = {
+  command: "archctx resolve (--path <repo-relative path> | --paths-from <file> | --paths-from -)",
+  rule: "ADR-0043. source.exclude applies first. When every matching node lies on one parent chain, the deepest node owns the path; refactor scan uses the same rule. When matching nodes lie on different chains, an ancestor yields to its own descendant, then the longest literal source.include prefix wins, and an equal-length tie is ambiguous.",
+  batch: "--paths-from reads one repository-relative POSIX path per line from a file (relative to the current directory) or from stdin (-). Blank lines are ignored and surrounding whitespace is trimmed. The model loads once. data.results has one entry per input path, in input order. The command reads no daemon state and no CodeGraph index.",
+  result: "Each result carries path, matched, ambiguous and owningCapabilityId. A match adds stableId, kind, name, source and extensions of the most specific node. An ambiguous result adds candidates. owningCapabilityId is the nearest kind: capability node on the owner's parent chain (the owner itself when it is a capability), or null. For an ambiguous result it is set only when all candidates share one owning capability.",
+  exitCodes: "--path: 0 matched, 1 no match or error, 2 ambiguous. --paths-from: 0 when no path is ambiguous (unowned paths included), 2 when any path is ambiguous, 1 on error."
+};
+function resolveResultData(path, outcome) {
+  if (outcome.status === "matched") {
+    const node = outcome.node;
+    return {
+      path,
+      matched: true,
+      ambiguous: false,
+      stableId: node.id,
+      kind: node.kind,
+      name: node.name,
+      owningCapabilityId: outcome.owningCapabilityId,
+      ...node.source ? { source: node.source } : {},
+      ...node.extensions ? { extensions: node.extensions } : {}
+    };
+  }
+  if (outcome.status === "ambiguous") {
+    return { path, matched: false, ambiguous: true, candidates: outcome.candidates.map((node) => node.id), owningCapabilityId: outcome.owningCapabilityId };
+  }
+  return { path, matched: false, ambiguous: false, owningCapabilityId: null };
+}
+async function readResolvePathsFrom(args, cwd, deps) {
+  const source = readFlag(args, "--paths-from");
+  if (source === undefined || source.startsWith("--"))
+    return { problem: "resolve --paths-from requires a file path or - for stdin" };
+  let content;
+  try {
+    content = source === "-" ? await (deps.readStdin ? deps.readStdin() : readFileSync28(0, "utf8")) : readFileSync28(resolve29(cwd, source), "utf8");
+  } catch (error) {
+    return { problem: `resolve --paths-from ${source} is not readable: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  const paths = [];
+  for (const [index, line] of content.split(`
+`).entries()) {
+    const path = line.trim();
+    if (path === "")
+      continue;
+    if (!isRepoRelativePosixPath(path))
+      return { problem: `resolve --paths-from line ${index + 1} must be a repository-relative POSIX path: ${path}` };
+    paths.push(path);
+  }
+  return { paths };
+}
 var CLI_PLAN_ENTITY_FLAGS = ["--op", "--path", "--expected-hash", "--body", "--body-file"];
+var CLI_DEPS_HELP = {
+  command: "archctx deps [--from <node-id>] [--into <node-id>] [--import-node-limit <n>] [--edge-limit <n>] [--json]",
+  description: "Read-only capability x capability import matrix. The command reads the model files, the HEAD tree and the CodeGraph index. It writes nothing and needs no daemon.",
+  rule: "Each file gets its owners from the parent-chain rule refactor scan uses. Each owner rolls up to the nearest kind: capability node on its parent chain. An edge counts in data.matrix only when both files roll up to exactly one capability. Other edges count in data.imports.unattributed by cause.",
+  filters: "--from <node-id> keeps edges whose importing file the node or a descendant owns. --into <node-id> keeps edges whose imported file the node or a descendant owns. An unknown node id is AC_SCHEMA_INVALID.",
+  imports: "data.imports reports coverage, reasonCodes, truncated, importNodeCount, importNodeLimit and importNodeLimitExceeded from the CodeGraph import read. A missing or stale index gives coverage unknown and an empty matrix. --import-node-limit raises the read cap (default 50000).",
+  calls: "Call counts are not available in v1. data.calls.coverage is unknown with reason call-edges-not-exposed, and every cell has calls: null.",
+  edges: "data.edges lists the attributed file-level edges behind the matrix, sorted by path, up to --edge-limit (default 200). data.edges.count is the full total."
+};
+function runDepsCommand(args, cwd) {
+  if (args.includes("--help") || args.includes("-h"))
+    return okEnvelope("deps", CLI_DEPS_HELP);
+  const importNodeLimit = readOptionalPositiveIntegerFlag(args, "--import-node-limit", "deps");
+  if (!importNodeLimit.ok)
+    return importNodeLimit.envelope;
+  const edgeLimit = readOptionalNonNegativeIntegerFlag(args, "--edge-limit", "deps");
+  if (!edgeLimit.ok)
+    return edgeLimit.envelope;
+  const from = readFlag(args, "--from");
+  const into = readFlag(args, "--into");
+  for (const [flag, value] of [["--from", from], ["--into", into]]) {
+    if (args.includes(flag) && (value === undefined || value.startsWith("--"))) {
+      return errorEnvelope("deps", "AC_SCHEMA_INVALID", `deps ${flag} requires a node id`);
+    }
+  }
+  try {
+    return okEnvelope("deps", readCapabilityDependencies(findRepositoryRoot2(cwd), {
+      ...from === undefined ? {} : { from },
+      ...into === undefined ? {} : { into },
+      ...importNodeLimit.value === undefined ? {} : { importNodeLimit: importNodeLimit.value },
+      ...edgeLimit.value === undefined ? {} : { edgeLimit: edgeLimit.value }
+    }));
+  } catch (error) {
+    if (error instanceof CapabilityDependenciesError)
+      return errorEnvelope("deps", error.code, error.message);
+    throw error;
+  }
+}
 var CLI_PLAN_HELP = {
-  command: "archctx plan --id <changeset.id> (--op <create_entity|update_entity_fields|delete_entity> --path <file> [--expected-hash sha256:<64-hex>] [--body <yaml> | --body - | --body-file <path>] | --operations-file <operations.json>)",
-  operations: "--operations-file takes a repository-relative path to a JSON array of operations in the archcontext_plan_update MCP shape and plans them as one ChangeSet; it cannot be combined with --op, --path, --expected-hash, --body or --body-file.",
-  body: "--body is the complete new YAML document, not a field patch. Give exactly one of --body <yaml>, --body - (stdin) or --body-file <path>. --body-file and --operations-file read only repository-relative files inside the repository (no absolute or .. paths, no symlinks); content from outside the repository must come through --body - (stdin). delete_entity accepts no body.",
+  command: "archctx plan --id <changeset.id> (--op <create_entity|update_entity_fields|delete_entity> --path <file> [--expected-hash sha256:<64-hex>] [--body <yaml> | --body - | --body-file <path>] | --operations-file <operations.json | ->)",
+  operations: "--operations-file takes a repository-relative path to a JSON array of operations in the archcontext_plan_update MCP shape, or - to read that array from stdin, and plans them as one ChangeSet; it cannot be combined with --op, --path, --expected-hash, --body or --body-file.",
+  body: "--body is the complete new YAML document, not a field patch. Give exactly one of --body <yaml>, --body - (stdin) or --body-file <path>. --body-file and --operations-file read only repository-relative files inside the repository (no absolute or .. paths, no symlinks); content from outside the repository must come through stdin (--body - or --operations-file -). delete_entity accepts no body.",
   expectedHash: "digestJson({ body }) of the file's current UTF-8 contents, not sha256sum of the file. Read it with `archctx hash --path <file>`; use `missing` (the create default) for a new file.",
   drafts: "A draft lives in daemon memory. Planning the same --id again replaces it, and a daemon restart between plan and apply drops it: apply then fails with `Unknown ChangeSet`; plan again.",
+  ownershipDelta: "When the plan writes a node file, data.preview.ownershipDelta compares file ownership before and after the planned model over the files the HEAD tree carries, with the parent-chain rule refactor scan uses. becameOwned, becameContested, ownerChanged and becameUnowned each give count, up to 50 files with before and after owners, and omittedCount. status unavailable gives the reason, for example a planned body that does not parse. Read-only.",
   next: "archctx apply --id <changeset.id> --approved --expected-worktree-digest <draft.base.worktreeDigest>"
 };
 var CLI_HASH_HELP = {
@@ -54295,7 +55845,7 @@ function readRepositoryInputFile(cwd, flag, file) {
     const absolute = assertPathHasNoSymlinkSegments2(cwd, file);
     if (!statSync10(absolute).isFile())
       return { problem: `plan ${flag} ${file} is not a regular file` };
-    return { content: readFileSync27(absolute, "utf8") };
+    return { content: readFileSync28(absolute, "utf8") };
   } catch (error) {
     return { problem: `plan ${flag} ${file} is not readable: ${error instanceof Error ? error.message : String(error)}` };
   }
@@ -54313,10 +55863,10 @@ function runHashCommand(args, cwd) {
   } catch (error) {
     return errorEnvelope("hash", "AC_SCHEMA_INVALID", error instanceof Error ? error.message : String(error));
   }
-  if (!existsSync27(absolute) || !statSync10(absolute).isFile()) {
+  if (!existsSync28(absolute) || !statSync10(absolute).isFile()) {
     return errorEnvelope("hash", "AC_SCHEMA_INVALID", `hash --path is not an existing file: ${path}`);
   }
-  return okEnvelope("hash", { path, hash: digestJson({ body: readFileSync27(absolute, "utf8") }) });
+  return okEnvelope("hash", { path, hash: digestJson({ body: readFileSync28(absolute, "utf8") }) });
 }
 async function readCliPlanOperations(args, cwd, deps) {
   if (args.includes("--operations-file")) {
@@ -54326,7 +55876,7 @@ async function readCliPlanOperations(args, cwd, deps) {
     const file = readFlag(args, "--operations-file");
     if (!file)
       return "plan --operations-file requires a path";
-    const read = readRepositoryInputFile(cwd, "--operations-file", file);
+    const read = file === "-" ? { content: await (deps.readStdin ? deps.readStdin() : readFileSync28(0, "utf8")) } : readRepositoryInputFile(cwd, "--operations-file", file);
     if ("problem" in read)
       return read.problem;
     let parsed;
@@ -54388,7 +55938,7 @@ async function readCliPlanBody(args, cwd, deps) {
     return { problem: "plan --body requires a value (use - to read stdin)" };
   if (inline !== "-")
     return inline;
-  return deps.readStdin ? deps.readStdin() : readFileSync27(0, "utf8");
+  return deps.readStdin ? deps.readStdin() : readFileSync28(0, "utf8");
 }
 function readFlag(args, flag) {
   const index = args.indexOf(flag);
@@ -54399,7 +55949,7 @@ function readFlag(args, flag) {
 function requireFlag(args, flag) {
   const value = readFlag(args, flag);
   if (!value)
-    throw new Error(`${flag} is required`);
+    throw new CliUsageError(`${flag} is required`);
   return value;
 }
 function copyOptionalFlag(args, flag) {
@@ -54424,11 +55974,11 @@ function explorerProjectionQueryV2FromCli(args) {
   const expectedObservedFactsDigest = readFlag(args, "--expected-observed-facts-digest");
   const expectedRequired = [expectedHeadSha, expectedWorktreeDigest, expectedGraphDigest];
   if (expectedRequired.some(Boolean) && !expectedRequired.every(Boolean)) {
-    throw new Error("--expected-head-sha, --expected-worktree-digest, and --expected-graph-digest must be provided together");
+    throw new CliUsageError("--expected-head-sha, --expected-worktree-digest, and --expected-graph-digest must be provided together");
   }
   const viewId = readFlag(args, "--view") ?? "system-map";
   if (!EXPLORER_VIEW_IDS.includes(viewId))
-    throw new Error(`unsupported Explorer view: ${viewId}`);
+    throw new CliUsageError(`unsupported Explorer view: ${viewId}`);
   return {
     schemaVersion: "archcontext.explorer-projection-query/v2",
     viewId,
@@ -54451,6 +56001,44 @@ function explorerProjectionQueryV2FromCli(args) {
     }
   };
 }
+function cliFailureEnvelope(error) {
+  if (error instanceof CliUsageError)
+    return errorEnvelope("cli", "AC_SCHEMA_INVALID", error.message);
+  return errorEnvelope("cli", "AC_RUNTIME_UNAVAILABLE", error instanceof Error ? error.message : String(error));
+}
+if (__require.main == __require.module) {
+  if (command === "capabilities") {
+    const result = await runCli(command, args, process.cwd());
+    if ("ok" in result) {
+      process.stdout.write(`${renderResult(result, "json")}
+`);
+      if (result.ok === false)
+        process.exitCode = 1;
+    } else {
+      process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+    }
+  } else if (command === "mcp" && args.length === 0) {
+    await runStdioMcpLoop(stdinLines(), (line) => process.stdout.write(`${line}
+`), (line) => process.stderr.write(`${line}
+`), { runtimeResolver: (root) => createOrStartRuntimeRpcClient(root) });
+  } else if (command === "daemon" && args[0] === "start" && args.includes("--foreground")) {
+    await runForegroundDaemon(process.cwd(), args).catch((error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`${message}
+`);
+      process.exitCode = isDaemonOwnedElsewhereError(message) ? DAEMON_OWNED_ELSEWHERE_EXIT_CODE : 1;
+    });
+  } else {
+    const result = await runCli(command, args, process.cwd()).catch(cliFailureEnvelope);
+    process.stdout.write(`${renderResult(result, readFlag(args, "--format") ?? "json")}
+`);
+    if (result.ok === false)
+      process.exitCode = 1;
+    if (command === "resolve")
+      process.exitCode = resolveCommandExitCode(result);
+  }
+}
 export {
   resolveCommandExitCode,
   runCapabilitiesCommand,