archctx 0.9.4 → 0.11.0

package/bin/archctx.mjs

@@ -173,6 +173,22 @@ var init_architecture = __esm(() => {
   ];
 });
 
+// packages/contracts/src/architecture-history.ts
+function decodeArchitectureHistoryState(value) {
+  if (!object(value))
+    return;
+  if (value.nodes === null && value.edges === null && value.structure === null && error(value.error))
+    return value;
+  if (value.error === undefined && list(value.nodes, node) && list(value.edges, edge) && list(value.structure, structure))
+    return value;
+  return;
+}
+var ARCHITECTURE_HISTORY_SCHEMA_VERSION = "archcontext.architecture-history/v1", ARCHITECTURE_HISTORY_MERMAID_SCHEMA_VERSION = "archcontext.architecture-history-mermaid/v1", ARCHITECTURE_HISTORY_DERIVATION_VERSION = "v3", object = (v) => typeof v === "object" && v !== null && !Array.isArray(v), string = (v) => typeof v === "string", edge = (v) => object(v) && string(v.source) && string(v.target), kind = (v) => v === "capability" || v === "module" || v === "component", item = (v) => object(v) && string(v.id) && kind(v.kind) && (v.capability === null || string(v.capability)) && (v.kind !== "capability" || v.capability === v.id), structure = (v) => item(v) && object(v) && string(v.name), node = (v) => object(v) && string(v.id) && string(v.name) && (v.domain === null || string(v.domain)), errors, error = (v) => object(v) && string(v.code) && errors.includes(v.code) && (v.path === undefined || string(v.path) && isRepoRelativePosixPath(v.path)), list = (v, check) => Array.isArray(v) && v.every(check);
+var init_architecture_history = __esm(() => {
+  init_schema();
+  errors = ["history-model-layout-unsupported", "history-model-missing", "history-model-invalid", "history-model-too-large"];
+});
+
 // packages/contracts/src/architecture-debt.ts
 function architectureDebtReportIssues(report) {
   const issues = [];
@@ -1961,6 +1977,450 @@ var init_projection = __esm(() => {
   ISO_INSTANT = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/;
 });
 
+// packages/contracts/src/projection-manifest.ts
+function isRuntimeTopologyTargetType(type) {
+  return typeof type === "string" && RUNTIME_TOPOLOGY_TARGET_TYPES.includes(type);
+}
+function architectureDocsProjectionManifestIssues(value) {
+  const issues = [];
+  const manifest = record2(value);
+  if (!manifest)
+    return ["manifest must be an object"];
+  issues.push(...exactKeys(manifest, ["schemaVersion", "rendererVersion", "profile", "layoutVersion", "generatedFrom", "semanticBaseline", "targets"], ["minimumRendererVersion", "minimumProtocolVersion"], "manifest"));
+  if (manifest.schemaVersion !== ARCHITECTURE_DOCS_PROJECTION_MANIFEST_SCHEMA_VERSION)
+    issues.push("manifest.schemaVersion is unsupported");
+  if (!isNonEmptyString(manifest.rendererVersion))
+    issues.push("manifest.rendererVersion must be a non-empty string");
+  for (const [key, family] of [["minimumRendererVersion", "archcontext.docs-renderer/v"], ["minimumProtocolVersion", "archcontext.projection-request/v"]]) {
+    if (Object.hasOwn(manifest, key) && versionNumber(manifest[key], family) === undefined)
+      issues.push(`manifest.${key} must name a supported version family`);
+  }
+  if (!ARCHITECTURE_DOCS_PROJECTION_PROFILES.includes(manifest.profile))
+    issues.push("manifest.profile is unsupported");
+  if (manifest.layoutVersion !== ARCHITECTURE_DOCS_LAYOUT_VERSION_V1)
+    issues.push("manifest.layoutVersion is unsupported");
+  issues.push(...generatedFromIssues(manifest.generatedFrom, "manifest.generatedFrom"));
+  const baseline = record2(manifest.semanticBaseline);
+  if (!baseline)
+    issues.push("manifest.semanticBaseline must be an object");
+  else {
+    issues.push(...exactKeys(baseline, ["modelDigest", "capabilities"], [], "manifest.semanticBaseline"));
+    if (!isDigest(baseline.modelDigest))
+      issues.push("manifest.semanticBaseline.modelDigest must be a SHA-256 digest");
+    issues.push(...capabilityEntriesIssues(baseline.capabilities, "manifest.semanticBaseline.capabilities", true));
+  }
+  const targets = record2(manifest.targets);
+  if (!targets) {
+    issues.push("manifest.targets must be an object keyed by targetId");
+    return issues;
+  }
+  const paths = new Set;
+  const stampOwners = new Map;
+  let topologyStamps;
+  for (const [targetId, row] of Object.entries(targets)) {
+    const prefix = `manifest.targets[${JSON.stringify(targetId)}]`;
+    if (!isNonEmptyString(targetId))
+      issues.push("manifest.targets keys must be non-empty targetIds");
+    issues.push(...manifestTargetIssues(row, prefix));
+    const path = record2(row)?.path;
+    if (typeof path === "string") {
+      if (paths.has(path))
+        issues.push(`${prefix}.path is recorded by another target`);
+      paths.add(path);
+    }
+    const stamps = record2(record2(row)?.sourceStamps) ?? {};
+    if (isRuntimeTopologyTargetType(record2(row)?.type)) {
+      const serialized = JSON.stringify(Object.keys(stamps).sort(compareStrings).map((nodeId) => [nodeId, stamps[nodeId]]));
+      if (topologyStamps === undefined)
+        topologyStamps = { targetId, stamps: serialized };
+      else if (topologyStamps.stamps !== serialized)
+        issues.push(`${prefix}.sourceStamps must equal the sourceStamps of ${topologyStamps.targetId}`);
+      for (const nodeId of Object.keys(stamps)) {
+        const owner = stampOwners.get(nodeId);
+        if (owner !== undefined && !isRuntimeTopologyTargetType(record2(targets[owner])?.type))
+          issues.push(`${prefix}.sourceStamps.${nodeId} is already stamped on ${owner}`);
+        else if (owner === undefined)
+          stampOwners.set(nodeId, targetId);
+      }
+      continue;
+    }
+    for (const nodeId of Object.keys(stamps)) {
+      const owner = stampOwners.get(nodeId);
+      if (owner !== undefined)
+        issues.push(`${prefix}.sourceStamps.${nodeId} is already stamped on ${owner}`);
+      else
+        stampOwners.set(nodeId, targetId);
+    }
+  }
+  return issues;
+}
+function architectureDocsProjectionManifestSchemaVersion(body) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return;
+  }
+  const schemaVersion = record2(parsed)?.schemaVersion;
+  return typeof schemaVersion === "string" ? schemaVersion : undefined;
+}
+function isSupersededArchitectureDocsProjectionManifestSchemaVersion(schemaVersion) {
+  return SUPERSEDED_ARCHITECTURE_DOCS_PROJECTION_MANIFEST_SCHEMA_VERSIONS.includes(schemaVersion);
+}
+function serializeArchitectureDocsProjectionManifest(manifest) {
+  const capabilities = [...manifest.semanticBaseline.capabilities].sort((left, right) => compareStrings(left.capabilityId, right.capabilityId)).map(canonicalCapability);
+  const capabilityBlock = JSON.stringify(capabilities, null, 2).split(`
+`).map((line, index) => index === 0 ? line : `    ${line}`).join(`
+`);
+  const targetIds = Object.keys(manifest.targets).sort(compareStrings);
+  const targetLines = targetIds.length === 0 ? ['  "targets": {}'] : [
+    '  "targets": {',
+    ...targetIds.flatMap((targetId, index) => [
+      `    ${JSON.stringify(targetId)}:`,
+      `      ${JSON.stringify(canonicalTargetRow(manifest.targets[targetId]))}${index === targetIds.length - 1 ? "" : ","}`
+    ]),
+    "  }"
+  ];
+  return [
+    "{",
+    `  "schemaVersion": ${JSON.stringify(manifest.schemaVersion)},`,
+    `  "rendererVersion": ${JSON.stringify(manifest.rendererVersion)},`,
+    ...manifest.minimumRendererVersion === undefined ? [] : [`  "minimumRendererVersion": ${JSON.stringify(manifest.minimumRendererVersion)},`],
+    ...manifest.minimumProtocolVersion === undefined ? [] : [`  "minimumProtocolVersion": ${JSON.stringify(manifest.minimumProtocolVersion)},`],
+    `  "profile": ${JSON.stringify(manifest.profile)},`,
+    `  "layoutVersion": ${JSON.stringify(manifest.layoutVersion)},`,
+    `  "generatedFrom": ${JSON.stringify({ codeGraphPackage: manifest.generatedFrom.codeGraphPackage, codeGraphVersion: manifest.generatedFrom.codeGraphVersion })},`,
+    '  "semanticBaseline": {',
+    `    "modelDigest": ${JSON.stringify(manifest.semanticBaseline.modelDigest)},`,
+    `    "capabilities": ${capabilityBlock}`,
+    "  },",
+    ...targetLines,
+    "}",
+    ""
+  ].join(`
+`);
+}
+function architectureDocsProjectionManifestSemanticState(manifest) {
+  return architectureSemanticStateFromCapabilities(manifest.semanticBaseline.capabilities.map(({ selectorEvidenceDigest: _selectorEvidenceDigest, ...capability }) => capability));
+}
+function architectureSemanticStateFromCapabilities(capabilities) {
+  const sorted = [...capabilities].sort((left, right) => compareStrings(left.capabilityId, right.capabilityId));
+  return {
+    schemaVersion: ARCHITECTURE_SEMANTIC_STATE_SCHEMA_VERSION,
+    capabilities: sorted,
+    semanticFingerprint: digestJson(sorted.map(({ capabilityId, semanticFingerprint }) => ({ capabilityId, semanticFingerprint }))),
+    flowProofFingerprint: digestJson(sorted.map(({ capabilityId, flowProofFingerprint }) => ({ capabilityId, flowProofFingerprint })))
+  };
+}
+function architectureDocsProjectionManifestSourceStamps(manifest) {
+  const stamps = {};
+  for (const row of Object.values(manifest.targets))
+    Object.assign(stamps, row.sourceStamps ?? {});
+  return stamps;
+}
+function architectureDocsProjectionManifestProofEvidence(manifest) {
+  return {
+    rendererVersion: manifest.rendererVersion,
+    selectorEvidenceDigests: Object.fromEntries(manifest.semanticBaseline.capabilities.map((capability) => [capability.capabilityId, capability.selectorEvidenceDigest])),
+    sourceStamps: architectureDocsProjectionManifestSourceStamps(manifest)
+  };
+}
+function architectureSourceStampsDigest(stamps) {
+  return digestJson({
+    schemaVersion: "archcontext.architecture-source-stamps/v1",
+    stamps: Object.keys(stamps).sort(compareStrings).map((nodeId) => ({ nodeId, digest: stamps[nodeId] }))
+  });
+}
+function architectureProjectionOutputsDigest(input) {
+  return digestJson({
+    schemaVersion: "archcontext.architecture-projection-outputs/v1",
+    rendererVersion: input.rendererVersion,
+    profile: input.profile,
+    outputs: Object.keys(input.outputDigests).sort(compareStrings).map((targetId) => ({ targetId, outputDigest: input.outputDigests[targetId] }))
+  });
+}
+function architectureDocsProjectionManifestDigests(manifest) {
+  return {
+    modelDigest: manifest.semanticBaseline.modelDigest,
+    sourceTreeDigest: architectureSourceStampsDigest(architectureDocsProjectionManifestSourceStamps(manifest)),
+    flowProofDigest: architectureDocsProjectionManifestSemanticState(manifest).flowProofFingerprint,
+    projectionDigest: architectureProjectionOutputsDigest({
+      rendererVersion: manifest.rendererVersion,
+      profile: manifest.profile,
+      outputDigests: Object.fromEntries(Object.entries(manifest.targets).map(([targetId, row]) => [targetId, row.outputDigest]))
+    })
+  };
+}
+function architectureDocsProjectionProvenanceIssues(value, prefix = "provenance") {
+  const provenance = record2(value);
+  if (!provenance)
+    return [`${prefix} must be an object`];
+  const issues = exactKeys(provenance, ["schemaVersion", "sourceTreeDigest", "modelDigest", "projectionInputDigest", "rendererVersion", "layoutVersion", "generatedFrom"], [], prefix);
+  if (provenance.schemaVersion !== ARCHITECTURE_DOCS_PROJECTION_PROVENANCE_SCHEMA_VERSION)
+    issues.push(`${prefix}.schemaVersion is unsupported`);
+  for (const field of ["sourceTreeDigest", "modelDigest", "projectionInputDigest"]) {
+    if (!isDigest(provenance[field]))
+      issues.push(`${prefix}.${field} must be a SHA-256 digest`);
+  }
+  if (provenance.rendererVersion !== ARCHITECTURE_DOCS_RENDERER_VERSION)
+    issues.push(`${prefix}.rendererVersion must be ${ARCHITECTURE_DOCS_RENDERER_VERSION}`);
+  if (provenance.layoutVersion !== ARCHITECTURE_DOCS_LAYOUT_VERSION_V1)
+    issues.push(`${prefix}.layoutVersion is unsupported`);
+  issues.push(...generatedFromIssues(provenance.generatedFrom, `${prefix}.generatedFrom`));
+  return issues;
+}
+function capabilityEntriesIssues(value, prefix, withSelectorEvidence) {
+  if (!Array.isArray(value))
+    return [`${prefix} must be an array`];
+  const issues = [];
+  const ids = value.map((entry) => record2(entry)?.capabilityId);
+  if (!isSortedUniqueStrings(ids))
+    issues.push(`${prefix} must be sorted and unique by capabilityId`);
+  value.forEach((entry, index) => {
+    const entryPrefix = `${prefix}[${index}]`;
+    const capability = record2(entry);
+    if (!capability) {
+      issues.push(`${entryPrefix} must be an object`);
+      return;
+    }
+    const required = ["capabilityId", "memberNodeIds", "semanticFingerprint", "flowProofFingerprint", "proofStatus", "facets", ...withSelectorEvidence ? ["selectorEvidenceDigest"] : []];
+    issues.push(...exactKeys(capability, required, [], entryPrefix));
+    if (!isNonEmptyString(capability.capabilityId))
+      issues.push(`${entryPrefix}.capabilityId must be a non-empty string`);
+    if (!Array.isArray(capability.memberNodeIds) || !isSortedUniqueStrings(capability.memberNodeIds))
+      issues.push(`${entryPrefix}.memberNodeIds must be sorted and unique`);
+    if (!isDigest(capability.semanticFingerprint))
+      issues.push(`${entryPrefix}.semanticFingerprint must be a SHA-256 digest`);
+    if (!isDigest(capability.flowProofFingerprint))
+      issues.push(`${entryPrefix}.flowProofFingerprint must be a SHA-256 digest`);
+    if (withSelectorEvidence && !isDigest(capability.selectorEvidenceDigest))
+      issues.push(`${entryPrefix}.selectorEvidenceDigest must be a SHA-256 digest`);
+    if (!isArchitectureCapabilityProofStatus(capability.proofStatus))
+      issues.push(`${entryPrefix}.proofStatus must be a P1/P2 proof status`);
+    const facets = record2(capability.facets);
+    if (!facets)
+      issues.push(`${entryPrefix}.facets must be an object`);
+    else {
+      issues.push(...exactKeys(facets, [...ARCHITECTURE_SEMANTIC_FACETS], [], `${entryPrefix}.facets`));
+      for (const facet of ARCHITECTURE_SEMANTIC_FACETS) {
+        if (!isDigest(facets[facet]))
+          issues.push(`${entryPrefix}.facets.${facet} must be a SHA-256 digest`);
+      }
+    }
+  });
+  return issues;
+}
+function generatedFromIssues(value, prefix) {
+  const generatedFrom = record2(value);
+  if (!generatedFrom)
+    return [`${prefix} must be an object`];
+  const issues = exactKeys(generatedFrom, ["codeGraphPackage", "codeGraphVersion"], [], prefix);
+  for (const field of ["codeGraphPackage", "codeGraphVersion"]) {
+    if (!isNonEmptyString(generatedFrom[field]))
+      issues.push(`${prefix}.${field} must be a non-empty string`);
+  }
+  return issues;
+}
+function canonicalCapability(capability) {
+  return {
+    capabilityId: capability.capabilityId,
+    memberNodeIds: [...capability.memberNodeIds],
+    semanticFingerprint: capability.semanticFingerprint,
+    flowProofFingerprint: capability.flowProofFingerprint,
+    proofStatus: { p1: capability.proofStatus.p1, p2: capability.proofStatus.p2 },
+    facets: Object.fromEntries(Object.keys(capability.facets).sort(compareStrings).map((facet) => [facet, capability.facets[facet]])),
+    selectorEvidenceDigest: capability.selectorEvidenceDigest
+  };
+}
+function canonicalTargetRow(row) {
+  return {
+    type: row.type,
+    scope: {
+      kind: row.scope.kind,
+      ...row.scope.id !== undefined ? { id: row.scope.id } : {},
+      ...row.scope.entityKind !== undefined ? { entityKind: row.scope.entityKind } : {}
+    },
+    path: row.path,
+    ownership: row.ownership,
+    format: row.format,
+    outputDigest: row.outputDigest,
+    ...row.sourceStamps !== undefined ? { sourceStamps: Object.fromEntries(Object.keys(row.sourceStamps).sort(compareStrings).map((nodeId) => [nodeId, row.sourceStamps[nodeId]])) } : {},
+    ...row.scale !== undefined ? {
+      scale: {
+        fileCountBucket: { lower: row.scale.fileCountBucket.lower, upper: row.scale.fileCountBucket.upper },
+        lineCountBucket: { lower: row.scale.lineCountBucket.lower, upper: row.scale.lineCountBucket.upper }
+      }
+    } : {}
+  };
+}
+function isArchitectureScaleBucket(value) {
+  const bucket = record2(value);
+  if (!bucket || Object.keys(bucket).length !== 2)
+    return false;
+  const { lower, upper } = bucket;
+  if (typeof lower !== "number" || typeof upper !== "number" || !Number.isSafeInteger(lower) || !Number.isSafeInteger(upper))
+    return false;
+  if (lower === 0)
+    return upper === 1;
+  let magnitude = 1;
+  while (magnitude * 10 <= lower)
+    magnitude *= 10;
+  const mantissa = lower / magnitude;
+  if (mantissa === 1)
+    return upper === 2 * magnitude;
+  if (mantissa === 2)
+    return upper === 5 * magnitude;
+  if (mantissa === 5)
+    return upper === 10 * magnitude;
+  return false;
+}
+function manifestTargetIssues(value, prefix) {
+  const target = record2(value);
+  if (!target)
+    return [`${prefix} must be an object`];
+  const issues = exactKeys(target, ["type", "scope", "path", "ownership", "format", "outputDigest"], ["sourceStamps", "scale"], prefix);
+  if (typeof target.type !== "string" || !Object.hasOwn(TARGET_TYPES, target.type))
+    issues.push(`${prefix}.type is unsupported`);
+  const scope = record2(target.scope);
+  if (!scope || typeof scope.kind !== "string" || !Object.hasOwn(SCOPE_KINDS, scope.kind))
+    issues.push(`${prefix}.scope.kind is unsupported`);
+  else {
+    issues.push(...exactKeys(scope, ["kind"], ["id", "entityKind"], `${prefix}.scope`));
+    for (const field of ["id", "entityKind"]) {
+      if (scope[field] !== undefined && typeof scope[field] !== "string")
+        issues.push(`${prefix}.scope.${field} must be a string`);
+    }
+  }
+  if (typeof target.path !== "string" || !isRepoRelativePosixPath(target.path))
+    issues.push(`${prefix}.path must be a repository-relative POSIX path`);
+  if (typeof target.ownership !== "string" || !Object.hasOwn(OWNERSHIPS, target.ownership))
+    issues.push(`${prefix}.ownership is unsupported`);
+  if (typeof target.format !== "string" || !Object.hasOwn(FORMATS, target.format))
+    issues.push(`${prefix}.format is unsupported`);
+  if (!isDigest(target.outputDigest))
+    issues.push(`${prefix}.outputDigest must be a SHA-256 digest`);
+  if (target.sourceStamps !== undefined && target.type !== "entity-summary" && !isRuntimeTopologyTargetType(target.type)) {
+    issues.push(`${prefix}.sourceStamps are only allowed on entity-summary and runtime topology targets`);
+  }
+  if (target.scale !== undefined && target.type !== "entity-summary")
+    issues.push(`${prefix}.scale is only allowed on entity-summary targets`);
+  if (target.sourceStamps !== undefined) {
+    const stamps = record2(target.sourceStamps);
+    if (!stamps || Object.keys(stamps).length === 0)
+      issues.push(`${prefix}.sourceStamps must be a non-empty object keyed by node id`);
+    else {
+      for (const [nodeId, digest] of Object.entries(stamps)) {
+        if (!isNonEmptyString(nodeId))
+          issues.push(`${prefix}.sourceStamps keys must be non-empty node ids`);
+        if (!isDigest(digest))
+          issues.push(`${prefix}.sourceStamps.${nodeId} must be a SHA-256 digest`);
+      }
+    }
+  }
+  const ownNodeId = scope?.id;
+  const stampsOwnNode = typeof ownNodeId === "string" && record2(target.sourceStamps) !== undefined && Object.hasOwn(record2(target.sourceStamps), ownNodeId);
+  if (stampsOwnNode !== (target.scale !== undefined))
+    issues.push(`${prefix}.scale must be present exactly when sourceStamps stamps the target's own node`);
+  if (target.scale !== undefined) {
+    const scale = record2(target.scale);
+    if (!scale)
+      issues.push(`${prefix}.scale must be an object`);
+    else {
+      issues.push(...exactKeys(scale, ["fileCountBucket", "lineCountBucket"], [], `${prefix}.scale`));
+      for (const field of ["fileCountBucket", "lineCountBucket"]) {
+        if (!isArchitectureScaleBucket(scale[field]))
+          issues.push(`${prefix}.scale.${field} must be a 1-2-5 magnitude bucket`);
+      }
+    }
+  }
+  return issues;
+}
+function record2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function exactKeys(value, required, optional, prefix) {
+  const issues = required.filter((key) => !(key in value)).map((key) => `${prefix}.${key} is required`);
+  const allowed = new Set([...required, ...optional]);
+  for (const key of Object.keys(value))
+    if (!allowed.has(key))
+      issues.push(`${prefix}.${key} is not allowed`);
+  return issues;
+}
+function isDigest(value) {
+  return typeof value === "string" && SHA256.test(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function isSortedUniqueStrings(values) {
+  return values.every((value, index) => typeof value === "string" && (index === 0 || values[index - 1] < value));
+}
+function compareStrings(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function versionNumber(value, family) {
+  if (typeof value !== "string" || !value.startsWith(family))
+    return;
+  const suffix = value.slice(family.length);
+  if (!/^[1-9][0-9]*$/.test(suffix))
+    return;
+  const version = Number(suffix);
+  return Number.isSafeInteger(version) ? version : undefined;
+}
+function architectureDocsProjectionCompatibilityIssues(value, engine = {
+  rendererVersion: ARCHITECTURE_DOCS_RENDERER_VERSION,
+  protocolVersion: PROJECTION_REQUEST_SCHEMA_VERSION
+}) {
+  const manifest = record2(value);
+  if (!manifest)
+    return [];
+  const issues = [];
+  if (["minimumRendererVersion", "minimumProtocolVersion"].some((key) => Object.hasOwn(manifest, key)) && manifest.schemaVersion !== ARCHITECTURE_DOCS_PROJECTION_MANIFEST_SCHEMA_VERSION)
+    issues.push("projection manifest floors require the current schema");
+  if (typeof manifest.schemaVersion === "string" && manifest.schemaVersion !== ARCHITECTURE_DOCS_PROJECTION_MANIFEST_SCHEMA_VERSION && !isSupersededArchitectureDocsProjectionManifestSchemaVersion(manifest.schemaVersion))
+    issues.push("projection manifest schema is unsupported by this engine");
+  for (const [key, family, current] of [
+    ["minimumRendererVersion", "archcontext.docs-renderer/v", engine.rendererVersion],
+    ["minimumProtocolVersion", "archcontext.projection-request/v", engine.protocolVersion]
+  ]) {
+    if (!Object.hasOwn(manifest, key))
+      continue;
+    const required = versionNumber(manifest[key], family);
+    const supported = versionNumber(current, family);
+    if (required === undefined || supported === undefined || supported < required)
+      issues.push(`projection manifest ${key} is unsupported by this engine`);
+  }
+  return issues;
+}
+var ARCHITECTURE_DOCS_PROJECTION_MANIFEST_SCHEMA_VERSION = "archcontext.architecture-docs-projection-manifest/v3", SUPERSEDED_ARCHITECTURE_DOCS_PROJECTION_MANIFEST_SCHEMA_VERSIONS, ARCHITECTURE_DOCS_PROJECTION_MANIFEST_UPGRADE_COMMAND = "archctx docs apply --approved --profile <default|repo-harness/v1>", ARCHITECTURE_DOCS_PROJECTION_MANIFEST_MIGRATION_GUIDE = "docs/runbooks/architecture-documentation-projections.md", PROJECTION_MANIFEST_UPGRADE_REQUIRED = "projection-manifest-upgrade-required", PROJECTION_MANIFEST_INVALID = "projection-manifest-invalid", PROJECTION_FOOTPRINT_UNCOVERED = "projection-footprint-uncovered", ARCHITECTURE_DOCS_PROJECTION_PROVENANCE_SCHEMA_VERSION = "archcontext.architecture-docs-projection-provenance/v3", ARCHITECTURE_DOCS_LAYOUT_VERSION_V1 = "archcontext.docs-layout/v1", ARCHITECTURE_SEMANTIC_STATE_SCHEMA_VERSION = "archcontext.architecture-semantic-state/v1", ARCHITECTURE_DOCS_PROJECTION_PROFILES, SHA256, TARGET_TYPES, RUNTIME_TOPOLOGY_TARGET_TYPES, SCOPE_KINDS, OWNERSHIPS, FORMATS;
+var init_projection_manifest = __esm(() => {
+  init_projection();
+  init_schema();
+  SUPERSEDED_ARCHITECTURE_DOCS_PROJECTION_MANIFEST_SCHEMA_VERSIONS = [
+    "archcontext.architecture-docs-projection-manifest/v1",
+    "archcontext.architecture-docs-projection-manifest/v2"
+  ];
+  ARCHITECTURE_DOCS_PROJECTION_PROFILES = ["default", "repo-harness/v1"];
+  SHA256 = /^sha256:[a-f0-9]{64}$/;
+  TARGET_TYPES = {
+    "architecture-index": true,
+    "entity-summary": true,
+    "relation-summary": true,
+    "decision-index": true,
+    "architecture-changelog": true,
+    "diagram-mermaid": true,
+    "diagram-structurizr": true,
+    "diagram-likec4": true,
+    "diagram-runtime-topology": true,
+    "runtime-topology-summary": true,
+    "agent-context": true
+  };
+  RUNTIME_TOPOLOGY_TARGET_TYPES = ["diagram-runtime-topology", "runtime-topology-summary"];
+  SCOPE_KINDS = { repository: true, entity: true, relation: true, decision: true, diagram: true, changelog: true };
+  OWNERSHIPS = { generated: true, mixed: true };
+  FORMATS = { markdown: true, mermaid: true, "structurizr-json": true, likec4: true };
+});
+
 // packages/contracts/src/projection-recovery.ts
 function jsonDataCopy(input, maximum) {
   let measured = 0;
@@ -2085,7 +2545,7 @@ var init_projection_recovery = __esm(() => {
 // packages/contracts/src/failure.ts
 import { isNativeError } from "node:util/types";
 function ownData(input, key) {
-  if (!record2(input))
+  if (!record3(input))
     throw new Error("Failure metadata must be an object");
   const descriptor = Object.getOwnPropertyDescriptor(input, key);
   if (!descriptor) {
@@ -2133,7 +2593,7 @@ function detailsFor(policy, input) {
   if (policy.facts)
     return localFactsFor(policy.facts, input);
   const result = {};
-  if (!record2(input))
+  if (!record3(input))
     throw new Error("Failure details must be an object");
   let omitted = 0;
   for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(input))) {
@@ -2159,7 +2619,7 @@ function detailsFor(policy, input) {
   return result;
 }
 function dataRecord(value) {
-  if (!record2(value))
+  if (!record3(value))
     throw new Error("Facts must be a plain record");
   const proto = Object.getPrototypeOf(value), keys = Reflect.ownKeys(value);
   if (proto !== Object.prototype && proto !== null || keys.length > 16 || Object.keys(value).length !== keys.length || keys.some((key) => typeof key !== "string"))
@@ -2284,7 +2744,7 @@ function nativeFactsFor(policy, input) {
   let omitted = 0, characters = 0;
   const omit = (value) => {
     omitted++;
-    const strings = (v) => typeof v === "string" ? v.length : Array.isArray(v) ? v.reduce((n, item) => n + strings(item), 0) : record2(v) ? Object.values(v).reduce((n, item) => n + strings(item), 0) : 0;
+    const strings = (v) => typeof v === "string" ? v.length : Array.isArray(v) ? v.reduce((n, item) => n + strings(item), 0) : record3(v) ? Object.values(v).reduce((n, item) => n + strings(item), 0) : 0;
     characters += strings(value);
   };
   const text = (value) => {
@@ -2423,7 +2883,7 @@ function budgetIssues(value, depth = 0, maxStringBytes = 256) {
     return Number.isFinite(value) ? [] : ["detail number is not finite"];
   if (Array.isArray(value))
     return value.length <= 32 ? value.flatMap((item) => budgetIssues(item, depth + 1, maxStringBytes)) : ["detail list exceeds 32"];
-  if (record2(value))
+  if (record3(value))
     return Object.keys(value).length <= 16 ? Object.values(value).flatMap((item) => budgetIssues(item, depth + 1, maxStringBytes)) : ["detail object exceeds 16 fields"];
   return value === null || typeof value === "boolean" ? [] : ["detail value is not JSON"];
 }
@@ -2498,7 +2958,7 @@ function toEnvelope(requestId, error, stage) {
   }
 }
 function normalizeFailureResult(result, stage, requestId = "failure") {
-  if (!record2(result))
+  if (!record3(result))
     return result;
   try {
     if (ownData(result, "ok") !== false)
@@ -2528,7 +2988,7 @@ function jsonDataSnapshot(value, depth = 0, maxStringBytes = 256) {
       return jsonDataSnapshot(descriptor.value, depth + 1, maxStringBytes);
     });
   }
-  if (record2(value)) {
+  if (record3(value)) {
     const prototype = Object.getPrototypeOf(value);
     const keys = Reflect.ownKeys(value);
     if (prototype !== Object.prototype && prototype !== null || keys.length > 16 || Object.keys(value).length !== keys.length || keys.some((key) => typeof key !== "string"))
@@ -2539,7 +2999,7 @@ function jsonDataSnapshot(value, depth = 0, maxStringBytes = 256) {
 }
 function failureIssues(value) {
   try {
-    if (!record2(value))
+    if (!record3(value))
       return ["failure must be an object"];
     const fields = ["code", "message", "severity", "retryable", "action", "reasonCode", "details"];
     const keys = Reflect.ownKeys(value);
@@ -2558,10 +3018,12 @@ function failureIssues(value) {
     return ["failure violates its registered contract or budget"];
   }
 }
-var FAILURE_STAGES, ERROR_CLASSES, CODE_FACTS_ISSUE_MESSAGES, policies, FAILURE_POLICIES, catalogDefaults, actions, bytes = (value) => new TextEncoder().encode(value).byteLength, record2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value), finiteNonnegative = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0, criticalKey = (key) => /id$|digest|receipt|binding|readback|lookupkey/i.test(key), localEnums, nativeEnums, nativeDiagnosticKinds, FailureError;
+var FAILURE_STAGES, ERROR_CLASSES, CODE_FACTS_ISSUE_MESSAGES, policies, FAILURE_POLICIES, catalogDefaults, actions, bytes = (value) => new TextEncoder().encode(value).byteLength, record3 = (value) => value !== null && typeof value === "object" && !Array.isArray(value), finiteNonnegative = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0, criticalKey = (key) => /id$|digest|receipt|binding|readback|lookupkey/i.test(key), localEnums, nativeEnums, nativeDiagnosticKinds, FailureError;
 var init_failure = __esm(() => {
   init_changeset_recovery();
   init_ports();
+  init_projection();
+  init_projection_manifest();
   init_projection_recovery();
   init_schema();
   FAILURE_STAGES = Object.freeze(["debt", "complete", "practice-checkpoint", "cli", "mcp", "hook-checkpoint", "failure-metadata", "public-operation", "native-export", "docs-anchors", "flows-check"]);
@@ -2576,6 +3038,7 @@ var init_failure = __esm(() => {
     "pending-source-changes": "CodeGraph repository index has pending or unreported source changes"
   });
   policies = {
+    "history-shallow-repository": { code: "AC_PRECONDITION_FAILED", message: "Architecture history requires a complete Git repository.", action: "unshallow-repository" },
     "code-facts-read-not-ready": { code: "AC_CODE_FACTS_UNAVAILABLE", message: "The existing CodeGraph index does not attest to the current source population.", facts: { issues: "codeFactsIssues" }, action: "codegraph-sync", retryable: false },
     "code-facts-snapshot-changed": { code: "AC_CODE_FACTS_UNAVAILABLE", message: "Source or index inputs changed while reading the private snapshot.", action: "retry-read", retryable: true, facts: {} },
     "code-facts-snapshot-limit-exceeded": { code: "AC_CODE_FACTS_UNAVAILABLE", message: "The private CodeGraph snapshot exceeds its 512 MiB or 100000 entry limit.", action: "reduce-snapshot-size", retryable: false, facts: {} },
@@ -2589,7 +3052,7 @@ var init_failure = __esm(() => {
     "model-missing": { code: "AC_MODEL_ADOPTION_REQUIRED", message: "Architecture debt requires an adopted model.", fields: ["checks"] },
     "changed-path-invalid": { code: "AC_SCHEMA_INVALID", message: "Changed paths must be an array of repository-relative POSIX paths.", fields: ["checks"] },
     "debt-report-invalid": { code: "AC_SCHEMA_INVALID", message: "Architecture debt evidence violates its contract.", fields: ["checks"] },
-    "projection-manifest-upgrade-required": { code: "AC_PRECONDITION_FAILED", message: "The committed projection manifest requires supported re-baselining. First restore the original model if missing; the manifest digest cannot recover it. With the reviewed model available, follow docs/runbooks/architecture-documentation-projections.md before running archctx docs apply --approved --profile <default|repo-harness/v1>." },
+    "projection-manifest-upgrade-required": { code: "AC_PRECONDITION_FAILED", message: `The committed projection manifest requires supported re-baselining. First restore the original model if missing; the manifest digest cannot recover it. With the reviewed model available, follow ${ARCHITECTURE_DOCS_PROJECTION_MANIFEST_MIGRATION_GUIDE} before running ${ARCHITECTURE_DOCS_PROJECTION_MANIFEST_UPGRADE_COMMAND}.`, facts: { manifestPath: "optional:projectionManifestPath", foundSchemaVersion: "optional:projectionManifestSchemaVersion", supportedSchemaVersion: "optional:projectionManifestSchemaVersion", upgradeCommand: "optional:projectionManifestUpgradeCommand", migrationGuide: "optional:projectionManifestMigrationGuide" } },
     "projection-manifest-invalid": { code: "AC_PRECONDITION_FAILED", message: "The committed projection manifest violates its contract." },
     "architecture-model-ignored": { code: "AC_PRECONDITION_FAILED", action: "commit-architecture-model", message: "Git ignore rules exclude architecture model paths, so the model cannot be committed and a manifest digest cannot rebuild it. Remove or narrow the rule, commit the model, then retry adoption. The diagnostic command prints each deciding rule.", facts: { pathCount: "uint", paths: "optional:diagnosticPaths", commands: "optional:diagnosticCommands", omittedPathCount: "uint" } },
     "projection-footprint-uncovered": { code: "AC_PRECONDITION_FAILED", message: "Declared source footprints lack a projection target." },
@@ -2850,6 +3313,10 @@ var init_failure = __esm(() => {
     upgradeAction: ["upgrade-archctx-runtime"],
     upgradeCommand: ["archctx daemon upgrade"],
     ownershipAction: ["remove-whole-file-outputs-and-reapply"],
+    projectionManifestPath: [ARCHITECTURE_DOCS_PROJECTION_MANIFEST_PATH],
+    projectionManifestSchemaVersion: [...SUPERSEDED_ARCHITECTURE_DOCS_PROJECTION_MANIFEST_SCHEMA_VERSIONS, ARCHITECTURE_DOCS_PROJECTION_MANIFEST_SCHEMA_VERSION],
+    projectionManifestUpgradeCommand: [ARCHITECTURE_DOCS_PROJECTION_MANIFEST_UPGRADE_COMMAND],
+    projectionManifestMigrationGuide: [ARCHITECTURE_DOCS_PROJECTION_MANIFEST_MIGRATION_GUIDE],
     ledgerModeField: ["rolloutMode", "readMode", "writeMode"],
     depsField: ["from", "into", "importNodeLimit", "edgeLimit"],
     depsIssue: ["unknown-node", "invalid-limit", "missing-value"],
@@ -2974,6 +3441,7 @@ var init_failure = __esm(() => {
     ],
     operation: [
       "rev-parse",
+      "log",
       "ls-tree",
       "ls-files",
       "cat-file"
@@ -3566,450 +4034,6 @@ var PRACTICE_SCHEMA_VERSION = "archcontext.practice/v1", PRACTICE_PROFILE_SCHEMA
 var PROJECTION_PUBLISH_RUN_SCHEMA_VERSION = "archcontext.projection-publish-run/v1", PROJECTION_PUBLISH_STATUS_SCHEMA_VERSION = "archcontext.projection-publish-status/v1", PROJECTION_PR_VERIFICATION_SCHEMA_VERSION = "archcontext.projection-pr-verification/v1", PROJECTION_WRITER_BRANCH_PREFIX = "archctx/", PROJECTION_WRITER_DEFAULT_BRANCH = "archctx/projection";
 var init_projection_writer = () => {};
 
-// packages/contracts/src/projection-manifest.ts
-function isRuntimeTopologyTargetType(type) {
-  return typeof type === "string" && RUNTIME_TOPOLOGY_TARGET_TYPES.includes(type);
-}
-function architectureDocsProjectionManifestIssues(value) {
-  const issues = [];
-  const manifest = record3(value);
-  if (!manifest)
-    return ["manifest must be an object"];
-  issues.push(...exactKeys(manifest, ["schemaVersion", "rendererVersion", "profile", "layoutVersion", "generatedFrom", "semanticBaseline", "targets"], ["minimumRendererVersion", "minimumProtocolVersion"], "manifest"));
-  if (manifest.schemaVersion !== ARCHITECTURE_DOCS_PROJECTION_MANIFEST_SCHEMA_VERSION)
-    issues.push("manifest.schemaVersion is unsupported");
-  if (!isNonEmptyString(manifest.rendererVersion))
-    issues.push("manifest.rendererVersion must be a non-empty string");
-  for (const [key, family] of [["minimumRendererVersion", "archcontext.docs-renderer/v"], ["minimumProtocolVersion", "archcontext.projection-request/v"]]) {
-    if (Object.hasOwn(manifest, key) && versionNumber(manifest[key], family) === undefined)
-      issues.push(`manifest.${key} must name a supported version family`);
-  }
-  if (!ARCHITECTURE_DOCS_PROJECTION_PROFILES.includes(manifest.profile))
-    issues.push("manifest.profile is unsupported");
-  if (manifest.layoutVersion !== ARCHITECTURE_DOCS_LAYOUT_VERSION_V1)
-    issues.push("manifest.layoutVersion is unsupported");
-  issues.push(...generatedFromIssues(manifest.generatedFrom, "manifest.generatedFrom"));
-  const baseline = record3(manifest.semanticBaseline);
-  if (!baseline)
-    issues.push("manifest.semanticBaseline must be an object");
-  else {
-    issues.push(...exactKeys(baseline, ["modelDigest", "capabilities"], [], "manifest.semanticBaseline"));
-    if (!isDigest(baseline.modelDigest))
-      issues.push("manifest.semanticBaseline.modelDigest must be a SHA-256 digest");
-    issues.push(...capabilityEntriesIssues(baseline.capabilities, "manifest.semanticBaseline.capabilities", true));
-  }
-  const targets = record3(manifest.targets);
-  if (!targets) {
-    issues.push("manifest.targets must be an object keyed by targetId");
-    return issues;
-  }
-  const paths = new Set;
-  const stampOwners = new Map;
-  let topologyStamps;
-  for (const [targetId, row] of Object.entries(targets)) {
-    const prefix = `manifest.targets[${JSON.stringify(targetId)}]`;
-    if (!isNonEmptyString(targetId))
-      issues.push("manifest.targets keys must be non-empty targetIds");
-    issues.push(...manifestTargetIssues(row, prefix));
-    const path = record3(row)?.path;
-    if (typeof path === "string") {
-      if (paths.has(path))
-        issues.push(`${prefix}.path is recorded by another target`);
-      paths.add(path);
-    }
-    const stamps = record3(record3(row)?.sourceStamps) ?? {};
-    if (isRuntimeTopologyTargetType(record3(row)?.type)) {
-      const serialized = JSON.stringify(Object.keys(stamps).sort(compareStrings).map((nodeId) => [nodeId, stamps[nodeId]]));
-      if (topologyStamps === undefined)
-        topologyStamps = { targetId, stamps: serialized };
-      else if (topologyStamps.stamps !== serialized)
-        issues.push(`${prefix}.sourceStamps must equal the sourceStamps of ${topologyStamps.targetId}`);
-      for (const nodeId of Object.keys(stamps)) {
-        const owner = stampOwners.get(nodeId);
-        if (owner !== undefined && !isRuntimeTopologyTargetType(record3(targets[owner])?.type))
-          issues.push(`${prefix}.sourceStamps.${nodeId} is already stamped on ${owner}`);
-        else if (owner === undefined)
-          stampOwners.set(nodeId, targetId);
-      }
-      continue;
-    }
-    for (const nodeId of Object.keys(stamps)) {
-      const owner = stampOwners.get(nodeId);
-      if (owner !== undefined)
-        issues.push(`${prefix}.sourceStamps.${nodeId} is already stamped on ${owner}`);
-      else
-        stampOwners.set(nodeId, targetId);
-    }
-  }
-  return issues;
-}
-function architectureDocsProjectionManifestSchemaVersion(body) {
-  let parsed;
-  try {
-    parsed = JSON.parse(body);
-  } catch {
-    return;
-  }
-  const schemaVersion = record3(parsed)?.schemaVersion;
-  return typeof schemaVersion === "string" ? schemaVersion : undefined;
-}
-function isSupersededArchitectureDocsProjectionManifestSchemaVersion(schemaVersion) {
-  return SUPERSEDED_ARCHITECTURE_DOCS_PROJECTION_MANIFEST_SCHEMA_VERSIONS.includes(schemaVersion);
-}
-function serializeArchitectureDocsProjectionManifest(manifest) {
-  const capabilities = [...manifest.semanticBaseline.capabilities].sort((left, right) => compareStrings(left.capabilityId, right.capabilityId)).map(canonicalCapability);
-  const capabilityBlock = JSON.stringify(capabilities, null, 2).split(`
-`).map((line, index) => index === 0 ? line : `    ${line}`).join(`
-`);
-  const targetIds = Object.keys(manifest.targets).sort(compareStrings);
-  const targetLines = targetIds.length === 0 ? ['  "targets": {}'] : [
-    '  "targets": {',
-    ...targetIds.flatMap((targetId, index) => [
-      `    ${JSON.stringify(targetId)}:`,
-      `      ${JSON.stringify(canonicalTargetRow(manifest.targets[targetId]))}${index === targetIds.length - 1 ? "" : ","}`
-    ]),
-    "  }"
-  ];
-  return [
-    "{",
-    `  "schemaVersion": ${JSON.stringify(manifest.schemaVersion)},`,
-    `  "rendererVersion": ${JSON.stringify(manifest.rendererVersion)},`,
-    ...manifest.minimumRendererVersion === undefined ? [] : [`  "minimumRendererVersion": ${JSON.stringify(manifest.minimumRendererVersion)},`],
-    ...manifest.minimumProtocolVersion === undefined ? [] : [`  "minimumProtocolVersion": ${JSON.stringify(manifest.minimumProtocolVersion)},`],
-    `  "profile": ${JSON.stringify(manifest.profile)},`,
-    `  "layoutVersion": ${JSON.stringify(manifest.layoutVersion)},`,
-    `  "generatedFrom": ${JSON.stringify({ codeGraphPackage: manifest.generatedFrom.codeGraphPackage, codeGraphVersion: manifest.generatedFrom.codeGraphVersion })},`,
-    '  "semanticBaseline": {',
-    `    "modelDigest": ${JSON.stringify(manifest.semanticBaseline.modelDigest)},`,
-    `    "capabilities": ${capabilityBlock}`,
-    "  },",
-    ...targetLines,
-    "}",
-    ""
-  ].join(`
-`);
-}
-function architectureDocsProjectionManifestSemanticState(manifest) {
-  return architectureSemanticStateFromCapabilities(manifest.semanticBaseline.capabilities.map(({ selectorEvidenceDigest: _selectorEvidenceDigest, ...capability }) => capability));
-}
-function architectureSemanticStateFromCapabilities(capabilities) {
-  const sorted = [...capabilities].sort((left, right) => compareStrings(left.capabilityId, right.capabilityId));
-  return {
-    schemaVersion: ARCHITECTURE_SEMANTIC_STATE_SCHEMA_VERSION,
-    capabilities: sorted,
-    semanticFingerprint: digestJson(sorted.map(({ capabilityId, semanticFingerprint }) => ({ capabilityId, semanticFingerprint }))),
-    flowProofFingerprint: digestJson(sorted.map(({ capabilityId, flowProofFingerprint }) => ({ capabilityId, flowProofFingerprint })))
-  };
-}
-function architectureDocsProjectionManifestSourceStamps(manifest) {
-  const stamps = {};
-  for (const row of Object.values(manifest.targets))
-    Object.assign(stamps, row.sourceStamps ?? {});
-  return stamps;
-}
-function architectureDocsProjectionManifestProofEvidence(manifest) {
-  return {
-    rendererVersion: manifest.rendererVersion,
-    selectorEvidenceDigests: Object.fromEntries(manifest.semanticBaseline.capabilities.map((capability) => [capability.capabilityId, capability.selectorEvidenceDigest])),
-    sourceStamps: architectureDocsProjectionManifestSourceStamps(manifest)
-  };
-}
-function architectureSourceStampsDigest(stamps) {
-  return digestJson({
-    schemaVersion: "archcontext.architecture-source-stamps/v1",
-    stamps: Object.keys(stamps).sort(compareStrings).map((nodeId) => ({ nodeId, digest: stamps[nodeId] }))
-  });
-}
-function architectureProjectionOutputsDigest(input) {
-  return digestJson({
-    schemaVersion: "archcontext.architecture-projection-outputs/v1",
-    rendererVersion: input.rendererVersion,
-    profile: input.profile,
-    outputs: Object.keys(input.outputDigests).sort(compareStrings).map((targetId) => ({ targetId, outputDigest: input.outputDigests[targetId] }))
-  });
-}
-function architectureDocsProjectionManifestDigests(manifest) {
-  return {
-    modelDigest: manifest.semanticBaseline.modelDigest,
-    sourceTreeDigest: architectureSourceStampsDigest(architectureDocsProjectionManifestSourceStamps(manifest)),
-    flowProofDigest: architectureDocsProjectionManifestSemanticState(manifest).flowProofFingerprint,
-    projectionDigest: architectureProjectionOutputsDigest({
-      rendererVersion: manifest.rendererVersion,
-      profile: manifest.profile,
-      outputDigests: Object.fromEntries(Object.entries(manifest.targets).map(([targetId, row]) => [targetId, row.outputDigest]))
-    })
-  };
-}
-function architectureDocsProjectionProvenanceIssues(value, prefix = "provenance") {
-  const provenance = record3(value);
-  if (!provenance)
-    return [`${prefix} must be an object`];
-  const issues = exactKeys(provenance, ["schemaVersion", "sourceTreeDigest", "modelDigest", "projectionInputDigest", "rendererVersion", "layoutVersion", "generatedFrom"], [], prefix);
-  if (provenance.schemaVersion !== ARCHITECTURE_DOCS_PROJECTION_PROVENANCE_SCHEMA_VERSION)
-    issues.push(`${prefix}.schemaVersion is unsupported`);
-  for (const field of ["sourceTreeDigest", "modelDigest", "projectionInputDigest"]) {
-    if (!isDigest(provenance[field]))
-      issues.push(`${prefix}.${field} must be a SHA-256 digest`);
-  }
-  if (provenance.rendererVersion !== ARCHITECTURE_DOCS_RENDERER_VERSION)
-    issues.push(`${prefix}.rendererVersion must be ${ARCHITECTURE_DOCS_RENDERER_VERSION}`);
-  if (provenance.layoutVersion !== ARCHITECTURE_DOCS_LAYOUT_VERSION_V1)
-    issues.push(`${prefix}.layoutVersion is unsupported`);
-  issues.push(...generatedFromIssues(provenance.generatedFrom, `${prefix}.generatedFrom`));
-  return issues;
-}
-function capabilityEntriesIssues(value, prefix, withSelectorEvidence) {
-  if (!Array.isArray(value))
-    return [`${prefix} must be an array`];
-  const issues = [];
-  const ids = value.map((entry) => record3(entry)?.capabilityId);
-  if (!isSortedUniqueStrings(ids))
-    issues.push(`${prefix} must be sorted and unique by capabilityId`);
-  value.forEach((entry, index) => {
-    const entryPrefix = `${prefix}[${index}]`;
-    const capability = record3(entry);
-    if (!capability) {
-      issues.push(`${entryPrefix} must be an object`);
-      return;
-    }
-    const required = ["capabilityId", "memberNodeIds", "semanticFingerprint", "flowProofFingerprint", "proofStatus", "facets", ...withSelectorEvidence ? ["selectorEvidenceDigest"] : []];
-    issues.push(...exactKeys(capability, required, [], entryPrefix));
-    if (!isNonEmptyString(capability.capabilityId))
-      issues.push(`${entryPrefix}.capabilityId must be a non-empty string`);
-    if (!Array.isArray(capability.memberNodeIds) || !isSortedUniqueStrings(capability.memberNodeIds))
-      issues.push(`${entryPrefix}.memberNodeIds must be sorted and unique`);
-    if (!isDigest(capability.semanticFingerprint))
-      issues.push(`${entryPrefix}.semanticFingerprint must be a SHA-256 digest`);
-    if (!isDigest(capability.flowProofFingerprint))
-      issues.push(`${entryPrefix}.flowProofFingerprint must be a SHA-256 digest`);
-    if (withSelectorEvidence && !isDigest(capability.selectorEvidenceDigest))
-      issues.push(`${entryPrefix}.selectorEvidenceDigest must be a SHA-256 digest`);
-    if (!isArchitectureCapabilityProofStatus(capability.proofStatus))
-      issues.push(`${entryPrefix}.proofStatus must be a P1/P2 proof status`);
-    const facets = record3(capability.facets);
-    if (!facets)
-      issues.push(`${entryPrefix}.facets must be an object`);
-    else {
-      issues.push(...exactKeys(facets, [...ARCHITECTURE_SEMANTIC_FACETS], [], `${entryPrefix}.facets`));
-      for (const facet of ARCHITECTURE_SEMANTIC_FACETS) {
-        if (!isDigest(facets[facet]))
-          issues.push(`${entryPrefix}.facets.${facet} must be a SHA-256 digest`);
-      }
-    }
-  });
-  return issues;
-}
-function generatedFromIssues(value, prefix) {
-  const generatedFrom = record3(value);
-  if (!generatedFrom)
-    return [`${prefix} must be an object`];
-  const issues = exactKeys(generatedFrom, ["codeGraphPackage", "codeGraphVersion"], [], prefix);
-  for (const field of ["codeGraphPackage", "codeGraphVersion"]) {
-    if (!isNonEmptyString(generatedFrom[field]))
-      issues.push(`${prefix}.${field} must be a non-empty string`);
-  }
-  return issues;
-}
-function canonicalCapability(capability) {
-  return {
-    capabilityId: capability.capabilityId,
-    memberNodeIds: [...capability.memberNodeIds],
-    semanticFingerprint: capability.semanticFingerprint,
-    flowProofFingerprint: capability.flowProofFingerprint,
-    proofStatus: { p1: capability.proofStatus.p1, p2: capability.proofStatus.p2 },
-    facets: Object.fromEntries(Object.keys(capability.facets).sort(compareStrings).map((facet) => [facet, capability.facets[facet]])),
-    selectorEvidenceDigest: capability.selectorEvidenceDigest
-  };
-}
-function canonicalTargetRow(row) {
-  return {
-    type: row.type,
-    scope: {
-      kind: row.scope.kind,
-      ...row.scope.id !== undefined ? { id: row.scope.id } : {},
-      ...row.scope.entityKind !== undefined ? { entityKind: row.scope.entityKind } : {}
-    },
-    path: row.path,
-    ownership: row.ownership,
-    format: row.format,
-    outputDigest: row.outputDigest,
-    ...row.sourceStamps !== undefined ? { sourceStamps: Object.fromEntries(Object.keys(row.sourceStamps).sort(compareStrings).map((nodeId) => [nodeId, row.sourceStamps[nodeId]])) } : {},
-    ...row.scale !== undefined ? {
-      scale: {
-        fileCountBucket: { lower: row.scale.fileCountBucket.lower, upper: row.scale.fileCountBucket.upper },
-        lineCountBucket: { lower: row.scale.lineCountBucket.lower, upper: row.scale.lineCountBucket.upper }
-      }
-    } : {}
-  };
-}
-function isArchitectureScaleBucket(value) {
-  const bucket = record3(value);
-  if (!bucket || Object.keys(bucket).length !== 2)
-    return false;
-  const { lower, upper } = bucket;
-  if (typeof lower !== "number" || typeof upper !== "number" || !Number.isSafeInteger(lower) || !Number.isSafeInteger(upper))
-    return false;
-  if (lower === 0)
-    return upper === 1;
-  let magnitude = 1;
-  while (magnitude * 10 <= lower)
-    magnitude *= 10;
-  const mantissa = lower / magnitude;
-  if (mantissa === 1)
-    return upper === 2 * magnitude;
-  if (mantissa === 2)
-    return upper === 5 * magnitude;
-  if (mantissa === 5)
-    return upper === 10 * magnitude;
-  return false;
-}
-function manifestTargetIssues(value, prefix) {
-  const target = record3(value);
-  if (!target)
-    return [`${prefix} must be an object`];
-  const issues = exactKeys(target, ["type", "scope", "path", "ownership", "format", "outputDigest"], ["sourceStamps", "scale"], prefix);
-  if (typeof target.type !== "string" || !Object.hasOwn(TARGET_TYPES, target.type))
-    issues.push(`${prefix}.type is unsupported`);
-  const scope = record3(target.scope);
-  if (!scope || typeof scope.kind !== "string" || !Object.hasOwn(SCOPE_KINDS, scope.kind))
-    issues.push(`${prefix}.scope.kind is unsupported`);
-  else {
-    issues.push(...exactKeys(scope, ["kind"], ["id", "entityKind"], `${prefix}.scope`));
-    for (const field of ["id", "entityKind"]) {
-      if (scope[field] !== undefined && typeof scope[field] !== "string")
-        issues.push(`${prefix}.scope.${field} must be a string`);
-    }
-  }
-  if (typeof target.path !== "string" || !isRepoRelativePosixPath(target.path))
-    issues.push(`${prefix}.path must be a repository-relative POSIX path`);
-  if (typeof target.ownership !== "string" || !Object.hasOwn(OWNERSHIPS, target.ownership))
-    issues.push(`${prefix}.ownership is unsupported`);
-  if (typeof target.format !== "string" || !Object.hasOwn(FORMATS, target.format))
-    issues.push(`${prefix}.format is unsupported`);
-  if (!isDigest(target.outputDigest))
-    issues.push(`${prefix}.outputDigest must be a SHA-256 digest`);
-  if (target.sourceStamps !== undefined && target.type !== "entity-summary" && !isRuntimeTopologyTargetType(target.type)) {
-    issues.push(`${prefix}.sourceStamps are only allowed on entity-summary and runtime topology targets`);
-  }
-  if (target.scale !== undefined && target.type !== "entity-summary")
-    issues.push(`${prefix}.scale is only allowed on entity-summary targets`);
-  if (target.sourceStamps !== undefined) {
-    const stamps = record3(target.sourceStamps);
-    if (!stamps || Object.keys(stamps).length === 0)
-      issues.push(`${prefix}.sourceStamps must be a non-empty object keyed by node id`);
-    else {
-      for (const [nodeId, digest] of Object.entries(stamps)) {
-        if (!isNonEmptyString(nodeId))
-          issues.push(`${prefix}.sourceStamps keys must be non-empty node ids`);
-        if (!isDigest(digest))
-          issues.push(`${prefix}.sourceStamps.${nodeId} must be a SHA-256 digest`);
-      }
-    }
-  }
-  const ownNodeId = scope?.id;
-  const stampsOwnNode = typeof ownNodeId === "string" && record3(target.sourceStamps) !== undefined && Object.hasOwn(record3(target.sourceStamps), ownNodeId);
-  if (stampsOwnNode !== (target.scale !== undefined))
-    issues.push(`${prefix}.scale must be present exactly when sourceStamps stamps the target's own node`);
-  if (target.scale !== undefined) {
-    const scale = record3(target.scale);
-    if (!scale)
-      issues.push(`${prefix}.scale must be an object`);
-    else {
-      issues.push(...exactKeys(scale, ["fileCountBucket", "lineCountBucket"], [], `${prefix}.scale`));
-      for (const field of ["fileCountBucket", "lineCountBucket"]) {
-        if (!isArchitectureScaleBucket(scale[field]))
-          issues.push(`${prefix}.scale.${field} must be a 1-2-5 magnitude bucket`);
-      }
-    }
-  }
-  return issues;
-}
-function record3(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
-}
-function exactKeys(value, required, optional, prefix) {
-  const issues = required.filter((key) => !(key in value)).map((key) => `${prefix}.${key} is required`);
-  const allowed = new Set([...required, ...optional]);
-  for (const key of Object.keys(value))
-    if (!allowed.has(key))
-      issues.push(`${prefix}.${key} is not allowed`);
-  return issues;
-}
-function isDigest(value) {
-  return typeof value === "string" && SHA256.test(value);
-}
-function isNonEmptyString(value) {
-  return typeof value === "string" && value.trim() !== "";
-}
-function isSortedUniqueStrings(values) {
-  return values.every((value, index) => typeof value === "string" && (index === 0 || values[index - 1] < value));
-}
-function compareStrings(left, right) {
-  return left < right ? -1 : left > right ? 1 : 0;
-}
-function versionNumber(value, family) {
-  if (typeof value !== "string" || !value.startsWith(family))
-    return;
-  const suffix = value.slice(family.length);
-  if (!/^[1-9][0-9]*$/.test(suffix))
-    return;
-  const version = Number(suffix);
-  return Number.isSafeInteger(version) ? version : undefined;
-}
-function architectureDocsProjectionCompatibilityIssues(value, engine = {
-  rendererVersion: ARCHITECTURE_DOCS_RENDERER_VERSION,
-  protocolVersion: PROJECTION_REQUEST_SCHEMA_VERSION
-}) {
-  const manifest = record3(value);
-  if (!manifest)
-    return [];
-  const issues = [];
-  if (["minimumRendererVersion", "minimumProtocolVersion"].some((key) => Object.hasOwn(manifest, key)) && manifest.schemaVersion !== ARCHITECTURE_DOCS_PROJECTION_MANIFEST_SCHEMA_VERSION)
-    issues.push("projection manifest floors require the current schema");
-  if (typeof manifest.schemaVersion === "string" && manifest.schemaVersion !== ARCHITECTURE_DOCS_PROJECTION_MANIFEST_SCHEMA_VERSION && !isSupersededArchitectureDocsProjectionManifestSchemaVersion(manifest.schemaVersion))
-    issues.push("projection manifest schema is unsupported by this engine");
-  for (const [key, family, current] of [
-    ["minimumRendererVersion", "archcontext.docs-renderer/v", engine.rendererVersion],
-    ["minimumProtocolVersion", "archcontext.projection-request/v", engine.protocolVersion]
-  ]) {
-    if (!Object.hasOwn(manifest, key))
-      continue;
-    const required = versionNumber(manifest[key], family);
-    const supported = versionNumber(current, family);
-    if (required === undefined || supported === undefined || supported < required)
-      issues.push(`projection manifest ${key} is unsupported by this engine`);
-  }
-  return issues;
-}
-var ARCHITECTURE_DOCS_PROJECTION_MANIFEST_SCHEMA_VERSION = "archcontext.architecture-docs-projection-manifest/v3", SUPERSEDED_ARCHITECTURE_DOCS_PROJECTION_MANIFEST_SCHEMA_VERSIONS, PROJECTION_MANIFEST_UPGRADE_REQUIRED = "projection-manifest-upgrade-required", PROJECTION_MANIFEST_INVALID = "projection-manifest-invalid", PROJECTION_FOOTPRINT_UNCOVERED = "projection-footprint-uncovered", ARCHITECTURE_DOCS_PROJECTION_PROVENANCE_SCHEMA_VERSION = "archcontext.architecture-docs-projection-provenance/v3", ARCHITECTURE_DOCS_LAYOUT_VERSION_V1 = "archcontext.docs-layout/v1", ARCHITECTURE_SEMANTIC_STATE_SCHEMA_VERSION = "archcontext.architecture-semantic-state/v1", ARCHITECTURE_DOCS_PROJECTION_PROFILES, SHA256, TARGET_TYPES, RUNTIME_TOPOLOGY_TARGET_TYPES, SCOPE_KINDS, OWNERSHIPS, FORMATS;
-var init_projection_manifest = __esm(() => {
-  init_projection();
-  init_schema();
-  SUPERSEDED_ARCHITECTURE_DOCS_PROJECTION_MANIFEST_SCHEMA_VERSIONS = [
-    "archcontext.architecture-docs-projection-manifest/v1",
-    "archcontext.architecture-docs-projection-manifest/v2"
-  ];
-  ARCHITECTURE_DOCS_PROJECTION_PROFILES = ["default", "repo-harness/v1"];
-  SHA256 = /^sha256:[a-f0-9]{64}$/;
-  TARGET_TYPES = {
-    "architecture-index": true,
-    "entity-summary": true,
-    "relation-summary": true,
-    "decision-index": true,
-    "architecture-changelog": true,
-    "diagram-mermaid": true,
-    "diagram-structurizr": true,
-    "diagram-likec4": true,
-    "diagram-runtime-topology": true,
-    "runtime-topology-summary": true,
-    "agent-context": true
-  };
-  RUNTIME_TOPOLOGY_TARGET_TYPES = ["diagram-runtime-topology", "runtime-topology-summary"];
-  SCOPE_KINDS = { repository: true, entity: true, relation: true, decision: true, diagram: true, changelog: true };
-  OWNERSHIPS = { generated: true, mixed: true };
-  FORMATS = { markdown: true, mermaid: true, "structurizr-json": true, likec4: true };
-});
-
 // packages/contracts/src/product-version.ts
 function productVersionManifest() {
   return {
@@ -4095,7 +4119,7 @@ function compareVersionTriples(left, right) {
   }
   return 0;
 }
-var ARCHCONTEXT_PRODUCT_NAME = "archctx", ARCHCONTEXT_PRODUCT_VERSION = "0.9.4", ARCHCONTEXT_PACKAGE_MANAGER = "bun@1.4.3", ARCHCONTEXT_NODE_RANGE = ">=22.22 <26", LOCAL_RUNTIME_RPC_SCHEMA_VERSION = "archcontext.runtime-rpc/v2", ARCHCONTEXT_SCHEMA_SET_VERSION = "2026-07-11.explorer-view-v2";
+var ARCHCONTEXT_PRODUCT_NAME = "archctx", ARCHCONTEXT_PRODUCT_VERSION = "0.11.0", ARCHCONTEXT_PACKAGE_MANAGER = "bun@1.4.3", ARCHCONTEXT_NODE_RANGE = ">=22.22 <26", LOCAL_RUNTIME_RPC_SCHEMA_VERSION = "archcontext.runtime-rpc/v2", ARCHCONTEXT_SCHEMA_SET_VERSION = "2026-07-11.explorer-view-v2";
 
 // packages/contracts/src/refactor.ts
 function refactorNamespaceIssues(value, label = "product.id") {
@@ -5188,6 +5212,7 @@ var init_refactor = __esm(() => {
 var init_src = __esm(() => {
   init_control_plane_routes();
   init_architecture();
+  init_architecture_history();
   init_architecture_debt();
   init_docs_anchors();
   init_github_governance();
@@ -15651,7 +15676,7 @@ import { basename, posix, resolve as resolve6 } from "node:path";
 var composer = require_composer();
 var Document = require_Document();
 var Schema = require_Schema();
-var errors = require_errors();
+var errors2 = require_errors();
 var Alias = require_Alias();
 var identity = require_identity();
 var Pair = require_Pair();
@@ -15667,9 +15692,9 @@ var visit2 = require_visit();
 var $Composer = composer.Composer;
 var $Document = Document.Document;
 var $Schema = Schema.Schema;
-var $YAMLError = errors.YAMLError;
-var $YAMLParseError = errors.YAMLParseError;
-var $YAMLWarning = errors.YAMLWarning;
+var $YAMLError = errors2.YAMLError;
+var $YAMLParseError = errors2.YAMLParseError;
+var $YAMLWarning = errors2.YAMLWarning;
 var $Alias = Alias.Alias;
 var $isAlias = identity.isAlias;
 var $isCollection = identity.isCollection;
@@ -16013,6 +16038,114 @@ function sourceIncludeAnchors(patterns) {
   });
   return [...new Set(anchors)].sort(nativeByteCompare);
 }
+// packages/core/projection-engine/src/architecture-history.ts
+init_src();
+var ARCHITECTURE_HISTORY_PATH = "docs/architecture/history.md";
+var HISTORY_DETAIL_EDGE_LIMIT = 20;
+var capabilityDomain = (id) => id === null ? null : /^capability\.([a-z0-9]+(?:-[a-z0-9]+)*)\.([a-z0-9]+(?:-[a-z0-9]+)*)$/.exec(id)?.[1] ?? null;
+var compare2 = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+function renderHistoryMermaid(milestone, mode = "full") {
+  if (!milestone.nodes)
+    return null;
+  const removed = mode === "changes" ? milestone.delta.removed.filter((node) => node.kind === "capability") : [];
+  const nodes = mode === "changes" ? [...milestone.nodes, ...removed.map((node) => ({
+    id: node.id,
+    name: node.id,
+    domain: capabilityDomain(node.id)
+  }))].sort((a, b) => compare2(a.id, b.id)) : milestone.nodes;
+  const keys = new Map(nodes.map((node, index) => [node.id, `n${index}`]));
+  const label = (node) => `  ${keys.get(node.id)}["${node.name.replaceAll('"', "#quot;")}"]`;
+  const domains = [...new Set(nodes.flatMap((node) => node.domain === null ? [] : [node.domain]))].sort();
+  const lines = ["flowchart LR"];
+  for (const domain of domains) {
+    lines.push(`  subgraph ${JSON.stringify(domain)}`);
+    lines.push(...nodes.filter((node) => node.domain === domain).map((node) => `  ${label(node)}`));
+    lines.push("  end");
+  }
+  lines.push(...nodes.filter((node) => node.domain === null).map(label));
+  const added = mode === "changes" ? milestone.delta.edgesChanged.added : milestone.edges;
+  lines.push(...added.map((edge) => `  ${keys.get(edge.source)} --> ${keys.get(edge.target)}`));
+  if (mode === "changes")
+    lines.push(...milestone.delta.edgesChanged.removed.map((edge) => `  ${keys.get(edge.source)} -.-> ${keys.get(edge.target)}`));
+  if (removed.length) {
+    lines.push(...removed.map((node) => `  class ${keys.get(node.id)} removed`));
+    lines.push("  classDef removed stroke-dasharray: 4 4");
+  }
+  return lines.join(`
+`);
+}
+function renderHistoryDomainOverview(milestone) {
+  if (!milestone.nodes)
+    return null;
+  const counts = new Map;
+  const ensure = (domain) => {
+    if (!counts.has(domain))
+      counts.set(domain, 0);
+  };
+  for (const node of milestone.nodes) {
+    const domain = node.domain ?? "ungrouped";
+    counts.set(domain, (counts.get(domain) ?? 0) + 1);
+  }
+  const changed = new Set;
+  for (const item of [...milestone.delta.added, ...milestone.delta.removed, ...milestone.delta.renamed]) {
+    const domain = capabilityDomain(item.capability) ?? "ungrouped";
+    ensure(domain);
+    changed.add(domain);
+  }
+  const pairs = new Map;
+  for (const [kind, edges] of [["added", milestone.delta.edgesChanged.added], ["removed", milestone.delta.edgesChanged.removed]]) {
+    for (const edge of edges) {
+      const source = capabilityDomain(edge.source) ?? "ungrouped", target = capabilityDomain(edge.target) ?? "ungrouped";
+      ensure(source);
+      ensure(target);
+      changed.add(source);
+      changed.add(target);
+      if (source === target)
+        continue;
+      const key = JSON.stringify([source, target]);
+      const pair = pairs.get(key) ?? { source, target, added: 0, removed: 0 };
+      pair[kind]++;
+      pairs.set(key, pair);
+    }
+  }
+  const domains = [...counts.keys()].sort();
+  const keys = new Map(domains.map((domain, index) => [domain, `d${index}`]));
+  const lines = ["flowchart LR", ...domains.map((domain) => `  ${keys.get(domain)}["${domain} (${counts.get(domain)})"]`)];
+  for (const pair of [...pairs.values()].sort((a, b) => compare2(a.source, b.source) || compare2(a.target, b.target))) {
+    const arrow = pair.added === 0 ? "-.->" : "-->";
+    lines.push(`  ${keys.get(pair.source)} ${arrow}|+${pair.added} −${pair.removed}| ${keys.get(pair.target)}`);
+  }
+  if (changed.size) {
+    lines.push(...domains.filter((domain) => changed.has(domain)).map((domain) => `  class ${keys.get(domain)} changed`));
+    lines.push("  classDef changed stroke-width:3px");
+  }
+  return { mermaid: lines.join(`
+`), pairCount: pairs.size };
+}
+function projectHistoryMermaid(history) {
+  return { schemaVersion: ARCHITECTURE_HISTORY_MERMAID_SCHEMA_VERSION, head: history.head, total: history.total, offset: history.offset, limit: history.limit, diagrams: history.milestones.map((milestone) => ({ rev: milestone.rev, mermaid: renderHistoryMermaid(milestone) })) };
+}
+function renderHistoryMarkdown(history) {
+  const lines = ["<!-- Generated by ArchContext (archctx history). Do not edit by hand. -->", "", `Architecture history contains ${history.total} milestones. Run \`archctx history\` for the full list.`, ""];
+  for (const milestone of [...history.milestones].reverse()) {
+    lines.push(`## ${milestone.date.slice(0, 10)} · ${milestone.rev.slice(0, 12)}`, "", milestone.subject, "");
+    if (milestone.error)
+      lines.push(milestone.error.code, "");
+    else {
+      const delta = milestone.delta;
+      const overview = renderHistoryDomainOverview(milestone);
+      const edgeCount = delta.edgesChanged.added.length + delta.edgesChanged.removed.length;
+      lines.push(`Added ${delta.added.length} · Removed ${delta.removed.length} · Renamed ${delta.renamed.length} · Edges +${delta.edgesChanged.added.length} −${delta.edgesChanged.removed.length}`, "", "```mermaid", overview.mermaid, "```", "");
+      if (edgeCount <= HISTORY_DETAIL_EDGE_LIMIT)
+        lines.push("```mermaid", renderHistoryMermaid(milestone, "changes"), "```", "");
+      else
+        lines.push(`${edgeCount} changed edges across ${overview.pairCount} domain pairs; run archctx history --ref ${milestone.rev.slice(0, 12)} --format mermaid for the full shape.`, "");
+    }
+  }
+  return `${lines.join(`
+`)}
+`;
+}
 
 // packages/core/projection-engine/src/index.ts
 init_src();
@@ -18071,12 +18204,13 @@ function resolveArchitectureDocumentationLayout(input) {
   });
   const relationTargets = (profile === REPO_HARNESS_PROJECTION_PROFILE ? [] : input.relations).map((relation) => layoutTarget(`projection_target.relation.${stableId(relation.id)}`, "relation-summary", { kind: "relation", id: relation.id }, `docs/architecture/relations/${pathSegment(relation.id)}.md`, "mixed", "markdown"));
   const topologyTargets = hasRuntimeTopologyNodes(input.nodes) ? RUNTIME_TOPOLOGY_TARGETS : [];
-  const targets = [FIXED_TARGETS[0], ...entityTargets, ...relationTargets, ...FIXED_TARGETS.slice(1), ...topologyTargets].map((target) => ({ ...target, path: requiredPath(target.path, target.targetId) }));
+  const targets = (profile === REPO_HARNESS_PROJECTION_PROFILE ? [...entityTargets, ...topologyTargets] : [FIXED_TARGETS[0], ...entityTargets, ...relationTargets, ...FIXED_TARGETS.slice(1), ...topologyTargets]).map((target) => ({ ...target, path: requiredPath(target.path, target.targetId) }));
   assertUniqueTargets(targets);
   return {
     profile,
     targets,
     expectedPaths: [...new Set([...targets.map((target) => target.path), "docs/architecture/.projection-manifest.json"])].sort(),
+    retiredTargetPaths: profile === REPO_HARNESS_PROJECTION_PROFILE ? FIXED_TARGETS.map((target) => target.path) : [],
     orphanRoots: ["docs/architecture/modules", "docs/architecture/relations"],
     entityPathByNodeId: new Map(entityTargets.map((target, index) => [targetNodes[index].id, target.path]))
   };
@@ -18124,7 +18258,10 @@ function loadArchitectureFilesForLayout(root, layout) {
   }
   if (paths.has(ARCHITECTURE_DOCS_PROJECTION_MANIFEST_PATH)) {
     const manifest = readProjectionOwnedFile(resolve5(root, ARCHITECTURE_DOCS_PROJECTION_MANIFEST_PATH), ARCHITECTURE_DOCS_PROJECTION_MANIFEST_PATH);
-    for (const output of committedGeneratedOutputs(currentFormatManifest(manifest.body))) {
+    const retired = new Set(layout.retiredTargetPaths);
+    for (const output of committedProjectionOutputs(currentFormatManifest(manifest.body))) {
+      if (output.ownership !== "generated" && !retired.has(output.path))
+        continue;
       if (resolveSafeRegularPath(root, output.path, false))
         paths.add(output.path);
     }
@@ -18132,17 +18269,20 @@ function loadArchitectureFilesForLayout(root, layout) {
   return [...paths].sort().map((path) => readProjectionOwnedFile(resolve5(root, path), path));
 }
 var OUTPUT_DIGEST_PATTERN = /^sha256:[a-f0-9]{64}$/;
-function committedGeneratedOutputs(manifest) {
+function committedProjectionOutputs(manifest) {
   if (manifest === undefined)
     return [];
   const outputs = [];
   for (const [targetId, row] of Object.entries(manifest.targets)) {
-    if (row.ownership !== "generated" || !OUTPUT_DIGEST_PATTERN.test(row.outputDigest) || !isRepoRelativePosixPath(row.path) || !row.path.startsWith("docs/architecture/") || row.path === ARCHITECTURE_DOCS_PROJECTION_MANIFEST_PATH)
+    if (!OUTPUT_DIGEST_PATTERN.test(row.outputDigest) || !isRepoRelativePosixPath(row.path) || !row.path.startsWith("docs/architecture/") || row.path === ARCHITECTURE_DOCS_PROJECTION_MANIFEST_PATH)
       continue;
-    outputs.push({ targetId, path: row.path, outputDigest: row.outputDigest });
+    outputs.push({ targetId, path: row.path, ownership: row.ownership, outputDigest: row.outputDigest });
   }
   return outputs;
 }
+function committedGeneratedOutputs(manifest) {
+  return committedProjectionOutputs(manifest).filter((output) => output.ownership === "generated").map(({ targetId, path, outputDigest }) => ({ targetId, path, outputDigest }));
+}
 function currentFormatManifest(body) {
   let parsed;
   try {
@@ -20034,9 +20174,17 @@ class ProjectionPreconditionError extends Error {
 class ProjectionManifestUpgradeRequiredError extends ProjectionPreconditionError {
   schemaVersion;
   reasonCode = PROJECTION_MANIFEST_UPGRADE_REQUIRED;
+  details;
   constructor(schemaVersion) {
-    super(`${PROJECTION_MANIFEST_UPGRADE_REQUIRED}: ${ARCHITECTURE_DOCS_PROJECTION_MANIFEST_PATH} is ${schemaVersion}, and this archctx reads only ${ARCHITECTURE_DOCS_PROJECTION_MANIFEST_SCHEMA_VERSION}; reach a clean projection on the earlier release first, then re-baseline once with archctx docs apply --approved --profile <default|repo-harness/v1>; if that apply names whole-file outputs the earlier release wrote, remove them with git rm and run it again`);
+    super(`${PROJECTION_MANIFEST_UPGRADE_REQUIRED}: ${ARCHITECTURE_DOCS_PROJECTION_MANIFEST_PATH} is ${schemaVersion}, and this archctx reads only ${ARCHITECTURE_DOCS_PROJECTION_MANIFEST_SCHEMA_VERSION}; reach a clean projection on the earlier release first, then re-baseline once with ${ARCHITECTURE_DOCS_PROJECTION_MANIFEST_UPGRADE_COMMAND}; if that apply names whole-file outputs the earlier release wrote, remove them with git rm and run it again; ${ARCHITECTURE_DOCS_PROJECTION_MANIFEST_MIGRATION_GUIDE} lists the model and release preconditions`);
     this.schemaVersion = schemaVersion;
+    this.details = isSupersededArchitectureDocsProjectionManifestSchemaVersion(schemaVersion) ? {
+      manifestPath: ARCHITECTURE_DOCS_PROJECTION_MANIFEST_PATH,
+      foundSchemaVersion: schemaVersion,
+      supportedSchemaVersion: ARCHITECTURE_DOCS_PROJECTION_MANIFEST_SCHEMA_VERSION,
+      upgradeCommand: ARCHITECTURE_DOCS_PROJECTION_MANIFEST_UPGRADE_COMMAND,
+      migrationGuide: ARCHITECTURE_DOCS_PROJECTION_MANIFEST_MIGRATION_GUIDE
+    } : {};
   }
 }
 
@@ -22177,7 +22325,7 @@ function sameOwners(left, right) {
 
 // packages/core/module-statistics/src/index.ts
 function evaluateDependencyConstraints(input) {
-  const constraints = [...input.constraints].sort((left, right) => compare2(left.id, right.id));
+  const constraints = [...input.constraints].sort((left, right) => compare3(left.id, right.id));
   const certification = certifyCodeFacts(input.codeFacts, input.worktreeDigest, input.truncated, input.importNodeLimitExceeded ?? false);
   if (constraints.length === 0) {
     return {
@@ -22255,7 +22403,7 @@ function evaluateDependencyConstraints(input) {
     reasonCodes.add("unresolved-import");
   if (input.workspacePackagesResolved === false)
     reasonCodes.add("workspace-resolution-failed");
-  const sortedViolations = [...violations.values()].sort((left, right) => compare2(left.constraintId, right.constraintId) || compare2(left.fromPath, right.fromPath) || compare2(left.toPath, right.toPath));
+  const sortedViolations = [...violations.values()].sort((left, right) => compare3(left.constraintId, right.constraintId) || compare3(left.fromPath, right.fromPath) || compare3(left.toPath, right.toPath));
   return {
     schemaVersion: "archcontext.dependency-constraint-evaluation/v1",
     status: sortedViolations.length > 0 ? "violated" : reasonCodes.size > 0 ? "undetermined" : "pass",
@@ -22332,7 +22480,7 @@ function measureCapabilityDependencies(input) {
     const cellKey = JSON.stringify([from.capability, to.capability]);
     let cell = cells.get(cellKey);
     if (cell === undefined) {
-      const relationIds = [...new Set(declaringRelations.get(cellKey) ?? [])].sort(compare2);
+      const relationIds = [...new Set(declaringRelations.get(cellKey) ?? [])].sort(compare3);
       cell = { from: from.capability, to: to.capability, imports: 0, calls: null, declared: from.capability === to.capability || relationIds.length > 0, relationIds };
       cells.set(cellKey, cell);
     }
@@ -22340,14 +22488,14 @@ function measureCapabilityDependencies(input) {
     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) => compare2(left.fromPath, right.fromPath) || compare2(left.toPath, right.toPath));
+  attributedEdges.sort((left, right) => compare3(left.fromPath, right.fromPath) || compare3(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(compare2),
-    matrix: [...cells.values()].sort((left, right) => compare2(left.from, right.from) || compare2(left.to, right.to)),
+    capabilities: input.nodes.filter((node) => node.kind === "capability").map((node) => node.id).sort(compare3),
+    matrix: [...cells.values()].sort((left, right) => compare3(left.from, right.from) || compare3(left.to, right.to)),
     imports: {
       coverage: certification.coverage,
       reasonCodes: [...certification.reasonCodes].sort(),
@@ -22383,7 +22531,7 @@ function isRepositoryLocalSpecifier(specifier, workspacePackages) {
     return true;
   return workspacePackages.some((workspacePackage) => specifier === workspacePackage.name || specifier.startsWith(`${workspacePackage.name}/`));
 }
-function compare2(left, right) {
+function compare3(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
 function measureModuleStatistics(input) {
@@ -22468,7 +22616,7 @@ function modelDigest(model, constraints) {
     nodes: [...model.nodes].sort((left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0),
     relations: [...model.relations].sort((left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0),
     flows: [...model.flows ?? []].sort((left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0),
-    ...constraints.length === 0 ? {} : { constraints: [...constraints].sort((left, right) => compare2(left.id, right.id)) }
+    ...constraints.length === 0 ? {} : { constraints: [...constraints].sort((left, right) => compare3(left.id, right.id)) }
   });
 }
 function countViolationsByNode(evaluation) {
@@ -23097,17 +23245,21 @@ function assertNativeGitRevision(ref) {
     throw new NativeContextError("native-context-ref-unsafe", { selector: "ref" });
 }
 function readOnlyGit(root, operation, args, options = {}) {
-  if (!["rev-parse", "ls-tree", "ls-files", "cat-file"].includes(operation))
+  if (!["rev-parse", "ls-tree", "ls-files", "cat-file", "log"].includes(operation))
     throw new NativeContextError("native-context-git-read-failed", { category: "unsupported-operation" });
   const unsafeArguments = () => {
     throw new NativeContextError("native-context-git-read-failed", { operation, category: "unsupported-read-arguments" });
   };
   if (operation === "rev-parse") {
-    if (args.length === 1 && args[0] === "--show-toplevel") {} else if (args.length === 1 && isGitRevisionArgument(args[0])) {} else if (args.length === 3 && args[0] === "--verify" && args[1] === "--end-of-options")
+    if (args.length === 1 && ["--show-toplevel", "--is-shallow-repository"].includes(args[0])) {} else if (args.length === 1 && isGitRevisionArgument(args[0])) {} else if (args.length === 3 && args[0] === "--verify" && args[1] === "--end-of-options")
       assertNativeGitRevision(args[2]);
     else
       unsafeArguments();
   }
+  if (operation === "log") {
+    if (args.length !== 8 || args[0] !== "--first-parent" || args[1] !== "--reverse" || args[2] !== "-z" || args[3] !== "--format=%H%x00%cI%x00%s" || !OBJECT_ID.test(args[4]) || args[5] !== "--" || args[6] !== ".archcontext/model" || args[7] !== ".archcontext/manifest.yaml")
+      unsafeArguments();
+  }
   if (operation === "ls-tree") {
     const flags = args.slice(0, -1);
     if (!flags.includes("-r") || !flags.includes("-z") || flags.some((flag) => !["-r", "-z", "-t", "-l"].includes(flag)) || new Set(flags).size !== flags.length)
@@ -23133,7 +23285,7 @@ function readOnlyGit(root, operation, args, options = {}) {
   const env = { ...process.env, LC_ALL: "C", GIT_NO_REPLACE_OBJECTS: "1", GIT_NO_LAZY_FETCH: "1", GIT_OPTIONAL_LOCKS: "0", GIT_PAGER: "cat", GIT_ALLOW_PROTOCOL: "", GIT_TERMINAL_PROMPT: "0" };
   for (const key of ["GIT_DIR", "GIT_WORK_TREE", "GIT_COMMON_DIR", "GIT_INDEX_FILE", "GIT_OBJECT_DIRECTORY", "GIT_ALTERNATE_OBJECT_DIRECTORIES", "GIT_NAMESPACE"])
     delete env[key];
-  const result = spawnSync("git", ["--no-pager", "--no-replace-objects", "-c", "core.fsmonitor=false", operation, ...args], {
+  const result = spawnSync("git", ["--no-pager", "--no-replace-objects", "-c", "core.fsmonitor=false", ...operation === "log" ? ["-c", "log.showSignature=false"] : [], operation, ...args], {
     cwd: root,
     env,
     input: options.input,
@@ -23811,10 +23963,10 @@ function record5(value) {
 function text(value) {
   return typeof value === "string" && value.length > 0;
 }
-function node(value) {
+function node2(value) {
   return record5(value) && ["id", "kind", "name", "qualifiedName", "filePath", "language"].every((key) => typeof value[key] === "string") && text(value.id) && ["startLine", "endLine", "startColumn", "endColumn", "updatedAt"].every((key) => typeof value[key] === "number" && Number.isFinite(value[key]));
 }
-function edge(value) {
+function edge2(value) {
   return record5(value) && text(value.source) && text(value.target) && (value.kind === "calls" || value.kind === "references") && (value.line === undefined || typeof value.line === "number" && Number.isFinite(value.line)) && (value.column === undefined || typeof value.column === "number" && Number.isFinite(value.column)) && (value.metadata === undefined || record5(value.metadata));
 }
 function fileRecord(value) {
@@ -23861,12 +24013,12 @@ function decodeReader(output, root, request) {
     }
     return result;
   };
-  const names = table(wire.names, (value) => rows(value, node));
+  const names = table(wire.names, (value) => rows(value, node2));
   sameKeys(names, request.names);
   for (const [name, nodes] of names)
     if (nodes.some((item) => item.name !== name))
       unavailable();
-  const filesByPath = table(wire.filesByPath, (value) => rows(value, node));
+  const filesByPath = table(wire.filesByPath, (value) => rows(value, node2));
   const sources = new Map;
   const sourcePaths = new Set(request.sources.map((source) => source.path));
   for (const source of request.sources) {
@@ -23880,7 +24032,7 @@ function decodeReader(output, root, request) {
     }
   }
   sameKeys(filesByPath, sourcePaths);
-  const outgoing = table(wire.outgoing, (value) => rows(value, edge));
+  const outgoing = table(wire.outgoing, (value) => rows(value, edge2));
   sameKeys(outgoing, sources.keys());
   const targetIds = new Set;
   for (const [id, edges] of outgoing)
@@ -23890,7 +24042,7 @@ function decodeReader(output, root, request) {
       targetIds.add(item.target);
     }
   const targets = table(wire.targets, (value) => {
-    if (++items > MAX_ITEMS || value !== null && !node(value))
+    if (++items > MAX_ITEMS || value !== null && !node2(value))
       return unavailable();
     return value;
   });
@@ -25459,6 +25611,8 @@ function architectureDeltaTask(git) {
 var CODEGRAPH_IMPORT_NODE_READ_LIMIT = 50000;
 var CODEGRAPH_IMPORT_NODE_OUTPUT_BYTES = 4 * 1024;
 function prepareArchitectureDocumentationProjectionSnapshot(root, model, options = {}) {
+  if (codeGraphIndexAvailable(root))
+    assertRepositoryCodeFactsReady(root, options.binary ? { binary: options.binary } : {});
   const baseHeadSha = readProjectionHeadSha(root);
   const sourceFiles = listGitVisibleFiles(root);
   const worktreeDigest = architectureDocumentationProjectionWorktreeDigest(root, model, sourceFiles);
@@ -25603,7 +25757,33 @@ function prepareProjectionCodeFacts(root, model, options) {
     }
   };
 }
+
+class CodeGraphIndexBuildInProgressError extends Error {
+  constructor() {
+    super("CodeGraph index build is in progress");
+    this.name = "CodeGraphIndexBuildInProgressError";
+  }
+}
+function codeGraphIndexBuildInProgress(workspaceRoot) {
+  let raw;
+  try {
+    raw = readFileSync7(join3(workspaceRoot, ".codegraph", "codegraph.lock"), "utf8").trim();
+  } catch {
+    return false;
+  }
+  const pid = Number.parseInt(raw, 10);
+  if (!Number.isSafeInteger(pid) || pid <= 0 || String(pid) !== raw)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
 function readProjectionCodeGraphStatus(invocation, root, timeout, envOverrides) {
+  if (codeGraphIndexBuildInProgress(root))
+    throw new CodeGraphIndexBuildInProgressError;
   const output = runProjectionCodeGraph(invocation, root, ["status", "-j", root], timeout, envOverrides);
   try {
     return JSON.parse(output);
@@ -25922,8 +26102,9 @@ function mirrorCodeGraphInputs(root, gitDir, commonDir, destination) {
 var CODEGRAPH_NO_DOWNLOAD_ENV = { CODEGRAPH_NO_DOWNLOAD: "1" };
 function inspectRepositoryCodeFacts(root, options = {}) {
   const schemaVersion = "archcontext.repository-code-facts/v1";
-  let codeGraphVersion;
+  let codeGraphVersion = "";
   let status;
+  let indexBuildInProgress = false;
   const indexPresent = codeGraphIndexAvailable(root);
   try {
     const invocation = options.binary ? codeGraphCliInvocation(options.binary, root, "") : packagedCodeGraphCliInvocation();
@@ -25931,18 +26112,37 @@ function inspectRepositoryCodeFacts(root, options = {}) {
     if (indexPresent)
       status = readProjectionCodeGraphStatus(invocation, root, options.timeouts?.statusMs ?? 1e4, CODEGRAPH_NO_DOWNLOAD_ENV);
   } catch (error) {
-    return {
-      schemaVersion,
-      state: "unavailable",
-      requiredVersion: REQUIRED_CODEGRAPH_VERSION,
-      reasonCode: "codegraph-unavailable",
-      message: (error instanceof Error ? error.message : String(error)).replace(/\s+/g, " ").trim().slice(0, 400)
-    };
+    if (!(error instanceof CodeGraphIndexBuildInProgressError)) {
+      return {
+        schemaVersion,
+        state: "unavailable",
+        requiredVersion: REQUIRED_CODEGRAPH_VERSION,
+        reasonCode: "codegraph-unavailable",
+        message: (error instanceof Error ? error.message : String(error)).replace(/\s+/g, " ").trim().slice(0, 400)
+      };
+    }
+    indexBuildInProgress = true;
   }
   const versionIssues = codeGraphVersion === REQUIRED_CODEGRAPH_VERSION ? [] : [{ code: "version-mismatch", message: CODE_FACTS_ISSUE_MESSAGES["version-mismatch"] }];
   if (!indexPresent) {
     return { schemaVersion, state: "index-missing", indexPresent: false, requiredVersion: REQUIRED_CODEGRAPH_VERSION, codeGraphVersion, issues: versionIssues };
   }
+  if (indexBuildInProgress) {
+    return {
+      schemaVersion,
+      state: "not-ready",
+      indexPresent: true,
+      requiredVersion: REQUIRED_CODEGRAPH_VERSION,
+      codeGraphVersion,
+      indexBuiltWithVersion: null,
+      extractionVersion: { builtWith: null, current: null },
+      indexState: null,
+      reindexRecommended: null,
+      pendingRefs: null,
+      pendingChanges: null,
+      issues: [...versionIssues, { code: "index-incomplete", message: CODE_FACTS_ISSUE_MESSAGES["index-incomplete"] }]
+    };
+  }
   if (typeof status !== "object" || status === null || Array.isArray(status)) {
     return {
       schemaVersion,
@@ -26329,6 +26529,8 @@ function selectedProducerFailure(error, stage) {
       const details = stage === "docs-anchors" || stage === "flows-check" ? {} : { checks: ["ownership", "anchors"] };
       return new FailureError(selectedProducerData(error, "code"), selectedProducerData(error, "reasonCode"), details);
     }
+    if (error instanceof ProjectionManifestUpgradeRequiredError)
+      return new FailureError("AC_PRECONDITION_FAILED", selectedProducerData(error, "reasonCode"), selectedProducerData(error, "details"));
     if (error instanceof ProjectionPreconditionError)
       return new FailureError("AC_PRECONDITION_FAILED", selectedProducerData(error, "reasonCode"));
     if (error instanceof ProjectionCodeFactsUnavailableError)
@@ -26346,10 +26548,10 @@ function selectedProducerFailureEnvelope(requestId, error, stage) {
 // packages/local-runtime/runtime-daemon/src/refactor-scan.ts
 init_src();
 init_src();
-import { execFileSync as execFileSync3 } from "node:child_process";
-import { createHash as createHash8 } from "node:crypto";
-import { existsSync as existsSync8, readdirSync as readdirSync6, readFileSync as readFileSync9 } from "node:fs";
-import { join as join5 } from "node:path";
+import { execFileSync as execFileSync4 } from "node:child_process";
+import { createHash as createHash9 } from "node:crypto";
+import { existsSync as existsSync8, readdirSync as readdirSync7, readFileSync as readFileSync10 } from "node:fs";
+import { join as join7 } from "node:path";
 
 // packages/core/refactor-assessment/src/index.ts
 init_src();
@@ -27192,7 +27394,7 @@ function buildObservations(snapshot, structure, model) {
       evidence: evidence.evidenceGap()
     });
   }
-  return drafts.map((draft, index) => ({ draft, order: draft.kind === "cycle" ? index : 0 })).sort((left, right) => compare3(left.draft.kind, right.draft.kind) || left.order - right.order || compare3(left.draft.subjectSelectorId, right.draft.subjectSelectorId)).map(({ draft }) => ({
+  return drafts.map((draft, index) => ({ draft, order: draft.kind === "cycle" ? index : 0 })).sort((left, right) => compare4(left.draft.kind, right.draft.kind) || left.order - right.order || compare4(left.draft.subjectSelectorId, right.draft.subjectSelectorId)).map(({ draft }) => ({
     kind: draft.kind,
     subjectSelectorId: draft.subjectSelectorId,
     affectedNodeIds: draft.affectedNodeIds,
@@ -27382,13 +27584,13 @@ function signalIdFor(draft) {
 }
 function modelDigest2(model, constraints) {
   return digestJson({
-    nodes: [...model.nodes].sort((left, right) => compare3(left.id, right.id)),
-    relations: [...model.relations].sort((left, right) => compare3(left.id, right.id)),
-    flows: [...model.flows ?? []].sort((left, right) => compare3(left.id, right.id)),
-    ...constraints.length === 0 ? {} : { constraints: [...constraints].sort((left, right) => compare3(left.id, right.id)) }
+    nodes: [...model.nodes].sort((left, right) => compare4(left.id, right.id)),
+    relations: [...model.relations].sort((left, right) => compare4(left.id, right.id)),
+    flows: [...model.flows ?? []].sort((left, right) => compare4(left.id, right.id)),
+    ...constraints.length === 0 ? {} : { constraints: [...constraints].sort((left, right) => compare4(left.id, right.id)) }
   });
 }
-function compare3(left, right) {
+function compare4(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
 function isNumber(value) {
@@ -27400,8 +27602,117 @@ function isPresent2(value) {
 
 // packages/local-runtime/model-store-yaml/src/index.ts
 init_src();
-import { existsSync as existsSync7, lstatSync as lstatSync6, mkdirSync as mkdirSync5, readdirSync as readdirSync5, readFileSync as readFileSync8, rmSync as rmSync5 } from "node:fs";
-import { dirname as dirname5, resolve as resolve12 } from "node:path";
+import { existsSync as existsSync7, lstatSync as lstatSync6, mkdirSync as mkdirSync6, readdirSync as readdirSync6, readFileSync as readFileSync9, rmSync as rmSync5 } from "node:fs";
+import { dirname as dirname5, resolve as resolve13 } from "node:path";
+
+// packages/local-runtime/model-store-yaml/src/architecture-history.ts
+init_src();
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync8, renameSync as renameSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join5 } from "node:path";
+import { randomUUID } from "node:crypto";
+
+// packages/local-runtime/runtime-state-paths/src/index.ts
+import { execFileSync as execFileSync3 } from "node:child_process";
+import { createHash as createHash6 } from "node:crypto";
+import { readdirSync as readdirSync5, realpathSync as realpathSync4 } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute as isAbsolute5, join as join4, resolve as resolve11 } from "node:path";
+var ARCHCONTEXT_STATE_DIR_ENV = "ARCHCONTEXT_STATE_DIR";
+var ARCHCONTEXT_LOCAL_STORE_PATH_ENV = "ARCHCONTEXT_LOCAL_STORE_PATH";
+function defaultArchContextStateRoot(env = process.env, platform = process.platform, home = homedir()) {
+  const override = env[ARCHCONTEXT_STATE_DIR_ENV];
+  if (override)
+    return { path: resolve11(override), source: "environment" };
+  if (platform === "darwin")
+    return { path: join4(home, "Library", "Application Support", "ArchContext"), source: "os-user-data" };
+  if (platform === "win32")
+    return { path: join4(env.LOCALAPPDATA ?? join4(home, "AppData", "Local"), "ArchContext"), source: "os-user-data" };
+  return { path: join4(env.XDG_DATA_HOME ?? join4(home, ".local", "share"), "archcontext"), source: "os-user-data" };
+}
+function runtimeStatePaths(root = process.cwd(), env = process.env) {
+  const repositoryRoot = readGitPath(root, ["rev-parse", "--show-toplevel"]) ?? root;
+  const canonicalRepositoryRoot = canonicalPath(repositoryRoot);
+  const gitCommonDir = readGitPath(canonicalRepositoryRoot, ["rev-parse", "--git-common-dir"]);
+  const repositoryAnchor = canonicalPath(gitCommonDir ? resolveMaybeRelative(canonicalRepositoryRoot, gitCommonDir) : canonicalRepositoryRoot);
+  const workspaceAnchor = canonicalRepositoryRoot;
+  const storageRepositoryId = stableStorageId("repo", repositoryAnchor);
+  const storageWorkspaceId = stableStorageId("ws", workspaceAnchor);
+  const stateRoot = defaultArchContextStateRoot(env);
+  const repositoryStateDir = join4(stateRoot.path, REPOSITORIES_DIR, storageRepositoryId);
+  const workspaceStateDir = join4(repositoryStateDir, WORKTREES_DIR, storageWorkspaceId);
+  const legacyControlDir = resolve11(canonicalRepositoryRoot, ".archcontext", ".local");
+  return {
+    schemaVersion: "archcontext.runtime-state-paths/v1",
+    stateRoot: stateRoot.path,
+    source: stateRoot.source,
+    repositoryRoot: canonicalRepositoryRoot,
+    repositoryAnchor,
+    workspaceAnchor,
+    storageRepositoryId,
+    storageWorkspaceId,
+    repositoryId: storageRepositoryId,
+    workspaceId: storageWorkspaceId,
+    repositoryStateDir,
+    workspaceStateDir,
+    sharedCacheDir: join4(repositoryStateDir, "shared", "cache"),
+    localStorePath: env[ARCHCONTEXT_LOCAL_STORE_PATH_ENV] ?? join4(workspaceStateDir, "runtime.sqlite"),
+    ...daemonControlPaths(workspaceStateDir),
+    developerReviewRunStateDir: join4(workspaceStateDir, "developer-review-runs"),
+    legacyControlDir,
+    legacyLocalStorePath: join4(legacyControlDir, "runtime.sqlite")
+  };
+}
+var REPOSITORIES_DIR = "repositories";
+var WORKTREES_DIR = "worktrees";
+function daemonControlPaths(workspaceStateDir) {
+  return {
+    daemonConnectionPath: join4(workspaceStateDir, "archctxd.json"),
+    daemonLockPath: join4(workspaceStateDir, "archctxd.lock"),
+    daemonLogPath: join4(workspaceStateDir, "archctxd.log")
+  };
+}
+function listWorkspaceStateDirs(stateRoot) {
+  return listDirectoryNames(join4(stateRoot, REPOSITORIES_DIR)).flatMap((storageRepositoryId) => listDirectoryNames(join4(stateRoot, REPOSITORIES_DIR, storageRepositoryId, WORKTREES_DIR)).map((storageWorkspaceId) => ({
+    storageRepositoryId,
+    storageWorkspaceId,
+    workspaceStateDir: join4(stateRoot, REPOSITORIES_DIR, storageRepositoryId, WORKTREES_DIR, storageWorkspaceId)
+  })));
+}
+function listDirectoryNames(path) {
+  try {
+    return readdirSync5(path, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return [];
+    throw error;
+  }
+}
+function readGitPath(root, args) {
+  try {
+    const value = execFileSync3("git", args, {
+      cwd: root,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return value.length > 0 ? value : undefined;
+  } catch {
+    return;
+  }
+}
+function resolveMaybeRelative(base, path) {
+  return isAbsolute5(path) ? resolve11(path) : resolve11(base, path);
+}
+function canonicalPath(path) {
+  const resolved = resolve11(path);
+  try {
+    return realpathSync4.native(resolved);
+  } catch {
+    return resolved;
+  }
+}
+function stableStorageId(prefix, value) {
+  return `${prefix}.${createHash6("sha256").update(value).digest("hex").slice(0, 16)}`;
+}
 // schemas/repo/architecture-node.schema.json
 var architecture_node_schema_default = {
   $schema: "https://json-schema.org/draft/2020-12/schema",
@@ -27522,12 +27833,6 @@ var architecture_node_schema_default = {
     extensions: { type: "object", additionalProperties: true }
   }
 };
-
-// packages/local-runtime/model-store-yaml/src/native-context.ts
-init_src();
-import { createHash as createHash6 } from "node:crypto";
-import { constants, closeSync as closeSync4, fstatSync as fstatSync2, lstatSync as lstatSync5, openSync as openSync4, readSync as readSync2, realpathSync as realpathSync4 } from "node:fs";
-import { join as join4, resolve as resolve11 } from "node:path";
 // schemas/repo/architecture-relation.schema.json
 var architecture_relation_schema_default = {
   $schema: "https://json-schema.org/draft/2020-12/schema",
@@ -27555,6 +27860,185 @@ var architecture_relation_schema_default = {
     extensions: { type: "object", additionalProperties: true }
   }
 };
+
+// packages/local-runtime/model-store-yaml/src/architecture-history.ts
+var compare5 = nativeByteCompare;
+var modelRoot = ".archcontext/model";
+var failed = (code, path) => ({ nodes: null, edges: null, structure: null, error: { code, ...path ? { path } : {} } });
+var edgeKey = (e) => JSON.stringify([e.source, e.target]);
+function stateForRevision(root, rev, parsed) {
+  try {
+    let context;
+    try {
+      context = readGitBlobTree(root, `${rev}:.archcontext`, { sizes: false });
+    } catch (error) {
+      if (!(error instanceof NativeContextError) || error.reasonCode !== "native-context-git-read-failed")
+        throw error;
+      if (readGitBlobTree(root, rev, { sizes: false }).some((entry) => entry.path === ".archcontext" && entry.type === "tree"))
+        throw error;
+      return failed("history-model-missing");
+    }
+    const manifest = context.find((entry) => entry.path === "manifest.yaml");
+    if (manifest && manifest.type !== "blob")
+      return failed("history-model-layout-unsupported");
+    const read = (entry) => {
+      if (!parsed.has(entry.objectId)) {
+        const body = readGitBlobs(root, [entry])[0];
+        try {
+          parsed.set(entry.objectId, { value: parseJsonOrStableYaml(decodeUtf8(body), entry.path) });
+        } catch {
+          parsed.set(entry.objectId, { invalid: true });
+        }
+      }
+      return parsed.get(entry.objectId);
+    };
+    if (manifest) {
+      const data = read(manifest);
+      if (data.value?.schemaVersion !== "archcontext.manifest/v1" || data.value.model?.layout !== "split" || data.value.model.root !== modelRoot)
+        return failed("history-model-layout-unsupported");
+    }
+    if (!context.some((entry) => entry.path === "model" && entry.type === "tree"))
+      return failed("history-model-missing");
+    const all = readGitBlobTree(root, `${rev}:${modelRoot}`, { sizes: false }).map((entry) => ({ ...entry, path: `${modelRoot}/${entry.path}` }));
+    const nodesDir = all.find((entry) => entry.path === `${modelRoot}/nodes` && entry.type === "tree");
+    if (!nodesDir)
+      return failed("history-model-missing");
+    const files = all.filter((entry) => entry.type === "blob" && (entry.path.startsWith(`${modelRoot}/nodes/`) || entry.path.startsWith(`${modelRoot}/relations/`)) && /\.ya?ml$/.test(entry.path)).sort((a, b) => compare5(a.path, b.path));
+    const missing = [...new Map(files.filter((file) => !parsed.has(file.objectId)).map((file) => [file.objectId, file])).values()];
+    const blobs = readGitBlobs(root, missing);
+    missing.forEach((file, index) => {
+      try {
+        parsed.set(file.objectId, { value: parseJsonOrStableYaml(decodeUtf8(blobs[index]), file.path) });
+      } catch {
+        parsed.set(file.objectId, { invalid: true });
+      }
+    });
+    const nodes = [], relations = [];
+    const paths = new Map;
+    for (const file of files) {
+      const result = read(file);
+      const isNode = file.path.startsWith(`${modelRoot}/nodes/`);
+      if (result.invalid || result.value === undefined || !validateJsonSchema(isNode ? architecture_node_schema_default : architecture_relation_schema_default, result.value).valid)
+        return failed("history-model-invalid", file.path);
+      if (isNode) {
+        const value = result.value;
+        if (paths.has(value.id))
+          return failed("history-model-invalid", file.path);
+        paths.set(value.id, file.path);
+        nodes.push(value);
+      } else
+        relations.push(result.value);
+    }
+    const byId = new Map(nodes.map((node) => [node.id, node]));
+    for (const node of nodes) {
+      const visited = new Set;
+      let cursor = node;
+      while (cursor) {
+        if (visited.has(cursor.id))
+          return failed("history-model-invalid", paths.get(node.id));
+        visited.add(cursor.id);
+        cursor = cursor.parent ? byId.get(cursor.parent) : undefined;
+      }
+    }
+    const nearest = (id) => {
+      let node = byId.get(id);
+      while (node) {
+        if (node.kind === "capability")
+          return node.id;
+        node = node.parent ? byId.get(node.parent) : undefined;
+      }
+      return;
+    };
+    const edges = new Map;
+    for (const relation of relations) {
+      const source = nearest(relation.source), target = nearest(relation.target);
+      if (source && target && source !== target) {
+        const edge = { source, target };
+        edges.set(edgeKey(edge), edge);
+      }
+    }
+    return {
+      nodes: nodes.filter((node) => node.kind === "capability").map((node) => ({ id: node.id, name: node.name, domain: /^capability\.([a-z0-9]+(?:-[a-z0-9]+)*)\.([a-z0-9]+(?:-[a-z0-9]+)*)$/.exec(node.id)?.[1] ?? null })).sort((a, b) => compare5(a.id, b.id)),
+      edges: [...edges.values()].sort((a, b) => compare5(a.source, b.source) || compare5(a.target, b.target)),
+      structure: nodes.filter((node) => ["capability", "module", "component"].includes(node.kind)).map((node) => ({ id: node.id, kind: node.kind, name: node.name, capability: nearest(node.id) ?? null })).sort((a, b) => compare5(a.id, b.id))
+    };
+  } catch (error) {
+    if (error instanceof NativeContextError && error.reasonCode === "native-context-limit-exceeded")
+      return failed("history-model-too-large");
+    throw error;
+  }
+}
+function difference(before, after, baseRev) {
+  const a = new Map(before.structure.map((node) => [node.id, node])), b = new Map(after.structure.map((node) => [node.id, node]));
+  const ae = new Map(before.edges.map((edge) => [edgeKey(edge), edge])), be = new Map(after.edges.map((edge) => [edgeKey(edge), edge]));
+  return {
+    baseRev,
+    added: after.structure.filter((node) => !a.has(node.id)).map(({ id, kind, capability }) => ({ id, kind, capability })),
+    removed: before.structure.filter((node) => !b.has(node.id)).map(({ id, kind, capability }) => ({ id, kind, capability })),
+    renamed: after.structure.flatMap((node) => {
+      const old = a.get(node.id);
+      return old && old.name !== node.name ? [{ id: node.id, kind: node.kind, capability: node.capability, from: old.name, to: node.name }] : [];
+    }),
+    edgesChanged: { added: after.edges.filter((edge) => !ae.has(edgeKey(edge))), removed: before.edges.filter((edge) => !be.has(edgeKey(edge))) }
+  };
+}
+function readArchitectureHistory(cwd, options = {}) {
+  const root = readNativeGitRoot(cwd);
+  if (decodeUtf8(readOnlyGit(root, "rev-parse", ["--is-shallow-repository"])).trim() === "true")
+    throw new FailureError("AC_PRECONDITION_FAILED", "history-shallow-repository");
+  const head = resolveNativeGitSnapshot(root, options.ref ?? "HEAD").commitSha;
+  const output = decodeUtf8(readOnlyGit(root, "log", ["--first-parent", "--reverse", "-z", "--format=%H%x00%cI%x00%s", head, "--", modelRoot, ".archcontext/manifest.yaml"]));
+  const fields = output ? output.split("\x00") : [];
+  if (fields.length && fields.pop() !== "")
+    throw new NativeContextError("native-context-git-read-failed", { operation: "log", category: "malformed-record" });
+  if (fields.length % 3 !== 0)
+    throw new NativeContextError("native-context-git-read-failed", { operation: "log", category: "malformed-record" });
+  for (let i = 0;i < fields.length; i += 3)
+    if (!/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(fields[i]))
+      throw new NativeContextError("native-context-git-read-failed", { operation: "log", category: "malformed-record" });
+  const parsed = new Map;
+  const milestones = [];
+  let previous = { nodes: [], edges: [], structure: [] };
+  let havePrevious = false, priorError, previousMilestone = null;
+  const cacheDir = join5(runtimeStatePaths(root, options.env).sharedCacheDir, "architecture-history", ARCHITECTURE_HISTORY_DERIVATION_VERSION);
+  for (let i = 0;i < fields.length; i += 3) {
+    const [rev, date, subject] = fields.slice(i, i + 3);
+    const cache = join5(cacheDir, `${rev}.json`);
+    let state;
+    try {
+      state = decodeArchitectureHistoryState(JSON.parse(readFileSync8(cache, "utf8")));
+    } catch {}
+    if (!state) {
+      state = stateForRevision(root, rev, parsed);
+      mkdirSync5(cacheDir, { recursive: true });
+      const temporary = `${cache}.${randomUUID()}.tmp`;
+      writeFileSync4(temporary, JSON.stringify(state));
+      renameSync3(temporary, cache);
+    }
+    if (state.error) {
+      if (priorError !== state.error.code)
+        milestones.push({ rev, date, subject, nodes: null, edges: null, delta: null, error: state.error });
+      priorError = state.error.code;
+      continue;
+    }
+    const recovered = priorError !== undefined;
+    priorError = undefined;
+    const delta = difference(previous, state, previousMilestone);
+    if (!havePrevious || recovered || delta.added.length || delta.removed.length || delta.renamed.length || delta.edgesChanged.added.length || delta.edgesChanged.removed.length) {
+      milestones.push({ rev, date, subject, nodes: state.nodes, edges: state.edges, delta });
+      previousMilestone = rev;
+      previous = state;
+      havePrevious = true;
+    }
+  }
+  const offset = options.offset ?? 0, limit = options.limit ?? 200;
+  return { schemaVersion: ARCHITECTURE_HISTORY_SCHEMA_VERSION, head, total: milestones.length, offset, limit, milestones: milestones.slice(offset, offset + limit) };
+}
+// packages/local-runtime/model-store-yaml/src/native-context.ts
+init_src();
+import { createHash as createHash7 } from "node:crypto";
+import { constants, closeSync as closeSync4, fstatSync as fstatSync2, lstatSync as lstatSync5, openSync as openSync4, readSync as readSync2, realpathSync as realpathSync5 } from "node:fs";
+import { join as join6, resolve as resolve12 } from "node:path";
 // schemas/repo/architecture-flow.schema.json
 var architecture_flow_schema_default = {
   $schema: "https://json-schema.org/draft/2020-12/schema",
@@ -27659,7 +28143,7 @@ var SCHEMAS = { node: architecture_node_schema_default, relation: architecture_r
 var MANIFEST = ".archcontext/manifest.yaml";
 var MODEL_KINDS = ["nodes", "relations", "flows"];
 function contentDigest(bytes) {
-  return `sha256:${createHash6("sha256").update(bytes).digest("hex")}`;
+  return `sha256:${createHash7("sha256").update(bytes).digest("hex")}`;
 }
 function record6(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype ? value : undefined;
@@ -27787,23 +28271,23 @@ function observePath(root, path, directory = false) {
   const segments = path.split("/");
   for (let index = -1;index < segments.length; index += 1) {
     if (index >= 0)
-      absolute = join4(absolute, segments[index]);
+      absolute = join6(absolute, segments[index]);
     let stat;
     try {
       stat = lstatSync5(absolute, { bigint: true });
     } catch (error) {
       if (error.code === "ENOENT")
-        return { exists: false, identity: identities.join("/") + "/missing", absolute: resolve11(root, path) };
+        return { exists: false, identity: identities.join("/") + "/missing", absolute: resolve12(root, path) };
       throw new NativeContextError("native-context-input-unreadable", { path, category: "stat" });
     }
     const needsDirectory = index < segments.length - 1 || directory;
     if (stat.isSymbolicLink() || (needsDirectory ? !stat.isDirectory() : !stat.isFile()))
       throw new NativeContextError("native-context-entry-kind-unsupported", { path, category: stat.isSymbolicLink() ? "link" : "non-regular" });
-    if (index >= 0 && realpathSync4.native(absolute) !== absolute)
+    if (index >= 0 && realpathSync5.native(absolute) !== absolute)
       throw new NativeContextError("native-context-path-unsafe", { path, category: "filesystem-path-alias" });
     if (needsDirectory && index >= 0) {
       try {
-        lstatSync5(join4(absolute, ".git"));
+        lstatSync5(join6(absolute, ".git"));
         throw new NativeContextError("native-context-entry-kind-unsupported", { path: segments.slice(0, index + 1).join("/"), category: "nested-repository" });
       } catch (error) {
         if (error instanceof NativeContextError)
@@ -28147,7 +28631,7 @@ function readNativeContext(start, selector, hooks) {
 `, "utf8"));
     return data;
   }
-  const worktreeRoot = realpathSync4.native(root);
+  const worktreeRoot = realpathSync5.native(root);
   const head = resolveNativeGitSnapshot(worktreeRoot, "HEAD");
   const snapshot = { source: "worktree", headSha: head.commitSha, headTreeOid: head.treeOid, validation: "stable-read" };
   const first = new WorktreeSource(worktreeRoot, hooks, 1, head.treeOid);
@@ -28183,7 +28667,7 @@ init_src();
 
 // packages/local-runtime/codegraph-adapter/src/ref-impact-facts.ts
 init_src();
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 import { createRequire as createRequire3 } from "node:module";
 var nonDeclarations = new Set(["file", "import", "export", "parameter"]);
 var requireFromAdapter2 = createRequire3(import.meta.url);
@@ -28217,7 +28701,7 @@ function bindSnapshotRefImpactFacts(root, model, ref, graph) {
     for (let i = 0;i < files.length; i++) {
       const file = files[i], body = blobs[i];
       const content = decodeUtf8(body);
-      if (createHash7("sha256").update(content).digest("hex") !== file.contentHash)
+      if (createHash8("sha256").update(content).digest("hex") !== file.contentHash)
         return;
       lineCounts.set(file.path, content.split(`
 `).length);
@@ -28696,10 +29180,10 @@ function initializeArchContextModel(root, productName = "ArchContext Project") {
   });
   files.push({ path: ".archcontext/projections/targets.json", body: `${JSON.stringify(createDefaultProjectionTargetManifest(), null, 2)}
 ` });
-  mkdirSync5(root, { recursive: true });
+  mkdirSync6(root, { recursive: true });
   const existing = files.filter((file) => {
     assertPathHasNoSymlinkSegments(root, file.path);
-    return lstatIfExists(resolve12(root, file.path)) !== undefined;
+    return lstatIfExists(resolve13(root, file.path)) !== undefined;
   }).map((file) => file.path);
   if (existing.length > 0)
     throw new ArchContextInitRefusedError(existing);
@@ -28712,7 +29196,7 @@ function initializeArchContextModel(root, productName = "ArchContext Project") {
     rebuildGeneratedProjection(root);
   } catch (error) {
     for (const path of created.reverse())
-      rmSync5(resolve12(root, path), { force: true });
+      rmSync5(resolve13(root, path), { force: true });
     throw error;
   }
 }
@@ -28720,7 +29204,7 @@ function rebuildGeneratedProjection(root) {
   for (const operation of planGeneratedProjection(root)) {
     if (operation.operation === "delete_entity") {
       assertPathHasNoSymlinkSegments(root, dirname5(operation.path));
-      rmSync5(resolve12(root, operation.path), { force: true });
+      rmSync5(resolve13(root, operation.path), { force: true });
     } else {
       writeFileWithoutFollowingSymlinks({ root, path: operation.path, body: withTrailingNewline(operation.body), expectedHash: operation.expectedHash });
     }
@@ -28728,12 +29212,12 @@ function rebuildGeneratedProjection(root) {
 }
 function planGeneratedProjection(root) {
   const desiredBody = GENERATED_ARCHITECTURE_BODY;
-  const desiredAbsolute = resolve12(root, GENERATED_ARCHITECTURE_PATH);
+  const desiredAbsolute = resolve13(root, GENERATED_ARCHITECTURE_PATH);
   const operations = [];
-  if (!existsSync7(desiredAbsolute) || readFileSync8(desiredAbsolute, "utf8") !== desiredBody) {
+  if (!existsSync7(desiredAbsolute) || readFileSync9(desiredAbsolute, "utf8") !== desiredBody) {
     operations.push({
       path: GENERATED_ARCHITECTURE_PATH,
-      expectedHash: existsSync7(desiredAbsolute) ? digestJson({ body: readFileSync8(desiredAbsolute, "utf8") }) : "missing",
+      expectedHash: existsSync7(desiredAbsolute) ? digestJson({ body: readFileSync9(desiredAbsolute, "utf8") }) : "missing",
       body: desiredBody,
       operation: "render_projection"
     });
@@ -28741,7 +29225,7 @@ function planGeneratedProjection(root) {
   for (const path of collectGeneratedProjectionFiles(root)) {
     if (path === GENERATED_ARCHITECTURE_PATH)
       continue;
-    const body = readFileSync8(resolve12(root, path), "utf8");
+    const body = readFileSync9(resolve13(root, path), "utf8");
     operations.push({
       path,
       expectedHash: digestJson({ body }),
@@ -28753,9 +29237,9 @@ function planGeneratedProjection(root) {
 }
 function collectGeneratedProjectionFiles(root) {
   const generatedRoot = ".archcontext/generated";
-  if (!existsSync7(resolve12(root, generatedRoot)))
+  if (!existsSync7(resolve13(root, generatedRoot)))
     return [];
-  const walk = (relativeDir) => readdirSync5(resolve12(root, relativeDir), { withFileTypes: true }).flatMap((entry) => {
+  const walk = (relativeDir) => readdirSync6(resolve13(root, relativeDir), { withFileTypes: true }).flatMap((entry) => {
     const child = `${relativeDir}/${entry.name}`;
     if (entry.isDirectory())
       return walk(child);
@@ -28766,7 +29250,7 @@ function collectGeneratedProjectionFiles(root) {
 
 class YamlModelStore {
   async loadManifest(workspace) {
-    return readFileSync8(resolve12(workspace.root, ".archcontext/manifest.yaml"), "utf8");
+    return readFileSync9(resolve13(workspace.root, ".archcontext/manifest.yaml"), "utf8");
   }
   async loadModel(workspace) {
     return listModelFiles(workspace.root);
@@ -28777,7 +29261,7 @@ class YamlModelStore {
     const nodeSchemaErrors = [];
     for (const required of [".archcontext/manifest.yaml", ".archcontext/product.yaml"]) {
       try {
-        readFileSync8(resolve12(workspace.root, required), "utf8");
+        readFileSync9(resolve13(workspace.root, required), "utf8");
       } catch {
         const error = `missing ${required}`;
         errors.push(error);
@@ -28874,7 +29358,7 @@ function listModelFiles(root) {
     "docs/adr"
   ]);
   return paths.map((path) => {
-    const body = readFileSync8(resolve12(root, path), "utf8");
+    const body = readFileSync9(resolve13(root, path), "utf8");
     return {
       path,
       body,
@@ -28886,7 +29370,7 @@ function listModelFiles(root) {
 function collectArchContextFiles(root, entries) {
   const files = [];
   for (const entry of entries) {
-    const absolute = resolve12(root, entry);
+    const absolute = resolve13(root, entry);
     if (!existsSync7(absolute))
       continue;
     const stat = readdirOrFile(absolute);
@@ -28900,8 +29384,8 @@ function collectArchContextFiles(root, entries) {
   return [...new Set(files)].sort();
   function walk(relativeDir) {
     const out = [];
-    const dir = resolve12(root, relativeDir);
-    for (const entry of readdirSync5(dir, { withFileTypes: true })) {
+    const dir = resolve13(root, relativeDir);
+    for (const entry of readdirSync6(dir, { withFileTypes: true })) {
       const child = `${relativeDir}/${entry.name}`;
       if (entry.isDirectory())
         out.push(...walk(child));
@@ -28918,7 +29402,7 @@ function isCollectableModelFile(path) {
 }
 function readdirOrFile(path) {
   try {
-    readdirSync5(path);
+    readdirSync6(path);
     return "directory";
   } catch {
     return "file";
@@ -32381,10 +32865,10 @@ function evaluateWorktreeDependencyConstraints(input) {
   });
 }
 function reviewWorkspacePackages(root) {
-  if (!existsSync8(join5(root, "package.json")))
+  if (!existsSync8(join7(root, "package.json")))
     return { packages: [], resolved: true };
   try {
-    const manifest = JSON.parse(readFileSync9(join5(root, "package.json"), "utf8"));
+    const manifest = JSON.parse(readFileSync10(join7(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");
@@ -32397,10 +32881,10 @@ function reviewWorkspacePackages(root) {
       const parent = /^([^*?[\]{}!]+)\/\*$/.exec(pattern)?.[1];
       if (parent === undefined)
         throw new Error(`unsupported workspace pattern: ${entry}`);
-      return readdirSync6(join5(root, parent), { withFileTypes: true }).filter((child) => child.isDirectory() && existsSync8(join5(root, parent, child.name, "package.json"))).map((child) => `${parent}/${child.name}`);
+      return readdirSync7(join7(root, parent), { withFileTypes: true }).filter((child) => child.isDirectory() && existsSync8(join7(root, parent, child.name, "package.json"))).map((child) => `${parent}/${child.name}`);
     });
     const packages = directories.flatMap((directory) => {
-      const packageManifest = JSON.parse(readFileSync9(join5(root, ...directory.split("/"), "package.json"), "utf8"));
+      const packageManifest = JSON.parse(readFileSync10(join7(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"));
@@ -32426,7 +32910,7 @@ function modelNodes(files) {
 function readWorktreeFiles(root) {
   let output;
   try {
-    output = execFileSync3("git", ["ls-files", "--cached", "--others", "--exclude-standard", "-z"], {
+    output = execFileSync4("git", ["ls-files", "--cached", "--others", "--exclude-standard", "-z"], {
       cwd: root,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"],
@@ -32442,7 +32926,7 @@ function countFilesOutsideHead(root) {
   return readWorktreeFiles(root).filter((path) => !head.has(path)).length;
 }
 function declaredWorkspacePackages(root) {
-  return existsSync8(join5(root, "package.json")) ? readWorkspacePackages(root) : [];
+  return existsSync8(join7(root, "package.json")) ? readWorkspacePackages(root) : [];
 }
 function assertRequestedStateIsCurrent(request, worktree) {
   if (request.expectedHeadSha !== undefined && request.expectedHeadSha !== worktree.headSha) {
@@ -32454,13 +32938,13 @@ function assertRequestedStateIsCurrent(request, worktree) {
 }
 var REFACTOR_NAMESPACE_MANIFEST_PATH = ".archcontext/manifest.yaml";
 function readRefactorNamespace(root) {
-  const path = join5(root, REFACTOR_NAMESPACE_MANIFEST_PATH);
+  const path = join7(root, REFACTOR_NAMESPACE_MANIFEST_PATH);
   if (!existsSync8(path)) {
     throw new RefactorScanError("AC_MODEL_ADOPTION_REQUIRED", `${REFACTOR_NAMESPACE_MANIFEST_PATH} is missing; refactor recommendations are scoped by its product.id; run archctx init`, "product-id-missing");
   }
   let manifest;
   try {
-    manifest = parseJsonOrStableYaml(readFileSync9(path, "utf8"), REFACTOR_NAMESPACE_MANIFEST_PATH);
+    manifest = parseJsonOrStableYaml(readFileSync10(path, "utf8"), REFACTOR_NAMESPACE_MANIFEST_PATH);
   } catch (error) {
     throw new RefactorScanError("AC_SCHEMA_INVALID", `${REFACTOR_NAMESPACE_MANIFEST_PATH} is unreadable: ${error instanceof Error ? error.message : String(error)}`, "product-id-invalid");
   }
@@ -32502,7 +32986,7 @@ function readCodeFacts(root, worktreeDigest, edgeLimit) {
 }
 function attestCodeGraphBinary(root) {
   const invocation = codeGraphCliInvocation(CODEGRAPH_BINARY, root);
-  const version = execFileSync3(invocation.command, [...invocation.argsPrefix, "--version"], {
+  const version = execFileSync4(invocation.command, [...invocation.argsPrefix, "--version"], {
     cwd: root,
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"],
@@ -32511,7 +32995,7 @@ function attestCodeGraphBinary(root) {
   const binaryPath = invocation.argsPrefix[0] ?? invocation.command;
   return {
     version,
-    binaryDigest: `sha256:${createHash8("sha256").update(readFileSync9(binaryPath)).digest("hex")}`
+    binaryDigest: `sha256:${createHash9("sha256").update(readFileSync10(binaryPath)).digest("hex")}`
   };
 }
 
@@ -32608,8 +33092,8 @@ function unavailable2(reasons) {
 // packages/local-runtime/runtime-daemon/src/docs-anchors.ts
 init_src();
 import { spawnSync as spawnSync5 } from "node:child_process";
-import { readFileSync as readFileSync12 } from "node:fs";
-import { resolve as resolve15 } from "node:path";
+import { readFileSync as readFileSync13 } from "node:fs";
+import { resolve as resolve16 } from "node:path";
 
 // packages/local-runtime/runtime-daemon/src/projection-service.ts
 init_src();
@@ -33886,8 +34370,8 @@ class ChangeSetRecoveryUnresolvedError extends FailureError {
 
 // packages/local-runtime/runtime-daemon/src/projection-freshness.ts
 init_src();
-import { readFileSync as readFileSync10 } from "node:fs";
-import { posix as posix3, resolve as resolve13 } from "node:path";
+import { readFileSync as readFileSync11 } from "node:fs";
+import { posix as posix3, resolve as resolve14 } from "node:path";
 function evaluateProjectionFreshness(input) {
   const { model, profile, manifest, sourceFootprints, scope } = input;
   return scope.kind === "tree" ? evaluateArchitectureProjectionSnapshotFreshness({ model, profile, manifest, sourceFootprints, currentSourceTreeDigest: scope.currentSourceTreeDigest }) : evaluateArchitectureProjectionFreshness({ model, profile, manifest, sourceFootprints, nodeIds: scope.nodeIds });
@@ -33912,7 +34396,7 @@ function measureProjectionFreshness(root, options = {}) {
     assertProjectionFreshnessChangedPaths(options.changedPaths);
   const manifest = options.manifest ?? loadArchitectureProjectionManifestStamps(root);
   if (manifest.status === "manifest-unreadable") {
-    assertArchitectureDocsProjectionManifestAccepted(readFileSync10(resolve13(root, ARCHITECTURE_DOCS_PROJECTION_MANIFEST_PATH), "utf8"));
+    assertArchitectureDocsProjectionManifestAccepted(readFileSync11(resolve14(root, ARCHITECTURE_DOCS_PROJECTION_MANIFEST_PATH), "utf8"));
   }
   const model = loadNativeModelFromArchContext(root);
   const profile = manifest.status === "present" ? loadArchitectureDocumentationProfile(root) : undefined;
@@ -34030,6 +34514,8 @@ function publicOperationFailure(error) {
         failure = toEnvelope("public.operation", undefined, "public-operation").error;
     } else if (error instanceof GitVisibleFilesUnavailableError)
       failure = knownFailure(own2(error, "code"), own2(error, "reasonCode"));
+    else if (error instanceof ProjectionManifestUpgradeRequiredError)
+      failure = knownFailure("AC_PRECONDITION_FAILED", own2(error, "reasonCode"), own2(error, "details"));
     else if (error instanceof ProjectionPreconditionError)
       failure = knownFailure("AC_PRECONDITION_FAILED", own2(error, "reasonCode"));
     else if (error instanceof ProjectionCodeFactsUnavailableError)
@@ -34056,15 +34542,15 @@ function publicOperationResult(requestId, result) {
 }
 
 // packages/local-runtime/runtime-daemon/src/projection-service.ts
-import { existsSync as existsSync9, readFileSync as readFileSync11 } from "node:fs";
-import { resolve as resolve14 } from "node:path";
+import { existsSync as existsSync9, readFileSync as readFileSync12 } from "node:fs";
+import { resolve as resolve15 } from "node:path";
 
 // packages/local-runtime/runtime-daemon/src/projection-inputs.ts
-import { execFileSync as execFileSync4 } from "node:child_process";
+import { execFileSync as execFileSync5 } from "node:child_process";
 init_src();
 function readCurrentBranch(root) {
   try {
-    const branch = execFileSync4("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+    const branch = execFileSync5("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
       cwd: root,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
@@ -34380,7 +34866,7 @@ function architectureModelIgnoredEnvelope(requestId, root) {
   });
 }
 function committedArchitectureDocsProfile(root) {
-  return existsSync9(resolve14(root, ARCHITECTURE_DOCS_PROJECTION_MANIFEST_PATH)) ? loadArchitectureDocumentationProfile(root) : "default";
+  return existsSync9(resolve15(root, ARCHITECTURE_DOCS_PROJECTION_MANIFEST_PATH)) ? loadArchitectureDocumentationProfile(root) : "default";
 }
 function withProjectionMetadata(envelope, provenance, runtimeSnapshot, majorChange, refreshSignals, receiptDigest) {
   if (!envelope.ok)
@@ -34794,8 +35280,8 @@ function runProjectionCheckCommandUnchecked(request, root) {
     return publicFailureEnvelope("projection.run", "AC_SCHEMA_INVALID", "projection-check-mode-invalid");
   }
   const manifestPath = ".archcontext/manifest.yaml";
-  if (existsSync9(resolve14(root, manifestPath))) {
-    const diagnostics = manifestDecisionDiagnostics([{ path: manifestPath, body: readFileSync11(resolve14(root, manifestPath), "utf8") }]);
+  if (existsSync9(resolve15(root, manifestPath))) {
+    const diagnostics = manifestDecisionDiagnostics([{ path: manifestPath, body: readFileSync12(resolve15(root, manifestPath), "utf8") }]);
     if (diagnostics.length)
       return publicFailureEnvelope("projection.run", "AC_SCHEMA_INVALID", "native-context-model-invalid", { path: manifestPath, invariant: diagnostics[0] });
   }
@@ -35685,7 +36171,7 @@ function fileContentReader(root) {
   return (path) => {
     let content = cache.get(path);
     if (content === undefined) {
-      content = readFileSync12(resolve15(root, path), "utf8").replace(/\r\n/g, `
+      content = readFileSync13(resolve16(root, path), "utf8").replace(/\r\n/g, `
 `);
       cache.set(path, content);
     }
@@ -35753,7 +36239,7 @@ function proseAnchorSymbols(reader, files, contents) {
 
 // packages/local-runtime/runtime-daemon/src/architecture-debt.ts
 import { existsSync as existsSync10 } from "node:fs";
-import { join as join6 } from "node:path";
+import { join as join8 } from "node:path";
 function readArchitectureDebt(root, input = {}) {
   try {
     const { evidence } = readArchitectureDebtEvidence(root, input);
@@ -35779,7 +36265,7 @@ function readArchitectureDebtEvidence(root, input) {
   const changedPaths = [...new Set(input.changedPaths ?? [])].sort();
   if (changedPaths.some((path) => !isRepoRelativePosixPath(path)))
     throw new ArchitectureDebtReadError("AC_SCHEMA_INVALID", "changedPaths must contain repository-relative POSIX paths", "changed-path-invalid");
-  if (!existsSync10(join6(root, ".archcontext/manifest.yaml")))
+  if (!existsSync10(join8(root, ".archcontext/manifest.yaml")))
     throw new ArchitectureDebtReadError("AC_MODEL_ADOPTION_REQUIRED", "Architecture debt requires an adopted architecture model", "model-missing");
   const model = loadNativeModelFromArchContext(root);
   const files = listGitVisibleFiles(root);
@@ -35922,7 +36408,7 @@ function runNativeContextCommand(args, cwd, reader = exportNativeContext) {
 // packages/surfaces/cli/src/ref-impact.ts
 init_src();
 import { openSync as openSync5, closeSync as closeSync5, readSync as readSync3 } from "node:fs";
-import { resolve as resolve16 } from "node:path";
+import { resolve as resolve17 } from "node:path";
 var invalid2 = (category) => {
   throw new NativeContextError("native-context-arguments-invalid", { category });
 };
@@ -35965,7 +36451,7 @@ function runRefImpactCommand(args, cwd, reader = readRefImpact) {
       let text;
       let fd;
       try {
-        fd = path === "-" ? 0 : openSync5(resolve16(cwd, path), "r");
+        fd = path === "-" ? 0 : openSync5(resolve17(cwd, path), "r");
         const bytes = Buffer.alloc(REF_IMPACT_LIMITS.diffBytes + 1);
         let length = 0;
         while (length < bytes.length) {
@@ -36001,6 +36487,31 @@ function runRefImpactCommand(args, cwd, reader = readRefImpact) {
   }
 }
 
+// packages/surfaces/cli/src/architecture-history.ts
+init_src();
+function runArchitectureHistoryCommand(args, cwd) {
+  if (args.includes("--help") || args.includes("-h"))
+    return okEnvelope("history", { usage: "archctx history [--ref <rev>] [--format json|mermaid] [--offset <n>] [--limit <n>] --json" });
+  const values = new Map;
+  for (let i = 0;i < args.length; i++) {
+    const flag = args[i];
+    if (flag === "--json")
+      continue;
+    if (!["--ref", "--format", "--offset", "--limit"].includes(flag) || values.has(flag) || args[i + 1] === undefined)
+      return errorEnvelope("history", "AC_SCHEMA_INVALID", "Invalid history arguments", "cli-input-invalid");
+    values.set(flag, args[++i]);
+  }
+  const format = values.get("--format") ?? "json", offsetText = values.get("--offset") ?? "0", limitText = values.get("--limit") ?? "200";
+  if (!/^[0-9]+$/.test(offsetText) || !/^[0-9]+$/.test(limitText) || !Number.isSafeInteger(Number(offsetText)) || !Number.isSafeInteger(Number(limitText)) || Number(limitText) > 1000 || !["json", "mermaid"].includes(format))
+    return errorEnvelope("history", "AC_SCHEMA_INVALID", "Invalid history arguments", "cli-input-invalid");
+  try {
+    const history = readArchitectureHistory(cwd, { ref: values.get("--ref"), offset: Number(offsetText), limit: Number(limitText) });
+    return okEnvelope("history", format === "mermaid" ? projectHistoryMermaid(history) : history);
+  } catch (error) {
+    return toEnvelope("history", error, "cli");
+  }
+}
+
 // packages/local-runtime/runtime-daemon/src/index.ts
 init_src();
 
@@ -36037,7 +36548,7 @@ async function exportChangeSetReceipt(store, root, journalId) {
 // packages/local-runtime/runtime-daemon/src/architecture-debt.ts
 init_src();
 import { existsSync as existsSync11 } from "node:fs";
-import { join as join7 } from "node:path";
+import { join as join9 } from "node:path";
 function readArchitectureDebt2(root, input = {}) {
   try {
     const { evidence } = readArchitectureDebtEvidence2(root, input);
@@ -36051,7 +36562,7 @@ function readArchitectureDebt2(root, input = {}) {
 }
 function readCompleteTaskArchitectureDebt(root, practices) {
   try {
-    if (!existsSync11(join7(root, ".archcontext/manifest.yaml"))) {
+    if (!existsSync11(join9(root, ".archcontext/manifest.yaml"))) {
       return checkedDebt2({
         scope: { kind: "repository", changedPaths: [], capabilityIds: [] },
         unavailable: Object.fromEntries(ARCHITECTURE_DEBT_CHECKS.map((check) => [check, ["model-not-adopted"]]))
@@ -36083,7 +36594,7 @@ function readArchitectureDebtEvidence2(root, input) {
   const changedPaths = [...new Set(input.changedPaths ?? [])].sort();
   if (changedPaths.some((path) => !isRepoRelativePosixPath(path)))
     throw new ArchitectureDebtReadError2("AC_SCHEMA_INVALID", "changedPaths must contain repository-relative POSIX paths", "changed-path-invalid");
-  if (!existsSync11(join7(root, ".archcontext/manifest.yaml")))
+  if (!existsSync11(join9(root, ".archcontext/manifest.yaml")))
     throw new ArchitectureDebtReadError2("AC_MODEL_ADOPTION_REQUIRED", "Architecture debt requires an adopted architecture model", "model-missing");
   const model = loadNativeModelFromArchContext(root);
   const files = listGitVisibleFiles(root);
@@ -37716,8 +38227,8 @@ function validateRuntimeAgentProposalPlan(input) {
 }
 
 // packages/local-runtime/runtime-daemon/src/external-documentation.ts
-import { existsSync as existsSync14, readdirSync as readdirSync9, readFileSync as readFileSync15, statSync as statSync4 } from "node:fs";
-import { resolve as resolve19 } from "node:path";
+import { existsSync as existsSync14, readdirSync as readdirSync10, readFileSync as readFileSync16, statSync as statSync4 } from "node:fs";
+import { resolve as resolve20 } from "node:path";
 
 // packages/core/context-compiler/src/index.ts
 init_src();
@@ -37725,11 +38236,11 @@ init_src();
 // packages/core/practice-catalog/src/index.ts
 init_src();
 init_src();
-import { existsSync as existsSync12, lstatSync as lstatSync7, readdirSync as readdirSync7, readFileSync as readFileSync13, realpathSync as realpathSync5 } from "node:fs";
-import { dirname as dirname6, relative as relative5, resolve as resolve17, sep as sep3 } from "node:path";
+import { existsSync as existsSync12, lstatSync as lstatSync7, readdirSync as readdirSync8, readFileSync as readFileSync14, realpathSync as realpathSync6 } from "node:fs";
+import { dirname as dirname6, relative as relative5, resolve as resolve18, sep as sep3 } from "node:path";
 import { fileURLToPath } from "node:url";
 var PRACTICE_CATALOG_VERSION = "2026.06.0";
-var BUILTIN_PRACTICE_ASSETS_DIR = resolve17(dirname6(fileURLToPath(import.meta.url)), "../assets");
+var BUILTIN_PRACTICE_ASSETS_DIR = resolve18(dirname6(fileURLToPath(import.meta.url)), "../assets");
 var ALLOWED_CHECK_IDS = new Set([
   "compatibility-contract-required",
   "no-new-cycle",
@@ -37781,13 +38292,13 @@ var PRACTICE_ROOT_KEYS = new Set([
   "overlay"
 ]);
 function loadPracticeCatalog(options = {}) {
-  const root = options.root ? resolve17(options.root) : process.cwd();
+  const root = options.root ? resolve18(options.root) : process.cwd();
   const builtInAssetsDir = options.builtInAssetsDir ?? BUILTIN_PRACTICE_ASSETS_DIR;
   const errors = [];
   const warnings = [];
-  const builtIn = loadAssetFiles(resolve17(builtInAssetsDir, "practices"), "curated-static", errors);
-  const profiles = loadProfileFiles(resolve17(builtInAssetsDir, "profiles"), errors);
-  const sources = loadSourceFiles(resolve17(builtInAssetsDir, "sources"), errors);
+  const builtIn = loadAssetFiles(resolve18(builtInAssetsDir, "practices"), "curated-static", errors);
+  const profiles = loadProfileFiles(resolve18(builtInAssetsDir, "profiles"), errors);
+  const sources = loadSourceFiles(resolve18(builtInAssetsDir, "sources"), errors);
   const overlays = options.includeRepoOverlay === false ? [] : loadRepoOverlayAssets(root, errors);
   const merged = mergeCatalogAssets(builtIn, overlays, errors, options.now ?? new Date().toISOString());
   const sourceIds = new Set(sources.map((source) => source.id));
@@ -37973,7 +38484,7 @@ function loadProfileFiles(dir, errors) {
   return profiles.sort((a, b) => a.id.localeCompare(b.id));
 }
 function loadRepoOverlayAssets(root, errors) {
-  const overlayRoot = resolve17(root, ".archcontext/practices");
+  const overlayRoot = resolve18(root, ".archcontext/practices");
   if (!existsSync12(overlayRoot))
     return [];
   const out = [];
@@ -38336,8 +38847,8 @@ function listDataFiles(dir, allowedRoot, errors) {
       return;
     }
     if (stat.isDirectory()) {
-      for (const entry of readdirSync7(current, { withFileTypes: true }))
-        walk(resolve17(current, entry.name));
+      for (const entry of readdirSync8(current, { withFileTypes: true }))
+        walk(resolve18(current, entry.name));
       return;
     }
     if (!/\.(ya?ml|json)$/.test(current))
@@ -38352,7 +38863,7 @@ function listDataFiles(dir, allowedRoot, errors) {
 }
 function parseDataFile(path, errors) {
   try {
-    const body = readFileSync13(path, "utf8").replace(/^\uFEFF/, "").trim();
+    const body = readFileSync14(path, "utf8").replace(/^\uFEFF/, "").trim();
     const withoutDocumentMarker = body.startsWith("---") ? body.replace(/^---\s*/, "").trim() : body;
     return JSON.parse(withoutDocumentMarker);
   } catch (error) {
@@ -38379,14 +38890,14 @@ function assertRealChild(root, path) {
 }
 function safeRealpath(path) {
   try {
-    return realpathSync5.native(path);
+    return realpathSync6.native(path);
   } catch {
-    return resolve17(path);
+    return resolve18(path);
   }
 }
 function isRealChild(rootReal, pathReal) {
   const rel = relative5(rootReal, pathReal);
-  return rel === "" || !rel.startsWith("..") && !rel.includes(`..${sep3}`) && !resolve17(rel).startsWith("..");
+  return rel === "" || !rel.startsWith("..") && !rel.includes(`..${sep3}`) && !resolve18(rel).startsWith("..");
 }
 function displayPath(path) {
   return path.split(sep3).join("/");
@@ -38950,8 +39461,8 @@ function checkResult(input, result) {
 }
 // packages/core/practice-engine/src/enforcement.ts
 init_src();
-import { existsSync as existsSync13, lstatSync as lstatSync8, readdirSync as readdirSync8, readFileSync as readFileSync14 } from "node:fs";
-import { basename as basename4, join as join8, relative as relative6, resolve as resolve18, sep as sep4 } from "node:path";
+import { existsSync as existsSync13, lstatSync as lstatSync8, readdirSync as readdirSync9, readFileSync as readFileSync15 } from "node:fs";
+import { basename as basename4, join as join10, relative as relative6, resolve as resolve19, sep as sep4 } from "node:path";
 var ENFORCEMENT_RANK = { advisory: 0, checkpoint: 1, complete: 2 };
 var POLICY_MODES = new Set(["advisory", "active", "fail-open", "fail-closed"]);
 var DEFAULT_POLICY = {
@@ -38974,7 +39485,7 @@ function shouldEvaluatePracticeEnforcement(policy) {
   return practiceEnforcementPolicyMode(policy) !== "advisory";
 }
 function loadPracticeEnforcementPolicy(root) {
-  const path = resolve18(root, ".archcontext/policies/practices.yaml");
+  const path = resolve19(root, ".archcontext/policies/practices.yaml");
   if (!existsSync13(path))
     return defaultPracticeEnforcementPolicy();
   assertRepoPolicyFile(root, path, ".archcontext/policies/practices.yaml");
@@ -38982,7 +39493,7 @@ function loadPracticeEnforcementPolicy(root) {
   return validatePracticeEnforcementPolicy(parsed, ".archcontext/policies/practices.yaml");
 }
 function loadPracticeWaivers(root) {
-  const dir = resolve18(root, ".archcontext/waivers");
+  const dir = resolve19(root, ".archcontext/waivers");
   if (!existsSync13(dir))
     return [];
   const stat = lstatSync8(dir);
@@ -38992,10 +39503,10 @@ function loadPracticeWaivers(root) {
     throw new Error("practice-waiver-path-not-directory");
   const waivers = [];
   const ownerRegistry = loadPracticeWaiverOwnerRegistry(root);
-  for (const entry of readdirSync8(dir, { withFileTypes: true })) {
+  for (const entry of readdirSync9(dir, { withFileTypes: true })) {
     if (!entry.isFile() || !/\.(?:ya?ml|json)$/.test(entry.name))
       continue;
-    const path = join8(dir, entry.name);
+    const path = join10(dir, entry.name);
     const relativePath = `.archcontext/waivers/${entry.name}`;
     assertRepoPolicyFile(root, path, relativePath);
     waivers.push(validatePracticeWaiver(parseJsonYamlFile(path), relativePath, { allowedOwners: ownerRegistry.owners }));
@@ -39003,17 +39514,17 @@ function loadPracticeWaivers(root) {
   return waivers.sort((left, right) => waiverDigest(left).localeCompare(waiverDigest(right)));
 }
 function loadPracticeWaiverOwnerRegistry(root) {
-  const modelDir = resolve18(root, ".archcontext/model/nodes");
+  const modelDir = resolve19(root, ".archcontext/model/nodes");
   const sources = [];
   const subjects = [];
   if (existsSync13(modelDir)) {
     if (lstatSync8(modelDir).isSymbolicLink())
       throw new Error("practice-owner-registry-symlink-denied");
     for (const path of collectFiles(root, ".archcontext/model/nodes")) {
-      const absolute = resolve18(root, path);
+      const absolute = resolve19(root, path);
       if (lstatSync8(absolute).isSymbolicLink())
         throw new Error(`practice-owner-registry-symlink-denied: ${path}`);
-      const body = readFileSync14(absolute, "utf8");
+      const body = readFileSync15(absolute, "utf8");
       const lifecycleOwners = extractOwnershipOwners(body, "lifecycle");
       const dataOwners = extractOwnershipOwners(body, "data");
       for (const kind of ["lifecycle", "data"]) {
@@ -39288,14 +39799,14 @@ function isVagueReason(reason) {
   return /^(temporary|cleanup later|todo|tbd|later|just in case)$/i.test(trimmed);
 }
 function parseJsonYamlFile(path) {
-  const body = readFileSync14(path, "utf8").replace(/^\uFEFF/, "").trim();
+  const body = readFileSync15(path, "utf8").replace(/^\uFEFF/, "").trim();
   const withoutDocumentMarker = body.startsWith("---") ? body.replace(/^---\s*/, "").trim() : body;
   return JSON.parse(withoutDocumentMarker);
 }
 function collectFiles(root, relativeDir) {
-  const dir = resolve18(root, relativeDir);
+  const dir = resolve19(root, relativeDir);
   const out = [];
-  for (const entry of readdirSync8(dir, { withFileTypes: true })) {
+  for (const entry of readdirSync9(dir, { withFileTypes: true })) {
     const child = `${relativeDir}/${entry.name}`;
     if (entry.isDirectory())
       out.push(...collectFiles(root, child));
@@ -39381,8 +39892,8 @@ function assertRepoPolicyFile(root, path, relativePath) {
   assertRepoRelativePath(relativePath);
   if (lstatSync8(path).isSymbolicLink())
     throw new Error(`practice-policy-symlink-denied: ${relativePath}`);
-  const rootResolved = resolve18(root);
-  const pathResolved = resolve18(path);
+  const rootResolved = resolve19(root);
+  const pathResolved = resolve19(path);
   const rel = relative6(rootResolved, pathResolved);
   if (rel === "" || rel.startsWith("..") || rel.includes(`..${sep4}`))
     throw new Error(`practice-policy-path-escape: ${relativePath}`);
@@ -40742,7 +41253,7 @@ function readExactPackageVersion(root, packageName) {
   return;
 }
 function readPackageLockExactVersion(root, packageName) {
-  const lock = readJsonFile(resolve19(root, "package-lock.json"));
+  const lock = readJsonFile(resolve20(root, "package-lock.json"));
   if (!lock || typeof lock !== "object" || Array.isArray(lock))
     return;
   const packages = lock.packages;
@@ -40760,7 +41271,7 @@ function readPackageLockExactVersion(root, packageName) {
   return;
 }
 function packageManifestPaths(root) {
-  const paths = [resolve19(root, "package.json")];
+  const paths = [resolve20(root, "package.json")];
   const rootManifest = readJsonFile(paths[0]);
   for (const pattern of workspacePatternsFromManifest(rootManifest)) {
     for (const path of expandWorkspacePackageJson(root, pattern))
@@ -40783,15 +41294,15 @@ function expandWorkspacePackageJson(root, pattern) {
   if (pattern.includes("**") || pattern.startsWith("/") || pattern.includes("\\"))
     return [];
   if (!pattern.includes("*")) {
-    const path = resolve19(root, pattern, "package.json");
+    const path = resolve20(root, pattern, "package.json");
     return existsSync14(path) ? [path] : [];
   }
   if (!pattern.endsWith("/*"))
     return [];
-  const base = resolve19(root, pattern.slice(0, -2));
+  const base = resolve20(root, pattern.slice(0, -2));
   if (!existsSync14(base) || !statSync4(base).isDirectory())
     return [];
-  return readdirSync9(base, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => resolve19(base, entry.name, "package.json")).filter((path) => existsSync14(path));
+  return readdirSync10(base, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => resolve20(base, entry.name, "package.json")).filter((path) => existsSync14(path));
 }
 function exactVersionFromManifest(manifest, packageName) {
   if (!manifest || typeof manifest !== "object" || Array.isArray(manifest))
@@ -40810,7 +41321,7 @@ function readJsonFile(path) {
   if (!existsSync14(path))
     return;
   try {
-    return JSON.parse(readFileSync15(path, "utf8"));
+    return JSON.parse(readFileSync16(path, "utf8"));
   } catch {
     return;
   }
@@ -40833,7 +41344,7 @@ function readContext7LockfileState(root) {
       expectedHash: "missing"
     };
   }
-  const body = readFileSync15(path, "utf8");
+  const body = readFileSync16(path, "utf8");
   const parsed = JSON.parse(body);
   if (parsed.schemaVersion !== CONTEXT7_LOCKFILE_SCHEMA_VERSION || parsed.provider !== "context7" || !Array.isArray(parsed.libraries)) {
     throw new Error("Invalid Context7 lockfile");
@@ -40869,7 +41380,7 @@ function writeContext7Lockfile(root, lock, expectedHash) {
 
 // packages/core/application/src/index.ts
 import { existsSync as existsSync15, statSync as statSync5 } from "node:fs";
-import { extname, resolve as resolve20 } from "node:path";
+import { extname, resolve as resolve21 } from "node:path";
 init_src();
 async function prepareTask(input) {
   const confidence = computeRefactorConfidence({
@@ -41062,7 +41573,7 @@ function classifyCheckpointPath(root, path) {
     return "ignored";
   if (isGeneratedCheckpointPath(path))
     return "generated";
-  const absolute = resolve20(root, path);
+  const absolute = resolve21(root, path);
   if (!existsSync15(absolute))
     return "deleted";
   try {
@@ -41360,14 +41871,14 @@ function parsePracticeCheckpointBaselineState(state, repositoryId, taskSessionId
 init_src();
 init_src();
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { chmodSync as chmodSync3, existsSync as existsSync18, lstatSync as lstatSync9, mkdirSync as mkdirSync6, mkdtempSync as mkdtempSync3, readdirSync as readdirSync11, readFileSync as readFileSync17, rmSync as rmSync8, writeFileSync as writeFileSync5 } from "node:fs";
+import { chmodSync as chmodSync3, existsSync as existsSync18, lstatSync as lstatSync9, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync3, readdirSync as readdirSync11, readFileSync as readFileSync18, rmSync as rmSync8, writeFileSync as writeFileSync6 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { basename as basename5, dirname as dirname7, join as join12, resolve as resolve22, sep as sep5 } from "node:path";
+import { basename as basename5, dirname as dirname7, join as join13, resolve as resolve22, sep as sep5 } from "node:path";
 
 // packages/local-runtime/control-file-security/src/index.ts
-import { execFileSync as execFileSync5 } from "node:child_process";
-import { closeSync as closeSync6, constants as constants2, existsSync as existsSync16, fstatSync as fstatSync3, openSync as openSync6, readFileSync as readFileSync16, rmSync as rmSync6, writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join10 } from "node:path";
+import { execFileSync as execFileSync6 } from "node:child_process";
+import { closeSync as closeSync6, constants as constants2, existsSync as existsSync16, fstatSync as fstatSync3, openSync as openSync6, readFileSync as readFileSync17, rmSync as rmSync6, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join12 } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 var WINDOWS_CREATE_TIMEOUT_MS = 60000;
 var WINDOWS_READ_TIMEOUT_MS = 1e4;
@@ -41451,7 +41962,7 @@ function windowsControlFile(operation, path, body) {
   let output;
   const startedAt = performance.now();
   try {
-    output = execFileSync5(join10(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe"), [
+    output = execFileSync6(join12(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe"), [
       "-NoLogo",
       "-NoProfile",
       "-NonInteractive",
@@ -41506,7 +42017,7 @@ function createPrivateControlFile(path, body) {
   }
   const fd = openSync6(path, "wx", 384);
   try {
-    writeFileSync4(fd, body, "utf8");
+    writeFileSync5(fd, body, "utf8");
   } catch (error) {
     rmSync6(path, { force: true });
     throw error;
@@ -41526,7 +42037,7 @@ function readPrivateControlFile(path) {
       const stat = fstatSync3(fd);
       if (!stat.isFile() || (stat.mode & 63) !== 0)
         return;
-      return readFileSync16(fd, "utf8");
+      return readFileSync17(fd, "utf8");
     } finally {
       closeSync6(fd);
     }
@@ -41603,7 +42114,7 @@ function rpcRequiredBoolean(params, index, context, label) {
 function rpcOptionalString(params, index, context, label) {
   const value = params[index];
   if (value === undefined || value === null)
-    return value;
+    return;
   if (typeof value !== "string")
     throw rpcInputInvalid(context, `${label} must be a string`);
   return value;
@@ -41611,7 +42122,7 @@ function rpcOptionalString(params, index, context, label) {
 function rpcOptionalNumber(params, index, context, label) {
   const value = params[index];
   if (value === undefined || value === null)
-    return value;
+    return;
   if (typeof value !== "number" || !Number.isFinite(value))
     throw rpcInputInvalid(context, `${label} must be a number`);
   return value;
@@ -41619,7 +42130,7 @@ function rpcOptionalNumber(params, index, context, label) {
 function rpcOptionalStringArray(params, index, context, label) {
   const value = params[index];
   if (value === undefined || value === null)
-    return value;
+    return;
   if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string"))
     throw rpcInputInvalid(context, `${label} must be an array of strings`);
   return value;
@@ -41636,7 +42147,7 @@ function rpcRequiredObject(params, index, context, label) {
 function rpcOptionalObject(params, index, context, label) {
   const value = params[index];
   if (value === undefined || value === null)
-    return value;
+    return;
   if (!isPlainRpcObject(value))
     throw rpcInputInvalid(context, `${label} must be an object`);
   return value;
@@ -42063,111 +42574,6 @@ function daemonReadiness(root) {
 
 // packages/local-runtime/runtime-daemon/src/daemon-control.ts
 import { existsSync as existsSync17, openSync as openSync7, rmSync as rmSync7 } from "node:fs";
-
-// packages/local-runtime/runtime-state-paths/src/index.ts
-import { execFileSync as execFileSync6 } from "node:child_process";
-import { createHash as createHash9 } from "node:crypto";
-import { readdirSync as readdirSync10, realpathSync as realpathSync6 } from "node:fs";
-import { homedir } from "node:os";
-import { isAbsolute as isAbsolute5, join as join11, resolve as resolve21 } from "node:path";
-var ARCHCONTEXT_STATE_DIR_ENV = "ARCHCONTEXT_STATE_DIR";
-var ARCHCONTEXT_LOCAL_STORE_PATH_ENV = "ARCHCONTEXT_LOCAL_STORE_PATH";
-function defaultArchContextStateRoot(env = process.env, platform = process.platform, home = homedir()) {
-  const override = env[ARCHCONTEXT_STATE_DIR_ENV];
-  if (override)
-    return { path: resolve21(override), source: "environment" };
-  if (platform === "darwin")
-    return { path: join11(home, "Library", "Application Support", "ArchContext"), source: "os-user-data" };
-  if (platform === "win32")
-    return { path: join11(env.LOCALAPPDATA ?? join11(home, "AppData", "Local"), "ArchContext"), source: "os-user-data" };
-  return { path: join11(env.XDG_DATA_HOME ?? join11(home, ".local", "share"), "archcontext"), source: "os-user-data" };
-}
-function runtimeStatePaths(root = process.cwd(), env = process.env) {
-  const repositoryRoot = readGitPath(root, ["rev-parse", "--show-toplevel"]) ?? root;
-  const canonicalRepositoryRoot = canonicalPath(repositoryRoot);
-  const gitCommonDir = readGitPath(canonicalRepositoryRoot, ["rev-parse", "--git-common-dir"]);
-  const repositoryAnchor = canonicalPath(gitCommonDir ? resolveMaybeRelative(canonicalRepositoryRoot, gitCommonDir) : canonicalRepositoryRoot);
-  const workspaceAnchor = canonicalRepositoryRoot;
-  const storageRepositoryId = stableStorageId("repo", repositoryAnchor);
-  const storageWorkspaceId = stableStorageId("ws", workspaceAnchor);
-  const stateRoot = defaultArchContextStateRoot(env);
-  const repositoryStateDir = join11(stateRoot.path, REPOSITORIES_DIR, storageRepositoryId);
-  const workspaceStateDir = join11(repositoryStateDir, WORKTREES_DIR, storageWorkspaceId);
-  const legacyControlDir = resolve21(canonicalRepositoryRoot, ".archcontext", ".local");
-  return {
-    schemaVersion: "archcontext.runtime-state-paths/v1",
-    stateRoot: stateRoot.path,
-    source: stateRoot.source,
-    repositoryRoot: canonicalRepositoryRoot,
-    repositoryAnchor,
-    workspaceAnchor,
-    storageRepositoryId,
-    storageWorkspaceId,
-    repositoryId: storageRepositoryId,
-    workspaceId: storageWorkspaceId,
-    repositoryStateDir,
-    workspaceStateDir,
-    sharedCacheDir: join11(repositoryStateDir, "shared", "cache"),
-    localStorePath: env[ARCHCONTEXT_LOCAL_STORE_PATH_ENV] ?? join11(workspaceStateDir, "runtime.sqlite"),
-    ...daemonControlPaths(workspaceStateDir),
-    developerReviewRunStateDir: join11(workspaceStateDir, "developer-review-runs"),
-    legacyControlDir,
-    legacyLocalStorePath: join11(legacyControlDir, "runtime.sqlite")
-  };
-}
-var REPOSITORIES_DIR = "repositories";
-var WORKTREES_DIR = "worktrees";
-function daemonControlPaths(workspaceStateDir) {
-  return {
-    daemonConnectionPath: join11(workspaceStateDir, "archctxd.json"),
-    daemonLockPath: join11(workspaceStateDir, "archctxd.lock"),
-    daemonLogPath: join11(workspaceStateDir, "archctxd.log")
-  };
-}
-function listWorkspaceStateDirs(stateRoot) {
-  return listDirectoryNames(join11(stateRoot, REPOSITORIES_DIR)).flatMap((storageRepositoryId) => listDirectoryNames(join11(stateRoot, REPOSITORIES_DIR, storageRepositoryId, WORKTREES_DIR)).map((storageWorkspaceId) => ({
-    storageRepositoryId,
-    storageWorkspaceId,
-    workspaceStateDir: join11(stateRoot, REPOSITORIES_DIR, storageRepositoryId, WORKTREES_DIR, storageWorkspaceId)
-  })));
-}
-function listDirectoryNames(path) {
-  try {
-    return readdirSync10(path, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
-  } catch (error) {
-    if (error.code === "ENOENT")
-      return [];
-    throw error;
-  }
-}
-function readGitPath(root, args) {
-  try {
-    const value = execFileSync6("git", args, {
-      cwd: root,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    }).trim();
-    return value.length > 0 ? value : undefined;
-  } catch {
-    return;
-  }
-}
-function resolveMaybeRelative(base, path) {
-  return isAbsolute5(path) ? resolve21(path) : resolve21(base, path);
-}
-function canonicalPath(path) {
-  const resolved = resolve21(path);
-  try {
-    return realpathSync6.native(resolved);
-  } catch {
-    return resolved;
-  }
-}
-function stableStorageId(prefix, value) {
-  return `${prefix}.${createHash9("sha256").update(value).digest("hex").slice(0, 16)}`;
-}
-
-// packages/local-runtime/runtime-daemon/src/daemon-control.ts
 function defaultDeveloperReviewRunStateDir(root = process.cwd()) {
   return runtimeStatePaths(root).developerReviewRunStateDir;
 }
@@ -42380,9 +42786,9 @@ class DeveloperReviewRunService {
       challengeId: input.challenge.challengeId,
       tempRoot: input.tempRoot
     });
-    mkdirSync6(paths.stateDir, { recursive: true });
-    mkdirSync6(paths.runRoot, { recursive: true });
-    mkdirSync6(paths.worktreeTempRoot, { recursive: true });
+    mkdirSync7(paths.stateDir, { recursive: true });
+    mkdirSync7(paths.runRoot, { recursive: true });
+    mkdirSync7(paths.worktreeTempRoot, { recursive: true });
     const createdAt = this.clock();
     writeDeveloperReviewRunOwnerMarker({
       runRoot: paths.runRoot,
@@ -42506,7 +42912,7 @@ class DeveloperReviewRunService {
     this.assertRunning();
     const sourceRoot = findRepositoryRoot(input.repositoryRoot);
     const safeChallengeId = safeControlFileSegment(input.challengeId);
-    const manifestPath = join12(defaultDeveloperReviewRunStateDir(sourceRoot), `${safeChallengeId}.json`);
+    const manifestPath = join13(defaultDeveloperReviewRunStateDir(sourceRoot), `${safeChallengeId}.json`);
     const manifest = readDeveloperReviewRunManifest(manifestPath);
     if (!manifest)
       throw developerReviewRunNotOwned("persisted-manifest-missing");
@@ -42533,7 +42939,7 @@ class DeveloperReviewRunService {
     for (const entry of readdirSync11(stateDir).sort()) {
       if (!entry.endsWith(".json"))
         continue;
-      const manifestPath = join12(stateDir, entry);
+      const manifestPath = join13(stateDir, entry);
       const stats = lstatIfExists2(manifestPath);
       if (!stats || !stats.isFile()) {
         recovery.rejected.push(`${entry}: not-a-regular-file`);
@@ -42561,7 +42967,7 @@ class DeveloperReviewRunService {
     for (const entry of readdirSync11(stateDir).sort()) {
       if (!entry.endsWith(".lock"))
         continue;
-      const lockPath = join12(stateDir, entry);
+      const lockPath = join13(stateDir, entry);
       const stats = lstatIfExists2(lockPath);
       if (!stats || !stats.isFile()) {
         recovery.rejected.push(`${entry}: not-a-regular-file`);
@@ -42590,15 +42996,15 @@ function createDeveloperReviewRunPaths(input) {
   const runId = `${safeChallengeId}-${randomBytes2(6).toString("hex")}`;
   const stateDir = defaultDeveloperReviewRunStateDir(input.sourceRoot);
   const tempParent = input.tempRoot ? resolve22(input.tempRoot) : tmpdir3();
-  mkdirSync6(tempParent, { recursive: true });
-  const runRoot = mkdtempSync3(join12(tempParent, `${DEVELOPER_REVIEW_RUN_ROOT_PREFIX}${safeChallengeId.slice(0, 32)}-`));
+  mkdirSync7(tempParent, { recursive: true });
+  const runRoot = mkdtempSync3(join13(tempParent, `${DEVELOPER_REVIEW_RUN_ROOT_PREFIX}${safeChallengeId.slice(0, 32)}-`));
   return {
     runId,
     stateDir,
     runRoot,
-    worktreeTempRoot: join12(runRoot, "worktrees"),
-    manifestPath: join12(stateDir, `${safeChallengeId}.json`),
-    lockPath: join12(stateDir, `${safeChallengeId}.lock`)
+    worktreeTempRoot: join13(runRoot, "worktrees"),
+    manifestPath: join13(stateDir, `${safeChallengeId}.json`),
+    lockPath: join13(stateDir, `${safeChallengeId}.lock`)
   };
 }
 function writeDeveloperReviewRunOwnerMarker(input) {
@@ -42612,7 +43018,7 @@ function writeDeveloperReviewRunOwnerMarker(input) {
     pid: process.pid,
     createdAt: input.createdAt
   };
-  writePrivateJson(join12(input.runRoot, DEVELOPER_REVIEW_RUN_OWNER_MARKER_FILE), marker, "wx");
+  writePrivateJson(join13(input.runRoot, DEVELOPER_REVIEW_RUN_OWNER_MARKER_FILE), marker, "wx");
 }
 function readDeveloperReviewRunOwnerMarker(path) {
   const stats = lstatIfExists2(path);
@@ -42636,8 +43042,8 @@ function resolveOwnedDeveloperReviewRunTargets(run) {
   if (!runIdSuffix || !DEVELOPER_REVIEW_RUN_ID_SUFFIX.test(runIdSuffix))
     throw developerReviewRunNotOwned("run-id");
   const stateDir = defaultDeveloperReviewRunStateDir(run.sourceRoot);
-  const manifestPath = join12(stateDir, `${safeChallengeId}.json`);
-  const lockPath = join12(stateDir, `${safeChallengeId}.lock`);
+  const manifestPath = join13(stateDir, `${safeChallengeId}.json`);
+  const lockPath = join13(stateDir, `${safeChallengeId}.lock`);
   if (resolve22(run.manifestPath) !== manifestPath)
     throw developerReviewRunNotOwned("manifest-path");
   if (resolve22(run.lockPath) !== lockPath)
@@ -42659,7 +43065,7 @@ function resolveOwnedDeveloperReviewRunTargets(run) {
   if (!runRootName.startsWith(runRootPrefix) || !DEVELOPER_REVIEW_RUN_ROOT_SUFFIX.test(runRootName.slice(runRootPrefix.length))) {
     throw developerReviewRunNotOwned("run-root-name");
   }
-  const worktreeTempRoot = join12(runRoot, "worktrees");
+  const worktreeTempRoot = join13(runRoot, "worktrees");
   if (resolve22(run.worktreeTempRoot) !== worktreeTempRoot)
     throw developerReviewRunNotOwned("worktree-temp-root");
   if (resolve22(run.codeGraphTemporaryState.root) !== runRoot)
@@ -42669,7 +43075,7 @@ function resolveOwnedDeveloperReviewRunTargets(run) {
     return { stateDir, manifestPath, lockPath };
   if (!runRootStats.isDirectory())
     throw developerReviewRunNotOwned("run-root-not-a-directory");
-  const marker = readDeveloperReviewRunOwnerMarker(join12(runRoot, DEVELOPER_REVIEW_RUN_OWNER_MARKER_FILE));
+  const marker = readDeveloperReviewRunOwnerMarker(join13(runRoot, DEVELOPER_REVIEW_RUN_OWNER_MARKER_FILE));
   if (!marker)
     throw developerReviewRunNotOwned("run-root-owner-marker-missing");
   if (marker.runId !== run.runId || marker.challengeId !== run.challengeId)
@@ -42706,8 +43112,8 @@ function writeDeveloperReviewRunManifest(manifest) {
   writePrivateJson(manifest.manifestPath, manifest);
 }
 function writePrivateJson(path, value, flag = "w") {
-  mkdirSync6(dirname7(path), { recursive: true });
-  writeFileSync5(path, JSON.stringify(value, null, 2), { mode: 384, flag });
+  mkdirSync7(dirname7(path), { recursive: true });
+  writeFileSync6(path, JSON.stringify(value, null, 2), { mode: 384, flag });
   chmodSync3(path, 384);
 }
 function readDeveloperReviewRunManifest(path) {
@@ -42719,7 +43125,7 @@ function readDeveloperReviewRunManifest(path) {
 }
 function readJsonObject(path) {
   try {
-    const parsed = JSON.parse(readFileSync17(path, "utf8"));
+    const parsed = JSON.parse(readFileSync18(path, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
   } catch {
     return;
@@ -44316,8 +44722,8 @@ function uniqueStrings2(values) {
 // packages/local-runtime/runtime-daemon/src/ledger-admin.ts
 init_src();
 init_src();
-import { existsSync as existsSync20, readFileSync as readFileSync19 } from "node:fs";
-import { join as join14, resolve as resolve24 } from "node:path";
+import { existsSync as existsSync20, readFileSync as readFileSync20 } from "node:fs";
+import { join as join15, resolve as resolve24 } from "node:path";
 
 // packages/core/reconcile-engine/src/index.ts
 function reconcileArchitectureLedgerDrift(input) {
@@ -44394,11 +44800,11 @@ init_src();
 
 // packages/local-runtime/local-store-sqlite/src/index.ts
 init_src();
-import { createHash as createHash10, randomUUID } from "node:crypto";
-import { chmodSync as chmodSync4, closeSync as closeSync7, copyFileSync, existsSync as existsSync19, fsyncSync as fsyncSync3, lstatSync as lstatSync10, mkdirSync as mkdirSync7, openSync as openSync8, readFileSync as readFileSync18, readSync as readSync4, realpathSync as realpathSync7, renameSync as renameSync3, rmSync as rmSync9, statfsSync, statSync as statSync7, writeFileSync as writeFileSync6 } from "node:fs";
+import { createHash as createHash10, randomUUID as randomUUID2 } from "node:crypto";
+import { chmodSync as chmodSync4, closeSync as closeSync7, copyFileSync, existsSync as existsSync19, fsyncSync as fsyncSync3, lstatSync as lstatSync10, mkdirSync as mkdirSync8, openSync as openSync8, readFileSync as readFileSync19, readSync as readSync4, realpathSync as realpathSync7, renameSync as renameSync4, rmSync as rmSync9, statfsSync, statSync as statSync7, writeFileSync as writeFileSync7 } from "node:fs";
 import { readdir, readFile } from "node:fs/promises";
 import { createRequire as createRequire4 } from "node:module";
-import { dirname as dirname8, isAbsolute as isAbsolute6, join as join13, relative as relative7, resolve as resolve23 } from "node:path";
+import { dirname as dirname8, isAbsolute as isAbsolute6, join as join14, relative as relative7, resolve as resolve23 } from "node:path";
 init_src();
 // schemas/runtime/explorer-projection-v2.schema.json
 var explorer_projection_v2_schema_default = {
@@ -45815,8 +46221,8 @@ function migrateLegacyLocalStoreIfNeeded(root = process.cwd(), env = process.env
   }
   assertTrustedLegacyLocalStoreSource(paths);
   const lock = acquireLegacyMigrationLock(paths);
-  const stagingDir = join13(paths.workspaceStateDir, `.runtime.sqlite.migration-${process.pid}-${randomUUID()}`);
-  const stagingPath = join13(stagingDir, "runtime.sqlite");
+  const stagingDir = join14(paths.workspaceStateDir, `.runtime.sqlite.migration-${process.pid}-${randomUUID2()}`);
+  const stagingPath = join14(stagingDir, "runtime.sqlite");
   try {
     if (targetExists)
       quarantinedFiles.push(...quarantineExistingLocalStore(paths));
@@ -45908,7 +46314,7 @@ class SqliteLocalStore {
   }
   async beginSnapshot(snapshot) {
     const db = await this.database();
-    const snapshotId = `snapshot_${randomUUID()}`;
+    const snapshotId = `snapshot_${randomUUID2()}`;
     db.prepare(`INSERT INTO snapshots
         (id, repository_id, head_sha, worktree_digest, state, created_at)
         VALUES (?, ?, ?, ?, ?, ?)`).run(snapshotId, snapshot.repositoryId, snapshot.headSha, snapshot.worktreeDigest, "pending", nowIso());
@@ -46246,7 +46652,7 @@ class SqliteLocalStore {
   }
   async beginChangeSet(root, draft) {
     const db = await this.database();
-    const journalId = `changeset_${randomUUID()}`;
+    const journalId = `changeset_${randomUUID2()}`;
     db.prepare(`INSERT INTO changeset_journal
         (journal_id, changeset_id, root, status, metadata_json, files_json, created_at, updated_at)
         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(journalId, draft.id, root, "pending", stableJson(changeSetMetadata(draft)), "[]", nowIso(), nowIso());
@@ -49170,7 +49576,7 @@ function ftsMatchKind(query, doc) {
 function recordArchitectureLedgerOperation(db, input) {
   db.prepare(`INSERT INTO architecture_ledger_operations
       (operation_id, storage_repository_id, storage_workspace_id, operation_kind, duration_ms, row_count, rebuild_reason, created_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(`ledger_operation_${randomUUID()}`, input.scope.repository.storageRepositoryId, architectureLedgerWorkspaceKey(input.scope.worktree), input.operationKind, Math.max(0, Math.trunc(input.durationMs)), input.rowCount, input.rebuildReason, nowIso());
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(`ledger_operation_${randomUUID2()}`, input.scope.repository.storageRepositoryId, architectureLedgerWorkspaceKey(input.scope.worktree), input.operationKind, Math.max(0, Math.trunc(input.durationMs)), input.rowCount, input.rebuildReason, nowIso());
 }
 function stableLedgerId(prefix, ...parts) {
   return `${prefix}.${createHash10("sha256").update(parts.join("\x00")).digest("hex").slice(0, 24)}`;
@@ -49738,7 +50144,7 @@ function publishStagedLocalStore(stagingPath, targetPath) {
     if (existsSync19(path))
       throw new Error(`Cannot publish migrated SQLite over existing target file: ${path}`);
   }
-  renameSync3(stagingPath, targetPath);
+  renameSync4(stagingPath, targetPath);
   makePrivateFile(targetPath);
   fsyncDirectory2(dirname8(targetPath));
 }
@@ -49759,7 +50165,7 @@ function acquireLegacyMigrationLock(paths) {
   ensurePrivateDir(dirname8(lockPath));
   try {
     const fd = openSync8(lockPath, "wx", 384);
-    writeFileSync6(fd, JSON.stringify({
+    writeFileSync7(fd, JSON.stringify({
       schemaVersion: "archcontext.legacy-local-store-migration-lock/v1",
       pid: process.pid,
       root: paths.repositoryRoot,
@@ -49785,7 +50191,7 @@ function releaseLegacyMigrationLock(lock) {
 }
 function isStaleMigrationLock(lockPath) {
   try {
-    const parsed = JSON.parse(readFileSync18(lockPath, "utf8"));
+    const parsed = JSON.parse(readFileSync19(lockPath, "utf8"));
     if (typeof parsed.pid !== "number" || parsed.pid <= 0)
       return true;
     return !isProcessAlive(parsed.pid);
@@ -49836,7 +50242,7 @@ function acquireLocalStoreWriterOwnership(databasePath) {
     throw error;
   }
   makePrivateFile(lockPath);
-  const token = randomUUID();
+  const token = randomUUID2();
   writeOwnerRecord(recordPath, { pid: process.pid, databasePath, acquiredAt: nowIso(), token });
   let released = false;
   return {
@@ -49870,17 +50276,17 @@ function sleepSync(ms) {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
 function writeOwnerRecord(recordPath, record) {
-  const tempPath = `${recordPath}.${process.pid}-${randomUUID()}.tmp`;
+  const tempPath = `${recordPath}.${process.pid}-${randomUUID2()}.tmp`;
   try {
-    writeFileSync6(tempPath, JSON.stringify(record, null, 2), { encoding: "utf8", mode: 384, flag: "wx" });
-    renameSync3(tempPath, recordPath);
+    writeFileSync7(tempPath, JSON.stringify(record, null, 2), { encoding: "utf8", mode: 384, flag: "wx" });
+    renameSync4(tempPath, recordPath);
   } catch {
     rmSync9(tempPath, { force: true });
   }
 }
 function readOwnerRecord(recordPath) {
   try {
-    const parsed = JSON.parse(readFileSync18(recordPath, "utf8"));
+    const parsed = JSON.parse(readFileSync19(recordPath, "utf8"));
     return parsed && typeof parsed === "object" ? parsed : undefined;
   } catch {
     return;
@@ -49888,7 +50294,7 @@ function readOwnerRecord(recordPath) {
 }
 function readLegacyOwnerLockPid(legacyPath) {
   try {
-    const pid = JSON.parse(readFileSync18(legacyPath, "utf8"))?.pid;
+    const pid = JSON.parse(readFileSync19(legacyPath, "utf8"))?.pid;
     return typeof pid === "number" && Number.isInteger(pid) && pid > 0 ? pid : undefined;
   } catch {
     return;
@@ -49903,21 +50309,21 @@ function changeSetJournalRecoveryErrorMessage(metadataJson) {
   return "pending ChangeSet journal without a recorded recovery error";
 }
 function quarantineExistingLocalStore(paths) {
-  const quarantineDir = join13(paths.workspaceStateDir, "quarantine", `runtime.sqlite-${Date.now()}-${randomUUID()}`);
+  const quarantineDir = join14(paths.workspaceStateDir, "quarantine", `runtime.sqlite-${Date.now()}-${randomUUID2()}`);
   ensurePrivateDir(quarantineDir);
   const quarantinedFiles = [];
   for (const suffix of SQLITE_SIDECAR_SUFFIXES) {
     const source = `${paths.localStorePath}${suffix}`;
     if (!existsSync19(source))
       continue;
-    const target = join13(quarantineDir, `runtime.sqlite${suffix}`);
-    renameSync3(source, target);
+    const target = join14(quarantineDir, `runtime.sqlite${suffix}`);
+    renameSync4(source, target);
     quarantinedFiles.push(target);
   }
   const markerPath = legacyMigrationMarkerPath(paths);
   if (existsSync19(markerPath)) {
-    const target = join13(quarantineDir, LEGACY_MIGRATION_MARKER_FILE);
-    renameSync3(markerPath, target);
+    const target = join14(quarantineDir, LEGACY_MIGRATION_MARKER_FILE);
+    renameSync4(markerPath, target);
     quarantinedFiles.push(target);
   }
   fsyncDirectory2(quarantineDir);
@@ -49925,16 +50331,16 @@ function quarantineExistingLocalStore(paths) {
   return quarantinedFiles;
 }
 function legacyMigrationMarkerPath(paths) {
-  return join13(paths.workspaceStateDir, LEGACY_MIGRATION_MARKER_FILE);
+  return join14(paths.workspaceStateDir, LEGACY_MIGRATION_MARKER_FILE);
 }
 function legacyMigrationLockPath(paths) {
-  return join13(paths.workspaceStateDir, LEGACY_MIGRATION_LOCK_FILE);
+  return join14(paths.workspaceStateDir, LEGACY_MIGRATION_LOCK_FILE);
 }
 function writePrivateJson2(path, value) {
   ensurePrivateDir(dirname8(path));
   const fd = openSync8(path, "w", 384);
   try {
-    writeFileSync6(fd, JSON.stringify(value, null, 2), "utf8");
+    writeFileSync7(fd, JSON.stringify(value, null, 2), "utf8");
     fsyncSync3(fd);
   } finally {
     closeSync7(fd);
@@ -49943,7 +50349,7 @@ function writePrivateJson2(path, value) {
   fsyncDirectory2(dirname8(path));
 }
 function ensurePrivateDir(path) {
-  mkdirSync7(path, { recursive: true, mode: 448 });
+  mkdirSync8(path, { recursive: true, mode: 448 });
   if (process.platform !== "win32") {
     try {
       chmodSync4(path, 448);
@@ -50306,7 +50712,7 @@ function recoverJournalFiles(root, files) {
     try {
       const stat = lstatSync10(absolute);
       if (stat.isFile() && !stat.isSymbolicLink()) {
-        const bytes = readFileSync18(absolute), body = bytes.toString("utf8");
+        const bytes = readFileSync19(absolute), body = bytes.toString("utf8");
         if (Buffer.from(body, "utf8").equals(bytes))
           current = digestJson({ body });
       }
@@ -50325,7 +50731,7 @@ function recoverJournalFiles(root, files) {
     if (file.existed) {
       if (file.backupPath && existsSync19(file.backupPath)) {
         rmSync9(absolute, { recursive: true, force: true });
-        renameSync3(file.backupPath, absolute);
+        renameSync4(file.backupPath, absolute);
       } else if (!existsSync19(absolute) && firstExistedByPath.get(pathKey(absolute)) === true) {
         missing.push(file.path);
         continue;
@@ -50383,7 +50789,7 @@ async function readRelationFiles(root, relationsDir) {
   for (const entry of entries) {
     if (!entry.isFile() || !/\.(json|ya?ml)$/.test(entry.name))
       continue;
-    const relativePath = join13(relationsDir, entry.name).split("\\").join("/");
+    const relativePath = join14(relationsDir, entry.name).split("\\").join("/");
     relations.push(parseCrossRepoRelationFile(await readFile(resolve23(root, relativePath), "utf8"), relativePath));
   }
   return relations.sort((a, b) => a.id.localeCompare(b.id));
@@ -50515,7 +50921,7 @@ class LedgerAdminService {
       }
       const paths = runtimeStatePaths(repositoryRoot);
       const backupCreatedAt = this.context.clock();
-      const backupPath = uniqueRuntimeBackupPath(join14(paths.workspaceStateDir, "backups", "ledger-migrate", safePathSegment(backupCreatedAt), "runtime.sqlite"));
+      const backupPath = uniqueRuntimeBackupPath(join15(paths.workspaceStateDir, "backups", "ledger-migrate", safePathSegment(backupCreatedAt), "runtime.sqlite"));
       const backup = await this.context.localStore.backupArchitectureLedger({ backupPath });
       const append = await this.context.appendArchitectureEventsWithFeed(repositoryRoot, {
         writer: "runtime-daemon",
@@ -51014,7 +51420,7 @@ function obsoleteManagedProjectionPaths(currentFiles, projectedFiles) {
 }
 function expectedFileHash(root, path) {
   const absolute = resolve24(root, path);
-  return existsSync20(absolute) ? digestJson({ body: readFileSync19(absolute, "utf8") }) : "missing";
+  return existsSync20(absolute) ? digestJson({ body: readFileSync20(absolute, "utf8") }) : "missing";
 }
 function architectureProjectionRollbackBackup(files, options = {}) {
   const manifest = {
@@ -51069,12 +51475,12 @@ function isEmptyArchitectureLedgerState(state) {
 // packages/local-runtime/runtime-daemon/src/architecture-book.ts
 init_src();
 import { existsSync as existsSync22 } from "node:fs";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 
 // packages/local-runtime/runtime-daemon/src/refactor-decisions.ts
 init_src();
-import { existsSync as existsSync21, lstatSync as lstatSync11, readdirSync as readdirSync12, readFileSync as readFileSync20 } from "node:fs";
-import { join as join15 } from "node:path";
+import { existsSync as existsSync21, lstatSync as lstatSync11, readdirSync as readdirSync12, readFileSync as readFileSync21 } from "node:fs";
+import { join as join16 } from "node:path";
 var REFACTOR_DECISION_SET_SCHEMA_VERSION = "archcontext.refactor-decision-set/v1";
 var REFACTOR_DECISION_FILE_NAME = /^recommendation\.[a-f0-9]{16}\.json$/;
 var CHANGESET_TRANSIENT_DECISION_NAME = /^recommendation\.[a-f0-9]{16}\.json\.(archctx-backup|archctx-tmp-[0-9]+-[0-9]+)$/;
@@ -51113,11 +51519,11 @@ function readRefactorDecisionSet(root) {
       const name = path.slice(prefix.length);
       if (name.includes("/"))
         throw decisionReadError(`${path} must sit directly in ${REFACTOR_DECISION_DIRECTORY}`);
-      if (!lstatSync11(join15(absoluteDirectory, name)).isFile())
+      if (!lstatSync11(join16(absoluteDirectory, name)).isFile())
         throw decisionReadError(`${path} must be a regular file, not a directory or symlink`);
       let decision;
       try {
-        decision = parseRefactorDecisionFile(path, readFileSync20(join15(absoluteDirectory, name), "utf8"));
+        decision = parseRefactorDecisionFile(path, readFileSync21(join16(absoluteDirectory, name), "utf8"));
       } catch (error) {
         throw decisionReadError(error instanceof Error ? error.message : String(error));
       }
@@ -51206,7 +51612,7 @@ function buildRefactorDecision(input) {
 function refactorDecisionWrite(root, decision) {
   const path = refactorDecisionPath(decision.recommendationId);
   const absolute = assertPathHasNoSymlinkSegments(root, path);
-  const expectedHash = existsSync21(absolute) ? digestJson({ body: readFileSync20(absolute, "utf8") }) : "missing";
+  const expectedHash = existsSync21(absolute) ? digestJson({ body: readFileSync21(absolute, "utf8") }) : "missing";
   return { path, expectedHash, body: serializeRefactorDecision(decision) };
 }
 function refactorDecisionIdentityIssues(decision, namespace) {
@@ -51396,7 +51802,7 @@ class ArchitectureBookService {
       const gitScope = await this.context.architectureLedgerGitScope(root);
       let refactorDecisionStatuses = new Map;
       const repositoryRoot = findRepositoryRoot(root);
-      if (replay.events.some(eventCarriesRefactorRecommendation) || existsSync22(join16(repositoryRoot, REFACTOR_DECISION_DIRECTORY))) {
+      if (replay.events.some(eventCarriesRefactorRecommendation) || existsSync22(join17(repositoryRoot, REFACTOR_DECISION_DIRECTORY))) {
         try {
           const decisions = readRefactorDecisionSet(repositoryRoot);
           refactorDecisionStatuses = new Map(decisions.decisions.map((decision) => [decision.recommendationId, decision.status]));
@@ -51752,8 +52158,8 @@ init_src();
 init_src();
 import { randomBytes as randomBytes4 } from "node:crypto";
 import { execFileSync as execFileSync7 } from "node:child_process";
-import { chmodSync as chmodSync5, existsSync as existsSync23, lstatSync as lstatSync12, mkdirSync as mkdirSync8, readFileSync as readFileSync21, renameSync as renameSync4, rmSync as rmSync10, writeFileSync as writeFileSync7 } from "node:fs";
-import { basename as basename6, dirname as dirname9, join as join17 } from "node:path";
+import { chmodSync as chmodSync5, existsSync as existsSync23, lstatSync as lstatSync12, mkdirSync as mkdirSync9, readFileSync as readFileSync22, renameSync as renameSync5, rmSync as rmSync10, writeFileSync as writeFileSync8 } from "node:fs";
+import { basename as basename6, dirname as dirname9, join as join18 } from "node:path";
 
 // packages/local-runtime/runtime-daemon/src/investigation-transport.ts
 import { spawn } from "node:child_process";
@@ -51995,7 +52401,7 @@ var AUDIT_EGRESS_POLICY_DIGEST = digestJson(AUDIT_EGRESS_POLICY);
 function auditConsentBinding(root, env) {
   const paths = runtimeStatePaths(root, env);
   return {
-    path: join17(paths.repositoryStateDir, AUDIT_CONSENT_FILE),
+    path: join18(paths.repositoryStateDir, AUDIT_CONSENT_FILE),
     storageRepositoryId: paths.storageRepositoryId,
     repositoryAnchor: paths.repositoryAnchor,
     origin: readSanitizedOrigin(paths.repositoryRoot)
@@ -52043,7 +52449,7 @@ function readAuditConsentUnchecked(root, env = process.env) {
   try {
     if (!lstatSync12(binding.path).isFile())
       return { granted: false, path: binding.path, reason: "unreadable" };
-    record = JSON.parse(readFileSync21(binding.path, "utf8"));
+    record = JSON.parse(readFileSync22(binding.path, "utf8"));
   } catch {
     return { granted: false, path: binding.path, reason: "unreadable" };
   }
@@ -52081,13 +52487,13 @@ function grantAuditConsentUnchecked(root, env = process.env, now = new Date().to
 }
 function writePrivateJsonAtomically(path, value) {
   const directory = dirname9(path);
-  mkdirSync8(directory, { recursive: true, mode: 448 });
-  const tempPath = join17(directory, `.${basename6(path)}.${process.pid}.${randomBytes4(6).toString("hex")}.tmp`);
+  mkdirSync9(directory, { recursive: true, mode: 448 });
+  const tempPath = join18(directory, `.${basename6(path)}.${process.pid}.${randomBytes4(6).toString("hex")}.tmp`);
   try {
-    writeFileSync7(tempPath, `${JSON.stringify(value, null, 2)}
+    writeFileSync8(tempPath, `${JSON.stringify(value, null, 2)}
 `, { encoding: "utf8", mode: 384, flag: "wx" });
     chmodSync5(tempPath, 384);
-    renameSync4(tempPath, path);
+    renameSync5(tempPath, path);
   } catch (error) {
     rmSync10(tempPath, { force: true });
     throw error;
@@ -52120,9 +52526,9 @@ function auditConsentRequiredEnvelope(requestId, reason) {
 
 // packages/local-runtime/runtime-daemon/src/github-issue-executor.ts
 import { execFile } from "node:child_process";
-import { mkdtempSync as mkdtempSync4, rmSync as rmSync11, writeFileSync as writeFileSync8 } from "node:fs";
+import { mkdtempSync as mkdtempSync4, rmSync as rmSync11, writeFileSync as writeFileSync9 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 var DEFAULT_GH_EXECUTOR_TIMEOUT_MS = 30000;
 var GITHUB_ISSUE_LIST_LIMIT = 100;
 function createNodeGithubIssueExecutor(options = {}) {
@@ -52187,10 +52593,10 @@ function runGh(args, env, timeoutMs) {
   });
 }
 async function withGithubIssueBodyFile(body, fn, deps = {}) {
-  const writeFile = deps.writeFile ?? writeFileSync8;
-  const dir = mkdtempSync4(join18(tmpdir4(), "archctx-gh-issue-body-"));
+  const writeFile = deps.writeFile ?? writeFileSync9;
+  const dir = mkdtempSync4(join19(tmpdir4(), "archctx-gh-issue-body-"));
   try {
-    const bodyFile = join18(dir, "body.md");
+    const bodyFile = join19(dir, "body.md");
     writeFile(bodyFile, body, { mode: 384 });
     return await fn(bodyFile);
   } finally {
@@ -53174,10 +53580,10 @@ function runtimeProjectionOwnedOutputDigest(projection) {
 }
 // packages/local-runtime/runtime-daemon/src/projection-writer.ts
 import { execFile as execFile2, spawnSync as spawnSync6 } from "node:child_process";
-import { createHash as createHash11, randomUUID as randomUUID2 } from "node:crypto";
-import { closeSync as closeSync8, existsSync as existsSync24, mkdirSync as mkdirSync9, mkdtempSync as mkdtempSync5, openSync as openSync9, readFileSync as readFileSync22, readSync as readSync5, realpathSync as realpathSync8, renameSync as renameSync5, rmSync as rmSync12, writeFileSync as writeFileSync9 } from "node:fs";
+import { createHash as createHash11, randomUUID as randomUUID3 } from "node:crypto";
+import { closeSync as closeSync8, existsSync as existsSync24, mkdirSync as mkdirSync10, mkdtempSync as mkdtempSync5, openSync as openSync9, readFileSync as readFileSync23, readSync as readSync5, realpathSync as realpathSync8, renameSync as renameSync6, rmSync as rmSync12, writeFileSync as writeFileSync10 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { extname as extname2, join as join19, resolve as resolve25 } from "node:path";
+import { extname as extname2, join as join20, resolve as resolve25 } from "node:path";
 init_src();
 var PROJECTION_PUBLISH_REQUEST_ID = "projection.publish";
 var PROJECTION_PUBLISH_STATUS_REQUEST_ID = "projection.publish-status";
@@ -53190,6 +53596,10 @@ var PROJECTION_WRITER_MAX_ITERATIONS = 3;
 var PROJECTION_WRITER_TARGETS = ["agent-context", "architecture-docs"];
 var PUBLISHER_TIMEOUT_MS = 120000;
 var PR_BODY_MAX_LISTED_PATHS = 200;
+function renderRecentHistory(root, ref, env) {
+  const { total } = readArchitectureHistory(root, { ref, limit: 0, env });
+  return renderHistoryMarkdown(readArchitectureHistory(root, { ref, offset: Math.max(0, total - 20), limit: 20, env }));
+}
 
 class ProjectionWriterFailure extends Error {
   code;
@@ -53207,8 +53617,8 @@ class ProjectionWriterFailure extends Error {
 }
 function projectionWriterPaths(repositoryRoot, remote, base, env = process.env) {
   const key = createHash11("sha256").update(`${remote}\x00${base}`, "utf8").digest("hex").slice(0, 16);
-  const dir = join19(runtimeStatePaths(repositoryRoot, env).repositoryStateDir, "projection-writer", key);
-  return { dir, baseRef: `refs/archctx/projection-writer/${key}/base`, worktree: join19(dir, "worktree"), state: join19(dir, "state.json"), lock: join19(dir, "lock") };
+  const dir = join20(runtimeStatePaths(repositoryRoot, env).repositoryStateDir, "projection-writer", key);
+  return { dir, baseRef: `refs/archctx/projection-writer/${key}/base`, worktree: join20(dir, "worktree"), state: join20(dir, "state.json"), lock: join20(dir, "lock") };
 }
 async function runProjectionPublishCommand(options) {
   const env = options.env ?? process.env;
@@ -53253,7 +53663,7 @@ async function runProjectionPublishCommand(options) {
   });
   let lock;
   try {
-    mkdirSync9(paths.dir, { recursive: true, mode: 448 });
+    mkdirSync10(paths.dir, { recursive: true, mode: 448 });
     lock = acquireProjectionWriterLock(paths.lock, startedAt);
   } catch (error) {
     const failure = asWriterFailure(error);
@@ -53362,6 +53772,12 @@ async function runLockedProjectionPublish(input) {
       if (!["noop", "applied", "applied-partial"].includes(projectionStatus)) {
         throw new ProjectionWriterFailure("AC_PRECONDITION_FAILED", "projection-apply-status-unsupported", `projection apply ended with status ${projectionStatus}; the writer publishes only noop, applied and applied-partial results`);
       }
+      const historyBody = renderRecentHistory(paths.worktree, baseSha, options.env);
+      const historyPath = join20(paths.worktree, ARCHITECTURE_HISTORY_PATH);
+      mkdirSync10(join20(paths.worktree, "docs/architecture"), { recursive: true });
+      const historyTemp = `${historyPath}.${randomUUID3()}.tmp`;
+      writeFileSync10(historyTemp, historyBody);
+      renameSync6(historyTemp, historyPath);
       const changed = worktreeChangedPaths(paths.worktree);
       if (changed.length === 0) {
         const tip = lsRemoteBranch(repositoryRoot, pushRemote, base, env);
@@ -53373,6 +53789,7 @@ async function runLockedProjectionPublish(input) {
         return finish("up-to-date", { projectionStatus });
       }
       const written = new Set(result.files.filter((file) => file.action !== "unchanged").map((file) => file.path));
+      written.add(ARCHITECTURE_HISTORY_PATH);
       const offending = changed.filter((path) => !written.has(path) || !isProjectionOwnedPath(path, ownedPatterns));
       if (offending.length > 0) {
         return failed(new ProjectionWriterFailure("AC_POLICY_VIOLATION", "projection-writer-non-owned-change", `projection apply changed paths the writer may not publish: ${offending.join(", ")}`), { projectionStatus });
@@ -53475,10 +53892,10 @@ function projectionPublishBody(input) {
 async function publishPullRequest(publisher, input) {
   if (publisher.kind === "none")
     return { ok: true, pullRequest: null };
-  const dir = mkdtempSync5(join19(tmpdir5(), "archctx-projection-pr-body-"));
+  const dir = mkdtempSync5(join20(tmpdir5(), "archctx-projection-pr-body-"));
   try {
-    const bodyFile = join19(dir, "body.md");
-    writeFileSync9(bodyFile, projectionPublishBody(input), { mode: 384 });
+    const bodyFile = join20(dir, "body.md");
+    writeFileSync10(bodyFile, projectionPublishBody(input), { mode: 384 });
     const pullRequest = await publisher.ensurePullRequest({
       worktree: input.worktree,
       remote: input.remote,
@@ -53617,11 +54034,13 @@ function runProjectionVerifyPrCommand(options) {
     } catch {
       agentContextDiffering = [...classified.agentContextPaths];
     }
+    const historyDiffering = changedPaths.includes(ARCHITECTURE_HISTORY_PATH) && readFileAtRevision(root, headSha, ARCHITECTURE_HISTORY_PATH) !== renderRecentHistory(root, headSha) ? [ARCHITECTURE_HISTORY_PATH] : [];
     const differingPaths = [...new Set([
       ...result.files.filter((file) => file.action !== "unchanged").map((file) => file.path),
-      ...agentContextDiffering
+      ...agentContextDiffering,
+      ...historyDiffering
     ])].sort();
-    const renderEquivalent = result.status === "noop" && agentContextDiffering.length === 0;
+    const renderEquivalent = result.status === "noop" && agentContextDiffering.length === 0 && historyDiffering.length === 0;
     return verification({
       verdict: renderEquivalent ? "generated-only-render-equivalent" : "generated-only-not-render-equivalent",
       generatedOnly: true,
@@ -53640,7 +54059,7 @@ function classifyPullRequestPaths(root, mergeBase, headSha, changedPaths) {
   const humanEdited = [];
   const agentContext = [];
   for (const path of changedPaths) {
-    if (path === ARCHITECTURE_DOCS_PROJECTION_MANIFEST_PATH)
+    if (path === ARCHITECTURE_DOCS_PROJECTION_MANIFEST_PATH || path === ARCHITECTURE_HISTORY_PATH)
       continue;
     const atBase = baseTargets.get(path);
     const atHead = headTargets.get(path);
@@ -53979,7 +54398,7 @@ function acquireProjectionWriterLock(lockPath, startedAt) {
       return { kind: "busy", pid: holder.pid };
     }
     rmSync12(lockPath, { force: true });
-    const record = JSON.stringify({ pid: process.pid, startedAt, token: randomUUID2() }, null, 2);
+    const record = JSON.stringify({ pid: process.pid, startedAt, token: randomUUID3() }, null, 2);
     createPrivateControlFile(lockPath, record);
     return { kind: "acquired", record, release() {
       try {
@@ -54035,7 +54454,7 @@ function readProjectionWriterState(path, remote, base) {
     return emptyProjectionWriterState(remote, base);
   let value;
   try {
-    value = JSON.parse(readFileSync22(path, "utf8"));
+    value = JSON.parse(readFileSync23(path, "utf8"));
   } catch (error) {
     throw new ProjectionWriterFailure("AC_PRECONDITION_FAILED", "projection-writer-state-invalid", `projection writer state is unreadable at ${path}: ${errorMessage(error)}`);
   }
@@ -54057,9 +54476,9 @@ function readProjectionWriterState(path, remote, base) {
 }
 function writeProjectionWriterState(path, state) {
   const temporary = `${path}.${process.pid}.tmp`;
-  writeFileSync9(temporary, `${JSON.stringify(state, null, 2)}
+  writeFileSync10(temporary, `${JSON.stringify(state, null, 2)}
 `, { encoding: "utf8", mode: 384 });
-  renameSync5(temporary, path);
+  renameSync6(temporary, path);
 }
 function prepareProjectionWriterWorktree(repositoryRoot, worktree, sha) {
   git(repositoryRoot, ["worktree", "prune"]);
@@ -54072,7 +54491,7 @@ function prepareProjectionWriterWorktree(repositoryRoot, worktree, sha) {
   git(worktree, ["clean", "-ffdq"]);
 }
 function isRegisteredWorktree(repositoryRoot, worktree) {
-  if (!existsSync24(join19(worktree, ".git")))
+  if (!existsSync24(join20(worktree, ".git")))
     return false;
   const wanted = canonical(worktree);
   return git(repositoryRoot, ["worktree", "list", "--porcelain", "-z"]).split("\x00").filter((line) => line.startsWith("worktree ")).some((line) => canonical(line.slice("worktree ".length)) === wanted);
@@ -54324,7 +54743,7 @@ function runFlowSelectorCheckCommand(cwd, options = {}) {
 }
 // packages/local-runtime/runtime-daemon/src/recommendations.ts
 import { existsSync as existsSync25 } from "node:fs";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 
 // packages/local-runtime/runtime-daemon/src/refactor-verify.ts
 init_src();
@@ -54926,7 +55345,7 @@ class RecommendationsService {
     });
   }
   readGitOnlyDecision(repositoryRoot, recommendationId, surface) {
-    if (!existsSync25(join20(repositoryRoot, REFACTOR_DECISION_DIRECTORY)))
+    if (!existsSync25(join21(repositoryRoot, REFACTOR_DECISION_DIRECTORY)))
       return;
     let decisions;
     try {
@@ -55596,7 +56015,7 @@ function lifecycleEnvelope(input) {
   });
 }
 function refactorDecisionsInPlay(repositoryRoot, records) {
-  return records.some(isRefactorRecommendation) || existsSync25(join20(repositoryRoot, REFACTOR_DECISION_DIRECTORY));
+  return records.some(isRefactorRecommendation) || existsSync25(join21(repositoryRoot, REFACTOR_DECISION_DIRECTORY));
 }
 function ledgerAuditDecisionRefused(surface, record, recommendations, decisions) {
   let head = record.recommendationId;
@@ -55718,14 +56137,14 @@ function recommendationActorKind(input) {
 init_src();
 init_src();
 init_src();
-import { existsSync as existsSync26, readFileSync as readFileSync24 } from "node:fs";
+import { existsSync as existsSync26, readFileSync as readFileSync25 } from "node:fs";
 import { resolve as resolve27 } from "node:path";
 init_src();
 
 // packages/local-runtime/runtime-daemon/src/committed-change-acceptance.ts
 init_src();
 import { execFileSync as execFileSync9 } from "node:child_process";
-import { closeSync as closeSync9, constants as fsConstants3, fstatSync as fstatSync4, lstatSync as lstatSync13, openSync as openSync10, readdirSync as readdirSync13, readFileSync as readFileSync23 } from "node:fs";
+import { closeSync as closeSync9, constants as fsConstants3, fstatSync as fstatSync4, lstatSync as lstatSync13, openSync as openSync10, readdirSync as readdirSync13, readFileSync as readFileSync24 } from "node:fs";
 import { resolve as resolve26 } from "node:path";
 init_src();
 var SEMANTIC_MODEL_DIRECTORIES = ["nodes", "relations", "flows"];
@@ -55804,7 +56223,7 @@ function readRegularFileBytes(absolute, path) {
   try {
     if (!fstatSync4(fd).isFile())
       throw new FailureError("AC_PRECONDITION_FAILED", "semantic-model-entry-not-regular");
-    return readFileSync23(fd);
+    return readFileSync24(fd);
   } finally {
     closeSync9(fd);
   }
@@ -56307,7 +56726,7 @@ class ChangeSetAuthorityService {
       const absolute = resolve27(session.workspace.root, path);
       const body = `${JSON.stringify(waiver, null, 2)}
 `;
-      const expectedHash = existsSync26(absolute) ? digestJson({ body: readFileSync24(absolute, "utf8") }) : "missing";
+      const expectedHash = existsSync26(absolute) ? digestJson({ body: readFileSync25(absolute, "utf8") }) : "missing";
       const draft = this.changeSetEngine.plan({
         id: input.id ?? `changeset.practice-waiver-${waiverId.replace(/[^A-Za-z0-9_-]/g, "-")}`,
         base: {
@@ -56747,7 +57166,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 closeSync10, existsSync as existsSync27, mkdirSync as mkdirSync10 } from "node:fs";
+import { closeSync as closeSync10, existsSync as existsSync27, mkdirSync as mkdirSync11 } from "node:fs";
 import { dirname as dirname10 } from "node:path";
 import { randomBytes as randomBytes5 } from "node:crypto";
 var DEFAULT_DAEMON_IDLE_TIMEOUT_MS = 30 * 60000;
@@ -56818,8 +57237,8 @@ class ArchctxRuntimeRpcServer {
     const root = this.options.root ?? process.cwd();
     const connectionPath = this.options.connectionPath ?? defaultDaemonConnectionPath(root);
     const lockPath = this.options.lockPath ?? defaultDaemonLockPath(root);
-    mkdirSync10(dirname10(connectionPath), { recursive: true });
-    mkdirSync10(dirname10(lockPath), { recursive: true });
+    mkdirSync11(dirname10(connectionPath), { recursive: true });
+    mkdirSync11(dirname10(lockPath), { recursive: true });
     this.lockFd = acquireDaemonLock(lockPath, root);
     const token = this.options.token ?? randomBytes5(18).toString("base64url");
     const server = createServer2((request, response) => {
@@ -57138,7 +57557,7 @@ async function readRpcRequestBody(request, limits) {
 }
 
 // packages/local-runtime/runtime-daemon/src/index.ts
-import { existsSync as existsSync28, readFileSync as readFileSync25 } from "node:fs";
+import { existsSync as existsSync28, readFileSync as readFileSync26 } from "node:fs";
 import { resolve as resolve28 } from "node:path";
 init_src();
 
@@ -57333,7 +57752,7 @@ class ArchctxDaemon {
             const model = loadNativeModelFromArchContext(root);
             const canonical = renderAgentContextProjection({ model, sourceDigest: digestJson({ model }), existingFiles: loadAgentContextProjectionFiles(root, model) });
             const canonicalBody = canonical.files.find((candidate) => candidate.path === file.path)?.body;
-            if (canonicalBody === undefined || projectionOwnedWriteBody(canonicalBody, readFileSync25(resolve28(root, file.path), "utf8")) !== file.body) {
+            if (canonicalBody === undefined || projectionOwnedWriteBody(canonicalBody, readFileSync26(resolve28(root, file.path), "utf8")) !== file.body) {
               throw new Error(`Root contract requires canonical marker-only content: ${file.path}`);
             }
           }
@@ -58651,8 +59070,8 @@ function isArchContextGeneratedProjectionPath2(path) {
 
 // packages/surfaces/cli/src/github-review-state.ts
 init_src();
-import { chmodSync as chmodSync6, existsSync as existsSync29, mkdirSync as mkdirSync11, readFileSync as readFileSync26, rmSync as rmSync13, writeFileSync as writeFileSync10 } from "node:fs";
-import { dirname as dirname11, join as join22 } from "node:path";
+import { chmodSync as chmodSync6, existsSync as existsSync29, mkdirSync as mkdirSync12, readFileSync as readFileSync27, rmSync as rmSync13, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname11, join as join23 } from "node:path";
 var text2 = { type: "string", minLength: 1 };
 var digest2 = { type: "string", pattern: "^sha256:[0-9a-f]{64}$" };
 var record7 = (properties, required = Object.keys(properties)) => ({ type: "object", additionalProperties: false, properties, required });
@@ -58683,7 +59102,7 @@ var stateSchema = record7({
 }, ["schemaVersion", "status", "challenge", "challengeDigest", "updatedAt"]);
 function defaultGithubDeveloperReviewStatePath(cwd, pullRequestNumber) {
   const suffix = pullRequestNumber ? `github-developer-review-pr-${pullRequestNumber}.json` : "github-developer-review.json";
-  return join22(runtimeStatePaths(cwd).workspaceStateDir, suffix);
+  return join23(runtimeStatePaths(cwd).workspaceStateDir, suffix);
 }
 function metadata(state) {
   const { submission, ...rest } = state;
@@ -58737,8 +59156,8 @@ async function writeGithubDeveloperReviewState(cwd, state, secrets = []) {
     assertNoCliSecretMaterial(state.submission);
     assertNoReviewSecrets(state.submission, secrets);
   }
-  mkdirSync11(dirname11(path), { recursive: true });
-  writeFileSync10(path, serialized, { mode: 384 });
+  mkdirSync12(dirname11(path), { recursive: true });
+  writeFileSync11(path, serialized, { mode: 384 });
   if (process.platform !== "win32")
     chmodSync6(path, 384);
   return { state: { ...validated, ...state.submission === undefined ? {} : { submission: state.submission } }, path };
@@ -58748,7 +59167,7 @@ function readGithubDeveloperReviewState(path) {
     return;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync26(path, "utf8"));
+    parsed = JSON.parse(readFileSync27(path, "utf8"));
   } catch {
     throw new Error("github-review-state-metadata-invalid");
   }
@@ -58763,7 +59182,7 @@ function discardLegacyGithubDeveloperReviewState(path) {
     return false;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync26(path, "utf8"));
+    parsed = JSON.parse(readFileSync27(path, "utf8"));
   } catch {
     throw new Error("github-review-state-metadata-invalid");
   }
@@ -58865,13 +59284,14 @@ function localEgressStatus2(env = process.env, live = {}) {
 
 // packages/surfaces/cli/src/main.ts
 import { spawn as spawn2, spawnSync as spawnSync9 } from "child_process";
-import { accessSync as accessSync3, closeSync as closeSync14, constants as constants3, existsSync as existsSync35, mkdirSync as mkdirSync16, openSync as openSync14, readFileSync as readFileSync33, rmSync as rmSync18, statSync as statSync12 } from "fs";
-import { dirname as dirname16, join as join27, parse, resolve as resolve37 } from "path";
+import { accessSync as accessSync3, closeSync as closeSync14, constants as constants3, existsSync as existsSync35, mkdirSync as mkdirSync17, openSync as openSync14, readFileSync as readFileSync34, rmSync as rmSync18, statSync as statSync12 } from "fs";
+import { dirname as dirname16, join as join28, parse, resolve as resolve37 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // packages/contracts/src/index.ts
 init_control_plane_routes();
 init_architecture();
+init_architecture_history();
 init_architecture_debt();
 init_docs_anchors();
 init_github_governance();
@@ -58893,12 +59313,12 @@ init_changeset_recovery();
 
 // packages/core/changeset-engine/src/index.ts
 init_src();
-import { chmodSync as chmodSync7, closeSync as closeSync11, existsSync as existsSync30, fsyncSync as fsyncSync4, lstatSync as lstatSync14, mkdirSync as mkdirSync12, openSync as openSync11, readFileSync as readFileSync27, renameSync as renameSync6, rmSync as rmSync14, writeFileSync as writeFileSync11 } from "node:fs";
+import { chmodSync as chmodSync7, closeSync as closeSync11, existsSync as existsSync30, fsyncSync as fsyncSync4, lstatSync as lstatSync14, mkdirSync as mkdirSync13, openSync as openSync11, readFileSync as readFileSync28, renameSync as renameSync7, rmSync as rmSync14, writeFileSync as writeFileSync12 } from "node:fs";
 import { dirname as dirname12, isAbsolute as isAbsolute7, relative as relative8, resolve as resolve29, sep as sep6 } from "node:path";
 var EMPTY_PATH_SET2 = new Set;
 function planManifestFieldsOperation(root, fields) {
   const absolute = assertPathHasNoSymlinkSegments2(root, MANIFEST_UPDATE_PATH);
-  const body = readFileSync27(absolute, "utf8");
+  const body = readFileSync28(absolute, "utf8");
   const operation = { op: "update_manifest_fields", path: MANIFEST_UPDATE_PATH, expectedHash: digestJson({ body }), fields };
   assertManifestUpdateOperation(operation);
   renderManifestFieldsUpdate(body, fields);
@@ -59006,7 +59426,7 @@ function assertAllowedArchContextPath2(root, relativePath, scope) {
 
 // packages/core/architecture-domain/src/index.ts
 import { createHash as createHash12 } from "node:crypto";
-import { readFileSync as readFileSync28, realpathSync as realpathSync10, statSync as statSync8 } from "node:fs";
+import { readFileSync as readFileSync29, realpathSync as realpathSync10, statSync as statSync8 } from "node:fs";
 import { resolve as resolve31 } from "node:path";
 init_src();
 var DEFAULT_IGNORES2 = new Set([
@@ -59059,7 +59479,7 @@ function computeWorktreeDigest2(root, files, options = {}) {
     return {
       path,
       size: statSync8(absolute).size,
-      digest: createHash12("sha256").update(readFileSync28(absolute)).digest("hex")
+      digest: createHash12("sha256").update(readFileSync29(absolute)).digest("hex")
     };
   });
   return digestJson(payload);
@@ -59374,7 +59794,7 @@ var UNTRUSTED_TOOL_ESCAPE_KEYS2 = new Set([
 ]);
 
 // packages/cloud/hardening/src/index.ts
-import { readdirSync as readdirSync14, readFileSync as readFileSync29, statSync as statSync9 } from "node:fs";
+import { readdirSync as readdirSync14, readFileSync as readFileSync30, statSync as statSync9 } from "node:fs";
 import { resolve as resolve32 } from "node:path";
 init_src2();
 init_src();
@@ -59422,7 +59842,7 @@ function uninstallMarker(content, host) {
 `).trim();
 }
 function dependencyAudit(root) {
-  const packageJson = JSON.parse(readFileSync29(resolve32(root, "package.json"), "utf8"));
+  const packageJson = JSON.parse(readFileSync30(resolve32(root, "package.json"), "utf8"));
   const issues = [];
   if (packageJson.engines?.node !== ARCHCONTEXT_NODE_RANGE) {
     issues.push(`node engine must equal ${ARCHCONTEXT_NODE_RANGE}`);
@@ -59436,7 +59856,7 @@ function secretScan(root) {
       continue;
     if (file === "packages/cloud/hardening/src/index.ts" || file.includes("/test/"))
       continue;
-    const body = readFileSync29(resolve32(root, file), "utf8");
+    const body = readFileSync30(resolve32(root, file), "utf8");
     if (/(sk-[A-Za-z0-9]{20,}|ghp_[A-Za-z0-9]{20,}|BEGIN PRIVATE KEY)/.test(body))
       findings.push(file);
   }
@@ -59485,10 +59905,10 @@ function listFiles(root) {
 
 // packages/local-runtime/local-store-sqlite/src/index.ts
 init_src();
-import { createHash as createHash14, randomUUID as randomUUID3 } from "node:crypto";
-import { chmodSync as chmodSync8, closeSync as closeSync12, copyFileSync as copyFileSync2, existsSync as existsSync32, fsyncSync as fsyncSync5, lstatSync as lstatSync15, mkdirSync as mkdirSync13, openSync as openSync12, readFileSync as readFileSync30, readSync as readSync6, realpathSync as realpathSync11, renameSync as renameSync7, rmSync as rmSync15, statfsSync as statfsSync2, statSync as statSync10, writeFileSync as writeFileSync12 } from "node:fs";
+import { createHash as createHash14, randomUUID as randomUUID4 } from "node:crypto";
+import { chmodSync as chmodSync8, closeSync as closeSync12, copyFileSync as copyFileSync2, existsSync as existsSync32, fsyncSync as fsyncSync5, lstatSync as lstatSync15, mkdirSync as mkdirSync14, openSync as openSync12, readFileSync as readFileSync31, readSync as readSync6, realpathSync as realpathSync11, renameSync as renameSync8, rmSync as rmSync15, statfsSync as statfsSync2, statSync as statSync10, writeFileSync as writeFileSync13 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
-import { dirname as dirname13, isAbsolute as isAbsolute9, join as join23, relative as relative10, resolve as resolve33 } from "node:path";
+import { dirname as dirname13, isAbsolute as isAbsolute9, join as join24, relative as relative10, resolve as resolve33 } from "node:path";
 init_src();
 var runtimeRequire2 = createRequire5(import.meta.url);
 var SQLITE_SIDECAR_SUFFIXES2 = ["", "-wal", "-shm"];
@@ -60407,8 +60827,8 @@ function recoverRuntimeStateTarget(input) {
   }
   assertRuntimeStateRecoveryDaemonStopped(paths);
   const lock = acquireLegacyMigrationLock2(paths);
-  const stagingDir = join23(paths.workspaceStateDir, `.runtime.sqlite.recovery-${process.pid}-${randomUUID3()}`);
-  const stagingPath = join23(stagingDir, "runtime.sqlite");
+  const stagingDir = join24(paths.workspaceStateDir, `.runtime.sqlite.recovery-${process.pid}-${randomUUID4()}`);
+  const stagingPath = join24(stagingDir, "runtime.sqlite");
   let quarantineDirectory;
   let quarantineFiles = [];
   let receiptPath;
@@ -60427,7 +60847,7 @@ function recoverRuntimeStateTarget(input) {
       throw new Error(`runtime-state-recovery-target-fingerprint-mismatch:${lockedSnapshot.fingerprint}`);
     }
     assertRuntimeStateRecoveryDiskBudget(inspection.availableBytes, inspection.requiredFreeBytes);
-    quarantineDirectory = join23(paths.workspaceStateDir, "quarantine", `runtime-state-recovery-${Date.now()}-${randomUUID3()}`);
+    quarantineDirectory = join24(paths.workspaceStateDir, "quarantine", `runtime-state-recovery-${Date.now()}-${randomUUID4()}`);
     ensurePrivateDir2(quarantineDirectory);
     assertRuntimeStateRecoveryPrivatePermissions(quarantineDirectory, 448);
     quarantineFiles = copyRuntimeStateRecoveryFiles(lockedSnapshot.files, quarantineDirectory);
@@ -60440,7 +60860,7 @@ function recoverRuntimeStateTarget(input) {
     assertRuntimeStateRecoveryPrivatePermissions(stagingDir, 448);
     migrateSqliteDatabaseSync2(stagingPath);
     const stagingIntegrity = assertCurrentLocalStore2(stagingPath);
-    receiptPath = join23(quarantineDirectory, RUNTIME_STATE_RECOVERY_RECEIPT_FILE);
+    receiptPath = join24(quarantineDirectory, RUNTIME_STATE_RECOVERY_RECEIPT_FILE);
     writeRuntimeStateRecoveryReceipt(receiptPath, {
       status: "quarantine-verified",
       paths,
@@ -60504,7 +60924,7 @@ function completeRuntimeStateRecovery(input) {
   if (resolve33(input.recovery.receiptPath) !== expectedReceiptPath) {
     throw new Error("runtime-state-recovery-completion-receipt-path-mismatch");
   }
-  const parsed = JSON.parse(readFileSync30(expectedReceiptPath, "utf8"));
+  const parsed = JSON.parse(readFileSync31(expectedReceiptPath, "utf8"));
   if (parsed.schemaVersion !== "archcontext.runtime-state-recovery-receipt/v1" || parsed.status !== "target-published-rebuild-required" || parsed.targetFingerprint !== input.recovery.targetFingerprintBefore || parsed.expectedWorktreeDigest !== input.recovery.expectedWorktreeDigest) {
     throw new Error("runtime-state-recovery-completion-receipt-mismatch");
   }
@@ -60558,8 +60978,8 @@ function migrateLegacyLocalStoreIfNeeded2(root = process.cwd(), env = process.en
   }
   assertTrustedLegacyLocalStoreSource2(paths);
   const lock = acquireLegacyMigrationLock2(paths);
-  const stagingDir = join23(paths.workspaceStateDir, `.runtime.sqlite.migration-${process.pid}-${randomUUID3()}`);
-  const stagingPath = join23(stagingDir, "runtime.sqlite");
+  const stagingDir = join24(paths.workspaceStateDir, `.runtime.sqlite.migration-${process.pid}-${randomUUID4()}`);
+  const stagingPath = join24(stagingDir, "runtime.sqlite");
   try {
     if (targetExists)
       quarantinedFiles.push(...quarantineExistingLocalStore2(paths));
@@ -61295,13 +61715,13 @@ function runtimeStateRecoveryInspection(paths, migration, status, reasonCode, fi
   };
 }
 function runtimeStateRecoveryStartupProbe(paths, sourceFiles) {
-  const probeDirectory = join23(paths.workspaceStateDir, `.runtime.sqlite.recovery-probe-${process.pid}-${randomUUID3()}`);
-  const probePath = join23(probeDirectory, "runtime.sqlite");
+  const probeDirectory = join24(paths.workspaceStateDir, `.runtime.sqlite.recovery-probe-${process.pid}-${randomUUID4()}`);
+  const probePath = join24(probeDirectory, "runtime.sqlite");
   try {
     ensurePrivateDir2(probeDirectory);
     assertRuntimeStateRecoveryPrivatePermissions(probeDirectory, 448);
     for (const source of sourceFiles.filter((file) => file.name.startsWith("runtime.sqlite") && file.name !== LEGACY_MIGRATION_MARKER_FILE2)) {
-      const target = join23(probeDirectory, source.name);
+      const target = join24(probeDirectory, source.name);
       copyFileSync2(source.path, target);
       makePrivateFile2(target);
     }
@@ -61393,7 +61813,7 @@ function runtimeStateRecoveryAvailableBytes(path) {
 }
 function copyRuntimeStateRecoveryFiles(sourceFiles, quarantineDirectory) {
   return sourceFiles.map((source) => {
-    const target = join23(quarantineDirectory, source.name);
+    const target = join24(quarantineDirectory, source.name);
     copyFileSync2(source.path, target);
     makePrivateFile2(target);
     assertRuntimeStateRecoveryPrivatePermissions(target, 384);
@@ -61439,7 +61859,7 @@ function removeRuntimeStateRecoveryTargetFamily(paths) {
 }
 function restoreRuntimeStateRecoveryFiles(files, paths) {
   for (const file of files) {
-    const target = file.name === LEGACY_MIGRATION_MARKER_FILE2 ? legacyMigrationMarkerPath2(paths) : join23(dirname13(paths.localStorePath), file.name);
+    const target = file.name === LEGACY_MIGRATION_MARKER_FILE2 ? legacyMigrationMarkerPath2(paths) : join24(dirname13(paths.localStorePath), file.name);
     copyFileSync2(file.path, target);
     makePrivateFile2(target);
     fsyncFile2(target);
@@ -61607,7 +62027,7 @@ function publishStagedLocalStore2(stagingPath, targetPath) {
     if (existsSync32(path))
       throw new Error(`Cannot publish migrated SQLite over existing target file: ${path}`);
   }
-  renameSync7(stagingPath, targetPath);
+  renameSync8(stagingPath, targetPath);
   makePrivateFile2(targetPath);
   fsyncDirectory3(dirname13(targetPath));
 }
@@ -61628,7 +62048,7 @@ function acquireLegacyMigrationLock2(paths) {
   ensurePrivateDir2(dirname13(lockPath));
   try {
     const fd = openSync12(lockPath, "wx", 384);
-    writeFileSync12(fd, JSON.stringify({
+    writeFileSync13(fd, JSON.stringify({
       schemaVersion: "archcontext.legacy-local-store-migration-lock/v1",
       pid: process.pid,
       root: paths.repositoryRoot,
@@ -61654,7 +62074,7 @@ function releaseLegacyMigrationLock2(lock) {
 }
 function isStaleMigrationLock2(lockPath) {
   try {
-    const parsed = JSON.parse(readFileSync30(lockPath, "utf8"));
+    const parsed = JSON.parse(readFileSync31(lockPath, "utf8"));
     if (typeof parsed.pid !== "number" || parsed.pid <= 0)
       return true;
     return !isProcessAlive(parsed.pid);
@@ -61664,21 +62084,21 @@ function isStaleMigrationLock2(lockPath) {
 }
 var LOCAL_STORE_WRITER_OWNED_ERROR = "local-store-writer-owned";
 function quarantineExistingLocalStore2(paths) {
-  const quarantineDir = join23(paths.workspaceStateDir, "quarantine", `runtime.sqlite-${Date.now()}-${randomUUID3()}`);
+  const quarantineDir = join24(paths.workspaceStateDir, "quarantine", `runtime.sqlite-${Date.now()}-${randomUUID4()}`);
   ensurePrivateDir2(quarantineDir);
   const quarantinedFiles = [];
   for (const suffix of SQLITE_SIDECAR_SUFFIXES2) {
     const source = `${paths.localStorePath}${suffix}`;
     if (!existsSync32(source))
       continue;
-    const target = join23(quarantineDir, `runtime.sqlite${suffix}`);
-    renameSync7(source, target);
+    const target = join24(quarantineDir, `runtime.sqlite${suffix}`);
+    renameSync8(source, target);
     quarantinedFiles.push(target);
   }
   const markerPath = legacyMigrationMarkerPath2(paths);
   if (existsSync32(markerPath)) {
-    const target = join23(quarantineDir, LEGACY_MIGRATION_MARKER_FILE2);
-    renameSync7(markerPath, target);
+    const target = join24(quarantineDir, LEGACY_MIGRATION_MARKER_FILE2);
+    renameSync8(markerPath, target);
     quarantinedFiles.push(target);
   }
   fsyncDirectory3(quarantineDir);
@@ -61686,16 +62106,16 @@ function quarantineExistingLocalStore2(paths) {
   return quarantinedFiles;
 }
 function legacyMigrationMarkerPath2(paths) {
-  return join23(paths.workspaceStateDir, LEGACY_MIGRATION_MARKER_FILE2);
+  return join24(paths.workspaceStateDir, LEGACY_MIGRATION_MARKER_FILE2);
 }
 function legacyMigrationLockPath2(paths) {
-  return join23(paths.workspaceStateDir, LEGACY_MIGRATION_LOCK_FILE2);
+  return join24(paths.workspaceStateDir, LEGACY_MIGRATION_LOCK_FILE2);
 }
 function writePrivateJson3(path, value) {
   ensurePrivateDir2(dirname13(path));
   const fd = openSync12(path, "w", 384);
   try {
-    writeFileSync12(fd, JSON.stringify(value, null, 2), "utf8");
+    writeFileSync13(fd, JSON.stringify(value, null, 2), "utf8");
     fsyncSync5(fd);
   } finally {
     closeSync12(fd);
@@ -61704,7 +62124,7 @@ function writePrivateJson3(path, value) {
   fsyncDirectory3(dirname13(path));
 }
 function ensurePrivateDir2(path) {
-  mkdirSync13(path, { recursive: true, mode: 448 });
+  mkdirSync14(path, { recursive: true, mode: 448 });
   if (process.platform !== "win32") {
     try {
       chmodSync8(path, 448);
@@ -61750,8 +62170,8 @@ function isIgnorableDirectoryFsyncError3(error) {
 
 // packages/local-runtime/git-adapter/src/index.ts
 import { execFileSync as execFileSync10, spawnSync as spawnSync7 } from "node:child_process";
-import { existsSync as existsSync33, lstatSync as lstatSync16, mkdirSync as mkdirSync14, mkdtempSync as mkdtempSync6, readdirSync as readdirSync15, readFileSync as readFileSync31, rmSync as rmSync16 } from "node:fs";
-import { dirname as dirname14, join as join24, resolve as resolve34 } from "node:path";
+import { existsSync as existsSync33, lstatSync as lstatSync16, mkdirSync as mkdirSync15, mkdtempSync as mkdtempSync6, readdirSync as readdirSync15, readFileSync as readFileSync32, rmSync as rmSync16 } from "node:fs";
+import { dirname as dirname14, join as join25, resolve as resolve34 } from "node:path";
 init_src();
 var GIT_CAT_FILE_MAX_BYTES2 = 512 * 1024 * 1024;
 function findRepositoryRoot2(start) {
@@ -61801,7 +62221,7 @@ function listGitVisibleFiles2(root, pathspec) {
   }
   return [...new Set(output.split("\x00").filter(Boolean))].filter((path) => {
     try {
-      return lstatSync16(join24(root, path)).isFile();
+      return lstatSync16(join25(root, path)).isFile();
     } catch {
       return false;
     }
@@ -61821,14 +62241,14 @@ function readHeadSha2(root) {
 
 // packages/local-runtime/runtime-state-paths/src/index.ts
 import { readdirSync as readdirSync16, realpathSync as realpathSync12 } from "node:fs";
-import { isAbsolute as isAbsolute10, join as join25, resolve as resolve35 } from "node:path";
+import { isAbsolute as isAbsolute10, join as join26, resolve as resolve35 } from "node:path";
 var REPOSITORIES_DIR2 = "repositories";
 var WORKTREES_DIR2 = "worktrees";
 function listWorkspaceStateDirs2(stateRoot) {
-  return listDirectoryNames2(join25(stateRoot, REPOSITORIES_DIR2)).flatMap((storageRepositoryId) => listDirectoryNames2(join25(stateRoot, REPOSITORIES_DIR2, storageRepositoryId, WORKTREES_DIR2)).map((storageWorkspaceId) => ({
+  return listDirectoryNames2(join26(stateRoot, REPOSITORIES_DIR2)).flatMap((storageRepositoryId) => listDirectoryNames2(join26(stateRoot, REPOSITORIES_DIR2, storageRepositoryId, WORKTREES_DIR2)).map((storageWorkspaceId) => ({
     storageRepositoryId,
     storageWorkspaceId,
-    workspaceStateDir: join25(stateRoot, REPOSITORIES_DIR2, storageRepositoryId, WORKTREES_DIR2, storageWorkspaceId)
+    workspaceStateDir: join26(stateRoot, REPOSITORIES_DIR2, storageRepositoryId, WORKTREES_DIR2, storageWorkspaceId)
   })));
 }
 function listDirectoryNames2(path) {
@@ -61844,9 +62264,9 @@ function listDirectoryNames2(path) {
 // packages/local-runtime/codegraph-adapter/src/index.ts
 init_src();
 import { execFileSync as execFileSync11, spawnSync as spawnSync8 } from "node:child_process";
-import { accessSync as accessSync2, closeSync as closeSync13, constants as fsConstants4, existsSync as existsSync34, lstatSync as lstatSync17, mkdirSync as mkdirSync15, mkdtempSync as mkdtempSync7, openSync as openSync13, readFileSync as readFileSync32, readdirSync as readdirSync17, readSync as readSync7, realpathSync as realpathSync13, rmSync as rmSync17, statSync as statSync11, writeFileSync as writeFileSync13 } from "node:fs";
+import { accessSync as accessSync2, closeSync as closeSync13, constants as fsConstants4, existsSync as existsSync34, lstatSync as lstatSync17, mkdirSync as mkdirSync16, mkdtempSync as mkdtempSync7, openSync as openSync13, readFileSync as readFileSync33, readdirSync as readdirSync17, readSync as readSync7, realpathSync as realpathSync13, rmSync as rmSync17, statSync as statSync11, writeFileSync as writeFileSync14 } from "node:fs";
 import { createRequire as createRequire6 } from "node:module";
-import { basename as basename7, delimiter as delimiter2, dirname as dirname15, isAbsolute as isAbsolute11, join as join26, posix as posix4, relative as relative11, resolve as resolve36 } from "node:path";
+import { basename as basename7, delimiter as delimiter2, dirname as dirname15, isAbsolute as isAbsolute11, join as join27, posix as posix4, relative as relative11, resolve as resolve36 } from "node:path";
 init_src();
 var REQUIRED_CODEGRAPH_PACKAGE2 = "@colbymchenry/codegraph";
 var REQUIRED_CODEGRAPH_VERSION2 = productVersionManifest().runtime.codeGraph.requiredVersion;
@@ -61883,13 +62303,13 @@ function codeGraphCliInvocation2(binary, cwd, pathValue = process.env.PATH ?? ""
 }
 function resolveExecutable2(binary, cwd, pathValue) {
   if (binary.includes("/") || binary.includes("\\")) {
-    const path = isAbsolute11(binary) ? binary : join26(cwd, binary);
+    const path = isAbsolute11(binary) ? binary : join27(cwd, binary);
     return existsSync34(path) ? realpathSync13.native(path) : undefined;
   }
   for (const dir of pathValue.split(delimiter2)) {
     if (!dir)
       continue;
-    const path = join26(dir, binary);
+    const path = join27(dir, binary);
     if (isExecutablePath2(path))
       return realpathSync13.native(path);
   }
@@ -61909,7 +62329,7 @@ function isExecutablePath2(path) {
 function resolvePackagedCodeGraphShim2() {
   try {
     const manifestPath = requireFromAdapter3.resolve(`${REQUIRED_CODEGRAPH_PACKAGE2}/package.json`);
-    const manifest = JSON.parse(readFileSync32(manifestPath, "utf8"));
+    const manifest = JSON.parse(readFileSync33(manifestPath, "utf8"));
     const relativeBin = manifest.bin?.codegraph;
     if (manifest.version !== REQUIRED_CODEGRAPH_VERSION2 || !relativeBin)
       return;
@@ -61940,7 +62360,32 @@ function readFilePrefix2(path, length) {
   }
 }
 var CODEGRAPH_IMPORT_NODE_OUTPUT_BYTES2 = 4 * 1024;
+class CodeGraphIndexBuildInProgressError2 extends Error {
+  constructor() {
+    super("CodeGraph index build is in progress");
+    this.name = "CodeGraphIndexBuildInProgressError";
+  }
+}
+function codeGraphIndexBuildInProgress2(workspaceRoot) {
+  let raw;
+  try {
+    raw = readFileSync33(join27(workspaceRoot, ".codegraph", "codegraph.lock"), "utf8").trim();
+  } catch {
+    return false;
+  }
+  const pid = Number.parseInt(raw, 10);
+  if (!Number.isSafeInteger(pid) || pid <= 0 || String(pid) !== raw)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
 function readProjectionCodeGraphStatus2(invocation, root, timeout, envOverrides) {
+  if (codeGraphIndexBuildInProgress2(root))
+    throw new CodeGraphIndexBuildInProgressError2;
   const output = runProjectionCodeGraph2(invocation, root, ["status", "-j", root], timeout, envOverrides);
   try {
     return JSON.parse(output);
@@ -62011,8 +62456,9 @@ var CODEGRAPH_SNAPSHOT_MAX_BYTES2 = 512 * 1024 * 1024;
 var CODEGRAPH_NO_DOWNLOAD_ENV2 = { CODEGRAPH_NO_DOWNLOAD: "1" };
 function inspectRepositoryCodeFacts2(root, options = {}) {
   const schemaVersion = "archcontext.repository-code-facts/v1";
-  let codeGraphVersion;
+  let codeGraphVersion = "";
   let status;
+  let indexBuildInProgress = false;
   const indexPresent = codeGraphIndexAvailable2(root);
   try {
     const invocation = options.binary ? codeGraphCliInvocation2(options.binary, root, "") : packagedCodeGraphCliInvocation2();
@@ -62020,18 +62466,37 @@ function inspectRepositoryCodeFacts2(root, options = {}) {
     if (indexPresent)
       status = readProjectionCodeGraphStatus2(invocation, root, options.timeouts?.statusMs ?? 1e4, CODEGRAPH_NO_DOWNLOAD_ENV2);
   } catch (error) {
-    return {
-      schemaVersion,
-      state: "unavailable",
-      requiredVersion: REQUIRED_CODEGRAPH_VERSION2,
-      reasonCode: "codegraph-unavailable",
-      message: (error instanceof Error ? error.message : String(error)).replace(/\s+/g, " ").trim().slice(0, 400)
-    };
+    if (!(error instanceof CodeGraphIndexBuildInProgressError2)) {
+      return {
+        schemaVersion,
+        state: "unavailable",
+        requiredVersion: REQUIRED_CODEGRAPH_VERSION2,
+        reasonCode: "codegraph-unavailable",
+        message: (error instanceof Error ? error.message : String(error)).replace(/\s+/g, " ").trim().slice(0, 400)
+      };
+    }
+    indexBuildInProgress = true;
   }
   const versionIssues = codeGraphVersion === REQUIRED_CODEGRAPH_VERSION2 ? [] : [{ code: "version-mismatch", message: CODE_FACTS_ISSUE_MESSAGES["version-mismatch"] }];
   if (!indexPresent) {
     return { schemaVersion, state: "index-missing", indexPresent: false, requiredVersion: REQUIRED_CODEGRAPH_VERSION2, codeGraphVersion, issues: versionIssues };
   }
+  if (indexBuildInProgress) {
+    return {
+      schemaVersion,
+      state: "not-ready",
+      indexPresent: true,
+      requiredVersion: REQUIRED_CODEGRAPH_VERSION2,
+      codeGraphVersion,
+      indexBuiltWithVersion: null,
+      extractionVersion: { builtWith: null, current: null },
+      indexState: null,
+      reindexRecommended: null,
+      pendingRefs: null,
+      pendingChanges: null,
+      issues: [...versionIssues, { code: "index-incomplete", message: CODE_FACTS_ISSUE_MESSAGES["index-incomplete"] }]
+    };
+  }
   if (typeof status !== "object" || status === null || Array.isArray(status)) {
     return {
       schemaVersion,
@@ -62065,7 +62530,7 @@ function inspectRepositoryCodeFacts2(root, options = {}) {
   };
 }
 function codeGraphIndexAvailable2(workspaceRoot) {
-  return existsSync34(join26(workspaceRoot, ".codegraph"));
+  return existsSync34(join27(workspaceRoot, ".codegraph"));
 }
 var NON_DECLARATION_KINDS2 = new Set(["file", "import", "export", "parameter"]);
 var RUNTIME_BUILTIN_CALL_NAMES2 = new Set([
@@ -63146,6 +63611,7 @@ var CLI_COMMAND_FLAGS = {
   repo: { value: ["--name", "--repository-id", "--root"], boolean: [] },
   resolve: { value: ["--path", "--paths-from"], boolean: [] },
   impact: { value: ["--base", "--head", "--depth", "--paths-from"], boolean: [] },
+  history: { value: ["--ref", "--format", "--offset", "--limit"], boolean: [] },
   review: { value: ["--head-sha", "--posture", "--task", "--task-session-id"], boolean: [] },
   state: { value: ["--expected-target-fingerprint", "--expected-worktree-digest"], boolean: ["--accept-external-projection", "--dry-run", "--from-git", "--write"] },
   status: { value: [], boolean: [] },
@@ -63413,6 +63879,8 @@ function runCapabilitiesCommand() {
 async function runCliUnchecked(command = "help", args = [], cwd, deps = {}) {
   if (command === "impact")
     return runRefImpactCommand(args, cwd);
+  if (command === "history")
+    return runArchitectureHistoryCommand(args, cwd);
   if (command === "export" && args[0] === "native")
     return runNativeContextCommand(args.slice(1), cwd);
   const preflight = preflightCliArguments(command, args);
@@ -63727,7 +64195,7 @@ 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", "impact", "tunnel", "flows", "deps", "constraints", "debt"],
+            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", "impact", "history", "tunnel", "flows", "deps", "constraints", "debt"],
             examples: CLI_HELP_EXAMPLES
           }
         };
@@ -65121,7 +65589,7 @@ function auditGithubIssuesEnabled(cwd) {
     return false;
   let raw;
   try {
-    raw = readFileSync33(manifestPath, "utf8");
+    raw = readFileSync34(manifestPath, "utf8");
   } catch {
     return false;
   }
@@ -65694,7 +66162,7 @@ async function digestReviewChallenge(challenge) {
   return reviewChallengeV2Digest(challenge);
 }
 function defaultGithubConnectionPath(cwd) {
-  return join27(dirname16(defaultDaemonConnectionPath(cwd)), "github-connection.json");
+  return join28(dirname16(defaultDaemonConnectionPath(cwd)), "github-connection.json");
 }
 function sanitizeGithubConnection(record, connectionPath) {
   return {
@@ -65718,7 +66186,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 ?? readFileSync33(resolve37(cwd, challengePath), "utf8");
+    const raw = inline ?? readFileSync34(resolve37(cwd, challengePath), "utf8");
     const parsed = JSON.parse(raw);
     const attestation = await Promise.resolve().then(() => (init_src6(), {}));
     const assertReviewChallengeV2 = assertReviewChallengeV22;
@@ -66032,7 +66500,7 @@ async function doctorReport(cwd, args = []) {
 function doctorManifest(root) {
   const path = ".archcontext/manifest.yaml";
   try {
-    return { warnings: manifestDecisionDiagnostics2([{ path, body: readFileSync33(resolve37(root, path), "utf8") }]) };
+    return { warnings: manifestDecisionDiagnostics2([{ path, body: readFileSync34(resolve37(root, path), "utf8") }]) };
   } catch {
     return { warnings: [] };
   }
@@ -66230,8 +66698,8 @@ function runtimePathsReport(cwd) {
     ...paths,
     legacyLocalStore: inspectLegacyLocalStoreMigration(cwd),
     runtimeRepositoryId: repositoryFingerprint2(paths.repositoryRoot),
-    repositoryTruthDir: join27(paths.repositoryRoot, ".archcontext"),
-    codeGraphIndexDir: join27(paths.repositoryRoot, ".codegraph"),
+    repositoryTruthDir: join28(paths.repositoryRoot, ".archcontext"),
+    codeGraphIndexDir: join28(paths.repositoryRoot, ".codegraph"),
     npmGlobalInstallState: "forbidden",
     overrides: {
       stateRootEnv: "ARCHCONTEXT_STATE_DIR",
@@ -66520,8 +66988,8 @@ async function startBackgroundDaemon(args, cwd) {
   const recovery = discovered.recovery;
   const connectionPath = defaultDaemonConnectionPath(cwd);
   const controlDir = dirname16(connectionPath);
-  const logPath = join27(controlDir, "archctxd.log");
-  mkdirSync16(controlDir, { recursive: true });
+  const logPath = join28(controlDir, "archctxd.log");
+  mkdirSync17(controlDir, { recursive: true });
   const logFd = openSync14(logPath, "a", 384);
   try {
     let childExit;
@@ -66845,7 +67313,7 @@ function sleep2(ms) {
 }
 function readFileTail(path, maxBytes = 4096) {
   try {
-    const content = readFileSync33(path, "utf8");
+    const content = readFileSync34(path, "utf8");
     return content.slice(Math.max(0, content.length - maxBytes)).replace(/\s+/g, " ").trim();
   } catch {
     return "<unavailable>";
@@ -66947,7 +67415,7 @@ function cliArgumentFailure(requestId, message) {
   };
 }
 function loadResolveModel(cwd) {
-  if (!existsSync35(join27(cwd, ".archcontext/manifest.yaml"))) {
+  if (!existsSync35(join28(cwd, ".archcontext/manifest.yaml"))) {
     throw new NativeContextError("native-context-model-missing", { path: ".archcontext/manifest.yaml" });
   }
   let model;
@@ -67003,7 +67471,7 @@ async function readResolvePathsFrom(args, cwd, deps) {
     return { problem: "resolve --paths-from requires a file path or - for stdin" };
   let content;
   try {
-    content = source === "-" ? await (deps.readStdin ? deps.readStdin() : readFileSync33(0, "utf8")) : readFileSync33(resolve37(cwd, source), "utf8");
+    content = source === "-" ? await (deps.readStdin ? deps.readStdin() : readFileSync34(0, "utf8")) : readFileSync34(resolve37(cwd, source), "utf8");
   } catch (error) {
     return { problem: `resolve --paths-from ${source} is not readable: ${error instanceof Error ? error.message : String(error)}` };
   }
@@ -67091,7 +67559,7 @@ function readRepositoryInputFile(cwd, flag, file) {
     const absolute = assertPathHasNoSymlinkSegments2(cwd, file);
     if (!statSync12(absolute).isFile())
       return { problem: `plan ${flag} ${file} is not a regular file` };
-    return { content: readFileSync33(absolute, "utf8") };
+    return { content: readFileSync34(absolute, "utf8") };
   } catch (error) {
     return { problem: `plan ${flag} ${file} is not readable: ${error instanceof Error ? error.message : String(error)}` };
   }
@@ -67112,7 +67580,7 @@ function runHashCommand(args, cwd) {
   if (!existsSync35(absolute) || !statSync12(absolute).isFile()) {
     return errorEnvelope("hash", "AC_SCHEMA_INVALID", `hash --path is not an existing file: ${path}`);
   }
-  return okEnvelope("hash", { path, hash: digestJson({ body: readFileSync33(absolute, "utf8") }) });
+  return okEnvelope("hash", { path, hash: digestJson({ body: readFileSync34(absolute, "utf8") }) });
 }
 async function readCliPlanOperations(args, cwd, deps) {
   if (args.includes("--operations-file")) {
@@ -67122,7 +67590,7 @@ async function readCliPlanOperations(args, cwd, deps) {
     const file = readFlag(args, "--operations-file");
     if (!file)
       return "plan --operations-file requires a path";
-    const read = file === "-" ? { content: await (deps.readStdin ? deps.readStdin() : readFileSync33(0, "utf8")) } : readRepositoryInputFile(cwd, "--operations-file", file);
+    const read = file === "-" ? { content: await (deps.readStdin ? deps.readStdin() : readFileSync34(0, "utf8")) } : readRepositoryInputFile(cwd, "--operations-file", file);
     if ("problem" in read)
       return read.problem;
     let parsed;
@@ -67184,7 +67652,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() : readFileSync33(0, "utf8");
+  return deps.readStdin ? deps.readStdin() : readFileSync34(0, "utf8");
 }
 function readFlag(args, flag) {
   const index = args.indexOf(flag);