archctx 0.8.0 → 0.9.0

package/bin/archctx.mjs

@@ -96,6 +96,7 @@ var init_schema = __esm(() => {
     AC_NODE_VERSION_UNSUPPORTED: { code: "AC_NODE_VERSION_UNSUPPORTED", severity: "error", retryable: false, action: "use-supported-node-version" },
     AC_CODEGRAPH_UNAVAILABLE: { code: "AC_CODEGRAPH_UNAVAILABLE", severity: "error", retryable: true, action: "run-diagnostics" },
     AC_CODE_FACTS_UNAVAILABLE: { code: "AC_CODE_FACTS_UNAVAILABLE", severity: "error", retryable: true, action: "codegraph-init" },
+    AC_CODE_FACTS_NOT_READY: { code: "AC_CODE_FACTS_NOT_READY", severity: "error", retryable: false, action: "codegraph-index" },
     AC_INDEX_STALE: { code: "AC_INDEX_STALE", severity: "warning", retryable: true, action: "sync-codefacts" },
     AC_CONTEXT_STALE: { code: "AC_CONTEXT_STALE", severity: "warning", retryable: true, action: "prepare-task-again" },
     AC_SCHEMA_INVALID: { code: "AC_SCHEMA_INVALID", severity: "error", retryable: false, action: "repair-model" },
@@ -1752,7 +1753,9 @@ var init_projection = __esm(() => {
     "projection-preview-v1",
     "projection-prior-committed-applies-v1",
     "projection-protocol-v2",
+    "projection-publish-v1",
     "projection-snapshot-v1",
+    "projection-verify-pr-v1",
     "recommendation-scan-decision-v1",
     "recommendation-v3",
     "refactor-assessment-v1",
@@ -2031,6 +2034,23 @@ function dataRecord(value) {
   return fields;
 }
 function localFactValue(rule, value) {
+  if (rule === "codeFactsIssues") {
+    if (!Array.isArray(value))
+      throw new Error("Code facts issues must be a list");
+    const length = Object.getOwnPropertyDescriptor(value, "length")?.value;
+    if (!Number.isSafeInteger(length) || length < 1 || length > 32 || Reflect.ownKeys(value).length !== length + 1)
+      throw new Error("Code facts issues exceed their closed budget");
+    return Array.from({ length }, (_, index) => {
+      const entry = Object.getOwnPropertyDescriptor(value, String(index));
+      if (!entry || !("value" in entry))
+        throw new Error("Code facts issues must use own data");
+      const fields = dataRecord(entry.value);
+      const code = fields.code?.value, message = fields.message?.value;
+      if (Object.keys(fields).length !== 2 || typeof code !== "string" || !Object.hasOwn(CODE_FACTS_ISSUE_MESSAGES, code) || message !== CODE_FACTS_ISSUE_MESSAGES[code])
+        throw new Error("Unknown code facts diagnostic");
+      return { code, message };
+    });
+  }
   if (rule === "commandSuggestion" && (value === null || typeof value === "string" && bytes(value) <= 1024 && /^archctx (recommendations |refactor verify )[^\r\n]*$/.test(value)))
     return value;
   if (rule === "publicConfirmationToken" && typeof value === "string" && bytes(value) <= 1024 && /^public:github\.com\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+:[a-f0-9]{40}:[A-Za-z0-9_.:-]+$/.test(value))
@@ -2130,7 +2150,7 @@ function nativeFactsFor(policy, input) {
     }
     const item = dataRecord(value);
     if (type === "issues") {
-      if (Object.keys(item).length !== 3 || !["entityId", "field", "invariant"].every((key) => Object.hasOwn(item, key)))
+      if (!["entityId", "field", "invariant"].every((key) => Object.hasOwn(item, key)) || Object.keys(item).some((key) => !["entityId", "field", "invariant", "path"].includes(key)))
         throw new Error("Native issue schema is invalid");
       const clean = Object.fromEntries(Object.entries(item).map(([key, data]) => [key, text(data.value)]));
       if (Object.values(clean).some((v) => bytes(v) > 256)) {
@@ -2202,6 +2222,8 @@ function nativeFactsFor(policy, input) {
     }
     result[key] = values;
   }
+  const sourceIssues = Array.isArray(result.issues) ? result.issues : [];
+  const summarizePath = sourceIssues.some((issue) => typeof issue.path === "string");
   const counts = () => {
     if (!Number.isSafeInteger(omitted) || !Number.isSafeInteger(characters))
       throw new Error("Native diagnostic counts exceed schema");
@@ -2211,6 +2233,13 @@ function nativeFactsFor(policy, input) {
       result.omittedDiagnosticCharacters = characters;
   };
   const fits = () => {
+    if (summarizePath) {
+      const path = sourceIssues[0]?.path;
+      if (typeof path === "string" && sourceIssues.every((issue) => issue.path === path))
+        result.path = path;
+      else
+        delete result.path;
+    }
     counts();
     const base = catalogDefaults[policy.code];
     const error = { code: policy.code, message: policy.message, severity: base.severity, retryable: policy.retryable ?? base.retryable, action: policy.action ?? base.action, reasonCode: Object.entries(policies).find(([, p]) => p === policy)?.[0], details: result };
@@ -2325,12 +2354,21 @@ function normalizeFailureResult(result, stage, requestId = "failure") {
     return toEnvelope(requestId, undefined, "failure-metadata");
   }
 }
-var FAILURE_STAGES, 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, 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 init_failure = __esm(() => {
   init_changeset_recovery();
   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"]);
+  CODE_FACTS_ISSUE_MESSAGES = Object.freeze({
+    "not-initialized": "CodeGraph repository status is not initialized",
+    "version-mismatch": "CodeGraph repository status version mismatch",
+    "project-path-mismatch": "CodeGraph repository project path mismatch",
+    "index-incomplete": "CodeGraph repository index is not complete and compatible",
+    "extraction-version-mismatch": "CodeGraph repository extraction version mismatch",
+    "worktree-mismatch": "CodeGraph repository worktree mismatch",
+    "pending-source-changes": "CodeGraph repository index has pending or unreported source changes"
+  });
   policies = {
     "git-worktree-required": { code: "AC_REPO_NOT_FOUND", message: "This operation requires a Git worktree.", fields: ["checks"] },
     "model-missing": { code: "AC_MODEL_ADOPTION_REQUIRED", message: "Architecture debt requires an adopted model.", fields: ["checks"] },
@@ -2340,6 +2378,7 @@ var init_failure = __esm(() => {
     "projection-manifest-invalid": { code: "AC_PRECONDITION_FAILED", message: "The committed projection manifest violates its contract." },
     "projection-footprint-uncovered": { code: "AC_PRECONDITION_FAILED", message: "Declared source footprints lack a projection target." },
     "index-missing": { code: "AC_CODE_FACTS_UNAVAILABLE", message: "Required code facts have no available index. Run codegraph init." },
+    "code-facts-not-ready": { code: "AC_CODE_FACTS_NOT_READY", message: "Repository code facts are not ready. Run archctx doctor --json and follow the reported action.", facts: { issues: "codeFactsIssues" } },
     "checkpoint-input-invalid": { code: "AC_SCHEMA_INVALID", message: "Checkpoint arguments violate the declared input schema.", fields: ["issueCount"], action: "correct-command-arguments" },
     "cli-input-invalid": { code: "AC_SCHEMA_INVALID", message: "Command arguments violate the declared input contract.", action: "correct-command-arguments" },
     "complete-input-invalid": { code: "AC_SCHEMA_INVALID", message: "Completion input violates the caller authority contract.", action: "correct-command-arguments" },
@@ -2348,7 +2387,7 @@ var init_failure = __esm(() => {
     "runtime-version-unsupported": { code: "AC_RUNTIME_VERSION_UNSUPPORTED", message: "The connected runtime version is unsupported." },
     "rpc-timeout": { code: "RPC_TIMEOUT", message: "The runtime RPC deadline elapsed without a response; a mutation outcome is unknown.", fields: ["method", "timeoutMs", "elapsedMs", "mutationOutcome"], action: "reconcile-before-retry" },
     "rpc-aborted": { code: "RPC_ABORTED", message: "The runtime RPC caller aborted without a response; a mutation outcome is unknown.", fields: ["method", "timeoutMs", "elapsedMs", "mutationOutcome"], action: "reconcile-before-retry" },
-    "failure-unclassified": { code: "AC_UNCLASSIFIED_FAILURE", message: "The operation failed without a classified cause. Inspect local diagnostics before retrying.", action: "inspect-diagnostics" }
+    "failure-unclassified": { code: "AC_UNCLASSIFIED_FAILURE", message: "The operation failed without a classified cause. Run archctx doctor --json before retrying.", action: "inspect-diagnostics" }
   };
   Object.assign(policies, {
     "developer-review-run-not-owned": { code: "AC_PRECONDITION_FAILED", message: "developer-review-run-not-owned", facts: { refusal: "reviewOwnershipRefusal" } },
@@ -2585,7 +2624,7 @@ var init_failure = __esm(() => {
   }
   FAILURE_POLICIES = Object.freeze(policies);
   catalogDefaults = Object.fromEntries(Object.entries(ERROR_CATALOG).map(([code, value]) => [code, Object.freeze({ severity: value.severity, retryable: value.retryable, action: value.action })]));
-  actions = new Set([...Object.values(catalogDefaults).map((value) => value.action), "correct-command-arguments", "inspect-diagnostics", "reconcile-before-retry", ...Object.values(policies).flatMap((policy) => policy.action ? [policy.action] : [])]);
+  actions = new Set([...Object.values(catalogDefaults).map((value) => value.action), "correct-command-arguments", "inspect-diagnostics", "reconcile-before-retry", "install-compatible-codegraph", ...Object.values(policies).flatMap((policy) => policy.action ? [policy.action] : [])]);
   localEnums = {
     reviewWorktreeRefusal: ["UNKNOWN", "HEAD_UNAVAILABLE", "HEAD_SHA_MISMATCH", "TREE_OID_MISMATCH", "WORKTREE_NOT_DETACHED", "WORKTREE_NOT_CLEAN"],
     reviewOwnershipRefusal: ["persisted-manifest-missing", "persisted-manifest-identity-mismatch", "run-id", "manifest-path", "lock-path", "persisted-manifest-mismatch", "persisted-lock-mismatch", "run-root-name", "worktree-temp-root", "codegraph-temporary-state-root", "run-root-not-a-directory", "run-root-owner-marker-missing", "run-root-owner-marker-mismatch", "worktree-temporary-root", "worktree-root", "worktree-source-root"],
@@ -2992,9 +3031,13 @@ function nativeAllowedNodeKinds(schemas) {
     throw new Error("canonical-node-kind-enum-unavailable");
   return [...kinds];
 }
-function nativeContextModelIssues(model, schemas) {
+function nativeContextModelIssues(model, schemas, recordPaths) {
   const issues = [];
-  const add = (entityId, field, invariant) => issues.push({ entityId, field, invariant });
+  const add = (record, field, invariant) => {
+    const entityId = typeof record === "string" ? record : typeof record.id === "string" ? record.id : "(undeclared)";
+    const path = typeof record === "string" ? undefined : recordPaths?.get(record);
+    issues.push({ entityId, field, invariant, ...path === undefined ? {} : { path } });
+  };
   const resolveSchema = nativeContextSchemaResolver(schemas);
   const ids = new Set;
   for (const [kind, records] of [["node", model.nodes], ["relation", model.relations], ["flow", model.flows]]) {
@@ -3013,14 +3056,14 @@ function nativeContextModelIssues(model, schemas) {
           continue;
         }
         if (typeof value === "number" && !Number.isFinite(value)) {
-          add(id, item.field, "non-json-number");
+          add(record, item.field, "non-json-number");
           jsonInvalid = true;
           break;
         }
         if (value === null || typeof value !== "object")
           continue;
         if (active.has(value)) {
-          add(id, item.field, "non-json-cycle");
+          add(record, item.field, "non-json-cycle");
           jsonInvalid = true;
           break;
         }
@@ -3028,7 +3071,7 @@ function nativeContextModelIssues(model, schemas) {
           continue;
         const prototype = Object.getPrototypeOf(value);
         if (Array.isArray(value) ? prototype !== Array.prototype : prototype !== Object.prototype) {
-          add(id, item.field, "non-json-prototype");
+          add(record, item.field, "non-json-prototype");
           jsonInvalid = true;
           break;
         }
@@ -3041,36 +3084,35 @@ function nativeContextModelIssues(model, schemas) {
         continue;
       const schema = kind === "node" ? schemas.node : kind === "relation" ? schemas.relation : schemas.flow;
       for (const issue of validateJsonSchema(schema, record, { resolveSchema }).issues)
-        add(id, issue.path, issue.message);
+        add(record, issue.path, issue.message);
       if (ids.has(id))
-        add(id, "id", "duplicate-entity-id");
+        add(record, "id", "duplicate-entity-id");
       ids.add(id);
     }
   }
   if (issues.length > 0)
     return issues;
   for (const kind of ["nodes", "relations", "flows"]) {
-    const expected = new Set(model[kind].map((entity) => entity.id));
-    for (const id of expected)
+    const expected = new Map(model[kind].map((entity) => [entity.id, entity]));
+    for (const [id, entity] of expected)
       if (!Object.hasOwn(model.sourcePaths[kind], id))
-        add(id, `sourcePaths.${kind}`, "source-path-index-incomplete");
+        add(entity, `sourcePaths.${kind}`, "source-path-index-incomplete");
     for (const [id, path] of Object.entries(model.sourcePaths[kind])) {
       if (!expected.has(id))
         add(id, `sourcePaths.${kind}`, "source-path-index-unknown-entity");
       if (!isNativeContextPath(path))
-        add(id, `sourcePaths.${kind}`, "path-unsafe");
+        add(expected.get(id) ?? id, `sourcePaths.${kind}`, "path-unsafe");
     }
   }
   const nodes = new Map(model.nodes.map((node) => [node.id, node]));
   const checked = new Set;
   for (const node of model.nodes) {
-    const id = node.id;
     const chain = new Set;
     let cursor = node;
     while (cursor) {
       const current = cursor.id;
       if (chain.has(current)) {
-        add(id, "parent", "parent-cycle");
+        add(node, "parent", "parent-cycle");
         break;
       }
       if (checked.has(current))
@@ -3080,7 +3122,7 @@ function nativeContextModelIssues(model, schemas) {
         break;
       const parent = nodes.get(cursor.parent);
       if (!parent) {
-        add(current, "parent", "parent-node-missing");
+        add(cursor, "parent", "parent-node-missing");
         break;
       }
       cursor = parent;
@@ -3093,17 +3135,17 @@ function nativeContextModelIssues(model, schemas) {
     const source = node.source;
     for (const path of [...source?.include ?? [], ...source?.exclude ?? []])
       if (!isNativeContextPath(path))
-        add(node.id, "source", "path-unsafe");
+        add(node, "source", "path-unsafe");
     for (const entry of source?.entrypoints ?? []) {
       if (!isNativeContextPath(entry.path))
-        add(node.id, "source.entrypoints.path", "path-unsafe");
+        add(node, "source.entrypoints.path", "path-unsafe");
       for (const symbol of entry.symbols) {
         for (const sink of symbol.sinks) {
           if (!isNativeContextPath(sink.path))
-            add(node.id, "source.entrypoints.symbols.sinks.path", "path-unsafe");
+            add(node, "source.entrypoints.symbols.sinks.path", "path-unsafe");
           const selector = JSON.stringify([entry.id, symbol.name, sink.id]);
           if (selectors.has(selector))
-            add(node.id, "source.entrypoints.symbols.sinks.id", "selector-ambiguous");
+            add(node, "source.entrypoints.symbols.sinks.id", "selector-ambiguous");
           selectors.add(selector);
         }
       }
@@ -3112,43 +3154,42 @@ function nativeContextModelIssues(model, schemas) {
   for (const relation of model.relations) {
     for (const field of ["source", "target", "via"])
       if (relation[field] !== undefined && !nodes.has(relation[field]))
-        add(relation.id, field, "relation-node-missing");
+        add(relation, field, "relation-node-missing");
   }
   for (const flow of model.flows) {
-    const id = flow.id;
     if (nodes.get(flow.capabilityId)?.kind !== "capability")
-      add(id, "capabilityId", "flow-capability-missing");
+      add(flow, "capabilityId", "flow-capability-missing");
     if (flow.applicability !== "required")
       continue;
     const participants = flow.participants;
     const participantIds = new Set;
     for (const participant of participants) {
       if (participantIds.has(participant.id))
-        add(id, "participants.id", "participant-id-ambiguous");
+        add(flow, "participants.id", "participant-id-ambiguous");
       participantIds.add(participant.id);
       if (!nodes.has(participant.nodeId))
-        add(id, "participants.nodeId", "participant-node-missing");
+        add(flow, "participants.nodeId", "participant-node-missing");
     }
     const definitions = new Map;
     const outcomes = flow.outcomes;
     const outcomeIds = new Set;
     for (const outcome of outcomes) {
       if (outcomeIds.has(outcome.id))
-        add(id, "outcomes.id", "outcome-id-ambiguous");
+        add(flow, "outcomes.id", "outcome-id-ambiguous");
       outcomeIds.add(outcome.id);
       if (!participantIds.has(outcome.terminal.participant))
-        add(id, "outcomes.terminal", "terminal-participant-missing");
+        add(flow, "outcomes.terminal", "terminal-participant-missing");
     }
     for (const step of [...flow.steps, ...outcomes.flatMap((outcome) => outcome.steps)]) {
       if (!participantIds.has(step.from) || !participantIds.has(step.to))
-        add(id, "steps", "step-participant-missing");
+        add(flow, "steps", "step-participant-missing");
       const definition = canonicalize(step);
       if (definitions.has(step.id) && definitions.get(step.id) !== definition)
-        add(id, "steps.id", "step-definition-ambiguous");
+        add(flow, "steps.id", "step-definition-ambiguous");
       definitions.set(step.id, definition);
       const selector = step.evidence;
       if (!selectors.has(JSON.stringify([selector.entrypointId, selector.sourceSymbol, selector.sinkId])))
-        add(id, "steps.evidence", "selector-missing");
+        add(flow, "steps.evidence", "selector-missing");
     }
   }
   return issues;
@@ -3324,6 +3365,10 @@ var init_ports = __esm(() => {
 // packages/contracts/src/practices.ts
 var PRACTICE_SCHEMA_VERSION = "archcontext.practice/v1", PRACTICE_PROFILE_SCHEMA_VERSION = "archcontext.practice-profile/v1", PRACTICE_SOURCE_SCHEMA_VERSION = "archcontext.practice-source/v1", PRACTICE_CATALOG_MANIFEST_SCHEMA_VERSION = "archcontext.practice-catalog-manifest/v1", PRACTICE_ENFORCEMENT_POLICY_SCHEMA_VERSION = "archcontext.practice-enforcement-policy/v1", PRACTICE_WAIVER_SCHEMA_VERSION = "archcontext.practice-waiver/v1";
 
+// packages/contracts/src/projection-writer.ts
+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 architectureDocsProjectionManifestIssues(value) {
   const issues = [];
@@ -3828,7 +3873,7 @@ function compareVersionTriples(left, right) {
   }
   return 0;
 }
-var ARCHCONTEXT_PRODUCT_NAME = "archctx", ARCHCONTEXT_PRODUCT_VERSION = "0.8.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";
+var ARCHCONTEXT_PRODUCT_NAME = "archctx", ARCHCONTEXT_PRODUCT_VERSION = "0.9.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") {
@@ -4930,6 +4975,7 @@ var init_src = __esm(() => {
   init_ports();
   init_projection();
   init_projection_recovery();
+  init_projection_writer();
   init_projection_manifest();
   init_refactor();
   init_schema();
@@ -15338,7 +15384,7 @@ var init_src6 = __esm(() => {
 
 // packages/local-runtime/egress-admission/src/index.ts
 var LOCAL_EGRESS_MODE_ENV = "ARCHCONTEXT_EGRESS_MODE";
-var LOCAL_EGRESS_CHANNELS = ["context7", "agent-audit", "github-issue-publishing", "npm-update-check", "codegraph-telemetry"];
+var LOCAL_EGRESS_CHANNELS = ["context7", "agent-audit", "github-issue-publishing", "npm-update-check", "projection-publishing", "codegraph-telemetry"];
 
 class LocalEgressPolicyError extends Error {
 }
@@ -15748,10 +15794,10 @@ function sourceIncludeAnchors(patterns) {
 init_src();
 
 // packages/core/architecture-domain/src/index.ts
-init_src();
 import { createHash as createHash2 } from "node:crypto";
 import { readFileSync, realpathSync, statSync } from "node:fs";
 import { resolve } from "node:path";
+init_src();
 var LANDSCAPE_FILE = ".archcontext/landscape.yaml";
 var ADAPTER_PROTECTED_NATIVE_FIELDS = ["evidence", "verification", "constraint", "intervention"];
 var DEFAULT_IGNORES = new Set([
@@ -15980,7 +16026,7 @@ function parseJsonOrStableYaml(body, path) {
   if (!trimmed)
     throw new Error(`${path}: empty model file`);
   if (trimmed.startsWith("{") || trimmed.startsWith("["))
-    return checkedJsonDecode(trimmed, path, "json-document");
+    return checkedJsonOrFlowYaml(trimmed, path, "json-document");
   return new StableYamlParser(body, path).parse();
 }
 var ADR_FILE_PATH = /^docs\/adr\/ADR-\d{4}-.+\.md$/;
@@ -16361,7 +16407,7 @@ function parseScalar(value, path) {
   if (/^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?$/.test(value))
     return Number(value);
   if (/^["[{]/.test(value))
-    return checkedJsonDecode(value, path, "json-scalar");
+    return checkedJsonOrFlowYaml(value, path, "json-scalar");
   return value;
 }
 
@@ -16379,6 +16425,54 @@ class DuplicateModelKeyError extends Error {
     this.name = "DuplicateModelKeyError";
   }
 }
+function checkedJsonOrFlowYaml(source, path, branch) {
+  try {
+    return checkedJsonDecode(source, path, branch);
+  } catch (error) {
+    if (!(error instanceof SyntaxError) || !(source.startsWith("{") || source.startsWith("[")))
+      throw error;
+  }
+  return checkedFlowYamlDecode(source, path);
+}
+function checkedFlowYamlDecode(source, path) {
+  const document = $parseDocument(source, { version: "1.2", schema: "core", uniqueKeys: false, prettyErrors: false });
+  const invalid = (reason) => {
+    throw new SyntaxError(`${path}: invalid YAML flow collection (${reason})`);
+  };
+  if (document.errors.length || document.warnings.length)
+    invalid("parse error or warning");
+  if (!$isMap(document.contents) && !$isSeq(document.contents) || !document.contents.flow)
+    invalid("expected flow collection");
+  const decode = (node) => {
+    if (node === null)
+      return null;
+    if (!$isScalar(node) && !$isMap(node) && !$isSeq(node))
+      return invalid("unsupported node or alias");
+    if (node.anchor || node.tag)
+      return invalid("anchor or explicit tag");
+    if ($isScalar(node)) {
+      const value = node.value;
+      if (value === null || typeof value === "string" || typeof value === "boolean")
+        return value;
+      if (typeof value === "number" && Number.isFinite(value))
+        return value;
+      return invalid("non-JSON scalar");
+    }
+    if ($isSeq(node))
+      return node.items.map(decode);
+    const keys = new Set;
+    return Object.fromEntries(node.items.map((pair) => {
+      if (!$isScalar(pair.key))
+        return invalid("non-scalar key");
+      const key = String(decode(pair.key));
+      if (keys.has(key))
+        throw new DuplicateModelKeyError(path, "yaml-flow", key, pair.key.range[0]);
+      keys.add(key);
+      return [key, decode(pair.value)];
+    }));
+  };
+  return decode(document.contents);
+}
 function checkedJsonDecode(source, path, branch) {
   let offset = 0;
   const whitespace = () => {
@@ -16968,6 +17062,12 @@ function renderAdrReferenceUpdate(body, references) {
   return rendered;
 }
 // packages/core/changeset-engine/src/index.ts
+function changeSetBaseModelBlockingErrors(result, draft) {
+  const repairedPaths = new Set(draft.operations.filter((operation) => operation.op === "update_entity_fields" || operation.op === "delete_entity").map((operation) => operation.path));
+  const repairedErrors = new Set((result.nodeSchemaErrors ?? []).filter((issue) => repairedPaths.has(issue.path)).map((issue) => issue.error));
+  return baseModelBlockingErrors(result).filter((error) => !repairedErrors.has(error));
+}
+
 class ChangeSetEngine {
   deps;
   states = new Map;
@@ -17190,10 +17290,16 @@ class ChangeSetEngine {
   }
   async validateModel(root, draft, deps, phase) {
     const result = await deps.modelStore.validateModel({ root, repositoryId: draft.reason.taskSessionId, headSha: draft.base.headSha });
-    const blocked = phase === "before" ? baseModelBlockingErrors(result).length > 0 : !result.valid;
+    const errors = phase === "before" ? changeSetBaseModelBlockingErrors(result, draft) : result.errors;
+    const blocked = phase === "before" ? errors.length > 0 : !result.valid;
     if (blocked) {
-      const errors = phase === "before" ? baseModelBlockingErrors(result) : result.errors;
-      throw new Error(`ChangeSet model validation failed ${phase} apply: ${errors.join("; ") || "unknown validation error"}`);
+      const path = errors[0]?.match(/^(\.archcontext\/.+?): /)?.[1];
+      const error = new FailureError("AC_SCHEMA_INVALID", "native-context-model-invalid", {
+        invariant: `model-validation-${phase}-apply`,
+        ...path ? { path } : {}
+      });
+      error.message = `ChangeSet model validation failed ${phase} apply: ${errors.join("; ") || "unknown validation error"}`;
+      throw error;
     }
   }
   requireDeps() {
@@ -20916,6 +21022,16 @@ ${wrapped}`;
   }
   return `${existing.slice(0, region.start)}${wrapped}${existing.slice(region.end)}`;
 }
+function agentContextTextOutsideRegions(body, nodeIds) {
+  let text = body;
+  for (const nodeId of [...new Set(nodeIds)].sort()) {
+    const region = findAgentContextRegion(text, nodeId);
+    if (!region)
+      throw new Error(`agent-context-marker-missing: ${nodeId}`);
+    text = `${text.slice(0, region.start)}\x00archcontext-agent-context-region:${nodeId}\x00${text.slice(region.end)}`;
+  }
+  return text;
+}
 function findAgentContextRegion(body, nodeId) {
   const startPattern = new RegExp(`<!-- BEGIN ARCHCONTEXT AGENT CONTEXT id="${escapeRegExp(nodeId)}"[^>]*-->`);
   const startMatch = startPattern.exec(body);
@@ -22897,12 +23013,9 @@ function isGitWorktreeError(error) {
   return error instanceof Error && /git|Command failed/.test(error.message);
 }
 
-// packages/local-runtime/runtime-daemon/src/producer-failure.ts
-init_src();
-
 // packages/local-runtime/egress-admission/src/index.ts
 var LOCAL_EGRESS_MODE_ENV2 = "ARCHCONTEXT_EGRESS_MODE";
-var LOCAL_EGRESS_CHANNELS2 = ["context7", "agent-audit", "github-issue-publishing", "npm-update-check", "codegraph-telemetry"];
+var LOCAL_EGRESS_CHANNELS2 = ["context7", "agent-audit", "github-issue-publishing", "npm-update-check", "projection-publishing", "codegraph-telemetry"];
 
 class LocalEgressPolicyError2 extends Error {
 }
@@ -22931,6 +23044,7 @@ function withLocalEgress2(channel, operation, env = process.env) {
 }
 
 // packages/local-runtime/codegraph-adapter/src/index.ts
+init_src();
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { createHash as createHash5 } from "node:crypto";
 import { accessSync, closeSync as closeSync3, constants as fsConstants2, existsSync as existsSync6, openSync as openSync3, readFileSync as readFileSync7, readSync, realpathSync as realpathSync3, statSync as statSync3 } from "node:fs";
@@ -23932,10 +24046,15 @@ class CodeGraphCliProvider {
   }
   async indexAll(workspaceRoot) {
     this.workspaceRoot = workspaceRoot;
-    if (!existsSync6(join3(workspaceRoot, ".codegraph"))) {
-      throw new Error(`CodeGraph index missing at ${workspaceRoot}; run codegraph init before using archctxd`);
-    }
+    this.assertCanSync(workspaceRoot);
     this.run(["sync", workspaceRoot]);
+    this.assertReady(workspaceRoot);
+  }
+  assertReady(workspaceRoot) {
+    assertRepositoryCodeFactsReady(workspaceRoot, this.binary === DEFAULT_CODEGRAPH_BINARY ? {} : { binary: this.binary });
+  }
+  assertCanSync(workspaceRoot) {
+    this.assertReady(workspaceRoot);
   }
   async buildContext(task, options) {
     const query = scopedTaskQuery(task, options.changedPaths ?? []);
@@ -23998,7 +24117,7 @@ class CodeGraphCliProvider {
   }
   run(args) {
     disableCodeGraphTelemetryByDefault();
-    const invocation = codeGraphCliInvocation(this.binary, this.workspaceRoot);
+    const invocation = this.binary === DEFAULT_CODEGRAPH_BINARY ? packagedCodeGraphCliInvocation() : codeGraphCliInvocation(this.binary, this.workspaceRoot);
     try {
       return execFileSync2(invocation.command, [...invocation.argsPrefix, ...args], {
         cwd: this.workspaceRoot,
@@ -24129,8 +24248,14 @@ class CodeGraphAdapter {
     this.provider = provider;
     disableCodeGraphTelemetryByDefault();
   }
+  assertCanSync(workspaceRoot) {
+    this.assertCompatible();
+    this.provider.assertCanSync?.(workspaceRoot);
+  }
   async ensureReady(workspace) {
     this.assertCompatible();
+    if (this.#snapshot)
+      this.provider.assertReady?.(workspace.root);
     this.#snapshot ??= await this.sync({ workspace });
     return this.#snapshot;
   }
@@ -24594,7 +24719,7 @@ function readProjectionHeadSha(root) {
 function projectionCodeGraphStatusIssues(status, root, phase) {
   const issue = (code, text) => ({
     code,
-    message: `CodeGraph ${phase} ${text}`
+    message: phase === "repository" ? CODE_FACTS_ISSUE_MESSAGES[code] : `CodeGraph ${phase} ${text}`
   });
   if (!status.initialized)
     return [issue("not-initialized", "status is not initialized")];
@@ -24703,7 +24828,7 @@ function inspectRepositoryCodeFacts(root, options = {}) {
       message: (error instanceof Error ? error.message : String(error)).replace(/\s+/g, " ").trim().slice(0, 400)
     };
   }
-  const versionIssues = codeGraphVersion === REQUIRED_CODEGRAPH_VERSION ? [] : [{ code: "version-mismatch", message: `CodeGraph ${REQUIRED_CODEGRAPH_VERSION} required, got actual binary ${codeGraphVersion || "unknown"}` }];
+  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 };
   }
@@ -24733,12 +24858,25 @@ function inspectRepositoryCodeFacts(root, options = {}) {
       current: status.index?.currentExtractionVersion ?? null
     },
     indexState: status.index?.state ?? null,
-    reindexRecommended: status.index?.reindexRecommended ?? null,
+    reindexRecommended: issues.some((issue) => issue.code !== "pending-source-changes"),
     pendingRefs: status.index?.pendingRefs ?? null,
     pendingChanges: pending ? { added: pending.added, modified: pending.modified, removed: pending.removed } : null,
     issues
   };
 }
+function assertRepositoryCodeFactsReady(root, options = {}) {
+  const facts = inspectRepositoryCodeFacts(root, options);
+  if (facts.state === "index-missing")
+    throw new ProjectionCodeFactsUnavailableError("index-missing");
+  if (facts.state === "unavailable")
+    throw new FailureError("AC_CODE_FACTS_UNAVAILABLE", "code-facts-unavailable", {}, { action: "inspect-diagnostics", retryable: false });
+  if (facts.state === "not-ready") {
+    if (facts.issues.every((issue) => issue.code === "pending-source-changes"))
+      return;
+    const action = facts.codeGraphVersion !== REQUIRED_CODEGRAPH_VERSION ? "install-compatible-codegraph" : "codegraph-index";
+    throw new FailureError("AC_CODE_FACTS_NOT_READY", "code-facts-not-ready", { issues: facts.issues }, { action });
+  }
+}
 function codeGraphIndexAvailable(workspaceRoot) {
   return existsSync6(join3(workspaceRoot, ".codegraph"));
 }
@@ -25061,6 +25199,7 @@ function parseExploreSymbols(output, maxSymbols) {
 }
 
 // packages/local-runtime/runtime-daemon/src/producer-failure.ts
+init_src();
 function selectedProducerData(error, key) {
   const descriptor = Object.getOwnPropertyDescriptor(error, key);
   if (!descriptor || !("value" in descriptor))
@@ -26151,12 +26290,6 @@ function isPresent2(value) {
 init_src();
 import { existsSync as existsSync7, lstatSync as lstatSync5, mkdirSync as mkdirSync4, readdirSync as readdirSync4, readFileSync as readFileSync8, rmSync as rmSync4 } from "node:fs";
 import { dirname as dirname5, resolve as resolve11 } from "node:path";
-
-// 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 lstatSync4, openSync as openSync4, readSync as readSync2, realpathSync as realpathSync4 } from "node:fs";
-import { join as join4, resolve as resolve10 } from "node:path";
 // schemas/repo/architecture-node.schema.json
 var architecture_node_schema_default = {
   $schema: "https://json-schema.org/draft/2020-12/schema",
@@ -26245,6 +26378,12 @@ 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 lstatSync4, openSync as openSync4, readSync as readSync2, realpathSync as realpathSync4 } from "node:fs";
+import { join as join4, resolve as resolve10 } from "node:path";
 // schemas/repo/architecture-relation.schema.json
 var architecture_relation_schema_default = {
   $schema: "https://json-schema.org/draft/2020-12/schema",
@@ -26751,6 +26890,7 @@ function capture(source, snapshot) {
   if (typeof budget !== "number" || !Number.isSafeInteger(budget) || budget <= 0)
     throw new NativeContextError("native-context-budget-invalid", { path: MANIFEST, field: "runtime.contextBudgetBytes" });
   const model = { nodes: [], relations: [], flows: [], sourcePaths: { nodes: {}, relations: {}, flows: {} } };
+  const recordPaths = new Map;
   for (const spec of specs)
     if (spec.role !== "manifest") {
       const value = record5(parseInput(source, spec.path));
@@ -26758,10 +26898,11 @@ function capture(source, snapshot) {
         throw new NativeContextError("native-context-model-invalid", { path: spec.path, invariant: "entity-object-required" });
       const kind = spec.role === "node" ? "nodes" : spec.role === "relation" ? "relations" : "flows";
       model[kind].push(value);
+      recordPaths.set(value, spec.path);
       if (typeof value.id === "string")
         model.sourcePaths[kind][value.id] = spec.path;
     }
-  const issues = nativeContextModelIssues(model, SCHEMAS);
+  const issues = nativeContextModelIssues(model, SCHEMAS, recordPaths);
   if (issues.length > 0)
     throw new NativeContextError(issues.some((issue) => issue.invariant === "path-unsafe") ? "native-context-path-unsafe" : "native-context-model-invalid", { issues: issues.slice(0, 32), omittedDiagnosticCount: Math.max(0, issues.length - 32) });
   for (const kind of MODEL_KINDS)
@@ -27100,6 +27241,7 @@ class YamlModelStore {
   }
   async validateModel(workspace) {
     const errors = [];
+    const nodeSchemaErrors = [];
     for (const required of [".archcontext/manifest.yaml", ".archcontext/product.yaml"]) {
       try {
         readFileSync8(resolve11(workspace.root, required), "utf8");
@@ -27109,11 +27251,25 @@ class YamlModelStore {
     }
     const files = listModelFiles(workspace.root);
     for (const file of files) {
+      if (file.path.startsWith(".archcontext/model/") && /\.ya?ml$/.test(file.path)) {
+        try {
+          const value = parseJsonOrStableYaml(file.body, file.path);
+          if (file.path.startsWith(".archcontext/model/nodes/")) {
+            const { issues } = validateJsonSchema(architecture_node_schema_default, value);
+            for (const issue of issues) {
+              const error = `${file.path}: ${issue.path}: ${issue.message}`;
+              errors.push(error);
+              nodeSchemaErrors.push({ path: file.path, error });
+            }
+            continue;
+          }
+        } catch (error) {
+          errors.push(`${file.path}: invalid model YAML: ${error instanceof Error ? error.message : String(error)}`);
+          continue;
+        }
+      }
       if (!file.schemaVersion.startsWith("archcontext."))
         errors.push(`${file.path}: missing schemaVersion`);
-      if (file.path.startsWith(".archcontext/model/nodes/") && file.schemaVersion !== "archcontext.node/v2") {
-        errors.push(`${file.path}: expected archcontext.node/v2, got ${file.schemaVersion || "missing"}`);
-      }
       if (file.path.startsWith(".archcontext/model/flows/") && file.schemaVersion !== "archcontext.flow/v1") {
         errors.push(`${file.path}: expected archcontext.flow/v1, got ${file.schemaVersion || "missing"}`);
       }
@@ -27129,6 +27285,7 @@ class YamlModelStore {
       valid: errors.length === 0,
       errors,
       ...referenceErrors.length > 0 ? { referenceErrors } : {},
+      ...nodeSchemaErrors.length > 0 ? { nodeSchemaErrors } : {},
       ...warnings.length > 0 ? { warnings } : {},
       modelDigest
     };
@@ -33740,6 +33897,19 @@ async function runAgentContextProjectionCommand(input, cwd, daemon) {
     throw publicOperationFailure(error);
   }
 }
+function agentContextProjectionDifferingPaths(root, paths) {
+  const wanted = new Set(paths);
+  if (wanted.size === 0)
+    return [];
+  const projection = buildAgentContextProjection(root);
+  const onDisk = new Map(projection.existingFiles.map((file) => [file.path, file.onDisk]));
+  const written = projectionFilesBoundToRenderInput(projection.existingFiles, projection.plan.files);
+  const rendered = new Set(written.map((file) => file.path));
+  return [...new Set([
+    ...written.filter((file) => wanted.has(file.path) && onDisk.get(file.path) !== file.body).map((file) => file.path),
+    ...[...wanted].filter((path) => !rendered.has(path))
+  ])].sort();
+}
 function buildAgentContextProjection(root) {
   const model = loadNativeModelFromArchContext(root);
   const sourceDigest = digestJson({ model });
@@ -34042,7 +34212,7 @@ function readArchitectureDebtEvidence(root, input) {
     capabilityByNodeId
   } };
 }
-function runArchitectureDebtCommand(cwd, input = {}) {
+function runArchitectureDebtCommand(cwd, input = {}, codeFactsOptions = {}) {
   let root;
   try {
     root = findRepositoryRoot(cwd);
@@ -34050,6 +34220,8 @@ function runArchitectureDebtCommand(cwd, input = {}) {
     return failureEnvelope("debt", knownFailure("AC_REPO_NOT_FOUND", "git-worktree-required", { checks: ["ownership", "anchors"] }));
   }
   try {
+    if (codeGraphIndexAvailable(root))
+      assertRepositoryCodeFactsReady(root, codeFactsOptions);
     return okEnvelope("debt", readArchitectureDebt(root, input));
   } catch (error) {
     return selectedProducerFailureEnvelope("debt", error, "debt");
@@ -34424,6 +34596,8 @@ function effectiveEgressChannels(env, live) {
   }
   if (live.updateCheckRequested)
     channels.push({ channel: "npm-update-check", destination: "configured npm registry", trigger: "explicit update --check or doctor --check-updates", data: "archctx package version lookup", status: "enabled" });
+  if (live.projectionPublishRequested)
+    channels.push({ channel: "projection-publishing", destination: "configured git remote, plus GitHub via gh or the operator's publisher command", trigger: "explicit archctx projection publish", data: "one commit of generated projection outputs and a pull request title/body listing their paths", status: "enabled" });
   if (env[CODEGRAPH_TELEMETRY_ENV] !== undefined && env[CODEGRAPH_TELEMETRY_ENV] !== CODEGRAPH_TELEMETRY_DISABLED_VALUE)
     channels.push({ channel: "codegraph-telemetry", destination: "CodeGraph configured telemetry endpoint", trigger: "CodeGraph execution with telemetry enabled", data: "third-party telemetry", status: "enabled" });
   return channels.map((channel) => localEgressAdmission2(channel.channel, env).allowed ? channel : { ...channel, status: "blocked-by-policy" });
@@ -34458,9 +34632,9 @@ function localEgressStatus(env = process.env, live = {}) {
 }
 
 // packages/surfaces/cli/src/main.ts
-import { spawn as spawn2, spawnSync as spawnSync5 } from "child_process";
-import { accessSync as accessSync3, closeSync as closeSync12, constants as constants3, existsSync as existsSync34, mkdirSync as mkdirSync13, openSync as openSync12, readFileSync as readFileSync31, rmSync as rmSync15, statSync as statSync11 } from "fs";
-import { dirname as dirname16, join as join26, parse, resolve as resolve34 } from "path";
+import { spawn as spawn2, spawnSync as spawnSync6 } from "child_process";
+import { accessSync as accessSync3, closeSync as closeSync13, constants as constants3, existsSync as existsSync35, mkdirSync as mkdirSync14, openSync as openSync13, readFileSync as readFileSync32, rmSync as rmSync16, statSync as statSync11 } from "fs";
+import { dirname as dirname16, join as join27, parse, resolve as resolve35 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // packages/contracts/src/index.ts
@@ -34475,6 +34649,7 @@ init_ownership_dependencies();
 init_ports();
 init_projection();
 init_projection_recovery();
+init_projection_writer();
 init_projection_manifest();
 init_refactor();
 init_schema();
@@ -34596,10 +34771,10 @@ function assertAllowedArchContextPath2(root, relativePath, scope) {
 }
 
 // packages/core/architecture-domain/src/index.ts
-init_src();
 import { createHash as createHash9 } from "node:crypto";
 import { readFileSync as readFileSync14, realpathSync as realpathSync7, statSync as statSync4 } from "node:fs";
 import { resolve as resolve18 } from "node:path";
+init_src();
 var DEFAULT_IGNORES2 = new Set([
   ".git",
   ".codegraph",
@@ -34818,7 +34993,10 @@ var WINDOWS_CREATE_TIMEOUT_MS = 60000;
 var WINDOWS_READ_TIMEOUT_MS = 1e4;
 var REMOVE_HANDLE_RELEASE_MARGIN_MS = 2000;
 var REMOVE_RETRY_DELAY_MS = 25;
+var WINDOWS_CONTROL_FILE_PHASES = ["script", "input", "parsed", "opened", "verified", "done"];
+var WINDOWS_CONTROL_FILE_PHASE_MARKER = /^archctx-acl-phase:([a-z]+)\r?$/;
 var WINDOWS_CONTROL_FILE_SCRIPT = String.raw`
+[Console]::Error.WriteLine('archctx-acl-phase:script')
 $ErrorActionPreference = 'Stop'
 # A pwsh -> Node/Bun -> powershell.exe launch inherits incompatible PS7 module paths.
 $env:PSModulePath = "$PSHOME\Modules"
@@ -34840,7 +35018,10 @@ function Test-PrivateAcl($stream, $sid) {
     $rule.PropagationFlags -eq [System.Security.AccessControl.PropagationFlags]::None)
 }
 try {
-  $request = [Console]::In.ReadToEnd() | ConvertFrom-Json
+  $text = [Console]::In.ReadToEnd()
+  [Console]::Error.WriteLine('archctx-acl-phase:input')
+  $request = $text | ConvertFrom-Json
+  [Console]::Error.WriteLine('archctx-acl-phase:parsed')
   $sid = [System.Security.Principal.WindowsIdentity]::GetCurrent().User
   if ($request.operation -eq 'create') {
     $acl = New-Object System.Security.AccessControl.FileSecurity
@@ -34850,18 +35031,24 @@ try {
     $acl.AddAccessRule($rule)
     $stream = New-Object System.IO.FileStream($request.path, [System.IO.FileMode]::CreateNew, [System.Security.AccessControl.FileSystemRights]::FullControl, [System.IO.FileShare]::None, 4096, [System.IO.FileOptions]::None, $acl)
     $created = $true
+    [Console]::Error.WriteLine('archctx-acl-phase:opened')
     if (-not (Test-PrivateAcl $stream $sid)) { throw 'private ACL readback failed' }
+    [Console]::Error.WriteLine('archctx-acl-phase:verified')
     $bytes = [System.Text.Encoding]::UTF8.GetBytes([string]$request.body)
     $stream.Write($bytes, 0, $bytes.Length)
     $stream.Flush($true)
+    [Console]::Error.WriteLine('archctx-acl-phase:done')
     $result = @{ ok = $true }
   } elseif ($request.operation -eq 'read') {
     # Deny concurrent write/delete, validate the opened file, then read that same handle.
     $stream = New-Object System.IO.FileStream($request.path, [System.IO.FileMode]::Open, [System.IO.FileAccess]::Read, [System.IO.FileShare]::Read)
+    [Console]::Error.WriteLine('archctx-acl-phase:opened')
     if (-not (Test-PrivateAcl $stream $sid)) { throw 'private ACL readback failed' }
+    [Console]::Error.WriteLine('archctx-acl-phase:verified')
     if ($stream.Length -gt 1048576) { throw 'control file exceeds read budget' }
     $reader = New-Object System.IO.StreamReader($stream, [System.Text.Encoding]::UTF8, $true, 4096, $true)
     try { $body = $reader.ReadToEnd() } finally { $reader.Dispose() }
+    [Console]::Error.WriteLine('archctx-acl-phase:done')
     $result = @{ ok = $true; body = $body }
   } else { throw 'unsupported operation' }
   [Console]::Out.Write(($result | ConvertTo-Json -Compress))
@@ -34903,8 +35090,9 @@ function windowsControlFile(operation, path, body) {
     const code = ["ETIMEDOUT", "ENOENT", "EACCES", "EPERM", "ENOBUFS"].includes(String(failure?.code)) ? String(failure?.code) : "UNKNOWN";
     const signal = ["SIGTERM", "SIGKILL", "SIGABRT", "SIGINT"].includes(String(failure?.signal)) ? String(failure?.signal) : null;
     const status = typeof failure?.status === "number" && Number.isInteger(failure.status) ? failure.status : null;
+    const phase = lastWindowsControlFilePhase(failure?.stderr);
     const elapsedMs = Math.round(performance.now() - startedAt);
-    throw new Error(`Windows native ACL operation failed: ${JSON.stringify({ operation, code, status, signal, elapsedMs })}`);
+    throw new Error(`Windows native ACL operation failed: ${JSON.stringify({ operation, code, status, signal, phase, elapsedMs })}`);
   }
   const result = JSON.parse(output);
   if (!result || typeof result !== "object" || !("ok" in result))
@@ -34919,6 +35107,18 @@ function windowsControlFile(operation, path, body) {
     return result.body;
   }
 }
+function lastWindowsControlFilePhase(stderr) {
+  let phase = "none";
+  if (typeof stderr !== "string")
+    return phase;
+  for (const line of stderr.split(`
+`)) {
+    const name = WINDOWS_CONTROL_FILE_PHASE_MARKER.exec(line)?.[1];
+    if (name && WINDOWS_CONTROL_FILE_PHASES.includes(name))
+      phase = name;
+  }
+  return phase;
+}
 function createPrivateControlFile(path, body) {
   if (process.platform === "win32") {
     windowsControlFile("create", path, body);
@@ -37988,7 +38188,7 @@ function readArchitectureDebtEvidence2(root, input) {
     capabilityByNodeId
   } };
 }
-function runArchitectureDebtCommand2(cwd, input = {}) {
+function runArchitectureDebtCommand2(cwd, input = {}, codeFactsOptions = {}) {
   let root;
   try {
     root = findRepositoryRoot(cwd);
@@ -37996,6 +38196,8 @@ function runArchitectureDebtCommand2(cwd, input = {}) {
     return failureEnvelope("debt", knownFailure("AC_REPO_NOT_FOUND", "git-worktree-required", { checks: ["ownership", "anchors"] }));
   }
   try {
+    if (codeGraphIndexAvailable(root))
+      assertRepositoryCodeFactsReady(root, codeFactsOptions);
     return okEnvelope("debt", readArchitectureDebt2(root, input));
   } catch (error) {
     return selectedProducerFailureEnvelope("debt", error, "debt");
@@ -42988,7 +43190,13 @@ class PracticeCheckpointService {
   }
   async prepareUnchecked(root, task, maxBytes = 12288, maxItems = 12, taskSessionId = "task_runtime") {
     this.assertRunning();
+    if (this.codeFacts.assertCanSync) {
+      root = findRepositoryRoot(root);
+      this.codeFacts.assertCanSync(root);
+    }
     const session = await this.openSession(root);
+    if (this.codeFacts.assertCanSync)
+      await this.codeFacts.ensureReady(session.workspace);
     const result = await prepareTask({
       workspace: session.workspace,
       task,
@@ -54151,6 +54359,947 @@ function runtimeProjectionOwnedOutputDigest(projection) {
     files: projection.files.map((file) => ({ path: file.path, body: file.body })).sort((left, right) => left.path.localeCompare(right.path))
   });
 }
+// packages/local-runtime/runtime-daemon/src/projection-writer.ts
+import { execFile as execFile2, spawnSync as spawnSync5 } from "node:child_process";
+import { createHash as createHash13, randomUUID as randomUUID3 } from "node:crypto";
+import { closeSync as closeSync9, existsSync as existsSync29, mkdirSync as mkdirSync12, mkdtempSync as mkdtempSync5, openSync as openSync10, readFileSync as readFileSync27, readSync as readSync5, realpathSync as realpathSync12, renameSync as renameSync7, rmSync as rmSync15, writeFileSync as writeFileSync11 } from "node:fs";
+import { tmpdir as tmpdir4 } from "node:os";
+import { extname as extname2, join as join23, resolve as resolve30 } from "node:path";
+init_src();
+var PROJECTION_PUBLISH_REQUEST_ID = "projection.publish";
+var PROJECTION_PUBLISH_STATUS_REQUEST_ID = "projection.publish-status";
+var PROJECTION_VERIFY_PR_REQUEST_ID = "projection.verify-pr";
+var PROJECTION_WRITER_DEFAULT_BASE = "main";
+var PROJECTION_WRITER_DEFAULT_REMOTE = "origin";
+var PROJECTION_PR_BODY_MARKER = "<!-- archctx-projection-writer -->";
+var PROJECTION_WRITER_STATE_SCHEMA_VERSION = "archcontext.projection-writer-state/v1";
+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;
+
+class ProjectionWriterFailure extends Error {
+  code;
+  reasonCode;
+  constructor(code, reasonCode, message) {
+    super(message);
+    this.code = code;
+    this.reasonCode = reasonCode;
+    this.name = "ProjectionWriterFailure";
+  }
+}
+function projectionWriterPaths(repositoryRoot, remote, base, env = process.env) {
+  const key = createHash13("sha256").update(`${remote}\x00${base}`, "utf8").digest("hex").slice(0, 16);
+  const dir = join23(runtimeStatePaths(repositoryRoot, env).repositoryStateDir, "projection-writer", key);
+  return { dir, worktree: join23(dir, "worktree"), state: join23(dir, "state.json"), lock: join23(dir, "lock") };
+}
+async function runProjectionPublishCommand(options) {
+  const env = options.env ?? process.env;
+  const now = options.now ?? (() => new Date);
+  const remote = options.remote ?? PROJECTION_WRITER_DEFAULT_REMOTE;
+  const base = options.base ?? PROJECTION_WRITER_DEFAULT_BASE;
+  const branch = options.branch ?? PROJECTION_WRITER_DEFAULT_BRANCH;
+  let repositoryRoot;
+  try {
+    repositoryRoot = findRepositoryRoot(options.cwd);
+  } catch {
+    return errorEnvelope(PROJECTION_PUBLISH_REQUEST_ID, "AC_REPO_NOT_FOUND", `projection publish requires a Git worktree at ${options.cwd}`, "git-worktree-required");
+  }
+  const invalid = projectionWriterTargetIssue(repositoryRoot, { remote, base, branch });
+  if (invalid)
+    return errorEnvelope(PROJECTION_PUBLISH_REQUEST_ID, "AC_SCHEMA_INVALID", invalid, "projection-writer-input-invalid");
+  try {
+    assertLocalEgressAllowed2("projection-publishing", env);
+  } catch (error) {
+    return errorEnvelope(PROJECTION_PUBLISH_REQUEST_ID, "AC_POLICY_VIOLATION", errorMessage2(error), "egress-policy-denied");
+  }
+  const startedAt = now().toISOString();
+  const paths = projectionWriterPaths(repositoryRoot, remote, base, env);
+  const blank = () => ({
+    schemaVersion: PROJECTION_PUBLISH_RUN_SCHEMA_VERSION,
+    result: "failed",
+    remote,
+    base,
+    branch,
+    baseSha: null,
+    publishedCommit: null,
+    pushed: false,
+    pullRequest: null,
+    publisher: options.publisher.kind,
+    files: [],
+    projectionStatus: null,
+    humanActions: [],
+    error: null,
+    startedAt,
+    finishedAt: startedAt,
+    iterations: 0
+  });
+  let lock;
+  try {
+    mkdirSync12(paths.dir, { recursive: true, mode: 448 });
+    lock = acquireProjectionWriterLock(paths.lock, startedAt);
+  } catch (error) {
+    const failure = asWriterFailure(error);
+    return projectionPublishEnvelope({ ...blank(), finishedAt: now().toISOString(), error: writerError(failure) });
+  }
+  if (lock.kind === "busy") {
+    return projectionPublishEnvelope({ ...blank(), result: "busy", holderPid: lock.pid, finishedAt: now().toISOString() });
+  }
+  try {
+    let state;
+    try {
+      state = readProjectionWriterState(paths.state, remote, base);
+    } catch (error) {
+      return projectionPublishEnvelope({ ...blank(), finishedAt: now().toISOString(), error: writerError(asWriterFailure(error)) });
+    }
+    const outcome = await runLockedProjectionPublish({ options, env, now, repositoryRoot, paths, remote, base, branch, state, assertOwner: () => assertProjectionWriterOwner(paths.lock, lock.record), blank: blank() });
+    const next = nextProjectionWriterState(state, outcome);
+    try {
+      writeProjectionWriterState(paths.state, next);
+    } catch (error) {
+      return projectionPublishEnvelope({
+        ...outcome.run,
+        result: "failed",
+        error: writerError(new ProjectionWriterFailure("AC_PRECONDITION_FAILED", "projection-writer-state-unwritable", errorMessage2(error)))
+      });
+    }
+    return projectionPublishEnvelope(outcome.run);
+  } finally {
+    lock.release();
+  }
+}
+async function runLockedProjectionPublish(input) {
+  const { options, env, now, repositoryRoot, paths, remote, base, branch, state } = input;
+  const runSequence = state.runSequence + 1;
+  const publisherIdentity = options.publisher.identity ?? options.publisher.kind;
+  let iterations = 0;
+  let baseSha = null;
+  const finish = (result, fields = {}, extra = {}) => ({
+    run: { ...input.blank, ...fields, result, baseSha, iterations, finishedAt: now().toISOString() },
+    runSequence,
+    publisherIdentity,
+    ...extra
+  });
+  const failed = (failure, fields = {}, extra = {}) => finish("failed", { ...fields, error: writerError(failure) }, extra);
+  try {
+    const pushRemote = projectionWriterPushUrl(repositoryRoot, remote);
+    while (iterations < PROJECTION_WRITER_MAX_ITERATIONS) {
+      iterations += 1;
+      remoteGit(repositoryRoot, ["fetch", "--no-tags", remote, `+refs/heads/${base}:refs/remotes/${remote}/${base}`], env);
+      baseSha = git(repositoryRoot, ["rev-parse", "--verify", `refs/remotes/${remote}/${base}^{commit}`]).trim();
+      const successMatches = state.lastSuccessfulBranch === branch && state.lastSuccessfulSha === baseSha;
+      const pending = state.publisherPending?.branch === branch && state.publisherPending.baseSha === baseSha ? state.publisherPending : successMatches && state.lastSuccessfulCommit && state.lastSuccessfulPublisher !== publisherIdentity ? { branch, baseSha, commitSha: state.lastSuccessfulCommit, files: state.lastSuccessfulFiles } : null;
+      if (!pending && successMatches && state.lastSuccessfulPublisher === publisherIdentity && (state.lastSuccessfulCommit === null || lsRemoteBranch(repositoryRoot, pushRemote, branch, env) === state.lastSuccessfulCommit)) {
+        return finish("already-processed", { publishedCommit: state.lastSuccessfulCommit });
+      }
+      input.assertOwner();
+      prepareProjectionWriterWorktree(repositoryRoot, paths.worktree, baseSha);
+      if (pending && lsRemoteBranch(repositoryRoot, pushRemote, branch, env) === pending.commitSha) {
+        input.assertOwner();
+        const published = await publishPullRequest(options.publisher, { worktree: paths.worktree, remote, base, branch, baseSha, commitSha: pending.commitSha, files: pending.files });
+        if (!published.ok) {
+          return failed(published.failure, { publishedCommit: pending.commitSha, files: pending.files }, { publisherPending: pending });
+        }
+        return finish("published", { publishedCommit: pending.commitSha, files: pending.files, pullRequest: published.pullRequest });
+      }
+      const ownedPatterns = projectionOwnedPaths(loadNativeModelFromArchContext(paths.worktree));
+      const snapshot = runProjectionSnapshotCommand(paths.worktree);
+      if (!snapshot.ok)
+        throw envelopeFailure(snapshot, "projection-writer-snapshot-failed");
+      const expected = snapshot.data.expected;
+      const request = {
+        schemaVersion: PROJECTION_REQUEST_SCHEMA_VERSION,
+        requestId: `projection_publish.${baseSha.slice(0, 12)}.${runSequence}-${iterations}`,
+        profile: "repo-harness/v1",
+        mode: "apply",
+        targets: [...PROJECTION_WRITER_TARGETS],
+        changedPaths: [],
+        expected,
+        ...options.acceptObservedMajorChange ? { acceptObservedMajorChange: true } : {}
+      };
+      const applied = await options.apply(paths.worktree, request);
+      input.assertOwner();
+      if (!applied.ok) {
+        const failure = envelopeFailure(applied, "projection-apply-failed");
+        if (failure.code === "AC_CODE_FACTS_UNAVAILABLE") {
+          throw new ProjectionWriterFailure(failure.code, failure.reasonCode, `${failure.message}; the writer never initializes CodeGraph itself: run \`codegraph init ${paths.worktree}\` once, then publish again`);
+        }
+        throw failure;
+      }
+      const result = applied.data;
+      const projectionStatus = result.status;
+      if (projectionStatus === "human-action-required" || projectionStatus === "adoption-required") {
+        return finish("human-action-required", { projectionStatus, humanActions: publishHumanActions(result) });
+      }
+      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 changed = worktreeChangedPaths(paths.worktree);
+      if (changed.length === 0)
+        return finish("up-to-date", { projectionStatus });
+      const written = new Set(result.files.filter((file) => file.action !== "unchanged").map((file) => file.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 });
+      }
+      input.assertOwner();
+      git(paths.worktree, ["add", "-A", "--", ...changed]);
+      const title = projectionPublishTitle(base, baseSha);
+      try {
+        git(paths.worktree, ["commit", "--no-verify", "-q", "-m", title, "-m", `Archctx-Projection-Source: ${baseSha}`]);
+      } catch (error) {
+        return failed(new ProjectionWriterFailure("AC_PRECONDITION_FAILED", "projection-writer-commit-failed", `git commit failed in the writer worktree; configure a git identity (user.name, user.email) for the repository or set GIT_AUTHOR_*/GIT_COMMITTER_*: ${errorMessage2(error)}`), { projectionStatus, files: changed });
+      }
+      const commitSha = git(paths.worktree, ["rev-parse", "HEAD"]).trim();
+      const tip = lsRemoteBranch(repositoryRoot, remote, base, env);
+      if (tip === null) {
+        return failed(new ProjectionWriterFailure("AC_PRECONDITION_FAILED", "projection-writer-base-missing", `${remote} has no branch ${base}`), { projectionStatus, files: changed });
+      }
+      if (tip !== baseSha)
+        continue;
+      const lease = lsRemoteBranch(repositoryRoot, pushRemote, branch, env);
+      let publishedCommit = commitSha;
+      let pushed = false;
+      if (lease !== null && carriesSameProjection(paths.worktree, lease, commitSha, baseSha)) {
+        publishedCommit = lease;
+      } else {
+        input.assertOwner();
+        remoteGit(paths.worktree, ["push", "--no-verify", `--force-with-lease=refs/heads/${branch}:${lease ?? ""}`, "--", pushRemote, `${commitSha}:refs/heads/${branch}`], env);
+        pushed = true;
+      }
+      input.assertOwner();
+      const published = await publishPullRequest(options.publisher, { worktree: paths.worktree, remote, base, branch, baseSha, commitSha: publishedCommit, files: changed });
+      if (!published.ok) {
+        const pendingPublish = { baseSha, branch, commitSha: publishedCommit, files: changed };
+        return failed(published.failure, { projectionStatus, files: changed, publishedCommit, pushed }, { publisherPending: pendingPublish });
+      }
+      return finish("published", { projectionStatus, files: changed, publishedCommit, pushed, pullRequest: published.pullRequest });
+    }
+    return failed(new ProjectionWriterFailure("AC_PRECONDITION_FAILED", "projection-writer-base-unstable", `${remote}/${base} moved during each of ${PROJECTION_WRITER_MAX_ITERATIONS} attempts; nothing was pushed`));
+  } catch (error) {
+    return failed(asWriterFailure(error));
+  }
+}
+function nextProjectionWriterState(state, outcome) {
+  const run = outcome.run;
+  const next = { ...state, branch: run.branch, runSequence: outcome.runSequence, lastRun: run };
+  if (run.result === "already-processed")
+    return next;
+  if (run.baseSha !== null)
+    next.lastProcessedSha = run.baseSha;
+  if (run.result === "published" || run.result === "up-to-date") {
+    next.lastSuccessfulSha = run.baseSha;
+    next.lastSuccessfulBranch = run.branch;
+    next.lastSuccessfulPublisher = outcome.publisherIdentity;
+    next.lastSuccessfulFiles = run.files;
+    next.lastSuccessfulCommit = run.result === "published" ? run.publishedCommit : null;
+    next.publisherPending = null;
+  } else if (outcome.publisherPending) {
+    next.publisherPending = outcome.publisherPending;
+  } else if (run.result === "human-action-required") {
+    next.publisherPending = null;
+  }
+  return next;
+}
+function projectionPublishEnvelope(run) {
+  if (run.result !== "failed")
+    return okEnvelope(PROJECTION_PUBLISH_REQUEST_ID, run);
+  const error = run.error ?? { code: "AC_UNCLASSIFIED_FAILURE", message: "projection publish failed" };
+  return {
+    ...errorEnvelope(PROJECTION_PUBLISH_REQUEST_ID, error.code, error.message, error.reasonCode),
+    data: run
+  };
+}
+function publishHumanActions(result) {
+  return result.humanActions.map((action) => ({ reasonCode: action.reasonCode, ...action.path ? { path: action.path } : {} }));
+}
+function projectionPublishTitle(base, baseSha) {
+  return `chore(projection): refresh generated architecture outputs for ${base}@${baseSha.slice(0, 12)}`;
+}
+function projectionPublishBody(input) {
+  const listed = input.files.slice(0, PR_BODY_MAX_LISTED_PATHS).map((path) => `- \`${path}\``);
+  if (input.files.length > PR_BODY_MAX_LISTED_PATHS)
+    listed.push(`- … and ${input.files.length - PR_BODY_MAX_LISTED_PATHS} more`);
+  return [
+    PROJECTION_PR_BODY_MARKER,
+    "",
+    `Base: \`${input.base}\` at \`${input.baseSha}\``,
+    `Commit: \`${input.commitSha}\``,
+    "",
+    "Changed generated paths:",
+    "",
+    ...listed,
+    "",
+    `Generated by \`archctx projection publish\`; touches generated paths only. Verify with \`archctx projection verify-pr --base ${input.base}\`.`,
+    ""
+  ].join(`
+`);
+}
+async function publishPullRequest(publisher, input) {
+  if (publisher.kind === "none")
+    return { ok: true, pullRequest: null };
+  const dir = mkdtempSync5(join23(tmpdir4(), "archctx-projection-pr-body-"));
+  try {
+    const bodyFile = join23(dir, "body.md");
+    writeFileSync11(bodyFile, projectionPublishBody(input), { mode: 384 });
+    const pullRequest = await publisher.ensurePullRequest({
+      worktree: input.worktree,
+      remote: input.remote,
+      base: input.base,
+      branch: input.branch,
+      baseSha: input.baseSha,
+      commitSha: input.commitSha,
+      title: projectionPublishTitle(input.base, input.baseSha),
+      bodyFile
+    });
+    return { ok: true, pullRequest: { ...pullRequest.url ? { url: pullRequest.url } : {}, ...pullRequest.number !== undefined ? { number: pullRequest.number } : {} } };
+  } catch (error) {
+    if (error instanceof LocalEgressPolicyError2)
+      return { ok: false, failure: new ProjectionWriterFailure("AC_POLICY_VIOLATION", "egress-policy-denied", error.message) };
+    return { ok: false, failure: new ProjectionWriterFailure("AC_PRECONDITION_FAILED", "projection-publisher-failed", `${publisher.kind} publisher failed: ${errorMessage2(error)}`) };
+  } finally {
+    rmSync15(dir, { recursive: true, force: true });
+  }
+}
+function runProjectionPublishStatusCommand(options) {
+  const env = options.env ?? process.env;
+  const remote = options.remote ?? PROJECTION_WRITER_DEFAULT_REMOTE;
+  const base = options.base ?? PROJECTION_WRITER_DEFAULT_BASE;
+  let repositoryRoot;
+  try {
+    repositoryRoot = findRepositoryRoot(options.cwd);
+  } catch {
+    return errorEnvelope(PROJECTION_PUBLISH_STATUS_REQUEST_ID, "AC_REPO_NOT_FOUND", `projection publish-status requires a Git worktree at ${options.cwd}`, "git-worktree-required");
+  }
+  const invalid = refNameIssue(repositoryRoot, "--base", base) ?? remoteNameIssue(remote);
+  if (invalid)
+    return errorEnvelope(PROJECTION_PUBLISH_STATUS_REQUEST_ID, "AC_SCHEMA_INVALID", invalid, "projection-writer-input-invalid");
+  try {
+    const paths = projectionWriterPaths(repositoryRoot, remote, base, env);
+    const state = readProjectionWriterState(paths.state, remote, base);
+    const holder = readProjectionWriterLock(paths.lock);
+    const status = {
+      schemaVersion: PROJECTION_PUBLISH_STATUS_SCHEMA_VERSION,
+      remote,
+      base,
+      branch: state.branch,
+      worktreePath: paths.worktree,
+      running: holder && isProcessAlive(holder.pid) ? holder : null,
+      lastProcessedSha: state.lastProcessedSha,
+      lastSuccessfulSha: state.lastSuccessfulSha,
+      lastRun: state.lastRun
+    };
+    return okEnvelope(PROJECTION_PUBLISH_STATUS_REQUEST_ID, status);
+  } catch (error) {
+    if (error instanceof ProjectionWriterFailure)
+      return errorEnvelope(PROJECTION_PUBLISH_STATUS_REQUEST_ID, error.code, error.message, error.reasonCode);
+    return publicOperationErrorEnvelope(PROJECTION_PUBLISH_STATUS_REQUEST_ID, error);
+  }
+}
+async function runProjectionPublishFollow(options) {
+  let runs = 0;
+  while (!options.shouldStop()) {
+    let envelope;
+    try {
+      envelope = await options.runOnce();
+    } catch (error) {
+      envelope = publicOperationErrorEnvelope(PROJECTION_PUBLISH_REQUEST_ID, error);
+    }
+    runs += 1;
+    options.onResult(envelope);
+    if (options.shouldStop())
+      break;
+    await options.sleep(options.intervalMs);
+  }
+  return runs;
+}
+function runProjectionVerifyPrCommand(options) {
+  const requestId = PROJECTION_VERIFY_PR_REQUEST_ID;
+  let root;
+  try {
+    root = findRepositoryRoot(options.cwd);
+  } catch {
+    return errorEnvelope(requestId, "AC_REPO_NOT_FOUND", `projection verify-pr requires a Git worktree at ${options.cwd}`, "git-worktree-required");
+  }
+  if (!isGitRevisionArgument(options.base))
+    return errorEnvelope(requestId, "AC_SCHEMA_INVALID", `projection verify-pr --base is not a usable revision: ${JSON.stringify(options.base)}`, "projection-verify-pr-input-invalid");
+  try {
+    if (!isTrackedWorktreeClean(root)) {
+      return errorEnvelope(requestId, "AC_PRECONDITION_FAILED", "projection verify-pr requires a clean tracked worktree; HEAD is the pull request head", "projection-verify-pr-worktree-dirty");
+    }
+    let baseSha;
+    let mergeBase;
+    const headSha = git(root, ["rev-parse", "--verify", "HEAD^{commit}"]).trim();
+    try {
+      baseSha = git(root, ["rev-parse", "--verify", `${options.base}^{commit}`]).trim();
+      mergeBase = git(root, ["merge-base", baseSha, headSha]).trim();
+    } catch (error) {
+      return errorEnvelope(requestId, "AC_PRECONDITION_FAILED", `projection verify-pr cannot resolve ${options.base} against HEAD: ${errorMessage2(error)}`, "projection-verify-pr-base-unresolved");
+    }
+    const changedPaths = [...new Set(git(root, ["diff", "--name-only", "-z", "--no-renames", `${mergeBase}..${headSha}`, "--"]).split("\x00").filter(Boolean))].sort();
+    const verification = (fields) => okEnvelope(requestId, {
+      schemaVersion: PROJECTION_PR_VERIFICATION_SCHEMA_VERSION,
+      base: options.base,
+      baseSha,
+      headSha,
+      mergeBase,
+      changedPaths,
+      nonGeneratedPaths: [],
+      humanEditedPaths: [],
+      generatedOnly: false,
+      renderEquivalent: null,
+      differingPaths: [],
+      projectionStatus: null,
+      ...fields
+    });
+    if (changedPaths.length === 0)
+      return verification({ verdict: "no-changes" });
+    const classified = classifyPullRequestPaths(root, mergeBase, headSha, changedPaths);
+    if (classified.nonGeneratedPaths.length > 0) {
+      return verification({ verdict: "touches-non-generated", nonGeneratedPaths: classified.nonGeneratedPaths, humanEditedPaths: classified.humanEditedPaths });
+    }
+    const snapshot = runProjectionSnapshotCommand(root);
+    if (!snapshot.ok)
+      return { ...snapshot, requestId };
+    const request = {
+      schemaVersion: PROJECTION_REQUEST_SCHEMA_VERSION,
+      requestId: `projection_verify_pr.${headSha.slice(0, 12)}`,
+      profile: "repo-harness/v1",
+      mode: "check",
+      targets: [...PROJECTION_WRITER_TARGETS],
+      changedPaths: [],
+      expected: snapshot.data.expected
+    };
+    const checked = (options.check ?? runProjectionCheckInvocation)(request, root);
+    if (!checked.ok)
+      return { ...checked, requestId };
+    const result = checked.data;
+    let agentContextDiffering;
+    try {
+      agentContextDiffering = agentContextProjectionDifferingPaths(root, classified.agentContextPaths);
+    } catch {
+      agentContextDiffering = [...classified.agentContextPaths];
+    }
+    const differingPaths = [...new Set([
+      ...result.files.filter((file) => file.action !== "unchanged").map((file) => file.path),
+      ...agentContextDiffering
+    ])].sort();
+    const renderEquivalent = result.status === "noop" && agentContextDiffering.length === 0;
+    return verification({
+      verdict: renderEquivalent ? "generated-only-render-equivalent" : "generated-only-not-render-equivalent",
+      generatedOnly: true,
+      renderEquivalent,
+      differingPaths,
+      projectionStatus: result.status
+    });
+  } catch (error) {
+    return publicOperationErrorEnvelope(requestId, error);
+  }
+}
+function classifyPullRequestPaths(root, mergeBase, headSha, changedPaths) {
+  const baseTargets = projectionTargetsAtRevision(root, mergeBase);
+  const headTargets = projectionTargetsAtRevision(root, headSha);
+  const nonGenerated = [];
+  const humanEdited = [];
+  const agentContext = [];
+  for (const path of changedPaths) {
+    if (path === ARCHITECTURE_DOCS_PROJECTION_MANIFEST_PATH)
+      continue;
+    const atBase = baseTargets.get(path);
+    const atHead = headTargets.get(path);
+    if (!atBase && !atHead) {
+      nonGenerated.push(path);
+      continue;
+    }
+    const before = readFileAtRevision(root, mergeBase, path);
+    const after = readFileAtRevision(root, headSha, path);
+    if (!atHead && after !== null) {
+      nonGenerated.push(path);
+      continue;
+    }
+    const target = {
+      whole: (atBase?.whole ?? false) || (atHead?.whole ?? false),
+      mixedDocument: (atBase?.mixedDocument ?? false) || (atHead?.mixedDocument ?? false),
+      agentNodeIds: [...new Set([...atBase?.agentNodeIds ?? [], ...atHead?.agentNodeIds ?? []])].sort()
+    };
+    if (!target.mixedDocument && target.agentNodeIds.length === 0)
+      continue;
+    if (!mixedTargetTextUnchanged(before, after, target)) {
+      humanEdited.push(path);
+      nonGenerated.push(path);
+    } else if (target.agentNodeIds.length > 0) {
+      agentContext.push(path);
+    }
+  }
+  return { nonGeneratedPaths: nonGenerated.sort(), humanEditedPaths: humanEdited.sort(), agentContextPaths: agentContext.sort() };
+}
+function projectionTargetsAtRevision(root, revision) {
+  const targets = new Map;
+  const add = (path, ownership) => {
+    const known = targets.get(path) ?? { whole: false, mixedDocument: false, agentNodeIds: [] };
+    targets.set(path, {
+      whole: known.whole || ownership.whole === true,
+      mixedDocument: known.mixedDocument || ownership.mixedDocument === true,
+      agentNodeIds: [...known.agentNodeIds, ...ownership.agentNodeIds ?? []]
+    });
+  };
+  try {
+    const manifest = readFileAtRevision(root, revision, ARCHITECTURE_DOCS_PROJECTION_MANIFEST_PATH);
+    const rows = manifest === null ? {} : JSON.parse(manifest).targets;
+    if (rows && typeof rows === "object" && !Array.isArray(rows)) {
+      for (const row of Object.values(rows)) {
+        if (!row || typeof row.path !== "string")
+          continue;
+        add(row.path, row.ownership === "generated" ? { whole: true } : { mixedDocument: true });
+      }
+    }
+  } catch {}
+  try {
+    const listed = git(root, ["ls-tree", "-r", "-z", "--name-only", revision, "--", ".archcontext/model"]).split("\x00").filter(Boolean);
+    const files = new Map(listed.map((path) => [path, readFileAtRevision(root, revision, path) ?? ""]));
+    for (const target of agentContextProjectionTargetPaths(loadNativeModelFromModelFiles(files)))
+      add(target.path, { agentNodeIds: [target.nodeId] });
+  } catch {}
+  return targets;
+}
+function mixedTargetTextUnchanged(before, after, target) {
+  if (before === null || after === null)
+    return false;
+  try {
+    return JSON.stringify(textOutsideGeneratedRegions(before, target)) === JSON.stringify(textOutsideGeneratedRegions(after, target));
+  } catch {
+    return false;
+  }
+}
+function textOutsideGeneratedRegions(body, target) {
+  const text = target.agentNodeIds.length > 0 ? agentContextTextOutsideRegions(body, target.agentNodeIds) : body;
+  if (!target.mixedDocument)
+    return [text];
+  const scan = scanDocumentRegions(text);
+  if (scan.diagnostics.length > 0 || scan.generatedRegions.some((region) => !region.closed))
+    throw new Error("projection-generated-regions-unbalanced");
+  return scan.humanRegions.map((region) => region.text);
+}
+function readFileAtRevision(root, revision, path) {
+  if (!gitSucceeds2(root, ["cat-file", "-e", `${revision}:${path}`]))
+    return null;
+  return git(root, ["cat-file", "blob", `${revision}:${path}`]);
+}
+function createNoneProjectionPublisher() {
+  return { kind: "none", ensurePullRequest: async () => ({}) };
+}
+function createGhProjectionPublisher(options = {}) {
+  const exec = options.exec ?? nodeProjectionPublisherExec;
+  const admissionEnv = options.env ?? process.env;
+  const timeoutMs = options.timeoutMs ?? PUBLISHER_TIMEOUT_MS;
+  return {
+    kind: "gh",
+    async ensurePullRequest(input) {
+      assertLocalEgressAllowed2("projection-publishing", admissionEnv);
+      const repository = projectionPublisherRepository(input.worktree, input.remote);
+      const env = { ...stringEnv(process.env), GH_PROMPT_DISABLED: "1" };
+      delete env.GH_REPO;
+      const gh = (args) => withLocalEgress2("projection-publishing", () => exec("gh", [...args, "--repo", repository], { cwd: input.worktree, env, timeoutMs }), admissionEnv);
+      const listed = await gh(["pr", "list", "--head", input.branch, "--base", input.base, "--state", "open", "--json", "number,url", "--limit", "1"]);
+      const open = parseGhPullRequestList(listed.stdout);
+      if (open) {
+        await gh(["pr", "edit", String(open.number), "--title", input.title, "--body-file", input.bodyFile]);
+        return { number: open.number, ...open.url ? { url: open.url } : {} };
+      }
+      const created = await gh(["pr", "create", "--base", input.base, "--head", input.branch, "--title", input.title, "--body-file", input.bodyFile]);
+      const url = created.stdout.trim().split(`
+`).map((line) => line.trim()).filter(Boolean).pop() ?? "";
+      const number = /\/pull\/(\d+)(?:[/?#]|$)/.exec(url)?.[1];
+      return { ...url ? { url } : {}, ...number ? { number: Number(number) } : {} };
+    }
+  };
+}
+function projectionWriterPushUrl(worktree, remote) {
+  const urls = git(worktree, ["remote", "get-url", "--push", "--all", "--", remote]).trim().split(`
+`).filter(Boolean);
+  if (urls.length !== 1) {
+    throw new ProjectionWriterFailure("AC_SCHEMA_INVALID", "projection-writer-push-target-ambiguous", "projection publish requires exactly one push URL for the selected remote");
+  }
+  return urls[0];
+}
+function projectionPublisherRepository(worktree, remote) {
+  const source = projectionWriterPushUrl(worktree, remote);
+  const scp = /^[^/@:]+@([A-Za-z0-9.-]+):([^?#]+)$/.exec(source);
+  let host;
+  let path;
+  if (scp) {
+    host = scp[1];
+    path = scp[2];
+  } else {
+    const url = new URL(source);
+    if (!["https:", "ssh:"].includes(url.protocol) || url.search || url.hash || url.password || url.protocol === "https:" && url.username) {
+      throw new Error("the selected remote must be an SSH or HTTPS GitHub repository URL");
+    }
+    host = url.protocol === "ssh:" ? url.hostname : url.host;
+    path = url.pathname.replace(/^\//, "");
+  }
+  path = path.replace(/\.git$/, "");
+  if (!/^[A-Za-z0-9.-]+(?::[0-9]+)?$/.test(host) || !/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(path) || path.split("/").some((part) => part === "." || part === "..")) {
+    throw new Error("the selected remote must identify one GitHub host, owner, and repository");
+  }
+  return `${host.toLowerCase()}/${path}`;
+}
+function createCommandProjectionPublisher(options) {
+  const exec = options.exec ?? nodeProjectionPublisherExec;
+  const admissionEnv = options.env ?? process.env;
+  const sourceEnv = options.sourceEnv ?? process.env;
+  const platform = options.platform ?? process.platform;
+  const timeoutMs = options.timeoutMs ?? PUBLISHER_TIMEOUT_MS;
+  return {
+    kind: "command",
+    identity: `command:${resolve30(options.command)}`,
+    async ensurePullRequest(input) {
+      const env = {
+        ...commandPublisherBaseEnv(sourceEnv, platform),
+        ARCHCTX_PUBLISH_REMOTE: input.remote,
+        ARCHCTX_PUBLISH_BASE: input.base,
+        ARCHCTX_PUBLISH_BRANCH: input.branch,
+        ARCHCTX_PUBLISH_BASE_SHA: input.baseSha,
+        ARCHCTX_PUBLISH_COMMIT: input.commitSha,
+        ARCHCTX_PUBLISH_TITLE: input.title,
+        ARCHCTX_PUBLISH_BODY_FILE: input.bodyFile
+      };
+      const { stdout } = await withLocalEgress2("projection-publishing", async () => {
+        const invocation = commandPublisherInvocation(options.command, platform);
+        try {
+          return await exec(invocation.file, invocation.args, { cwd: input.worktree, env, timeoutMs });
+        } catch (error) {
+          if (invocation.interpreter !== undefined && error.code === "ENOENT") {
+            throw new Error(`publisher command ${options.command} needs the interpreter "${invocation.interpreter}" from its #! line, which was not found on PATH`);
+          }
+          throw error;
+        }
+      }, admissionEnv);
+      return parsePublisherCommandOutput(stdout);
+    }
+  };
+}
+var COMMAND_PUBLISHER_POSIX_ENV = ["PATH", "HOME"];
+var COMMAND_PUBLISHER_WINDOWS_ENV = ["PATH", "HOME", "SystemRoot", "windir", "ComSpec", "PATHEXT", "TEMP", "TMP", "USERPROFILE"];
+function commandPublisherBaseEnv(source, platform) {
+  const env = {};
+  if (platform !== "win32") {
+    for (const name of COMMAND_PUBLISHER_POSIX_ENV) {
+      const value = source[name];
+      if (value)
+        env[name] = value;
+    }
+    return env;
+  }
+  const allowed = new Set(COMMAND_PUBLISHER_WINDOWS_ENV.map((name) => name.toUpperCase()));
+  const forwarded = new Set;
+  for (const [name, value] of Object.entries(source)) {
+    const key = name.toUpperCase();
+    if (!value || !allowed.has(key) || forwarded.has(key))
+      continue;
+    forwarded.add(key);
+    env[name] = value;
+  }
+  return env;
+}
+function commandPublisherInvocation(command, platform) {
+  if (platform !== "win32")
+    return { file: command, args: [] };
+  const extension = extname2(command).toLowerCase();
+  if (extension === ".cmd" || extension === ".bat") {
+    throw new Error(`publisher command ${command} is a ${extension} script, which only runs through cmd.exe; the command publisher runs without a shell, so use an executable or a #! script`);
+  }
+  const firstLine = readCommandFirstLine(command);
+  if (!firstLine.startsWith("#!"))
+    return { file: command, args: [] };
+  const tokens = firstLine.slice(2).trim().split(/\s+/).filter((token) => token !== "");
+  if (tokens.length === 0)
+    throw new Error(`publisher command ${command} has an empty #! line`);
+  let interpreter = commandBasename(tokens[0]);
+  let interpreterArgs = tokens.slice(1);
+  if (interpreter === "env") {
+    const next = interpreterArgs[0];
+    if (next === undefined || next.startsWith("-")) {
+      throw new Error(`publisher command ${command} has an unsupported #! line "${firstLine}": /usr/bin/env must be followed by an interpreter name`);
+    }
+    interpreter = commandBasename(next);
+    interpreterArgs = interpreterArgs.slice(1);
+  }
+  return { file: interpreter, args: [...interpreterArgs, command], interpreter };
+}
+function commandBasename(token) {
+  const name = token.split(/[\\/]/).pop() ?? token;
+  return name.toLowerCase().endsWith(".exe") ? name.slice(0, -4) : name;
+}
+function readCommandFirstLine(command) {
+  let fd;
+  try {
+    fd = openSync10(command, "r");
+  } catch (error) {
+    throw new Error(`publisher command ${command} cannot be read: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  try {
+    const buffer = Buffer.alloc(1024);
+    const length = readSync5(fd, buffer, 0, buffer.length, 0);
+    const head = buffer.subarray(0, length).toString("utf8");
+    const newline = head.indexOf(`
+`);
+    return (newline === -1 ? head : head.slice(0, newline)).replace(/\r$/, "");
+  } finally {
+    closeSync9(fd);
+  }
+}
+function parseGhPullRequestList(stdout) {
+  const parsed = JSON.parse(stdout.trim() === "" ? "[]" : stdout);
+  if (!Array.isArray(parsed))
+    throw new Error("gh pr list returned an unexpected shape");
+  const first = parsed[0];
+  if (!first)
+    return;
+  if (typeof first.number !== "number" || !Number.isInteger(first.number) || first.number <= 0)
+    throw new Error("gh pr list returned a pull request without a number");
+  return { number: first.number, ...typeof first.url === "string" && first.url !== "" ? { url: first.url } : {} };
+}
+function parsePublisherCommandOutput(stdout) {
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout.trim());
+  } catch {
+    return {};
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    return {};
+  const value = parsed;
+  return {
+    ...typeof value.url === "string" && value.url !== "" ? { url: value.url } : {},
+    ...typeof value.number === "number" && Number.isInteger(value.number) && value.number > 0 ? { number: value.number } : {}
+  };
+}
+var nodeProjectionPublisherExec = (file, args, options) => new Promise((resolvePromise, rejectPromise) => {
+  execFile2(file, args, { cwd: options.cwd, env: options.env, timeout: options.timeoutMs, encoding: "utf8", maxBuffer: 16 * 1024 * 1024 }, (error, stdout, stderr) => {
+    if (error) {
+      rejectPromise(Object.assign(new Error(`${[file, ...args.slice(0, 2)].join(" ")} failed: ${(stderr ?? "").trim() || error.message}`), { code: error.code }));
+      return;
+    }
+    resolvePromise({ stdout });
+  });
+});
+function stringEnv(env) {
+  return Object.fromEntries(Object.entries(env).filter((entry) => typeof entry[1] === "string"));
+}
+function projectionWriterTargetIssue(repositoryRoot, input) {
+  const issue = refNameIssue(repositoryRoot, "--base", input.base) ?? refNameIssue(repositoryRoot, "--branch", input.branch) ?? remoteNameIssue(input.remote);
+  if (issue)
+    return issue;
+  if (!input.branch.startsWith(PROJECTION_WRITER_BRANCH_PREFIX))
+    return `projection publish --branch must start with ${PROJECTION_WRITER_BRANCH_PREFIX}; the writer never pushes to any other ref`;
+  if (input.branch === input.base)
+    return "projection publish --branch must differ from --base";
+  if (!gitSucceeds2(repositoryRoot, ["remote", "get-url", "--", input.remote]))
+    return `projection publish --remote names no configured remote: ${input.remote}`;
+  return;
+}
+function refNameIssue(repositoryRoot, flag, name) {
+  if (name === "" || name.startsWith("-") || name.includes("@{") || !gitSucceeds2(repositoryRoot, ["check-ref-format", "--branch", name])) {
+    return `${flag} is not a valid branch name: ${JSON.stringify(name)}`;
+  }
+  return;
+}
+function remoteNameIssue(remote) {
+  if (remote === "" || remote.startsWith("-") || !/^[A-Za-z0-9._-]+$/.test(remote))
+    return `--remote is not a valid remote name: ${JSON.stringify(remote)}`;
+  return;
+}
+function acquireProjectionWriterLock(lockPath, startedAt) {
+  let ownership;
+  try {
+    ownership = acquireLocalStoreWriterOwnership(`${lockPath}.coordination`);
+  } catch (error) {
+    if (error instanceof FailureError && error.reasonCode === "runtime-writer-owned") {
+      const holder = readProjectionWriterLock(lockPath);
+      if (holder && isProcessAlive(holder.pid))
+        return { kind: "busy", pid: holder.pid };
+      throw new ProjectionWriterFailure("AC_PRECONDITION_FAILED", "projection-writer-lock-unavailable", "another writer holds the OS lock; its diagnostic owner record is unavailable");
+    }
+    throw error;
+  }
+  try {
+    const body = readPrivateControlFile(lockPath);
+    if (body === undefined && existsSync29(lockPath)) {
+      throw new ProjectionWriterFailure("AC_PRECONDITION_FAILED", "projection-writer-lock-unverified", "the writer owner record has unverified permissions");
+    }
+    const holder = body === undefined ? undefined : parseProjectionWriterLock(body);
+    if (holder && isProcessAlive(holder.pid)) {
+      ownership.release();
+      return { kind: "busy", pid: holder.pid };
+    }
+    rmSync15(lockPath, { force: true });
+    const record = JSON.stringify({ pid: process.pid, startedAt, token: randomUUID3() }, null, 2);
+    createPrivateControlFile(lockPath, record);
+    return { kind: "acquired", record, release() {
+      try {
+        if (readPrivateControlFile(lockPath) === record)
+          rmSync15(lockPath, { force: true });
+      } finally {
+        ownership.release();
+      }
+    } };
+  } catch (error) {
+    ownership.release();
+    throw error;
+  }
+}
+function assertProjectionWriterOwner(lockPath, record) {
+  if (readPrivateControlFile(lockPath) !== record) {
+    throw new ProjectionWriterFailure("AC_PRECONDITION_FAILED", "projection-writer-lock-lost", "the writer owner record changed; publication stopped");
+  }
+}
+function readProjectionWriterLock(lockPath) {
+  const body = readPrivateControlFile(lockPath);
+  return body === undefined ? undefined : parseProjectionWriterLock(body);
+}
+function parseProjectionWriterLock(body) {
+  try {
+    const value = JSON.parse(body);
+    if (typeof value.pid !== "number" || !Number.isInteger(value.pid) || value.pid <= 0)
+      return;
+    return { pid: value.pid, startedAt: typeof value.startedAt === "string" ? value.startedAt : "" };
+  } catch {
+    return;
+  }
+}
+function emptyProjectionWriterState(remote, base) {
+  return {
+    schemaVersion: PROJECTION_WRITER_STATE_SCHEMA_VERSION,
+    remote,
+    base,
+    branch: null,
+    runSequence: 0,
+    lastProcessedSha: null,
+    lastSuccessfulSha: null,
+    lastSuccessfulCommit: null,
+    lastSuccessfulBranch: null,
+    lastSuccessfulPublisher: null,
+    lastSuccessfulFiles: [],
+    publisherPending: null,
+    lastRun: null
+  };
+}
+function readProjectionWriterState(path, remote, base) {
+  if (!existsSync29(path))
+    return emptyProjectionWriterState(remote, base);
+  let value;
+  try {
+    value = JSON.parse(readFileSync27(path, "utf8"));
+  } catch (error) {
+    throw new ProjectionWriterFailure("AC_PRECONDITION_FAILED", "projection-writer-state-invalid", `projection writer state is unreadable at ${path}: ${errorMessage2(error)}`);
+  }
+  if (value?.schemaVersion !== PROJECTION_WRITER_STATE_SCHEMA_VERSION || value.remote !== remote || value.base !== base || typeof value.runSequence !== "number") {
+    throw new ProjectionWriterFailure("AC_PRECONDITION_FAILED", "projection-writer-state-invalid", `projection writer state at ${path} does not belong to ${remote}/${base}`);
+  }
+  return { ...emptyProjectionWriterState(remote, base), ...value };
+}
+function writeProjectionWriterState(path, state) {
+  const temporary = `${path}.${process.pid}.tmp`;
+  writeFileSync11(temporary, `${JSON.stringify(state, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+  renameSync7(temporary, path);
+}
+function prepareProjectionWriterWorktree(repositoryRoot, worktree, sha) {
+  git(repositoryRoot, ["worktree", "prune"]);
+  if (!isRegisteredWorktree(repositoryRoot, worktree)) {
+    rmSync15(worktree, { recursive: true, force: true });
+    git(repositoryRoot, ["worktree", "add", "--detach", worktree, sha]);
+  }
+  git(worktree, ["checkout", "-q", "--force", "--detach", sha]);
+  git(worktree, ["reset", "-q", "--hard", sha]);
+  git(worktree, ["clean", "-ffdq"]);
+}
+function isRegisteredWorktree(repositoryRoot, worktree) {
+  if (!existsSync29(join23(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);
+}
+function canonical(path) {
+  try {
+    return realpathSync12.native(path);
+  } catch {
+    return resolve30(path);
+  }
+}
+function worktreeChangedPaths(worktree) {
+  const tokens = git(worktree, ["status", "--porcelain=v1", "-z", "--untracked-files=all"]).split("\x00");
+  const paths = new Set;
+  for (let index = 0;index < tokens.length; index += 1) {
+    const entry = tokens[index];
+    if (entry.length < 4)
+      continue;
+    paths.add(entry.slice(3));
+    if (entry[0] === "R" || entry[0] === "C") {
+      const source = tokens[index + 1];
+      if (source)
+        paths.add(source);
+      index += 1;
+    }
+  }
+  return [...paths].sort();
+}
+function isProjectionOwnedPath(path, patterns) {
+  return patterns.some((pattern) => pattern.endsWith("/**") ? path.startsWith(pattern.slice(0, -2)) : path === pattern);
+}
+function carriesSameProjection(worktree, remoteTip, commitSha, baseSha) {
+  if (!gitSucceeds2(worktree, ["cat-file", "-e", `${remoteTip}^{commit}`]))
+    return false;
+  const parents = git(worktree, ["rev-list", "--parents", "-n", "1", remoteTip]).trim().split(/\s+/).slice(1);
+  if (parents.length !== 1 || parents[0] !== baseSha)
+    return false;
+  return git(worktree, ["rev-parse", `${remoteTip}^{tree}`]).trim() === git(worktree, ["rev-parse", `${commitSha}^{tree}`]).trim();
+}
+function lsRemoteBranch(repositoryRoot, remote, branch, env) {
+  const line = remoteGit(repositoryRoot, ["ls-remote", "--", remote, `refs/heads/${branch}`], env).split(`
+`).find((entry) => entry.endsWith(`	refs/heads/${branch}`));
+  return line ? line.split("\t")[0] : null;
+}
+function remoteGit(cwd, args, env) {
+  return withLocalEgress2("projection-publishing", () => git(cwd, args, { GIT_TERMINAL_PROMPT: "0" }), env);
+}
+function git(cwd, args, extraEnv = {}) {
+  const result = spawnSync5("git", args, {
+    cwd,
+    encoding: "utf8",
+    env: { ...process.env, ...extraEnv },
+    stdio: ["ignore", "pipe", "pipe"],
+    maxBuffer: 256 * 1024 * 1024
+  });
+  if (result.error)
+    throw new ProjectionWriterFailure("AC_PRECONDITION_FAILED", "projection-writer-git-failed", `git ${args[0]} could not run: ${result.error.message}`);
+  if (result.status !== 0) {
+    throw new ProjectionWriterFailure("AC_PRECONDITION_FAILED", "projection-writer-git-failed", `git ${args[0]} failed: ${(result.stderr ?? "").trim() || `exit ${result.status}`}`);
+  }
+  return result.stdout ?? "";
+}
+function gitSucceeds2(cwd, args) {
+  return spawnSync5("git", args, { cwd, stdio: ["ignore", "ignore", "ignore"] }).status === 0;
+}
+function envelopeFailure(envelope, fallbackReason) {
+  const error = envelope.error;
+  return new ProjectionWriterFailure(error?.code ?? "AC_UNCLASSIFIED_FAILURE", error?.reasonCode ?? fallbackReason, error?.message ?? fallbackReason);
+}
+function asWriterFailure(error) {
+  if (error instanceof ProjectionWriterFailure)
+    return error;
+  if (error instanceof LocalEgressPolicyError2)
+    return new ProjectionWriterFailure("AC_POLICY_VIOLATION", "egress-policy-denied", error.message);
+  const envelope = publicOperationErrorEnvelope(PROJECTION_PUBLISH_REQUEST_ID, error);
+  return envelopeFailure(envelope, "projection-writer-failed");
+}
+function writerError(failure) {
+  return { code: failure.code, reasonCode: failure.reasonCode, message: failure.message };
+}
+function errorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
 // packages/local-runtime/runtime-daemon/src/capability-dependencies.ts
 init_src();
 var CODEGRAPH_BINARY2 = "codegraph";
@@ -54274,8 +55423,8 @@ function runFlowSelectorCheckCommand(cwd, options = {}) {
   }
 }
 // packages/local-runtime/runtime-daemon/src/recommendations.ts
-import { existsSync as existsSync29 } from "node:fs";
-import { join as join23 } from "node:path";
+import { existsSync as existsSync30 } from "node:fs";
+import { join as join24 } from "node:path";
 
 // packages/local-runtime/runtime-daemon/src/refactor-verify.ts
 init_src();
@@ -54877,7 +56026,7 @@ class RecommendationsService {
     });
   }
   readGitOnlyDecision(repositoryRoot, recommendationId, surface) {
-    if (!existsSync29(join23(repositoryRoot, REFACTOR_DECISION_DIRECTORY)))
+    if (!existsSync30(join24(repositoryRoot, REFACTOR_DECISION_DIRECTORY)))
       return;
     let decisions;
     try {
@@ -55547,7 +56696,7 @@ function lifecycleEnvelope(input) {
   });
 }
 function refactorDecisionsInPlay(repositoryRoot, records) {
-  return records.some(isRefactorRecommendation) || existsSync29(join23(repositoryRoot, REFACTOR_DECISION_DIRECTORY));
+  return records.some(isRefactorRecommendation) || existsSync30(join24(repositoryRoot, REFACTOR_DECISION_DIRECTORY));
 }
 function ledgerAuditDecisionRefused(surface, record, recommendations, decisions) {
   let head = record.recommendationId;
@@ -55668,15 +56817,15 @@ function recommendationActorKind(input) {
 // packages/local-runtime/runtime-daemon/src/changeset-authority.ts
 init_src();
 init_src();
-import { existsSync as existsSync30, readFileSync as readFileSync28 } from "node:fs";
-import { resolve as resolve31 } from "node:path";
+import { existsSync as existsSync31, readFileSync as readFileSync29 } from "node:fs";
+import { resolve as resolve32 } from "node:path";
 init_src();
 
 // packages/local-runtime/runtime-daemon/src/committed-change-acceptance.ts
 init_src();
 import { execFileSync as execFileSync10 } from "node:child_process";
-import { closeSync as closeSync9, constants as fsConstants3, fstatSync as fstatSync4, lstatSync as lstatSync15, openSync as openSync10, readdirSync as readdirSync15, readFileSync as readFileSync27 } from "node:fs";
-import { resolve as resolve30 } from "node:path";
+import { closeSync as closeSync10, constants as fsConstants3, fstatSync as fstatSync4, lstatSync as lstatSync15, openSync as openSync11, readdirSync as readdirSync15, readFileSync as readFileSync28 } from "node:fs";
+import { resolve as resolve31 } from "node:path";
 init_src();
 var SEMANTIC_MODEL_DIRECTORIES = ["nodes", "relations", "flows"];
 var SEMANTIC_MODEL_PATH = /^\.archcontext\/model\/(nodes|relations|flows)\/[^/]+\.ya?ml$/;
@@ -55741,7 +56890,7 @@ function readSemanticModelSnapshot(root, readEntry) {
     }
     for (const entry of entries.filter((name) => /\.ya?ml$/.test(name)).sort()) {
       const path = `${relativeDirectory}/${entry}`;
-      bodies.set(path, strictUtf8(readEntry(resolve30(absolute, entry), path), path));
+      bodies.set(path, strictUtf8(readEntry(resolve31(absolute, entry), path), path));
     }
   }
   const hashes = new Map([...bodies].map(([path, body]) => [path, digestJson({ body })]));
@@ -55750,13 +56899,13 @@ function readSemanticModelSnapshot(root, readEntry) {
 function readRegularFileBytes(absolute, path) {
   if (!lstatSync15(absolute).isFile())
     throw new FailureError("AC_PRECONDITION_FAILED", "semantic-model-entry-not-regular");
-  const fd = openSync10(absolute, fsConstants3.O_RDONLY | (fsConstants3.O_NOFOLLOW ?? 0) | (fsConstants3.O_NONBLOCK ?? 0));
+  const fd = openSync11(absolute, fsConstants3.O_RDONLY | (fsConstants3.O_NOFOLLOW ?? 0) | (fsConstants3.O_NONBLOCK ?? 0));
   try {
     if (!fstatSync4(fd).isFile())
       throw new FailureError("AC_PRECONDITION_FAILED", "semantic-model-entry-not-regular");
-    return readFileSync27(fd);
+    return readFileSync28(fd);
   } finally {
-    closeSync9(fd);
+    closeSync10(fd);
   }
 }
 function strictUtf8(bytes, path) {
@@ -56254,10 +57403,10 @@ class ChangeSetAuthorityService {
         return publicFailureEnvelope("practices.waive", "AC_SCHEMA_INVALID", "waiver-input-invalid");
       }
       const path = `.archcontext/waivers/${waiverId}.json`;
-      const absolute = resolve31(session.workspace.root, path);
+      const absolute = resolve32(session.workspace.root, path);
       const body = `${JSON.stringify(waiver, null, 2)}
 `;
-      const expectedHash = existsSync30(absolute) ? digestJson({ body: readFileSync28(absolute, "utf8") }) : "missing";
+      const expectedHash = existsSync31(absolute) ? digestJson({ body: readFileSync29(absolute, "utf8") }) : "missing";
       const draft = this.changeSetEngine.plan({
         id: input.id ?? `changeset.practice-waiver-${waiverId.replace(/[^A-Za-z0-9_-]/g, "-")}`,
         base: {
@@ -56409,7 +57558,7 @@ class ChangeSetAuthorityService {
       if (draft.base.worktreeDigest !== current)
         throw new FailureError("AC_PRECONDITION_FAILED", "apply-worktree-changed", { expectedWorktreeDigest: draft.base.worktreeDigest, actualWorktreeDigest: current });
       const currentModel = await this.readModelStore.validateModel(session.workspace);
-      const baseErrors = baseModelBlockingErrors(currentModel);
+      const baseErrors = changeSetBaseModelBlockingErrors(currentModel, draft);
       if (baseErrors.length > 0) {
         throw new FailureError("AC_PRECONDITION_FAILED", "apply-model-invalid", { issueCount: baseErrors.length });
       }
@@ -56693,7 +57842,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 existsSync31, mkdirSync as mkdirSync12 } from "node:fs";
+import { closeSync as closeSync11, existsSync as existsSync32, mkdirSync as mkdirSync13 } from "node:fs";
 import { dirname as dirname14 } from "node:path";
 import { randomBytes as randomBytes5 } from "node:crypto";
 var DEFAULT_DAEMON_IDLE_TIMEOUT_MS = 30 * 60000;
@@ -56751,7 +57900,7 @@ class ArchctxRuntimeRpcServer {
     if (connection)
       await removePrivateControlFile(connection.connectionPath);
     if (this.lockFd !== undefined) {
-      closeSync10(this.lockFd);
+      closeSync11(this.lockFd);
       this.lockFd = undefined;
       await removePrivateControlFile(this.options.lockPath ?? defaultDaemonLockPath(this.options.root ?? process.cwd()));
     }
@@ -56764,8 +57913,8 @@ class ArchctxRuntimeRpcServer {
     const root = this.options.root ?? process.cwd();
     const connectionPath = this.options.connectionPath ?? defaultDaemonConnectionPath(root);
     const lockPath = this.options.lockPath ?? defaultDaemonLockPath(root);
-    mkdirSync12(dirname14(connectionPath), { recursive: true });
-    mkdirSync12(dirname14(lockPath), { recursive: true });
+    mkdirSync13(dirname14(connectionPath), { recursive: true });
+    mkdirSync13(dirname14(lockPath), { recursive: true });
     this.lockFd = acquireDaemonLock(lockPath, root);
     const token = this.options.token ?? randomBytes5(18).toString("base64url");
     const server = createServer2((request, response) => {
@@ -56816,7 +57965,7 @@ class ArchctxRuntimeRpcServer {
         await removePrivateControlFile(connection.connectionPath);
     } finally {
       if (this.lockFd !== undefined)
-        closeSync10(this.lockFd);
+        closeSync11(this.lockFd);
       this.lockFd = undefined;
     }
     if (connection)
@@ -56858,7 +58007,7 @@ class ArchctxRuntimeRpcServer {
     });
     if (this.server && this.connection && (this.inFlightRpcRequests > 0 || this.authorizedRequests !== requestsBeforeRemoval)) {
       try {
-        if (!existsSync31(connection.connectionPath))
+        if (!existsSync32(connection.connectionPath))
           createPrivateControlFile(connection.connectionPath, JSON.stringify(connection, null, 2));
         this.idleExitPending = false;
         this.armIdleTimer();
@@ -57071,8 +58220,8 @@ async function readRpcRequestBody(request, limits) {
 }
 
 // packages/local-runtime/runtime-daemon/src/index.ts
-import { existsSync as existsSync32, readFileSync as readFileSync29 } from "node:fs";
-import { resolve as resolve32 } from "node:path";
+import { existsSync as existsSync33, readFileSync as readFileSync30 } from "node:fs";
+import { resolve as resolve33 } from "node:path";
 init_src();
 
 // packages/local-runtime/runtime-daemon/src/egress.ts
@@ -57108,6 +58257,8 @@ function effectiveEgressChannels2(env, live) {
   }
   if (live.updateCheckRequested)
     channels.push({ channel: "npm-update-check", destination: "configured npm registry", trigger: "explicit update --check or doctor --check-updates", data: "archctx package version lookup", status: "enabled" });
+  if (live.projectionPublishRequested)
+    channels.push({ channel: "projection-publishing", destination: "configured git remote, plus GitHub via gh or the operator's publisher command", trigger: "explicit archctx projection publish", data: "one commit of generated projection outputs and a pull request title/body listing their paths", status: "enabled" });
   if (env[CODEGRAPH_TELEMETRY_ENV] !== undefined && env[CODEGRAPH_TELEMETRY_ENV] !== CODEGRAPH_TELEMETRY_DISABLED_VALUE)
     channels.push({ channel: "codegraph-telemetry", destination: "CodeGraph configured telemetry endpoint", trigger: "CodeGraph execution with telemetry enabled", data: "third-party telemetry", status: "enabled" });
   return channels.map((channel) => localEgressAdmission2(channel.channel, env).allowed ? channel : { ...channel, status: "blocked-by-policy" });
@@ -57262,7 +58413,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, readFileSync29(resolve32(root, file.path), "utf8")) !== file.body) {
+            if (canonicalBody === undefined || projectionOwnedWriteBody(canonicalBody, readFileSync30(resolve33(root, file.path), "utf8")) !== file.body) {
               throw new Error(`Root contract requires canonical marker-only content: ${file.path}`);
             }
           }
@@ -57521,7 +58672,7 @@ class ArchctxDaemon {
       if (this.auditRunAbortControllers.size > 0)
         return true;
       for (const [repositoryId, session] of this.sessions) {
-        if (!existsSync32(session.workspace.root)) {
+        if (!existsSync33(session.workspace.root)) {
           this.sessions.delete(repositoryId);
           continue;
         }
@@ -57684,6 +58835,10 @@ class ArchctxDaemon {
   async completeTaskUnchecked(root, input) {
     this.assertRunning();
     assertNoCallerProvidedAttestationFields(input, "complete-task");
+    if (this.codeFacts.assertCanSync) {
+      root = findRepositoryRoot(root);
+      this.codeFacts.assertCanSync(root);
+    }
     const session = await this.openSession(root);
     let currentHeadSha = input.headSha;
     try {
@@ -57721,7 +58876,7 @@ class ArchctxDaemon {
     try {
       projectionDrift = completeTaskProjectionDrift(session.workspace.root);
       projectionFreshness = completeTaskProjectionFreshness(session.workspace.root);
-      if (model.valid || !existsSync32(resolve32(session.workspace.root, ".archcontext/manifest.yaml"))) {
+      if (model.valid || !existsSync33(resolve33(session.workspace.root, ".archcontext/manifest.yaml"))) {
         architectureDebt = readCompleteTaskArchitectureDebt(session.workspace.root, practiceEnforcement);
       }
     } catch (error) {
@@ -58210,7 +59365,7 @@ class ArchctxDaemon {
   }
   async restoreRepositorySessions() {
     for (const record of await this.localStore.listRepositorySessions()) {
-      if (!record.root || !existsSync32(record.root))
+      if (!record.root || !existsSync33(record.root))
         continue;
       if (repositoryFingerprint(record.root) !== record.repositoryId)
         continue;
@@ -58508,7 +59663,7 @@ function blockedProductionInjections(deps) {
   ].filter((key) => (key in deps));
 }
 function completeTaskProjectionDrift(root) {
-  if (!existsSync32(resolve32(root, "docs/architecture/.projection-manifest.json")))
+  if (!existsSync33(resolve33(root, "docs/architecture/.projection-manifest.json")))
     return;
   const profile = loadArchitectureDocumentationProfile(root);
   const loaded = loadArchitectureDocumentationInputs(root, profile);
@@ -58554,10 +59709,11 @@ function completeTaskProjectionFreshness(root) {
 }
 
 // packages/local-runtime/codegraph-adapter/src/index.ts
+init_src();
 import { execFileSync as execFileSync11 } from "node:child_process";
-import { accessSync as accessSync2, closeSync as closeSync11, constants as fsConstants4, existsSync as existsSync33, openSync as openSync11, readFileSync as readFileSync30, readSync as readSync5, realpathSync as realpathSync12, statSync as statSync10 } from "node:fs";
+import { accessSync as accessSync2, closeSync as closeSync12, constants as fsConstants4, existsSync as existsSync34, openSync as openSync12, readFileSync as readFileSync31, readSync as readSync6, realpathSync as realpathSync13, statSync as statSync10 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
-import { basename as basename7, delimiter as delimiter2, dirname as dirname15, isAbsolute as isAbsolute10, join as join25, posix as posix4, resolve as resolve33 } from "node:path";
+import { basename as basename7, delimiter as delimiter2, dirname as dirname15, isAbsolute as isAbsolute10, join as join26, posix as posix4, resolve as resolve34 } from "node:path";
 init_src();
 var REQUIRED_CODEGRAPH_PACKAGE2 = "@colbymchenry/codegraph";
 var REQUIRED_CODEGRAPH_VERSION2 = productVersionManifest().runtime.codeGraph.requiredVersion;
@@ -58594,15 +59750,15 @@ function codeGraphCliInvocation2(binary, cwd, pathValue = process.env.PATH ?? ""
 }
 function resolveExecutable2(binary, cwd, pathValue) {
   if (binary.includes("/") || binary.includes("\\")) {
-    const path = isAbsolute10(binary) ? binary : join25(cwd, binary);
-    return existsSync33(path) ? realpathSync12.native(path) : undefined;
+    const path = isAbsolute10(binary) ? binary : join26(cwd, binary);
+    return existsSync34(path) ? realpathSync13.native(path) : undefined;
   }
   for (const dir of pathValue.split(delimiter2)) {
     if (!dir)
       continue;
-    const path = join25(dir, binary);
+    const path = join26(dir, binary);
     if (isExecutablePath2(path))
-      return realpathSync12.native(path);
+      return realpathSync13.native(path);
   }
   return;
 }
@@ -58620,12 +59776,12 @@ function isExecutablePath2(path) {
 function resolvePackagedCodeGraphShim2() {
   try {
     const manifestPath = requireFromAdapter2.resolve(`${REQUIRED_CODEGRAPH_PACKAGE2}/package.json`);
-    const manifest = JSON.parse(readFileSync30(manifestPath, "utf8"));
+    const manifest = JSON.parse(readFileSync31(manifestPath, "utf8"));
     const relativeBin = manifest.bin?.codegraph;
     if (manifest.version !== REQUIRED_CODEGRAPH_VERSION2 || !relativeBin)
       return;
-    const shimPath = resolve33(dirname15(manifestPath), relativeBin);
-    return existsSync33(shimPath) ? realpathSync12.native(shimPath) : undefined;
+    const shimPath = resolve34(dirname15(manifestPath), relativeBin);
+    return existsSync34(shimPath) ? realpathSync13.native(shimPath) : undefined;
   } catch {
     return;
   }
@@ -58639,15 +59795,15 @@ function isNodeRuntimeScript2(path) {
 function readFilePrefix2(path, length) {
   let fd;
   try {
-    fd = openSync11(path, "r");
+    fd = openSync12(path, "r");
     const buffer = Buffer.alloc(length);
-    const bytes = readSync5(fd, buffer, 0, length, 0);
+    const bytes = readSync6(fd, buffer, 0, length, 0);
     return buffer.subarray(0, bytes).toString("utf8");
   } catch {
     return "";
   } finally {
     if (fd !== undefined)
-      closeSync11(fd);
+      closeSync12(fd);
   }
 }
 var CODEGRAPH_IMPORT_NODE_OUTPUT_BYTES2 = 4 * 1024;
@@ -58662,7 +59818,7 @@ function readProjectionCodeGraphStatus2(invocation, root, timeout, envOverrides)
 function projectionCodeGraphStatusIssues2(status, root, phase) {
   const issue = (code, text) => ({
     code,
-    message: `CodeGraph ${phase} ${text}`
+    message: phase === "repository" ? CODE_FACTS_ISSUE_MESSAGES[code] : `CodeGraph ${phase} ${text}`
   });
   if (!status.initialized)
     return [issue("not-initialized", "status is not initialized")];
@@ -58685,7 +59841,7 @@ function sameRealPath2(left, right) {
   if (typeof left !== "string")
     return false;
   try {
-    return realpathSync12.native(left) === realpathSync12.native(right);
+    return realpathSync13.native(left) === realpathSync13.native(right);
   } catch {
     return false;
   }
@@ -58738,7 +59894,7 @@ function inspectRepositoryCodeFacts2(root, options = {}) {
       message: (error instanceof Error ? error.message : String(error)).replace(/\s+/g, " ").trim().slice(0, 400)
     };
   }
-  const versionIssues = codeGraphVersion === REQUIRED_CODEGRAPH_VERSION2 ? [] : [{ code: "version-mismatch", message: `CodeGraph ${REQUIRED_CODEGRAPH_VERSION2} required, got actual binary ${codeGraphVersion || "unknown"}` }];
+  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 };
   }
@@ -58768,14 +59924,14 @@ function inspectRepositoryCodeFacts2(root, options = {}) {
       current: status.index?.currentExtractionVersion ?? null
     },
     indexState: status.index?.state ?? null,
-    reindexRecommended: status.index?.reindexRecommended ?? null,
+    reindexRecommended: issues.some((issue) => issue.code !== "pending-source-changes"),
     pendingRefs: status.index?.pendingRefs ?? null,
     pendingChanges: pending ? { added: pending.added, modified: pending.modified, removed: pending.removed } : null,
     issues
   };
 }
 function codeGraphIndexAvailable2(workspaceRoot) {
-  return existsSync33(join25(workspaceRoot, ".codegraph"));
+  return existsSync34(join26(workspaceRoot, ".codegraph"));
 }
 var NON_DECLARATION_KINDS2 = new Set(["file", "import", "export", "parameter"]);
 var RUNTIME_BUILTIN_CALL_NAMES2 = new Set([
@@ -59571,6 +60727,95 @@ function isExternalDocumentationResourceUri(uri) {
 function architectureBookResourceInput(uri) {
   return ARCHITECTURE_BOOK_RESOURCES.find((resource) => resource.uri === uri)?.input;
 }
+// schemas/repo/architecture-node.schema.json
+var architecture_node_schema_default2 = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://archctx.repoharness.com/schemas/repo/architecture-node.schema.json",
+  title: "ArchitectureNode",
+  type: "object",
+  additionalProperties: false,
+  required: ["schemaVersion", "id", "kind", "name", "status", "summary"],
+  properties: {
+    schemaVersion: { const: "archcontext.node/v2" },
+    id: { type: "string", pattern: "^([a-z][a-z0-9]*(\\.[a-z0-9][a-z0-9-]*)*::)?[a-z][a-z0-9]*(\\.[a-z0-9][a-z0-9-]*)+$" },
+    kind: {
+      type: "string",
+      enum: ["capability", "module", "component", "interface", "event", "datastore", "external-system", "deployment"]
+    },
+    name: { type: "string" },
+    status: { type: "string", enum: ["active", "planned", "deprecated", "removed"] },
+    parent: { type: "string", pattern: "^([a-z][a-z0-9]*(\\.[a-z0-9][a-z0-9-]*)*::)?[a-z][a-z0-9]*(\\.[a-z0-9][a-z0-9-]*)+$" },
+    summary: { type: "string" },
+    responsibilities: { type: "array", items: { type: "string" }, minItems: 1 },
+    source: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        include: { type: "array", items: { type: "string" } },
+        exclude: { type: "array", items: { type: "string" } },
+        entrypoints: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["id", "path", "symbols"],
+            properties: {
+              id: { type: "string", pattern: "^[a-z][a-z0-9-]*(\\.[a-z0-9][a-z0-9-]*)+$" },
+              path: { type: "string", minLength: 1 },
+              symbols: {
+                type: "array",
+                minItems: 1,
+                items: {
+                  type: "object",
+                  additionalProperties: false,
+                  required: ["name", "sinks"],
+                  properties: {
+                    name: { type: "string", minLength: 1 },
+                    sinks: {
+                      type: "array",
+                      minItems: 1,
+                      items: {
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["id", "path", "symbol"],
+                        properties: {
+                          id: { type: "string", pattern: "^[a-z][a-z0-9-]*(\\.[a-z0-9][a-z0-9-]*)+$" },
+                          path: { type: "string", minLength: 1 },
+                          symbol: { type: "string", minLength: 1 }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    ownership: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        lifecycle: { type: "array", items: { type: "string" } },
+        data: { type: "array", items: { type: "string" } }
+      }
+    },
+    interfaces: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        provides: { type: "array", items: { type: "string" } },
+        consumes: { type: "array", items: { type: "string" } }
+      }
+    },
+    criticality: { type: "string", enum: ["low", "medium", "high", "critical"] },
+    riskDomains: { type: "array", items: { type: "string" } },
+    notes: { type: "array", items: { type: "string" } },
+    extensions: { type: "object", additionalProperties: true }
+  }
+};
+
 // packages/surfaces/cli/src/main.ts
 var [, , command, ...args] = process.argv;
 var CLI_ENTRY = fileURLToPath2(import.meta.url);
@@ -59611,6 +60856,12 @@ var AUDIT_RUN_VALUE_FLAGS = ["--task-session-id", "--reason", "--risk", "--uncer
 var AUDIT_RUN_BOOLEAN_FLAGS = ["--no-wait", ...AUDIT_GLOBAL_BOOLEAN_FLAGS];
 var AUDIT_APPROVE_VALUE_FLAGS = ["--run-id", "--confirm-public-repo", ...AUDIT_GLOBAL_VALUE_FLAGS];
 var AUDIT_APPROVE_BOOLEAN_FLAGS = ["--resume", ...AUDIT_GLOBAL_BOOLEAN_FLAGS];
+var PROJECTION_PUBLISH_VALUE_FLAGS = ["--base", "--branch", "--interval", "--publisher", "--publisher-command", "--remote"];
+var PROJECTION_PUBLISH_BOOLEAN_FLAGS = ["--accept-observed-major-change", "--follow"];
+var PROJECTION_PUBLISH_STATUS_VALUE_FLAGS = ["--base", "--remote"];
+var PROJECTION_VERIFY_PR_VALUE_FLAGS = ["--base"];
+var PROJECTION_PUBLISH_DEFAULT_INTERVAL_SECONDS = 300;
+var PROJECTION_PUBLISH_MIN_INTERVAL_SECONDS = 30;
 var CLI_COMMAND_FLAGS = {
   debt: { value: ["--changed-path"], boolean: [] },
   "agent-context": { value: ["--expected-worktree-digest", "--id", "--task-session-id"], boolean: ["--approved"] },
@@ -59724,7 +60975,10 @@ var CLI_COMMAND_FLAGS = {
       recover: { value: ["--request-json"], boolean: [] },
       readback: { value: ["--request-json"], boolean: [] },
       snapshot: { value: [], boolean: [] },
-      freshness: { value: ["--changed-path"], boolean: [] }
+      freshness: { value: ["--changed-path"], boolean: [] },
+      publish: { value: PROJECTION_PUBLISH_VALUE_FLAGS, boolean: PROJECTION_PUBLISH_BOOLEAN_FLAGS },
+      "publish-status": { value: PROJECTION_PUBLISH_STATUS_VALUE_FLAGS, boolean: [] },
+      "verify-pr": { value: PROJECTION_VERIFY_PR_VALUE_FLAGS, boolean: [] }
     }
   },
   recommendations: {
@@ -59859,6 +61113,48 @@ var CLI_PROJECTION_FRESHNESS_HELP = {
   writes: "none; no daemon, no local store, no CodeGraph sync. Outside a Git worktree it fails with AC_REPO_NOT_FOUND (git-worktree-required).",
   capability: "projection-freshness-v1"
 };
+var CLI_PROJECTION_PUBLISH_HELP = {
+  usage: "archctx projection publish [--base <branch>] [--remote <name>] [--branch <archctx/...>] [--publisher gh|command|none] [--publisher-command <executable>] [--accept-observed-major-change] [--follow [--interval <seconds>]] [--json]",
+  description: "Projection writer mode. Fetches the remote base tip, resets a writer-owned worktree to it, applies the projection through that worktree's archctxd, and pushes the result as exactly one commit on top of the base tip to a rolling archctx/* branch, then opens or updates its pull request. Only paths the apply wrote that are projection-owned outputs may change; anything else fails before a commit. One run per remote and base at a time (busy otherwise); the same base SHA is a no-op once published or up to date; a base that moves during the run is re-evaluated and the stale commit is never pushed.",
+  options: {
+    "--base <branch>": "The branch the projection is computed for (default: main).",
+    "--remote <name>": "The remote to fetch the base from and push the rolling branch to (default: origin).",
+    "--branch <archctx/...>": "The rolling branch (default: archctx/projection). It must start with archctx/ and differ from --base; the writer never pushes to any other ref.",
+    "--publisher gh|command|none": "gh (default): the operator's own gh lists, then edits or creates the pull request. command: run --publisher-command. none: push only.",
+    "--publisher-command <executable>": "With --publisher command: an executable run with no shell or arguments in the owned worktree, with PATH, HOME and ARCHCTX_PUBLISH_REMOTE/BASE/BRANCH/BASE_SHA/COMMIT/TITLE/BODY_FILE only (on Windows also SystemRoot, windir, ComSpec, PATHEXT, TEMP, TMP, USERPROFILE; #! scripts run through their interpreter on PATH; .cmd/.bat are rejected). Optional stdout: a JSON object {url?, number?}.",
+    "--accept-observed-major-change": "Accept the major change the run observes (ProjectionRequestV1.acceptObservedMajorChange). Without it a major change stops at human-action-required and nothing is pushed.",
+    "--follow": "Run as a foreground loop: one publish per --interval, one JSON envelope line per run on stdout, until SIGINT or SIGTERM. For launchd/systemd KeepAlive on an always-on host.",
+    "--interval <seconds>": `With --follow: seconds between runs (default ${PROJECTION_PUBLISH_DEFAULT_INTERVAL_SECONDS}, minimum ${PROJECTION_PUBLISH_MIN_INTERVAL_SECONDS}).`,
+    "--json": "Accepted for symmetry; output is always JSON.",
+    "--help, -h": "Show help without fetching, pushing or starting a daemon."
+  },
+  results: "published, up-to-date, already-processed, human-action-required, busy (ok) or failed (ok: false with the run as data).",
+  writes: "the writer state, lock and owned worktree under the repository runtime state directory; one commit on the owned worktree; a push to refs/heads/<--branch> only. Outbound: the projection-publishing egress channel (git fetch/ls-remote/push, gh, the publisher command); ARCHCONTEXT_EGRESS_MODE=local-only refuses it with AC_POLICY_VIOLATION. archctx stores no credentials. It never runs codegraph init; when code facts are required, run codegraph init <worktreePath> once (see projection publish-status).",
+  capability: "projection-publish-v1"
+};
+var CLI_PROJECTION_PUBLISH_STATUS_HELP = {
+  usage: "archctx projection publish-status [--base <branch>] [--remote <name>] [--json]",
+  description: "Read-only state of the projection writer for one remote and base: the owned worktree path, a running writer's pid, the last processed and last successful base SHAs and the last run.",
+  options: {
+    "--base <branch>": "Default: main.",
+    "--remote <name>": "Default: origin.",
+    "--json": "Accepted for symmetry; output is always JSON.",
+    "--help, -h": "Show help without reading anything."
+  },
+  writes: "none; no fetch, no daemon.",
+  capability: "projection-publish-v1"
+};
+var CLI_PROJECTION_VERIFY_PR_HELP = {
+  usage: "archctx projection verify-pr --base <ref> [--json]",
+  description: "Checks the checked-out pull request head (HEAD, clean tracked worktree) against --base. A changed path is generated only when it is the projection manifest, a manifest target path or an agent-context target path at HEAD or at the merge base, and, for a mixed-ownership target, its text outside the generated regions is unchanged (otherwise it is listed in humanEditedPaths). Only a generated-only diff is rendered (projection check, plus the agent-context render for changed contract files). verdict is no-changes, touches-non-generated (answered from the diff alone, nothing rendered), generated-only-render-equivalent (generated files and regions equal a fresh render and no text outside them changed) or generated-only-not-render-equivalent. A mixed target that is added or deleted, or whose markers do not parse, is conservatively a human edit. The envelope is ok for every valid evaluation; the verdict carries the decision.",
+  options: {
+    "--base <ref>": "Required. The pull request base, for example origin/main.",
+    "--json": "Accepted for symmetry; output is always JSON.",
+    "--help, -h": "Show help without reading the repository."
+  },
+  writes: "none; no daemon, no local store. A dirty tracked worktree fails with AC_PRECONDITION_FAILED. A generated-only diff renders in-process like projection check, so it needs code facts when the manifest requires them.",
+  capability: "projection-verify-pr-v1"
+};
 function refactorFlagValue(args, flag) {
   const index = args.indexOf(flag);
   if (index === -1)
@@ -59995,14 +61291,14 @@ async function runCliUnchecked(command = "help", args = [], cwd, deps = {}) {
       case "status":
         return (await runtime()).runtimeStatus(cwd);
       case "projection":
-        return await runProjectionProtocolCommand2(args, cwd, runtime);
+        return await runProjectionProtocolCommand2(args, cwd, runtime, deps);
       case "flows":
         return runFlowsCommand(args, cwd);
       case "repo": {
         const subcommand = args[0] ?? "list";
         if (subcommand === "add") {
           const root = readFlag(args, "--root") ?? cwd;
-          if (resolve34(root) !== resolve34(cwd)) {
+          if (resolve35(root) !== resolve35(cwd)) {
             return errorEnvelope("repo.add", "AC_CAPABILITY_UNSUPPORTED", "Multi-repo architecture context is outside the Local Core MVP; run archctx inside one Git repository.");
           }
           const daemon = await runtime();
@@ -60244,7 +61540,7 @@ async function runCliUnchecked(command = "help", args = [], cwd, deps = {}) {
           const read = await readResolvePathsFrom(args, cwd, deps);
           if ("problem" in read)
             return errorEnvelope("resolve", "AC_SCHEMA_INVALID", read.problem);
-          const model = loadNativeModelFromArchContext(cwd);
+          const model = loadResolveModel(cwd);
           const outcomes = resolveArchitectureOwnersForPaths(model.nodes, read.paths);
           return okEnvelope("resolve", { results: outcomes.map((outcome, index) => resolveResultData(read.paths[index], outcome)) });
         }
@@ -60254,7 +61550,7 @@ async function runCliUnchecked(command = "help", args = [], cwd, deps = {}) {
         if (!isRepoRelativePosixPath(path)) {
           return errorEnvelope("resolve", "AC_SCHEMA_INVALID", "resolve --path must be a repository-relative POSIX path");
         }
-        const model = loadNativeModelFromArchContext(cwd);
+        const model = loadResolveModel(cwd);
         return okEnvelope("resolve", resolveResultData(path, resolveArchitectureOwnerForPath(model.nodes, path)));
       }
       case "help":
@@ -60346,6 +61642,12 @@ function cliHelpEnvelope(command, args) {
     case "projection":
       if (subcommand === "freshness")
         return okEnvelope("help", CLI_PROJECTION_FRESHNESS_HELP);
+      if (subcommand === "publish")
+        return okEnvelope("help", CLI_PROJECTION_PUBLISH_HELP);
+      if (subcommand === "publish-status")
+        return okEnvelope("help", CLI_PROJECTION_PUBLISH_STATUS_HELP);
+      if (subcommand === "verify-pr")
+        return okEnvelope("help", CLI_PROJECTION_VERIFY_PR_HELP);
       break;
     case "daemon":
       return okEnvelope("daemon", {
@@ -61062,8 +62364,10 @@ async function runAgentContextProjectionCommand2(args, cwd, daemon) {
     expectedWorktreeDigest: readFlag(args, "--expected-worktree-digest")
   });
 }
-async function runProjectionProtocolCommand2(args, cwd, runtime) {
+async function runProjectionProtocolCommand2(args, cwd, runtime, deps) {
   const action = args[0] ?? "run";
+  if (action === "publish" || action === "publish-status" || action === "verify-pr")
+    return runProjectionWriterCliCommand(action, args.slice(1), cwd, deps);
   if (action === "snapshot") {
     const unexpected = args.slice(1).filter((arg) => arg !== "--json");
     if (unexpected.length > 0)
@@ -61073,7 +62377,7 @@ async function runProjectionProtocolCommand2(args, cwd, runtime) {
   if (action === "freshness")
     return runProjectionFreshnessCliCommand(args.slice(1), cwd);
   if (!["run", "recover", "readback"].includes(action))
-    return errorEnvelope("projection", "AC_SCHEMA_INVALID", "projection requires run|recover|readback --request-json <request>, or snapshot|freshness [--json]");
+    return errorEnvelope("projection", "AC_SCHEMA_INVALID", "projection requires run|recover|readback --request-json <request>, snapshot|freshness [--json], or publish|publish-status|verify-pr");
   const raw = readFlag(args, "--request-json");
   if (!raw)
     return errorEnvelope(`projection.${action}`, "AC_SCHEMA_INVALID", `projection ${action} requires --request-json`);
@@ -61110,6 +62414,145 @@ function runProjectionFreshnessCliCommand(args, cwd) {
   }
   return runProjectionFreshnessCommand(cwd, changedPaths.length > 0 ? { changedPaths } : {});
 }
+async function runProjectionWriterCliCommand(action, args, cwd, deps) {
+  const requestId = `projection.${action}`;
+  const valueFlags = action === "publish" ? PROJECTION_PUBLISH_VALUE_FLAGS : action === "publish-status" ? PROJECTION_PUBLISH_STATUS_VALUE_FLAGS : PROJECTION_VERIFY_PR_VALUE_FLAGS;
+  const stray = projectionWriterStrayToken(args, valueFlags);
+  if (stray !== undefined)
+    return errorEnvelope(requestId, "AC_SCHEMA_INVALID", `projection ${action} does not accept ${stray}; use --help`, "cli-input-invalid");
+  if (action === "verify-pr") {
+    const base = readFlag(args, "--base");
+    if (!base)
+      return errorEnvelope(requestId, "AC_SCHEMA_INVALID", "projection verify-pr requires --base <ref>", "cli-input-invalid");
+    return runProjectionVerifyPrCommand({ cwd, base });
+  }
+  if (action === "publish-status") {
+    return runProjectionPublishStatusCommand({ cwd, base: readFlag(args, "--base"), remote: readFlag(args, "--remote") });
+  }
+  const parsed = parseProjectionPublishCliInput(args, cwd);
+  if (!parsed.ok)
+    return parsed.envelope;
+  if (parsed.input.follow) {
+    return errorEnvelope(requestId, "AC_SCHEMA_INVALID", "projection publish --follow is a foreground process loop of the archctx executable; without --follow this command runs once", "cli-input-invalid");
+  }
+  return runProjectionPublishOnce(parsed.input, cwd, deps);
+}
+function projectionWriterStrayToken(args, valueFlags) {
+  for (let index = 0;index < args.length; index += 1) {
+    const token = args[index];
+    if (valueFlags.includes(token) || token === "--format") {
+      index += 1;
+      continue;
+    }
+    if (isCliFlagToken(token))
+      continue;
+    return token;
+  }
+  return;
+}
+function parseProjectionPublishCliInput(args, cwd) {
+  const invalid = (message) => ({ ok: false, envelope: errorEnvelope("projection.publish", "AC_SCHEMA_INVALID", message, "cli-input-invalid") });
+  const publisherKind = readFlag(args, "--publisher") ?? "gh";
+  const publisherCommand = readFlag(args, "--publisher-command");
+  const follow = args.includes("--follow");
+  const intervalFlag = readFlag(args, "--interval");
+  if (intervalFlag !== undefined && !follow)
+    return invalid("projection publish --interval requires --follow");
+  const intervalSeconds = intervalFlag === undefined ? PROJECTION_PUBLISH_DEFAULT_INTERVAL_SECONDS : Number(intervalFlag);
+  if (!/^\d+$/.test(intervalFlag ?? "0") || !Number.isSafeInteger(intervalSeconds) || intervalSeconds < PROJECTION_PUBLISH_MIN_INTERVAL_SECONDS) {
+    return invalid(`projection publish --interval must be an integer number of seconds, at least ${PROJECTION_PUBLISH_MIN_INTERVAL_SECONDS}`);
+  }
+  let publisher;
+  if (publisherKind === "gh" || publisherKind === "none") {
+    if (publisherCommand !== undefined)
+      return invalid("projection publish --publisher-command requires --publisher command");
+    publisher = publisherKind === "gh" ? createGhProjectionPublisher() : createNoneProjectionPublisher();
+  } else if (publisherKind === "command") {
+    if (!publisherCommand)
+      return invalid("projection publish --publisher command requires --publisher-command <executable>");
+    const command = resolve35(cwd, publisherCommand);
+    if (!existsSync35(command) || !statSync11(command).isFile())
+      return invalid(`projection publish --publisher-command is not a file: ${command}`);
+    publisher = createCommandProjectionPublisher({ command });
+  } else {
+    return invalid("projection publish --publisher must be gh, command or none");
+  }
+  return {
+    ok: true,
+    input: {
+      remote: readFlag(args, "--remote"),
+      base: readFlag(args, "--base"),
+      branch: readFlag(args, "--branch"),
+      publisher,
+      acceptObservedMajorChange: args.includes("--accept-observed-major-change"),
+      follow,
+      intervalSeconds
+    }
+  };
+}
+function runProjectionPublishOnce(input, cwd, deps) {
+  const clients = new Map;
+  return runProjectionPublishCommand({
+    cwd,
+    remote: input.remote,
+    base: input.base,
+    branch: input.branch,
+    publisher: input.publisher,
+    acceptObservedMajorChange: input.acceptObservedMajorChange,
+    apply: async (worktree, request) => {
+      let client = deps.runtimeClient ?? clients.get(worktree);
+      if (!client) {
+        client = await createOrStartRuntimeRpcClient(worktree);
+        clients.set(worktree, client);
+      }
+      return client.projection(worktree, { action: "run", request });
+    }
+  });
+}
+async function runProjectionPublishFollowEntry(args, cwd) {
+  const stray = projectionWriterStrayToken(args, PROJECTION_PUBLISH_VALUE_FLAGS);
+  const parsed = stray === undefined ? parseProjectionPublishCliInput(args, cwd) : { ok: false, envelope: errorEnvelope("projection.publish", "AC_SCHEMA_INVALID", `projection publish does not accept ${stray}; use --help`, "cli-input-invalid") };
+  if (!parsed.ok) {
+    process.stdout.write(`${JSON.stringify(parsed.envelope)}
+`);
+    return 1;
+  }
+  const controller = new AbortController;
+  const stop = () => controller.abort();
+  process.on("SIGINT", stop);
+  process.on("SIGTERM", stop);
+  try {
+    await runProjectionPublishFollow({
+      runOnce: () => runProjectionPublishOnce(parsed.input, cwd, {}),
+      intervalMs: parsed.input.intervalSeconds * 1000,
+      sleep: (ms) => sleepUnlessAborted(ms, controller.signal),
+      shouldStop: () => controller.signal.aborted,
+      onResult: (envelope) => {
+        process.stdout.write(`${JSON.stringify(envelope)}
+`);
+      }
+    });
+  } finally {
+    process.off("SIGINT", stop);
+    process.off("SIGTERM", stop);
+  }
+  return 0;
+}
+function sleepUnlessAborted(ms, signal) {
+  return new Promise((resolvePromise) => {
+    if (signal.aborted) {
+      resolvePromise();
+      return;
+    }
+    const timer = setTimeout(done, ms);
+    function done() {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", done);
+      resolvePromise();
+    }
+    signal.addEventListener("abort", done, { once: true });
+  });
+}
 function runFlowsCommand(args, cwd) {
   const formatAt = args.indexOf("--format");
   const unexpected = args.slice(1).filter((arg, index) => arg !== "--json" && (formatAt < 0 || index + 1 !== formatAt && index !== formatAt));
@@ -61473,12 +62916,12 @@ function auditManifestGateRoot(cwd) {
   }
 }
 function auditGithubIssuesEnabled(cwd) {
-  const manifestPath = resolve34(auditManifestGateRoot(cwd), ".archcontext/manifest.yaml");
-  if (!existsSync34(manifestPath))
+  const manifestPath = resolve35(auditManifestGateRoot(cwd), ".archcontext/manifest.yaml");
+  if (!existsSync35(manifestPath))
     return false;
   let raw;
   try {
-    raw = readFileSync31(manifestPath, "utf8");
+    raw = readFileSync32(manifestPath, "utf8");
   } catch {
     return false;
   }
@@ -61763,8 +63206,8 @@ async function runGithubCommand(args, cwd, deps) {
   }
   if (subcommand === "disconnect") {
     const connection = await deps.githubConnectionReader?.readVerifiedConnection({ repositoryRoot: cwd });
-    const localRecordRemoved = existsSync34(connectionPath);
-    rmSync15(connectionPath, { force: true });
+    const localRecordRemoved = existsSync35(connectionPath);
+    rmSync16(connectionPath, { force: true });
     return okEnvelope("github.disconnect", {
       connected: connection !== undefined,
       localRecordRemoved,
@@ -62051,7 +63494,7 @@ async function digestReviewChallenge(challenge) {
   return reviewChallengeV2Digest(challenge);
 }
 function defaultGithubConnectionPath(cwd) {
-  return join26(dirname16(defaultDaemonConnectionPath(cwd)), "github-connection.json");
+  return join27(dirname16(defaultDaemonConnectionPath(cwd)), "github-connection.json");
 }
 function sanitizeGithubConnection(record, connectionPath) {
   return {
@@ -62075,7 +63518,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 ?? readFileSync31(resolve34(cwd, challengePath), "utf8");
+    const raw = inline ?? readFileSync32(resolve35(cwd, challengePath), "utf8");
     const parsed = JSON.parse(raw);
     const attestation = await Promise.resolve().then(() => (init_src6(), {}));
     const assertReviewChallengeV2 = assertReviewChallengeV22;
@@ -62459,7 +63902,7 @@ function readLatestPackageVersion(env) {
   if (env[LATEST_VERSION_ENV]) {
     return { source: "env", version: env[LATEST_VERSION_ENV] };
   }
-  const result = withLocalEgress("npm-update-check", () => spawnSync5("npm", ["view", RELEASE_PACKAGE_NAME, "version", "--json"], {
+  const result = withLocalEgress("npm-update-check", () => spawnSync6("npm", ["view", RELEASE_PACKAGE_NAME, "version", "--json"], {
     encoding: "utf8",
     timeout: NPM_VIEW_TIMEOUT_MS,
     shell: false
@@ -62553,10 +63996,10 @@ function doctorSqlite(cwd) {
   const legacyLocalStore = inspectLegacyLocalStoreMigration(cwd);
   return {
     path,
-    exists: existsSync34(path),
+    exists: existsSync35(path),
     migrations: productVersionManifest().runtime.sqliteMigrations,
     legacyPath: paths.legacyLocalStorePath,
-    legacyExists: existsSync34(paths.legacyLocalStorePath),
+    legacyExists: existsSync35(paths.legacyLocalStorePath),
     legacyLocalStore
   };
 }
@@ -62577,8 +64020,8 @@ function runtimePathsReport(cwd) {
     ...paths,
     legacyLocalStore: inspectLegacyLocalStoreMigration(cwd),
     runtimeRepositoryId: repositoryFingerprint2(paths.repositoryRoot),
-    repositoryTruthDir: join26(paths.repositoryRoot, ".archcontext"),
-    codeGraphIndexDir: join26(paths.repositoryRoot, ".codegraph"),
+    repositoryTruthDir: join27(paths.repositoryRoot, ".archcontext"),
+    codeGraphIndexDir: join27(paths.repositoryRoot, ".codegraph"),
     npmGlobalInstallState: "forbidden",
     overrides: {
       stateRootEnv: "ARCHCONTEXT_STATE_DIR",
@@ -62587,7 +64030,7 @@ function runtimePathsReport(cwd) {
   };
 }
 function pathAccess(path) {
-  const exists = existsSync34(path);
+  const exists = existsSync35(path);
   return {
     path,
     exists,
@@ -62828,7 +64271,7 @@ function daemonStopStateDir(args, cwd) {
     return { ok: false, envelope: errorEnvelope("daemon.stop", "AC_SCHEMA_INVALID", "daemon stop accepts at most one of --state-dir or --workspace-id") };
   }
   if (stateDir !== undefined)
-    return { ok: true, stateDir: resolve34(cwd, stateDir) };
+    return { ok: true, stateDir: resolve35(cwd, stateDir) };
   if (workspaceId === undefined)
     return { ok: true };
   if (!/^ws\.[0-9a-f]{16}$/.test(workspaceId)) {
@@ -62864,9 +64307,9 @@ async function startBackgroundDaemon(args, cwd) {
   const recovery = discovered.recovery;
   const connectionPath = defaultDaemonConnectionPath(cwd);
   const controlDir = dirname16(connectionPath);
-  const logPath = join26(controlDir, "archctxd.log");
-  mkdirSync13(controlDir, { recursive: true });
-  const logFd = openSync12(logPath, "a", 384);
+  const logPath = join27(controlDir, "archctxd.log");
+  mkdirSync14(controlDir, { recursive: true });
+  const logFd = openSync13(logPath, "a", 384);
   try {
     let childExit;
     let childError;
@@ -62906,7 +64349,7 @@ async function startBackgroundDaemon(args, cwd) {
       ...recoveryData(recovery)
     });
   } finally {
-    closeSync12(logFd);
+    closeSync13(logFd);
   }
 }
 async function upgradeDaemon(args, cwd) {
@@ -62915,7 +64358,7 @@ async function upgradeDaemon(args, cwd) {
   const record = readRuntimeRpcConnectionFile(cwd);
   const unchanged = () => JSON.stringify(readRuntimeRpcConnectionFile(cwd)) === JSON.stringify(record);
   const refuse = (reason) => errorEnvelope("daemon.upgrade", "AC_RUNTIME_VERSION_UNSUPPORTED", `Daemon ownership is unproven (${reason}); no process was signalled and no replacement was started. Run the previous archctx daemon stop, or verify and stop the original daemon in its owning terminal, then run archctx daemon upgrade.`, "daemon-ownership-unproven");
-  if (existsSync34(connectionPath) && (!record || typeof record.pid !== "number" || !Number.isInteger(record.pid) || record.pid <= 0)) {
+  if (existsSync35(connectionPath) && (!record || typeof record.pid !== "number" || !Number.isInteger(record.pid) || record.pid <= 0)) {
     return refuse("connection record cannot prove a daemon identity");
   }
   let lockOwner;
@@ -62965,9 +64408,9 @@ async function upgradeDaemon(args, cwd) {
     if (!stopped.ok)
       return refuse("live instance refused the expected identity");
     const deadline = Date.now() + daemonStartTimeoutMs(args);
-    while (existsSync34(connectionPath) || existsSync34(lockPath)) {
+    while (existsSync35(connectionPath) || existsSync35(lockPath)) {
       const current = readRuntimeRpcConnectionFile(cwd);
-      if (current ? JSON.stringify(current) !== JSON.stringify(record) : existsSync34(connectionPath)) {
+      if (current ? JSON.stringify(current) !== JSON.stringify(record) : existsSync35(connectionPath)) {
         return refuse("connection changed or cannot be verified during self-stop");
       }
       const owner = liveDaemonLockOwnerPid(cwd);
@@ -62987,7 +64430,7 @@ async function upgradeDaemon(args, cwd) {
     const started = await startBackgroundDaemon(args, cwd);
     return started.ok ? { ...started, requestId: "daemon.upgrade", data: { ...started.data, upgraded: false, reason: "runtime-compatible" } } : started;
   }
-  if (selfStopped ? existsSync34(connectionPath) || existsSync34(lockPath) : !unchanged() || record?.pid !== undefined && isPidAlive(record.pid) || liveDaemonLockOwnerPid(cwd) !== undefined) {
+  if (selfStopped ? existsSync35(connectionPath) || existsSync35(lockPath) : !unchanged() || record?.pid !== undefined && isPidAlive(record.pid) || liveDaemonLockOwnerPid(cwd) !== undefined) {
     return refuse("ownership changed before replacement");
   }
   const recovery = recoverStaleDaemonControlFiles(cwd, { removeUnhealthyConnection: true });
@@ -63153,7 +64596,7 @@ function daemonStartTimeoutMs(args) {
 }
 function daemonStartFailureMessage(cwd, logPath, childPid, childExit, childError) {
   const childState = childError ? `childError=${childError.message}` : childExit ? `childExit=${childExit.code ?? "null"}/${childExit.signal ?? "none"}` : "childState=still-running";
-  const lockOwnerPid = existsSync34(defaultDaemonConnectionPath(cwd)) ? undefined : liveDaemonLockOwnerPid(cwd);
+  const lockOwnerPid = existsSync35(defaultDaemonConnectionPath(cwd)) ? undefined : liveDaemonLockOwnerPid(cwd);
   const owner = lockOwnerPid === undefined || lockOwnerPid === childPid ? "" : `; ${orphanedDaemonMessage(lockOwnerPid)}`;
   return `archctxd did not become ready; ${childState}${owner}; log=${logPath}; logTail=${readFileTail(logPath)}`;
 }
@@ -63174,7 +64617,7 @@ function sleep2(ms) {
 }
 function readFileTail(path, maxBytes = 4096) {
   try {
-    const content = readFileSync31(path, "utf8");
+    const content = readFileSync32(path, "utf8");
     return content.slice(Math.max(0, content.length - maxBytes)).replace(/\s+/g, " ").trim();
   } catch {
     return "<unavailable>";
@@ -63259,7 +64702,7 @@ function resolveCommandExitCode(result) {
     return 2;
   return 1;
 }
-var CLI_HELP_EXAMPLES = ["archctx init --name MyApp", "archctx projection run --request-json '{...}'", "archctx projection snapshot --json", "archctx projection freshness --json", "archctx projection freshness --changed-path src/app.ts --json", "archctx plan --id changeset.<id> --op update_entity_fields --path .archcontext/model/nodes/<node>.yaml --expected-hash sha256:<64-hex> --body '<complete YAML>'", "archctx plan --id changeset.<id> --op delete_entity --path .archcontext/model/flows/<flow>.yaml --expected-hash sha256:<64-hex>", "archctx hash --path .archcontext/model/nodes/<node>.yaml", "archctx plan --id changeset.<id> --operations-file <operations.json>", "archctx plan --id changeset.<id> --op update_entity_fields --path .archcontext/model/nodes/<node>.yaml --expected-hash sha256:<64-hex> --body-file <entity.yaml>", "archctx apply --id changeset.<id> --approved --expected-worktree-digest <draft.base.worktreeDigest>", "archctx state recover --from-git", "archctx ledger migrate --from-yaml --dry-run", "archctx ledger promote --mode authoritative --preflight --rollback-plan", "archctx book recommendations --open --explain", "archctx recommendations accept --id recommendation.<id> --reason 'Accepted after local readback.'", "archctx recommendations metrics", "archctx recommendations list --status rejected", "archctx refactor scan --json", "archctx refactor verify --request-json '{...}' --json", "archctx practices validate --strict", "archctx practices list --json", "archctx practices waivers", "archctx practices waive --practice-id modularity.no-new-cycle --owner team-architecture --reason 'External migration window requires this edge until cutover.' --review-at 2026-07-10T00:00:00.000Z --expires-at 2026-07-24T00:00:00.000Z --evidence-digest sha256:<64-hex> --subject module.a->module.b", "archctx checkpoint --changed-path src/app.ts", "archctx practices checkpoint --task-session-id task_cli", "archctx investigate --runner-port codex", "archctx agents status --status queued,running", "archctx agents budget", "archctx hook enqueue --event post-edit --path src/app.ts", "archctx jobs list --status queued", "archctx audit consent", "archctx audit consent --revoke", "archctx audit run --reason 'quarterly architecture audit'", "archctx audit run --no-wait", "archctx audit list --status pending", "archctx audit show audit_run.<id>", "archctx audit approve audit_run.<id>", "archctx audit approve audit_run.<id> --confirm-public-repo public:<host>/<owner>/<repo>:<baseSha>:<runId>", "archctx audit approve audit_run.<id> --resume", "archctx hooks install --host codex", "archctx paths", "archctx update --check", "archctx doctor --check-updates", "archctx github connect", "archctx github status", "archctx daemon start", "archctx explore start --foreground", "archctx docs anchors --json", "archctx export native --worktree --json", "archctx export native --ref HEAD --profile repo-harness/v1 --json", "archctx export likec4", "archctx import structurizr --content '<json>'", "archctx resolve --path packages/core/projection-engine/src/index.ts", "archctx tunnel", "archctx refactor scan --import-node-limit 100000 --json", "archctx resolve --paths-from changed-paths.txt", "archctx flows check --json", "archctx recommendations defer --id recommendation.<id> --import-node-limit 100000 --reason 'Scanned with the same limit.'", "archctx deps --json", "archctx deps --into capability.<id> --json"];
+var CLI_HELP_EXAMPLES = ["archctx init --name MyApp", "archctx projection run --request-json '{...}'", "archctx projection snapshot --json", "archctx projection freshness --json", "archctx projection freshness --changed-path src/app.ts --json", "archctx projection publish --json", "archctx projection publish --publisher none --json", "archctx projection publish --follow --interval 300", "archctx projection publish-status --json", "archctx projection verify-pr --base origin/main --json", "archctx plan --id changeset.<id> --op update_entity_fields --path .archcontext/model/nodes/<node>.yaml --expected-hash sha256:<64-hex> --body '<complete YAML>'", "archctx plan --id changeset.<id> --op delete_entity --path .archcontext/model/flows/<flow>.yaml --expected-hash sha256:<64-hex>", "archctx hash --path .archcontext/model/nodes/<node>.yaml", "archctx plan --id changeset.<id> --operations-file <operations.json>", "archctx plan --id changeset.<id> --op update_entity_fields --path .archcontext/model/nodes/<node>.yaml --expected-hash sha256:<64-hex> --body-file <entity.yaml>", "archctx apply --id changeset.<id> --approved --expected-worktree-digest <draft.base.worktreeDigest>", "archctx state recover --from-git", "archctx ledger migrate --from-yaml --dry-run", "archctx ledger promote --mode authoritative --preflight --rollback-plan", "archctx book recommendations --open --explain", "archctx recommendations accept --id recommendation.<id> --reason 'Accepted after local readback.'", "archctx recommendations metrics", "archctx recommendations list --status rejected", "archctx refactor scan --json", "archctx refactor verify --request-json '{...}' --json", "archctx practices validate --strict", "archctx practices list --json", "archctx practices waivers", "archctx practices waive --practice-id modularity.no-new-cycle --owner team-architecture --reason 'External migration window requires this edge until cutover.' --review-at 2026-07-10T00:00:00.000Z --expires-at 2026-07-24T00:00:00.000Z --evidence-digest sha256:<64-hex> --subject module.a->module.b", "archctx checkpoint --changed-path src/app.ts", "archctx practices checkpoint --task-session-id task_cli", "archctx investigate --runner-port codex", "archctx agents status --status queued,running", "archctx agents budget", "archctx hook enqueue --event post-edit --path src/app.ts", "archctx jobs list --status queued", "archctx audit consent", "archctx audit consent --revoke", "archctx audit run --reason 'quarterly architecture audit'", "archctx audit run --no-wait", "archctx audit list --status pending", "archctx audit show audit_run.<id>", "archctx audit approve audit_run.<id>", "archctx audit approve audit_run.<id> --confirm-public-repo public:<host>/<owner>/<repo>:<baseSha>:<runId>", "archctx audit approve audit_run.<id> --resume", "archctx hooks install --host codex", "archctx paths", "archctx update --check", "archctx doctor --check-updates", "archctx github connect", "archctx github status", "archctx daemon start", "archctx explore start --foreground", "archctx docs anchors --json", "archctx export native --worktree --json", "archctx export native --ref HEAD --profile repo-harness/v1 --json", "archctx export likec4", "archctx import structurizr --content '<json>'", "archctx resolve --path packages/core/projection-engine/src/index.ts", "archctx tunnel", "archctx refactor scan --import-node-limit 100000 --json", "archctx resolve --paths-from changed-paths.txt", "archctx flows check --json", "archctx recommendations defer --id recommendation.<id> --import-node-limit 100000 --reason 'Scanned with the same limit.'", "archctx deps --json", "archctx deps --into capability.<id> --json"];
 var CLI_RESOLVE_HELP = {
   command: "archctx resolve (--path <repo-relative path> | --paths-from <file> | --paths-from -)",
   rule: "ADR-0043. source.exclude applies first. When every matching node lies on one parent chain, the deepest node owns the path; refactor scan uses the same rule. When matching nodes lie on different chains, an ancestor yields to its own descendant, then the longest literal source.include prefix wins, and an equal-length tie is ambiguous.",
@@ -63267,6 +64710,37 @@ var CLI_RESOLVE_HELP = {
   result: "Each result carries path, matched, ambiguous and owningCapabilityId. A match adds stableId, kind, name, source and extensions of the most specific node. An ambiguous result adds candidates. owningCapabilityId is the nearest kind: capability node on the owner's parent chain (the owner itself when it is a capability), or null. For an ambiguous result it is set only when all candidates share one owning capability.",
   exitCodes: "--path: 0 matched, 1 no match or error, 2 ambiguous. --paths-from: 0 when no path is ambiguous (unowned paths included), 2 when any path is ambiguous, 1 on error."
 };
+function loadResolveModel(cwd) {
+  if (!existsSync35(join27(cwd, ".archcontext/manifest.yaml"))) {
+    throw new NativeContextError("native-context-model-missing", { path: ".archcontext/manifest.yaml" });
+  }
+  let model;
+  try {
+    model = loadNativeModelFromArchContext(cwd);
+  } catch (error) {
+    const cause = error;
+    if (typeof cause?.code === "string") {
+      throw new NativeContextError("native-context-input-unreadable", {
+        category: "open-or-read",
+        ...typeof cause.path === "string" ? { path: cause.path } : {}
+      });
+    }
+    throw new NativeContextError("native-context-model-invalid", { invariant: "model-parse" });
+  }
+  if (model.nodes.length === 0) {
+    throw new NativeContextError("native-context-model-missing", { category: "no-native-nodes" });
+  }
+  for (const node of model.nodes) {
+    const { issues } = validateJsonSchema(architecture_node_schema_default2, node);
+    if (issues.length > 0) {
+      throw new NativeContextError("native-context-model-invalid", {
+        issues: issues.slice(0, 32).map((issue) => ({ entityId: typeof node.id === "string" ? node.id : "(undeclared)", field: issue.path, invariant: issue.message })),
+        omittedDiagnosticCount: Math.max(0, issues.length - 32)
+      });
+    }
+  }
+  return model;
+}
 function resolveResultData(path, outcome) {
   if (outcome.status === "matched") {
     const node = outcome.node;
@@ -63293,7 +64767,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() : readFileSync31(0, "utf8")) : readFileSync31(resolve34(cwd, source), "utf8");
+    content = source === "-" ? await (deps.readStdin ? deps.readStdin() : readFileSync32(0, "utf8")) : readFileSync32(resolve35(cwd, source), "utf8");
   } catch (error) {
     return { problem: `resolve --paths-from ${source} is not readable: ${error instanceof Error ? error.message : String(error)}` };
   }
@@ -63381,7 +64855,7 @@ function readRepositoryInputFile(cwd, flag, file) {
     const absolute = assertPathHasNoSymlinkSegments2(cwd, file);
     if (!statSync11(absolute).isFile())
       return { problem: `plan ${flag} ${file} is not a regular file` };
-    return { content: readFileSync31(absolute, "utf8") };
+    return { content: readFileSync32(absolute, "utf8") };
   } catch (error) {
     return { problem: `plan ${flag} ${file} is not readable: ${error instanceof Error ? error.message : String(error)}` };
   }
@@ -63399,10 +64873,10 @@ function runHashCommand(args, cwd) {
   } catch (error) {
     return errorEnvelope("hash", "AC_SCHEMA_INVALID", error instanceof Error ? error.message : String(error));
   }
-  if (!existsSync34(absolute) || !statSync11(absolute).isFile()) {
+  if (!existsSync35(absolute) || !statSync11(absolute).isFile()) {
     return errorEnvelope("hash", "AC_SCHEMA_INVALID", `hash --path is not an existing file: ${path}`);
   }
-  return okEnvelope("hash", { path, hash: digestJson({ body: readFileSync31(absolute, "utf8") }) });
+  return okEnvelope("hash", { path, hash: digestJson({ body: readFileSync32(absolute, "utf8") }) });
 }
 async function readCliPlanOperations(args, cwd, deps) {
   if (args.includes("--operations-file")) {
@@ -63412,7 +64886,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() : readFileSync31(0, "utf8")) } : readRepositoryInputFile(cwd, "--operations-file", file);
+    const read = file === "-" ? { content: await (deps.readStdin ? deps.readStdin() : readFileSync32(0, "utf8")) } : readRepositoryInputFile(cwd, "--operations-file", file);
     if ("problem" in read)
       return read.problem;
     let parsed;
@@ -63474,7 +64948,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() : readFileSync31(0, "utf8");
+  return deps.readStdin ? deps.readStdin() : readFileSync32(0, "utf8");
 }
 function readFlag(args, flag) {
   const index = args.indexOf(flag);
@@ -63566,6 +65040,8 @@ if (__require.main == __require.module) {
     await runStdioMcpLoop(stdinLines(), (line) => process.stdout.write(`${line}
 `), (line) => process.stderr.write(`${line}
 `), { runtimeResolver: (root, options) => createOrStartRuntimeRpcClient(root, options?.preserveHealthFailure) });
+  } else if (command === "projection" && args[0] === "publish" && args.includes("--follow") && preflightCliArguments(command, args) === undefined) {
+    process.exitCode = await runProjectionPublishFollowEntry(args.slice(1), process.cwd());
   } else if (command === "daemon" && args[0] === "start" && args.includes("--foreground") && preflightCliArguments(command, args) === undefined) {
     await runForegroundDaemon(process.cwd(), args).catch((error) => {
       const message = error instanceof Error ? error.message : String(error);
@@ -63579,6 +65055,8 @@ if (__require.main == __require.module) {
 `);
     if (result.ok === false)
       process.exitCode = 1;
+    if (command === "validate" && result.ok && result.data?.valid === false)
+      process.exitCode = 1;
     if (command === "resolve")
       process.exitCode = resolveCommandExitCode(result);
   }