archctx 0.8.1 → 0.9.0

package/bin/archctx.mjs

@@ -1753,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",
@@ -3363,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 = [];
@@ -3867,7 +3873,7 @@ function compareVersionTriples(left, right) {
   }
   return 0;
 }
-var ARCHCONTEXT_PRODUCT_NAME = "archctx", ARCHCONTEXT_PRODUCT_VERSION = "0.8.1", 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") {
@@ -4969,6 +4975,7 @@ var init_src = __esm(() => {
   init_ports();
   init_projection();
   init_projection_recovery();
+  init_projection_writer();
   init_projection_manifest();
   init_refactor();
   init_schema();
@@ -15377,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 {
 }
@@ -21015,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);
@@ -22998,7 +23015,7 @@ function isGitWorktreeError(error) {
 
 // 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 {
 }
@@ -33880,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 });
@@ -34566,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" });
@@ -34600,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
@@ -34617,6 +34649,7 @@ init_ownership_dependencies();
 init_ports();
 init_projection();
 init_projection_recovery();
+init_projection_writer();
 init_projection_manifest();
 init_refactor();
 init_schema();
@@ -54326,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";
@@ -54449,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();
@@ -55052,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 {
@@ -55722,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;
@@ -55843,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$/;
@@ -55916,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 })]));
@@ -55925,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) {
@@ -56429,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: {
@@ -56868,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;
@@ -56926,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()));
     }
@@ -56939,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) => {
@@ -56991,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)
@@ -57033,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();
@@ -57246,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
@@ -57283,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" });
@@ -57437,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}`);
             }
           }
@@ -57696,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;
         }
@@ -57900,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) {
@@ -58389,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;
@@ -58687,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);
@@ -58735,9 +59711,9 @@ 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;
@@ -58774,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;
 }
@@ -58800,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;
   }
@@ -58819,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;
@@ -58865,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;
   }
@@ -58955,7 +59931,7 @@ function inspectRepositoryCodeFacts2(root, options = {}) {
   };
 }
 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([
@@ -59880,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"] },
@@ -59993,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: {
@@ -60128,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)
@@ -60264,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();
@@ -60615,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", {
@@ -61331,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)
@@ -61342,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`);
@@ -61379,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));
@@ -61742,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;
   }
@@ -62032,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,
@@ -62320,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 {
@@ -62344,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;
@@ -62728,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
@@ -62822,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
   };
 }
@@ -62846,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",
@@ -62856,7 +64030,7 @@ function runtimePathsReport(cwd) {
   };
 }
 function pathAccess(path) {
-  const exists = existsSync34(path);
+  const exists = existsSync35(path);
   return {
     path,
     exists,
@@ -63097,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)) {
@@ -63133,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;
@@ -63175,7 +64349,7 @@ async function startBackgroundDaemon(args, cwd) {
       ...recoveryData(recovery)
     });
   } finally {
-    closeSync12(logFd);
+    closeSync13(logFd);
   }
 }
 async function upgradeDaemon(args, cwd) {
@@ -63184,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;
@@ -63234,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);
@@ -63256,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 });
@@ -63422,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)}`;
 }
@@ -63443,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>";
@@ -63528,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.",
@@ -63537,7 +64711,7 @@ var CLI_RESOLVE_HELP = {
   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 (!existsSync34(join26(cwd, ".archcontext/manifest.yaml"))) {
+  if (!existsSync35(join27(cwd, ".archcontext/manifest.yaml"))) {
     throw new NativeContextError("native-context-model-missing", { path: ".archcontext/manifest.yaml" });
   }
   let model;
@@ -63593,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)}` };
   }
@@ -63681,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)}` };
   }
@@ -63699,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")) {
@@ -63712,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;
@@ -63774,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);
@@ -63866,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);