@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-SNGM452K.js

@@ -0,0 +1,2002 @@
+import {
+  acquirePublicationTurn,
+  readPublicationTurn
+} from "./chunk-63DHNHGA.js";
+import {
+  repositoryFromGitHubRemoteUrl
+} from "./chunk-BDPYFAB4.js";
+import {
+  BUCKET_ALIASES,
+  defaultBucketArchivePath,
+  getBuckets
+} from "./chunk-V3KLVK7B.js";
+import {
+  fetchStorageBranch,
+  hasCompletedCheckout,
+  isAncestor,
+  isLinkedWorktree,
+  isStorageLockBusyError,
+  listTopLevelTreeEntries,
+  pathExists,
+  readLastFetchTime,
+  readPorcelainStatus,
+  readWorktreeGitDir,
+  readWorktreeId,
+  refreshDefaultBranchTracking,
+  resolveCommonGitDir,
+  resolveFetchTimeoutMs,
+  resolvePushTimeoutMs,
+  resolveRevision,
+  trackingRef,
+  withStorageLock
+} from "./chunk-BAWJNMWF.js";
+import {
+  resolveDefaultBranch
+} from "./chunk-XGU6PBO5.js";
+import {
+  parseGitStatus,
+  parseGitStatusPaths,
+  parsePorcelainLinePath
+} from "./chunk-5KQETTNS.js";
+import {
+  execGit
+} from "./chunk-MHLEZQQI.js";
+import {
+  isPlanningItemFile
+} from "./chunk-352PCJLK.js";
+import {
+  processOwnershipState
+} from "./chunk-MT2WAIR3.js";
+import {
+  GIT_HOOK_COMMIT_TIMEOUT_MS
+} from "./chunk-I56TH7VM.js";
+import {
+  getStateDir
+} from "./chunk-56WPYDJH.js";
+import {
+  DEFAULT_PRE_COMMIT_POLICY,
+  PUBLISH_OUTCOME_EXIT_CODES,
+  SHARED_BUCKET_NAMES,
+  loadStorageConfig,
+  parseStorageConfigLenient,
+  resolvePreCommitPolicy
+} from "./chunk-7VRJHTGZ.js";
+
+// src/planning/storage/guards.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import yaml2 from "js-yaml";
+
+// src/planning/storage/adopt.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import yaml from "js-yaml";
+var NO_ADOPTION = { moved: [], skippedIdentical: [] };
+function cleanRelativeDir(value) {
+  if (typeof value !== "string") return void 0;
+  const posix3 = path.posix.normalize(value.replace(/\\/g, "/").trim()).replace(/\/+$/, "");
+  if (!posix3 || posix3 === "." || posix3.startsWith("/") || /^[A-Za-z]:/.test(posix3)) {
+    return void 0;
+  }
+  if (posix3 === ".." || posix3.startsWith("../")) return void 0;
+  return posix3;
+}
+async function readSeamBucketPaths(ctx) {
+  const mainSha = ctx.seam?.mainSha;
+  if (!mainSha) return void 0;
+  const shown = await execGit(["show", `${mainSha}:.build-project/config/buckets.yaml`], {
+    cwd: ctx.projectRoot
+  });
+  if (shown.exitCode !== 0) return void 0;
+  let parsed;
+  try {
+    parsed = yaml.load(shown.stdout, { schema: yaml.JSON_SCHEMA });
+  } catch {
+    return void 0;
+  }
+  const buckets = parsed?.buckets;
+  if (!buckets || typeof buckets !== "object") return void 0;
+  const result2 = /* @__PURE__ */ new Map();
+  for (const [name, raw] of Object.entries(buckets)) {
+    const entry = raw ?? {};
+    const dir = cleanRelativeDir(entry.path);
+    const archiveDir = cleanRelativeDir(entry.archivePath);
+    const key = name.toLowerCase().trim();
+    result2.set(BUCKET_ALIASES[key] ?? key, {
+      ...dir ? { dir } : {},
+      ...archiveDir ? { archiveDir } : {}
+    });
+  }
+  return result2;
+}
+async function resolveLegacyBucketLayout(ctx) {
+  const seamPaths = await readSeamBucketPaths(ctx);
+  const shared = new Set(SHARED_BUCKET_NAMES);
+  return getBuckets(ctx.projectRoot).filter((bucket) => shared.has(bucket.name)).flatMap((bucket) => {
+    const newDir = cleanRelativeDir(bucket.path);
+    const newArchiveDir = cleanRelativeDir(bucket.archivePath);
+    if (!newDir || !newArchiveDir) return [];
+    const old = seamPaths?.get(bucket.name);
+    const oldDir = old?.dir ?? newDir;
+    const builtInArchiveDir = cleanRelativeDir(defaultBucketArchivePath(bucket.name));
+    const defaultArchiveDir = old?.dir ? builtInArchiveDir ?? `${old.dir}/archive` : newArchiveDir;
+    return [
+      {
+        name: bucket.name,
+        oldDir,
+        oldArchiveDir: old?.archiveDir ?? defaultArchiveDir,
+        newArchiveDir,
+        archivePublished: bucket.archivePublished !== false
+      }
+    ];
+  });
+}
+function isUnder(file, dir) {
+  return file.startsWith(`${dir}/`);
+}
+async function listLegacyBucketFilesOnRef(ctx, ref) {
+  const layout = await resolveLegacyBucketLayout(ctx);
+  const dirs = [...new Set(layout.map((bucket) => bucket.oldDir))];
+  if (dirs.length === 0) return [];
+  const tree = await execGit(["ls-tree", "-r", "--name-only", ref, "--", ...dirs], {
+    cwd: ctx.projectRoot
+  });
+  if (tree.exitCode !== 0) return [];
+  return tree.stdout.split("\n").filter(Boolean);
+}
+async function lsFiles(projectRoot, args, dirs) {
+  const result2 = await execGit(["ls-files", "-z", ...args, "--", ...dirs], { cwd: projectRoot });
+  if (result2.exitCode !== 0) {
+    throw new Error(`cannot list files under the old bucket locations: ${result2.stderr.trim()}`);
+  }
+  return result2.stdout.split("\0").filter(Boolean);
+}
+async function sameContent(a, b) {
+  const [left, right] = await Promise.all([fs.readFile(a), fs.readFile(b)]);
+  return left.equals(right);
+}
+function refusal(kind, paths, lead, tail) {
+  const sorted = [...new Set(paths)].sort();
+  return { kind, paths: sorted, message: `${lead}: ${sorted.join(", ")}. ${tail}` };
+}
+async function adoptLocalArchives(ctx) {
+  const layout = await resolveLegacyBucketLayout(ctx);
+  const storageRel = ctx.worktree ? cleanRelativeDir(ctx.worktree) : void 0;
+  const buckets = layout.filter((b) => !storageRel || !isUnder(`${b.oldDir}/`, storageRel));
+  const existing = [];
+  const candidateDirs = new Set(buckets.flatMap((b) => [b.oldDir, b.oldArchiveDir]));
+  for (const dir of candidateDirs) {
+    if (await pathExists(path.join(ctx.projectRoot, dir))) existing.push(dir);
+  }
+  if (existing.length === 0) return NO_ADOPTION;
+  const tracked = await lsFiles(ctx.projectRoot, ["--cached"], existing);
+  const untracked = await lsFiles(ctx.projectRoot, ["--others", "--exclude-standard"], existing);
+  const archiveDirs = buckets.map((b) => b.oldArchiveDir);
+  const activeDirs = [...new Set(buckets.map((b) => b.oldDir))].filter(
+    (dir) => existing.includes(dir)
+  );
+  const ignoredActive = activeDirs.length ? (await lsFiles(ctx.projectRoot, ["--others", "--ignored", "--exclude-standard"], activeDirs)).filter((f) => isPlanningItemFile(path.posix.basename(f))).filter((f) => !archiveDirs.some((dir) => isUnder(f, dir))) : [];
+  const unpublished = buckets.filter((b) => !b.archivePublished);
+  const ignored = unpublished.length ? await lsFiles(
+    ctx.projectRoot,
+    ["--others", "--ignored", "--exclude-standard"],
+    unpublished.map((b) => b.oldArchiveDir).filter((dir) => existing.includes(dir))
+  ) : [];
+  const archiveOf = (file) => unpublished.find((b) => isUnder(file, b.oldArchiveDir));
+  const movable = [.../* @__PURE__ */ new Set([...untracked, ...ignored])].filter((f) => archiveOf(f));
+  const leftovers = [];
+  for (const file of tracked) {
+    if (await pathExists(path.join(ctx.projectRoot, file))) leftovers.push(file);
+  }
+  leftovers.push(...untracked.filter((f) => !archiveOf(f)), ...ignoredActive);
+  if (leftovers.length > 0) {
+    return {
+      ...NO_ADOPTION,
+      refusal: refusal(
+        "leftover",
+        leftovers,
+        "planning storage moved to the git-branch backend, but tracked or uncommitted files remain in the old bucket locations",
+        "Commit, restore or remove them, then rerun; nothing was moved."
+      )
+    };
+  }
+  const plan = [];
+  const collisions = [];
+  for (const file of movable) {
+    const bucket = archiveOf(file);
+    if (!bucket) continue;
+    const src = path.join(ctx.projectRoot, file);
+    const stat4 = await fs.lstat(src).catch(() => void 0);
+    if (!stat4) continue;
+    const dst = path.join(
+      ctx.storageRoot,
+      bucket.newArchiveDir,
+      ...file.slice(bucket.oldArchiveDir.length + 1).split("/")
+    );
+    if (!stat4.isFile()) {
+      collisions.push(file);
+      continue;
+    }
+    const dstStat = await fs.lstat(dst).catch(() => void 0);
+    if (!dstStat) {
+      plan.push({ file, src, dst, identical: false });
+    } else if (dstStat.isFile() && await sameContent(src, dst)) {
+      plan.push({ file, src, dst, identical: true });
+    } else {
+      collisions.push(path.relative(ctx.projectRoot, dst).split(path.sep).join("/"));
+    }
+  }
+  if (collisions.length > 0) {
+    return {
+      ...NO_ADOPTION,
+      refusal: refusal(
+        "collision",
+        collisions,
+        "cannot move local archive files into planning storage; these paths already exist there with different content (or are not regular files)",
+        "Compare and remove one copy, then rerun; nothing was moved."
+      )
+    };
+  }
+  const moved = [];
+  const skippedIdentical = [];
+  for (const item of plan) {
+    if (item.identical) {
+      await fs.unlink(item.src);
+      skippedIdentical.push(item.file);
+      continue;
+    }
+    await fs.mkdir(path.dirname(item.dst), { recursive: true });
+    await fs.copyFile(item.src, item.dst, fs.constants.COPYFILE_EXCL);
+    const srcStat = await fs.stat(item.src);
+    await fs.utimes(item.dst, srcStat.atime, srcStat.mtime);
+    await fs.unlink(item.src);
+    moved.push(item.file);
+  }
+  return { moved, skippedIdentical };
+}
+
+// src/planning/storage/guards.ts
+var HOLD_FILE_NAME = "planning-storage-hold";
+function planningStorageHoldPath() {
+  return path2.join(getStateDir(), HOLD_FILE_NAME);
+}
+function isPlanningStorageHeld() {
+  try {
+    return fs2.existsSync(planningStorageHoldPath());
+  } catch {
+    return false;
+  }
+}
+function assertNoPlanningStorageHold() {
+  const holdPath = planningStorageHoldPath();
+  if (!isPlanningStorageHeld()) return;
+  throw new Error(
+    `planning storage is held by ${holdPath}; a migration is in progress. Remove the hold only when the migration runbook says so.`
+  );
+}
+async function assertNoStorageDrift(ctx, opts = {}) {
+  const remote = opts.remote ?? ctx.remote ?? "origin";
+  const defaultBranch = opts.defaultBranch ?? await resolveDefaultBranch(ctx.projectRoot);
+  if (!defaultBranch) return;
+  const ref = `${remote}/${defaultBranch}:.build-project/config/buckets.yaml`;
+  let raw;
+  try {
+    const result2 = await execGit(["show", ref], { cwd: ctx.projectRoot });
+    if (result2.exitCode !== 0) return;
+    raw = yaml2.load(result2.stdout, { schema: yaml2.JSON_SCHEMA });
+  } catch {
+    return;
+  }
+  const remoteConfig = parseStorageConfigLenient(raw, { source: ref });
+  if (remoteConfig === null) return;
+  const target = `${remote}/${defaultBranch}`;
+  if (remoteConfig.backend === ctx.backend) {
+    if (ctx.backend === "git-branch" && !opts.allowLegacyBucketFiles) {
+      await assertDefaultBranchTracksNoBuckets(ctx, target);
+    }
+    return;
+  }
+  if (remoteConfig.backend === "git-branch") {
+    throw new Error(
+      `planning storage moved to branch ${remoteConfig.branch} on ${target}; merge ${target} into this branch before writing managed items.`
+    );
+  }
+  throw new Error(
+    `planning storage rolled back to the checkout on ${target}; merge ${target} before writing managed items.`
+  );
+}
+async function assertDefaultBranchTracksNoBuckets(ctx, target) {
+  let files;
+  try {
+    files = await listLegacyBucketFilesOnRef(ctx, `refs/remotes/${target}`);
+  } catch {
+    return;
+  }
+  if (files.length === 0) return;
+  const shown = files.slice(0, 10).join(", ");
+  const more = files.length > 10 ? ` and ${files.length - 10} more` : "";
+  throw new Error(
+    `${target} tracks planning bucket files again (${shown}${more}) although planning storage lives on branch ${ctx.branch}; nothing is published until those files are removed from ${target}.`
+  );
+}
+
+// src/planning/storage/publish-transaction.ts
+import { randomUUID } from "crypto";
+import * as fs5 from "fs/promises";
+import * as path4 from "path";
+
+// src/planning/storage/materialize.ts
+var CODE_TREE_ENTRY = "src";
+async function materializeUnlocked(ctx, policy) {
+  if (ctx.backend !== "git-branch") {
+    return { materialized: true, created: false };
+  }
+  if (!ctx.branch || !ctx.remote) {
+    return {
+      materialized: false,
+      created: false,
+      reason: "planning storage backend is git-branch but branch/remote are not configured"
+    };
+  }
+  const fetchOutcome = await fetchStorageBranch(ctx, policy);
+  const ref = trackingRef(ctx);
+  const tip = await resolveRevision(ctx.projectRoot, ref);
+  if (!await pathExists(ctx.storageRoot)) {
+    return await withAdoption(ctx, await createWorktree(ctx, tip, fetchOutcome.reason));
+  }
+  if (!await isLinkedWorktree(ctx.storageRoot)) {
+    return {
+      materialized: false,
+      created: false,
+      reason: `${ctx.storageRoot} exists but is not a linked git worktree; move it aside manually`
+    };
+  }
+  const headSha = await resolveRevision(ctx.storageRoot, "HEAD");
+  const advanced = await advanceHeadWhenClean(ctx, headSha, tip);
+  const reason = fetchOutcome.reason ?? advanced.reason;
+  return await withAdoption(ctx, {
+    materialized: true,
+    created: false,
+    ...advanced.headSha ? { headSha: advanced.headSha } : headSha ? { headSha } : {},
+    ...advanced.headSha && headSha ? { advancedFrom: headSha } : {},
+    ...reason ? { reason } : {}
+  });
+}
+async function withAdoption(ctx, result2) {
+  if (!result2.materialized) return result2;
+  try {
+    const adopted = await adoptLocalArchives(ctx);
+    const reason = adopted.refusal ? [result2.reason, adopted.refusal.message].filter(Boolean).join("; ") : result2.reason;
+    return {
+      ...result2,
+      ...adopted.moved.length ? { adoptedFiles: adopted.moved } : {},
+      ...adopted.refusal ? { adoptionRefusal: adopted.refusal } : {},
+      ...reason ? { reason } : {}
+    };
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    const message = `adopting local archives into planning storage failed: ${detail}. Fix the cause and rerun; files already moved stay in storage.`;
+    return {
+      ...result2,
+      adoptionRefusal: { kind: "error", paths: [], message },
+      reason: [result2.reason, message].filter(Boolean).join("; ")
+    };
+  }
+}
+async function advanceHeadWhenClean(ctx, headSha, tip) {
+  if (!tip || !headSha || tip === headSha) return {};
+  const dirty = (await readPorcelainStatus(ctx.storageRoot)).split("\n").filter(Boolean);
+  if (!await isAncestor(ctx.storageRoot, headSha, tip)) return {};
+  if (dirty.length > 0) return { reason: staleDirtyTreeReason(tip, dirty) };
+  const refusal2 = await refuseUnsuitableTip(ctx, tip);
+  if (refusal2) return { reason: refusal2 };
+  const checkout = await execGit(["checkout", "--detach", "--no-overwrite-ignore", tip], {
+    cwd: ctx.storageRoot
+  });
+  if (checkout.exitCode === 0) return { headSha: tip };
+  const detail = (checkout.stderr || checkout.stdout).trim().replace(/\s+/g, " ");
+  return {
+    reason: `cannot advance planning storage to ${tip}; preserving the current worktree: ${detail}. Resolve conflicting local files before retrying.`
+  };
+}
+function staleDirtyTreeReason(tip, porcelainLines) {
+  const paths = porcelainLines.map(parsePorcelainLinePath);
+  const shown = paths.slice(0, 3).join(", ");
+  const more = paths.length > 3 ? ` and ${paths.length - 3} more` : "";
+  return `serving an older tree: uncommitted changes in the storage worktree (${shown}${more}) keep it from advancing to ${tip}. Finish and publish those edits, or discard them.`;
+}
+async function createWorktree(ctx, tip, fetchReason) {
+  if (!tip) {
+    return {
+      materialized: false,
+      created: false,
+      reason: fetchReason ?? `planning storage is unavailable: ${trackingRef(ctx)} does not exist and could not be fetched`
+    };
+  }
+  const refusal2 = await refuseUnsuitableTip(ctx, tip);
+  if (refusal2) return { materialized: false, created: false, reason: refusal2 };
+  const added = await execGit(["worktree", "add", "--detach", ctx.storageRoot, tip], {
+    cwd: ctx.projectRoot
+  });
+  if (added.exitCode !== 0) {
+    return {
+      materialized: false,
+      created: false,
+      reason: `cannot create the planning storage worktree at ${ctx.storageRoot}: ${added.stderr.trim()}`
+    };
+  }
+  return { materialized: true, created: true, headSha: tip };
+}
+async function refuseUnsuitableTip(ctx, tip) {
+  const seamRoot = ctx.seam?.workRootSha;
+  if (seamRoot && tip !== seamRoot && !await isAncestor(ctx.projectRoot, seamRoot, tip)) {
+    return `refusing to materialize ${tip}: it does not descend from the storage seam root ${seamRoot}`;
+  }
+  const entries = await listTopLevelTreeEntries(ctx.projectRoot, tip);
+  if (entries.includes(CODE_TREE_ENTRY)) {
+    return `refusing to materialize ${tip}: its tree contains a top-level ${CODE_TREE_ENTRY}/ entry, so it is a code commit`;
+  }
+  return void 0;
+}
+
+// src/planning/storage/pending-refs.ts
+import { randomBytes } from "crypto";
+var PENDING_REF_PREFIX = "refs/build/pending/";
+function generateOpId(now = /* @__PURE__ */ new Date()) {
+  const stamp = now.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+  return `${stamp}-${randomBytes(4).toString("hex")}`;
+}
+function pendingRefFor(opId) {
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(opId) || opId.includes("..") || opId.endsWith(".lock")) {
+    throw new Error(`Invalid planning storage operation id: ${opId}`);
+  }
+  return `${PENDING_REF_PREFIX}${opId}`;
+}
+async function listPendingRefs(projectRoot) {
+  const result2 = await execGit(
+    ["for-each-ref", "--format=%(refname) %(objectname)", "--sort=refname", PENDING_REF_PREFIX],
+    { cwd: projectRoot }
+  );
+  if (result2.exitCode !== 0) {
+    throw new Error(
+      `git for-each-ref ${PENDING_REF_PREFIX} failed (exit ${result2.exitCode}): ${result2.stderr.trim()}`
+    );
+  }
+  return result2.stdout.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => {
+    const [ref, sha] = line.split(/\s+/);
+    return { ref: ref ?? "", sha: sha ?? "" };
+  }).filter((entry) => entry.ref.length > 0 && entry.sha.length > 0);
+}
+async function writePendingRef(projectRoot, ref, sha, expectedSha) {
+  const args = ["update-ref", "--create-reflog", ref, sha];
+  if (expectedSha !== void 0) args.push(expectedSha);
+  const result2 = await execGit(args, { cwd: projectRoot });
+  if (result2.exitCode !== 0) {
+    throw new Error(`Cannot record planning storage candidate ${ref}: ${result2.stderr.trim()}`);
+  }
+}
+async function pendingRefHistory(projectRoot, entry) {
+  const result2 = await execGit(["reflog", "show", "--format=%H", entry.ref, "--"], {
+    cwd: projectRoot
+  });
+  const logged = result2.exitCode === 0 ? result2.stdout.split("\n").map((line) => line.trim()).filter(Boolean) : [];
+  if (logged.length > 0) {
+    const before = await execGit(
+      ["rev-parse", "--verify", "--quiet", `${entry.ref}@{${logged.length}}`],
+      { cwd: projectRoot }
+    );
+    if (before.exitCode === 0 && before.stdout.trim()) logged.push(before.stdout.trim());
+  }
+  return [.../* @__PURE__ */ new Set([entry.sha, ...logged])];
+}
+async function deletePendingRef(projectRoot, ref, expectedSha) {
+  const result2 = await execGit(["update-ref", "-d", ref, expectedSha], { cwd: projectRoot });
+  if (result2.exitCode !== 0) {
+    throw new Error(`Cannot delete planning storage candidate ${ref}: ${result2.stderr.trim()}`);
+  }
+}
+
+// src/planning/storage/pending-order.ts
+function dependencyClosure(ref, parents) {
+  const closure = /* @__PURE__ */ new Set();
+  const queue = [ref];
+  for (let next = queue.pop(); next !== void 0; next = queue.pop()) {
+    if (closure.has(next)) continue;
+    closure.add(next);
+    queue.push(...parents.get(next) ?? []);
+  }
+  return closure;
+}
+function closureOf(order, roots) {
+  const selected = new Set(roots.flatMap((root) => [...dependencyClosure(root, order.parents)]));
+  return {
+    ordered: order.ordered.filter((entry) => selected.has(entry.ref)),
+    parents: order.parents
+  };
+}
+async function orderByDependency(projectRoot, refs) {
+  const histories = /* @__PURE__ */ new Map();
+  for (const entry of refs) histories.set(entry.ref, await pendingRefHistory(projectRoot, entry));
+  const parents = /* @__PURE__ */ new Map();
+  for (const child of refs) {
+    const found = /* @__PURE__ */ new Set();
+    for (const other of refs) {
+      if (other.ref === child.ref) continue;
+      for (const sha of histories.get(other.ref) ?? []) {
+        if (sha !== child.sha && await isAncestor(projectRoot, sha, child.sha)) {
+          found.add(other.ref);
+          break;
+        }
+      }
+    }
+    parents.set(child.ref, found);
+  }
+  const remaining = [...refs];
+  const ordered = [];
+  while (remaining.length > 0) {
+    const waiting = new Set(remaining.map((entry) => entry.ref));
+    const index = remaining.findIndex(
+      (entry) => ![...parents.get(entry.ref) ?? []].some((parent) => waiting.has(parent))
+    );
+    ordered.push(...remaining.splice(Math.max(index, 0), 1));
+  }
+  return { ordered, parents };
+}
+
+// src/planning/storage/publication-owner.ts
+import { createHash } from "crypto";
+import * as fs4 from "fs/promises";
+
+// src/planning/storage/publish-staging.ts
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+var BRANCH_ROOT_FILES = ["README.md", ".gitignore"];
+var PATHSPEC_CHUNK = 100;
+var PlanningStoragePublishError = class extends Error {
+  paths;
+  constructor(message, paths = []) {
+    super(message);
+    this.name = "PlanningStoragePublishError";
+    this.paths = paths;
+  }
+};
+function sharedBuckets(ctx) {
+  const shared = new Set(SHARED_BUCKET_NAMES);
+  return getBuckets(ctx.projectRoot).filter(
+    (bucket) => shared.has(bucket.name)
+  );
+}
+function asDirPrefix(relativePath) {
+  return relativePath.endsWith("/") ? relativePath : `${relativePath}/`;
+}
+function sharedBucketDirs(ctx) {
+  return sharedBuckets(ctx).map((bucket) => normalizeRelativePath(bucket.path)).map(asDirPrefix);
+}
+function publishableBucketDirs(ctx) {
+  const dirs = new Set(sharedBucketDirs(ctx));
+  for (const bucket of sharedBuckets(ctx)) {
+    if (bucket.archivePath) dirs.add(asDirPrefix(normalizeRelativePath(bucket.archivePath)));
+  }
+  return [...dirs];
+}
+function unpublishedArchiveDirs(ctx) {
+  return sharedBuckets(ctx).filter((bucket) => bucket.archivePublished === false).map((bucket) => normalizeRelativePath(bucket.archivePath)).map(asDirPrefix);
+}
+function normalizeRelativePath(input) {
+  const posix3 = input.replace(/\\/g, "/").trim();
+  if (path3.isAbsolute(posix3) || /^[A-Za-z]:/.test(posix3)) {
+    throw new PlanningStoragePublishError(
+      `Planning storage touched paths must be storage-root relative: ${input}`,
+      [input]
+    );
+  }
+  const normalized = path3.posix.normalize(posix3).replace(/^\.\//, "");
+  if (normalized === ".." || normalized.startsWith("../")) {
+    throw new PlanningStoragePublishError(
+      `Planning storage touched path escapes the storage root: ${input}`,
+      [input]
+    );
+  }
+  return normalized;
+}
+function isAllowlisted(relativePath, bucketDirs) {
+  if (BRANCH_ROOT_FILES.includes(relativePath)) return true;
+  return bucketDirs.some((dir) => relativePath.startsWith(dir));
+}
+async function filterIgnoredPaths(storageRoot, relativePaths) {
+  if (relativePaths.length === 0) return /* @__PURE__ */ new Set();
+  const result2 = await execGit(["check-ignore", "-z", "--stdin"], {
+    cwd: storageRoot,
+    input: `${relativePaths.join("\0")}\0`
+  });
+  if (result2.exitCode === 1) return /* @__PURE__ */ new Set();
+  if (result2.exitCode !== 0) {
+    throw new PlanningStoragePublishError(
+      `Cannot classify planning storage paths against the branch ignore rules: ${result2.stderr.trim()}`
+    );
+  }
+  return new Set(result2.stdout.split("\0").filter(Boolean));
+}
+async function describeIgnoreSources(storageRoot, relativePaths) {
+  const result2 = await execGit(["check-ignore", "-v", "--stdin"], {
+    cwd: storageRoot,
+    input: `${relativePaths.join("\n")}
+`
+  });
+  if (result2.exitCode !== 0 && result2.exitCode !== 1) return [...relativePaths];
+  const described = result2.stdout.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => {
+    const [rule, pathSpec] = line.split("	");
+    const source = rule?.split(":")[0]?.trim() ?? "an ignore rule";
+    return `${pathSpec?.trim() ?? ""} (ignored by ${source})`;
+  });
+  return described.length > 0 ? described : [...relativePaths];
+}
+async function dropNeverPublishedAbsentPaths(storageRoot, relativePaths) {
+  const absent = [];
+  for (const relativePath of relativePaths) {
+    try {
+      await fs3.lstat(path3.join(storageRoot, relativePath));
+    } catch {
+      absent.push(relativePath);
+    }
+  }
+  if (absent.length === 0) return [...relativePaths];
+  const tracked = await snapshotIndexEntries(storageRoot, absent);
+  const drop = new Set(absent.filter((relativePath) => !tracked.has(relativePath)));
+  return relativePaths.filter((relativePath) => !drop.has(relativePath));
+}
+async function planAllowlist(ctx, touchedPaths) {
+  const bucketDirs = publishableBucketDirs(ctx);
+  const unpublishedArchives = unpublishedArchiveDirs(ctx);
+  const declared = new Set(touchedPaths.map(normalizeRelativePath));
+  const allowlisted = [...declared].filter(
+    (relativePath) => isAllowlisted(relativePath, bucketDirs)
+  );
+  const localByPolicy = allowlisted.filter(
+    (relativePath) => unpublishedArchives.some((dir) => relativePath.startsWith(dir))
+  );
+  const publishable = await dropNeverPublishedAbsentPaths(
+    ctx.storageRoot,
+    allowlisted.filter((relativePath) => !localByPolicy.includes(relativePath))
+  );
+  const ignored = await filterIgnoredPaths(ctx.storageRoot, publishable);
+  if (ignored.size > 0) {
+    const described = await describeIgnoreSources(ctx.storageRoot, [...ignored].sort());
+    throw new PlanningStoragePublishError(
+      `Planning storage publish aborted: ${described.join(", ")} would not be committed on the storage branch; remove the ignore rule or mark the bucket archive unpublished`,
+      [...ignored].sort()
+    );
+  }
+  await assertNoForeignDirtyPath(ctx.storageRoot, new Set(allowlisted));
+  return { staged: publishable, localByPolicy };
+}
+async function assertNoForeignDirtyPath(storageRoot, owned) {
+  const status = await readPorcelainStatus(storageRoot, { untracked: true });
+  for (const entry of parseGitStatus(status)) {
+    if (entry.indexStatus === " " || entry.indexStatus === "?") continue;
+    for (const candidate of [entry.path, entry.originalPath]) {
+      if (!candidate) continue;
+      const relativePath = normalizeRelativePath(candidate);
+      if (!owned.has(relativePath)) {
+        throw new PlanningStoragePublishError(
+          `Planning storage publish aborted: ${relativePath} is modified in ${storageRoot} but was not part of this operation`,
+          [relativePath]
+        );
+      }
+    }
+  }
+}
+async function stageAllowlist(storageRoot, relativePaths) {
+  for (let index = 0; index < relativePaths.length; index += PATHSPEC_CHUNK) {
+    const chunk = relativePaths.slice(index, index + PATHSPEC_CHUNK);
+    const result2 = await execGit(["add", "-A", "--", ...chunk], { cwd: storageRoot });
+    if (result2.exitCode !== 0) {
+      throw new PlanningStoragePublishError(
+        `Cannot stage planning storage paths: ${result2.stderr.trim()}`,
+        chunk
+      );
+    }
+  }
+}
+async function snapshotIndexEntries(storageRoot, relativePaths) {
+  const entries = /* @__PURE__ */ new Map();
+  for (let index = 0; index < relativePaths.length; index += PATHSPEC_CHUNK) {
+    const chunk = relativePaths.slice(index, index + PATHSPEC_CHUNK);
+    const result2 = await execGit(["ls-files", "-s", "-z", "--", ...chunk], { cwd: storageRoot });
+    if (result2.exitCode !== 0) {
+      throw new PlanningStoragePublishError(
+        `Cannot read the planning storage index: ${result2.stderr.trim()}`,
+        chunk
+      );
+    }
+    for (const record of result2.stdout.split("\0")) {
+      const match = record.match(/^(\d{6}) ([0-9a-f]+) 0\t(.+)$/s);
+      if (match?.[1] && match[2] && match[3]) entries.set(match[3], `${match[1]} ${match[2]}`);
+    }
+  }
+  return entries;
+}
+async function restoreIndexEntries(storageRoot, relativePaths, prior) {
+  const current = await snapshotIndexEntries(storageRoot, relativePaths);
+  const added = [...current.keys()].filter((entryPath) => !prior.has(entryPath));
+  const changed = [...prior].filter(([entryPath, entry]) => current.get(entryPath) !== entry);
+  if (added.length > 0) {
+    await execGit(["update-index", "--force-remove", "-z", "--stdin"], {
+      cwd: storageRoot,
+      input: `${added.join("\0")}\0`
+    });
+  }
+  if (changed.length > 0) {
+    await execGit(["update-index", "-z", "--index-info"], {
+      cwd: storageRoot,
+      input: changed.map(([entryPath, entry]) => `${entry}	${entryPath}\0`).join("")
+    });
+  }
+}
+async function withIndexRestoredOnFailure(storageRoot, relativePaths, prior, step) {
+  const headBefore = await resolveRevision(storageRoot, "HEAD");
+  try {
+    return await step();
+  } catch (error) {
+    if (await resolveRevision(storageRoot, "HEAD") === headBefore) {
+      await restoreIndexEntries(storageRoot, relativePaths, prior).catch(() => void 0);
+    }
+    throw error;
+  }
+}
+async function hasStagedChanges(storageRoot) {
+  const result2 = await execGit(["diff", "--cached", "--quiet"], { cwd: storageRoot });
+  return result2.exitCode !== 0;
+}
+async function resolveEffectiveHooksPath(projectRoot) {
+  const configured = await execGit(["config", "--get", "core.hooksPath"], { cwd: projectRoot });
+  if (configured.exitCode !== 0 && configured.exitCode !== 1) {
+    throw new PlanningStoragePublishError(
+      `Refusing to publish planning storage: cannot read core.hooksPath in ${projectRoot}: ${configured.stderr.trim()}`
+    );
+  }
+  const value = configured.exitCode === 0 ? configured.stdout.trim() : "";
+  if (value) {
+    return path3.isAbsolute(value) ? value : path3.resolve(projectRoot, value);
+  }
+  return path3.join(await resolveCommonGitDir(projectRoot), "hooks");
+}
+async function assertPreCommitHookRunnable(hooksPath, policy = DEFAULT_PRE_COMMIT_POLICY) {
+  const hookPath = path3.join(hooksPath, "pre-commit");
+  let entry;
+  try {
+    entry = await fs3.lstat(hookPath);
+  } catch (error) {
+    const code = error?.code;
+    if (code === "ENOENT") {
+      if (policy === "optional") return;
+      throw new PlanningStoragePublishError(
+        `Refusing to publish planning storage: no pre-commit hook at ${hookPath} (storage.preCommitPolicy: required)`,
+        [hookPath]
+      );
+    }
+    throw new PlanningStoragePublishError(
+      `Refusing to publish planning storage: cannot inspect pre-commit hook at ${hookPath}: ${error instanceof Error ? error.message : String(error)}`,
+      [hookPath]
+    );
+  }
+  const stat4 = entry.isSymbolicLink() ? await fs3.stat(hookPath).catch(() => void 0) : entry;
+  if (!stat4?.isFile()) {
+    throw new PlanningStoragePublishError(
+      `Refusing to publish planning storage: pre-commit hook at ${hookPath} is not a regular file git can run`,
+      [hookPath]
+    );
+  }
+  if ((stat4.mode & 73) === 0) {
+    throw new PlanningStoragePublishError(
+      `Refusing to publish planning storage: pre-commit hook at ${hookPath} is not executable, so git would skip it`,
+      [hookPath]
+    );
+  }
+}
+async function commitCandidate(ctx, message, backlogGatePassed = false) {
+  const policy = resolvePreCommitPolicy(loadStorageConfig(ctx.projectRoot));
+  const hooksPath = await resolveEffectiveHooksPath(ctx.projectRoot);
+  await assertPreCommitHookRunnable(hooksPath, policy);
+  const commit = await execGit(["-c", `core.hooksPath=${hooksPath}`, "commit", "-m", message], {
+    cwd: ctx.storageRoot,
+    timeoutMs: GIT_HOOK_COMMIT_TIMEOUT_MS,
+    ...backlogGatePassed ? { env: { BUILD_BACKLOG_SYNC: "1" } } : {}
+  });
+  if (commit.exitCode !== 0) {
+    throw new PlanningStoragePublishError(
+      `Planning storage commit refused (exit ${commit.exitCode}): ${commit.stderr.trim() || commit.stdout.trim()}`
+    );
+  }
+  const head = await execGit(["rev-parse", "HEAD"], { cwd: ctx.storageRoot });
+  const sha = head.stdout.trim();
+  if (head.exitCode !== 0 || !sha) {
+    throw new PlanningStoragePublishError("Planning storage commit produced no resolvable HEAD");
+  }
+  return { sha, hooksPath };
+}
+
+// src/planning/storage/publication-owner.ts
+var OWNER_PREFIX = "planning-storage:";
+var PUSH_DETAIL = /^planning storage push ([0-9a-f]{40}(?:[0-9a-f]{24})?)(?: held in (.+))?$/;
+var retainedTurns = /* @__PURE__ */ new Map();
+function hash(value, length) {
+  return createHash("sha256").update(value).digest("hex").slice(0, length);
+}
+async function resolveStoragePublicationOwner(ctx) {
+  const remote = ctx.remote ?? "origin";
+  const urlResult = await execGit(["remote", "get-url", "--push", "--all", remote], {
+    cwd: ctx.projectRoot
+  });
+  if (urlResult.exitCode !== 0) return void 0;
+  const urls = urlResult.stdout.trim().split(/\r?\n/).filter(Boolean);
+  const repositories = urls.map(repositoryFromGitHubRemoteUrl);
+  if (urls.length > 1 && repositories.some(Boolean)) {
+    throw new PlanningStoragePublishError(
+      "Planning storage publication requires one GitHub push destination"
+    );
+  }
+  const repository = repositories[0]?.toLowerCase();
+  if (!repository) return void 0;
+  const branch = ctx.branch ?? "";
+  const commonGitDir = await resolveCommonGitDir(ctx.projectRoot);
+  return {
+    repository,
+    branch,
+    ownerId: `${OWNER_PREFIX}clone:${hash(`${commonGitDir}\0${repository}\0${branch}`, 24)}`,
+    legacyOwnerId: `${OWNER_PREFIX}${hash(`${ctx.storageRoot}\0${ctx.branch}`, 16)}`,
+    commonGitDir
+  };
+}
+function parseRetainedPush(detail) {
+  const match = PUSH_DETAIL.exec(detail?.trim() ?? "");
+  if (!match) return {};
+  return { sha: match[1], ...match[2] ? { holdingClone: match[2] } : {} };
+}
+function ownerProcess(record) {
+  try {
+    const state = processOwnershipState(record.ownerPid, record.ownerPidIdentity, record.claimedAt);
+    return state === "owned" ? "live" : state === "reclaimable" ? "dead" : "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+async function hasCommit(projectRoot, sha) {
+  const probe = await execGit(["cat-file", "-e", `${sha}^{commit}`], { cwd: projectRoot });
+  return probe.exitCode === 0;
+}
+async function describeHoldingClone(holdingClone) {
+  if (!holdingClone) return "an unrecorded clone (the record predates holding-clone metadata)";
+  const present = await fs4.stat(holdingClone).then(
+    () => true,
+    (error) => error && typeof error === "object" && "code" in error && error.code === "ENOENT" ? false : void 0
+  );
+  if (present === false) return `${holdingClone} (not present on this machine)`;
+  return holdingClone;
+}
+async function classifyTurn(ctx, owner, record) {
+  const holder = record.ownerId === owner.ownerId ? "this-clone" : record.ownerId === owner.legacyOwnerId ? "this-checkout-legacy" : "other";
+  const ownerState = ownerProcess(record);
+  const { sha, holdingClone } = parseRetainedPush(record.detail);
+  const available = sha ? await hasCommit(ctx.projectRoot, sha) : void 0;
+  const fields = {
+    token: record.token,
+    ownerId: record.ownerId,
+    holder,
+    ownerProcess: ownerState,
+    recoveryRequired: record.recoveryRequired,
+    ...sha ? { retainedPush: sha } : {},
+    ...holdingClone ? { holdingClone } : {},
+    ...available === void 0 ? {} : { retainedPushAvailable: available }
+  };
+  const retained = record.recoveryRequired ? ` with an unresolved push${sha ? ` of ${sha}` : ""}` : "";
+  if (ownerState !== "dead") {
+    const evidence = ownerState === "live" ? "running" : "alive but unjudgeable";
+    return {
+      disposition: "active",
+      explanation: `held by ${record.ownerId} (process ${record.ownerPid}, ${evidence})${retained}; publication waits for it`,
+      ...fields
+    };
+  }
+  const legacyHere = holder === "this-checkout-legacy" && available === true;
+  if (!record.recoveryRequired || holder === "this-clone" || legacyHere) {
+    return {
+      disposition: "recoverable",
+      explanation: `left by exited process ${record.ownerPid}${retained}; the next publish from this clone claims it`,
+      ...fields
+    };
+  }
+  const where = await describeHoldingClone(holdingClone);
+  const objects = sha ? available ? "this clone has its commit" : "this clone does not have its commit" : "the record names no commit, so its outcome cannot be established";
+  return {
+    disposition: "stranded",
+    explanation: `${record.ownerId} left an unresolved push${sha ? ` of ${sha}` : ""} held in ${where} behind exited process ${record.ownerPid}; ${objects}. Publish it from the holding clone with: build plan storage sync, or settle it from remote evidence with: build plan storage sync --recover-turn ${record.token}`,
+    ...fields
+  };
+}
+async function inspectStorageTurn(ctx) {
+  let owner;
+  let record;
+  try {
+    owner = await resolveStoragePublicationOwner(ctx);
+    if (!owner) return void 0;
+    record = await readPublicationTurn({
+      repository: owner.repository,
+      targetBranch: owner.branch
+    });
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    return { disposition: "unreadable", explanation: reason.split("\n")[0] ?? reason };
+  }
+  return record ? await classifyTurn(ctx, owner, record) : void 0;
+}
+async function acquireStorageTurn(ctx) {
+  const owner = await resolveStoragePublicationOwner(ctx);
+  if (!owner) return void 0;
+  const target = { repository: owner.repository, targetBranch: owner.branch };
+  const retainKey = `${owner.repository}\0${owner.branch}\0${owner.commonGitDir}`;
+  const retained = retainedTurns.get(retainKey);
+  if (retained) {
+    retainedTurns.delete(retainKey);
+    const stillOwned = await retained.assertOwned().then(
+      () => true,
+      () => false
+    );
+    if (stillOwned) return retained;
+  }
+  const current = await readPublicationTurn(target).catch(() => void 0);
+  const status = current ? await classifyTurn(ctx, owner, current) : void 0;
+  if (status?.disposition === "stranded") {
+    throw new PlanningStoragePublishError(status.explanation);
+  }
+  const aliasToken = status?.disposition === "recoverable" && status.holder === "this-checkout-legacy" ? current?.token : void 0;
+  const handle = await acquirePublicationTurn({
+    ...target,
+    ownerId: owner.ownerId,
+    recover: true,
+    adopt: (record) => aliasToken !== void 0 && record.token === aliasToken
+  });
+  let unresolved = current?.recoveryRequired === true;
+  const turn = {
+    ...handle,
+    retainPush: async (sha) => {
+      await handle.requireRecovery(`planning storage push ${sha} held in ${owner.commonGitDir}`);
+      unresolved = true;
+    },
+    clearRecovery: async () => {
+      await handle.clearRecovery();
+      unresolved = false;
+    },
+    settle: async () => {
+      if (unresolved) {
+        retainedTurns.set(retainKey, turn);
+        return;
+      }
+      await handle.release();
+    }
+  };
+  return turn;
+}
+async function fetchSplitFromPush(ctx, owner) {
+  const remote = ctx.remote ?? "origin";
+  const urlResult = await execGit(["remote", "get-url", "--all", remote], {
+    cwd: ctx.projectRoot
+  });
+  if (urlResult.exitCode !== 0) return `cannot read the fetch URL of ${remote}`;
+  const urls = urlResult.stdout.trim().split(/\r?\n/).filter(Boolean);
+  const elsewhere = urls.some(
+    (url) => repositoryFromGitHubRemoteUrl(url)?.toLowerCase() !== owner.repository
+  );
+  if (urls.length > 0 && !elsewhere) return void 0;
+  return `${remote} fetches from a different repository than its push destination ${owner.repository}, so a fetch cannot prove what the push did`;
+}
+async function retainedPushOutcome(ctx, owner, sha) {
+  const cwd = ctx.projectRoot;
+  const split = await fetchSplitFromPush(ctx, owner);
+  if (split) return { state: "unknown", reason: split };
+  const fetched = await fetchStorageBranch(ctx, "always");
+  if (!fetched.fetched) {
+    const reason = fetched.reason ?? "the fetch was skipped";
+    return { state: "unknown", reason: `fresh remote evidence unavailable: ${reason}` };
+  }
+  const tip = await resolveRevision(cwd, trackingRef(ctx));
+  if (!tip) return { state: "unknown", reason: `${trackingRef(ctx)} does not resolve` };
+  if (tip === sha) return { state: "present" };
+  if (!await hasCommit(cwd, sha)) {
+    const shallow = await execGit(["rev-parse", "--is-shallow-repository"], { cwd });
+    const promisor = await execGit(
+      ["config", "--get", `remote.${ctx.remote ?? "origin"}.promisor`],
+      { cwd }
+    );
+    if (shallow.exitCode !== 0 || shallow.stdout.trim() !== "false" || promisor.stdout.trim()) {
+      return {
+        state: "unknown",
+        reason: "this clone is shallow or partial, so a missing commit proves nothing"
+      };
+    }
+    return { state: "absent" };
+  }
+  const ancestry = await execGit(["merge-base", "--is-ancestor", sha, tip], { cwd });
+  if (ancestry.exitCode === 0) return { state: "present" };
+  if (ancestry.exitCode === 1) return { state: "absent" };
+  return { state: "unknown", reason: `cannot compare ${sha} with ${tip}` };
+}
+async function recoverRetainedTurn(ctx, token) {
+  const refuse = (why) => {
+    throw new PlanningStoragePublishError(`Cannot recover publication turn ${token}: ${why}`);
+  };
+  const owner = await resolveStoragePublicationOwner(ctx);
+  if (!owner) return refuse("the storage remote is not a GitHub destination, so it has no turn");
+  const target = { repository: owner.repository, targetBranch: owner.branch };
+  const record = await readPublicationTurn(target);
+  if (!record) return refuse("no publication turn is recorded for this storage branch");
+  if (record.token !== token) {
+    return refuse(`the recorded turn is ${record.token}; inspect with: build plan storage status`);
+  }
+  if (!record.ownerId.startsWith(OWNER_PREFIX)) {
+    return refuse(`it belongs to ${record.ownerId}, not a planning storage publisher`);
+  }
+  if (!record.recoveryRequired) return refuse("it retains no unresolved push");
+  const ownerState = ownerProcess(record);
+  if (ownerState !== "dead") {
+    const evidence = ownerState === "live" ? "running" : "unjudgeable";
+    return refuse(`owner process ${record.ownerPid} is ${evidence}`);
+  }
+  const { sha, holdingClone } = parseRetainedPush(record.detail);
+  if (!sha) return refuse("the record names no pushed commit, so its outcome is unknowable");
+  const outcome = await retainedPushOutcome(ctx, owner, sha);
+  if (outcome.state === "unknown") return refuse(outcome.reason);
+  let adopted = false;
+  const handle = await acquirePublicationTurn({
+    ...target,
+    ownerId: owner.ownerId,
+    adopt: (current) => {
+      adopted = current.token === token;
+      return adopted;
+    }
+  });
+  try {
+    if (!adopted) return refuse("the recorded turn changed while it was being recovered");
+    await handle.clearRecovery();
+  } finally {
+    await handle.release();
+  }
+  const remote = `${ctx.remote ?? "origin"}/${owner.branch}`;
+  if (outcome.state === "present") {
+    return `retained push ${sha} is on ${remote}; turn ${token} cleared`;
+  }
+  const cleared = `retained push ${sha} is not on ${remote} and its process exited; turn ${token} cleared`;
+  const here = await heldPendingRef(ctx.projectRoot, sha);
+  if (here) return `${cleared}. Its candidate is held here as ${here} and publishes with this sync`;
+  return `${cleared}. Its candidate remains only in ${await describeHoldingClone(holdingClone)}; publish it there with: build plan storage sync`;
+}
+async function heldPendingRef(projectRoot, sha) {
+  for (const entry of await listPendingRefs(projectRoot)) {
+    if ((await pendingRefHistory(projectRoot, entry)).includes(sha)) return entry.ref;
+  }
+  return void 0;
+}
+
+// src/planning/storage/recover-candidates.ts
+var OPERATION_TRAILER = "Build-Planning-Operation";
+function storageCommitMessage(message, opId) {
+  pendingRefFor(opId);
+  return `${message.trimEnd()}
+
+${OPERATION_TRAILER}: ${opId}`;
+}
+function operationId(message) {
+  const matches = [
+    ...message.matchAll(/^Build-Planning-Operation: ([A-Za-z0-9][A-Za-z0-9._-]*)$/gm)
+  ];
+  const id = matches.at(-1)?.[1];
+  if (id) pendingRefFor(id);
+  return id;
+}
+async function contentOnTip(ctx, sha, tip) {
+  const paths = await execGit(
+    ["diff-tree", "-r", "-z", "--no-commit-id", "--no-renames", "--name-only", sha],
+    { cwd: ctx.projectRoot }
+  );
+  if (paths.exitCode !== 0) return false;
+  const changed = paths.stdout.split("\0").filter(Boolean);
+  if (changed.length === 0) return true;
+  const compared = await execGit(
+    [
+      "diff",
+      "--quiet",
+      "--no-ext-diff",
+      "--no-textconv",
+      sha,
+      tip,
+      "--",
+      ...changed.map((file) => `:(literal)${file}`)
+    ],
+    { cwd: ctx.projectRoot }
+  );
+  return compared.exitCode === 0;
+}
+async function recoverStorageCandidates(ctx) {
+  const tip = await resolveRevision(ctx.projectRoot, trackingRef(ctx));
+  if (!tip) {
+    throw new PlanningStoragePublishError(
+      "Cannot reconcile planning storage without its tracking tip"
+    );
+  }
+  const refs = await listPendingRefs(ctx.projectRoot);
+  const histories = await Promise.all(refs.map((ref) => pendingRefHistory(ctx.projectRoot, ref)));
+  const known = new Set(histories.flat());
+  const commits = await execGit(
+    [
+      "log",
+      "--reverse",
+      "--format=%H%x00%P%x00%B%x00",
+      "HEAD",
+      ...refs.map((ref) => ref.sha),
+      "--not",
+      tip,
+      "--"
+    ],
+    { cwd: ctx.storageRoot }
+  );
+  if (commits.exitCode !== 0) {
+    throw new PlanningStoragePublishError(
+      `Cannot read unrecorded storage commits: ${commits.stderr.trim()}`
+    );
+  }
+  const fields = commits.stdout.split("\0");
+  const missing = [];
+  let published;
+  for (let index = 0; index + 2 < fields.length; index += 3) {
+    const sha = fields[index]?.trim() ?? "";
+    if (!sha || known.has(sha)) continue;
+    const id = operationId(fields[index + 2] ?? "");
+    const ordinary = fields[index + 1]?.trim().split(/\s+/).filter(Boolean).length === 1;
+    if (!id && ordinary && await contentOnTip(ctx, sha, tip)) continue;
+    if (!id || !ordinary) {
+      throw new PlanningStoragePublishError(
+        `Cannot record or publish over unrecorded storage commit ${sha}: ownership is unavailable; HEAD and files were preserved. Inspect the commit and refresh publication evidence with build plan storage sync before retrying`
+      );
+    }
+    if (!published) {
+      const messages = await execGit(["log", "--format=%B%x00", tip, "--"], {
+        cwd: ctx.projectRoot
+      });
+      if (messages.exitCode !== 0)
+        throw new PlanningStoragePublishError("Cannot read published storage operations");
+      published = new Set(
+        messages.stdout.split("\0").flatMap((message) => {
+          const operation = operationId(message);
+          return operation ? [operation] : [];
+        })
+      );
+    }
+    if (!published.has(id)) missing.push({ ref: pendingRefFor(id), sha });
+  }
+  const dropped = missing.length > 0 ? await droppedByRemote(ctx, tip) : /* @__PURE__ */ new Set();
+  const recovered = missing.filter((candidate) => !dropped.has(candidate.sha));
+  for (const candidate of recovered) {
+    await writePendingRef(ctx.projectRoot, candidate.ref, candidate.sha, "");
+  }
+  return recovered;
+}
+async function droppedByRemote(ctx, tip) {
+  const reflog = await execGit(["reflog", "show", "--format=%H", trackingRef(ctx), "--"], {
+    cwd: ctx.projectRoot
+  });
+  const earlierTips = [
+    ...new Set(reflog.exitCode === 0 ? reflog.stdout.split("\n").map((line) => line.trim()) : [])
+  ].filter((sha) => sha && sha !== tip);
+  if (earlierTips.length === 0) return /* @__PURE__ */ new Set();
+  const reachable = await execGit(
+    ["rev-list", "--ignore-missing", ...earlierTips, "--not", tip, "--"],
+    { cwd: ctx.projectRoot }
+  );
+  if (reachable.exitCode !== 0) {
+    throw new PlanningStoragePublishError(
+      `Cannot read earlier storage tips: ${reachable.stderr.trim()}`
+    );
+  }
+  return new Set(
+    reachable.stdout.split("\n").map((line) => line.trim()).filter(Boolean)
+  );
+}
+
+// src/planning/storage/publish-transaction.ts
+var MAX_PUBLISH_ATTEMPTS = 3;
+function result(outcome, fields) {
+  return { outcome, exitCode: PUBLISH_OUTCOME_EXIT_CODES[outcome], ...fields };
+}
+function firstLine(value) {
+  return value.trim().split("\n")[0]?.trim() ?? "";
+}
+function rewoundRefusal(outcome) {
+  if (!outcome.rewound) return void 0;
+  return `remote storage branch was rewound (${outcome.rewound.previous}..${outcome.rewound.remote}); refusing to publish onto stale tracking evidence; inspect with: build plan storage status`;
+}
+function fetchRefusal(outcome) {
+  if (outcome.fetched) return void 0;
+  return rewoundRefusal(outcome) ?? `required fetch failed: ${outcome.reason ?? "no reason reported"}`;
+}
+function isNonFastForward(output) {
+  return /non-fast-forward|fetch first|rejected.*(?:fetch|behind)|\[rejected\]/i.test(output);
+}
+function describeError(error) {
+  return error instanceof Error ? firstLine(error.message) : String(error);
+}
+var PublicationOwnershipError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PublicationOwnershipError";
+  }
+};
+async function fenced(assertOwned, owner) {
+  try {
+    await assertOwned();
+  } catch (error) {
+    throw new PublicationOwnershipError(`${owner} ownership was lost: ${describeError(error)}`);
+  }
+}
+async function withOwnedStorageLock(storageRoot, step) {
+  let entered = false;
+  try {
+    return await withStorageLock(storageRoot, async (lock) => {
+      entered = true;
+      return await step(lock);
+    });
+  } catch (error) {
+    if (entered) throw error;
+    throw new PublicationOwnershipError(
+      `planning storage lock unavailable: ${describeError(error)}`
+    );
+  }
+}
+async function withPublicationOwnership(ctx, run) {
+  let turn;
+  try {
+    turn = await acquireStorageTurn(ctx);
+  } catch (error) {
+    throw new PublicationOwnershipError(`publication turn unavailable: ${describeError(error)}`);
+  }
+  if (!turn) {
+    return await withOwnedStorageLock(
+      ctx.storageRoot,
+      (lock) => run({
+        local: (step) => step(lock),
+        assertOwned: () => fenced(() => lock.assertOwned(), "planning storage lock")
+      })
+    );
+  }
+  const owned = turn;
+  try {
+    return await run({
+      turn: owned,
+      local: (step) => withOwnedStorageLock(ctx.storageRoot, step),
+      assertOwned: () => fenced(() => owned.assertOwned(), "publication turn")
+    });
+  } finally {
+    await owned.settle().catch(() => void 0);
+  }
+}
+async function publicationBoundaryRefusal(ctx) {
+  if (isPlanningStorageHeld()) {
+    return "planning storage is held: the storage hold file exists, so nothing is pushed until it is removed";
+  }
+  const remote = ctx.remote ?? "origin";
+  const refresh = await refreshDefaultBranchTracking(ctx.projectRoot, remote);
+  if (!refresh.ok) return refresh.reason;
+  try {
+    await assertNoStorageDrift(ctx, { remote, defaultBranch: refresh.defaultBranch });
+  } catch (error) {
+    return describeError(error);
+  }
+  return void 0;
+}
+async function remotePresence(ctx, sha, timeoutMs) {
+  const ref = `refs/heads/${ctx.branch ?? ""}`;
+  const lookup = await execGit(["ls-remote", "--heads", "--", ctx.remote ?? "origin", ref], {
+    cwd: ctx.projectRoot,
+    timeoutMs
+  }).catch(() => void 0);
+  if (!lookup || lookup.exitCode !== 0) return { state: "unknown" };
+  const tips = lookup.stdout.split("\n").map((line) => line.trim().split(/\s+/)).filter(([, name]) => name === ref).map(([tipSha]) => tipSha ?? "");
+  if (tips.length === 0) return { state: "absent" };
+  const tip = tips[0];
+  if (tips.length > 1 || !tip) return { state: "unknown" };
+  if (tip === sha) return { state: "present", tip };
+  const ancestry = await execGit(["merge-base", "--is-ancestor", sha, tip], {
+    cwd: ctx.projectRoot
+  });
+  if (ancestry.exitCode === 0) return { state: "present", tip };
+  return { state: ancestry.exitCode === 1 ? "absent" : "unknown", tip };
+}
+async function pushCandidate(ctx, sha) {
+  try {
+    const push = await execGit(
+      ["push", "--", ctx.remote ?? "origin", `${sha}:refs/heads/${ctx.branch ?? ""}`],
+      { cwd: ctx.projectRoot, timeoutMs: resolvePushTimeoutMs() }
+    );
+    return {
+      exitCode: push.exitCode,
+      output: `${push.stderr}
+${push.stdout}`,
+      detail: firstLine(push.stderr) || firstLine(push.stdout) || `exit ${push.exitCode}`
+    };
+  } catch (error) {
+    return { output: "", detail: describeError(error) };
+  }
+}
+function assertPublishable(ctx) {
+  if (ctx.backend !== "git-branch") {
+    throw new Error(
+      'publishManagedChange: planning storage backend is "checkout"; the sync dispatcher must not call the git-branch publisher'
+    );
+  }
+  if (!ctx.branch || !ctx.remote) {
+    throw new PlanningStoragePublishError(
+      "Planning storage backend is git-branch but branch/remote are not configured"
+    );
+  }
+  if (isPlanningStorageHeld()) {
+    throw new PlanningStoragePublishError(
+      "Planning storage is held: the storage hold file exists, so every publisher refuses until it is removed"
+    );
+  }
+}
+async function blobIdAt(cwd, revision, relativePath) {
+  const result_ = await execGit(
+    ["rev-parse", "--verify", "--quiet", `${revision}:${relativePath}`],
+    {
+      cwd
+    }
+  );
+  const sha = result_.stdout.trim();
+  return result_.exitCode === 0 && sha ? sha : void 0;
+}
+async function divergedPaths(cwd, base, tip, relativePaths) {
+  const diverged = [];
+  for (const relativePath of relativePaths) {
+    const [before, after] = await Promise.all([
+      blobIdAt(cwd, base, relativePath),
+      blobIdAt(cwd, tip, relativePath)
+    ]);
+    if (before !== after) diverged.push(relativePath);
+  }
+  return diverged;
+}
+async function rebuildOnto(ctx, candidate, tip) {
+  const gitDir = await readWorktreeGitDir(ctx.storageRoot);
+  const indexFile = path4.join(gitDir, `build-storage-index-${randomUUID()}`);
+  const env = { GIT_INDEX_FILE: indexFile };
+  const run = async (args) => {
+    const outcome = await execGit(args, { cwd: ctx.storageRoot, env });
+    if (outcome.exitCode !== 0) {
+      throw new PlanningStoragePublishError(
+        `Cannot re-apply the planning storage candidate onto ${tip}: git ${args[0]} failed: ${outcome.stderr.trim()}`
+      );
+    }
+    return outcome.stdout.trim();
+  };
+  try {
+    await run(["read-tree", tip]);
+    for (const relativePath of candidate.stagedPaths) {
+      const entry = await readTreeEntry(ctx.storageRoot, candidate.sha, relativePath);
+      if (!entry) {
+        await run(["update-index", "--force-remove", "--", relativePath]);
+        continue;
+      }
+      await run([
+        "update-index",
+        "--add",
+        "--cacheinfo",
+        `${entry.mode},${entry.sha},${relativePath}`
+      ]);
+    }
+    const tree = await run(["write-tree"]);
+    return await run(["commit-tree", tree, "-p", tip, "-m", candidate.message]);
+  } finally {
+    await fs5.rm(indexFile, { force: true }).catch(() => void 0);
+    await fs5.rm(`${indexFile}.lock`, { force: true }).catch(() => void 0);
+  }
+}
+async function readTreeEntry(cwd, revision, relativePath) {
+  const outcome = await execGit(["ls-tree", revision, "--", relativePath], { cwd });
+  if (outcome.exitCode !== 0) return void 0;
+  const line = outcome.stdout.split("\n").find((candidate) => candidate.trim().length > 0);
+  if (!line) return void 0;
+  const [meta] = line.split("	");
+  const [mode, type, sha] = (meta ?? "").trim().split(/\s+/);
+  if (type !== "blob" || !mode || !sha) return void 0;
+  return { mode, sha };
+}
+async function retargetWorktreeHead(storageRoot, previous, next) {
+  try {
+    const head = await resolveRevision(storageRoot, "HEAD");
+    if (head !== previous) {
+      return `its HEAD is ${head ?? "unreadable"}, not the replaced candidate ${previous}`;
+    }
+    const diff = await execGit(["diff", "-z", "--name-only", "--no-renames", previous, next], {
+      cwd: storageRoot
+    });
+    if (diff.exitCode !== 0) return `cannot compare ${previous} with ${next}`;
+    const moved = diff.stdout.split("\0").filter(Boolean);
+    if (moved.length > 0) {
+      const status = await execGit(
+        [
+          "status",
+          "--porcelain",
+          "--untracked-files=all",
+          "--ignored=traditional",
+          "--",
+          ...moved.map((file) => `:(literal)${file}`)
+        ],
+        { cwd: storageRoot }
+      );
+      if (status.exitCode !== 0) return "cannot read its status";
+      const local = parseGitStatus(status.stdout).map((entry) => entry.path);
+      if (local.length > 0) {
+        return `local, in-flight or ignored files would be overwritten: ${local.join(", ")}`;
+      }
+    }
+    const checkout = await execGit(["checkout", "--detach", next], { cwd: storageRoot });
+    if (checkout.exitCode !== 0) return `checkout failed: ${checkout.stderr.trim()}`;
+    return void 0;
+  } catch (error) {
+    return describeError(error);
+  }
+}
+async function finalizeCandidate(ctx, initial, scope) {
+  const remote = ctx.remote ?? "origin";
+  const timeoutMs = resolveFetchTimeoutMs();
+  const { turn } = scope;
+  let candidate = initial;
+  let attempts = 0;
+  let lastRejection = "";
+  const base = (outcome) => ({
+    commitSha: candidate.sha,
+    pendingRef: candidate.pendingRef,
+    stagedPaths: candidate.stagedPaths,
+    localByPolicyPaths: candidate.localByPolicyPaths,
+    attempts,
+    ...outcome.reason ? { reason: outcome.reason } : {},
+    ...outcome.remoteTip ? { remoteTip: outcome.remoteTip } : {}
+  });
+  const pending = (reason) => result("pending", base({ reason }));
+  const accept = async (tip) => {
+    await scope.local(() => deletePendingRef(ctx.projectRoot, candidate.pendingRef, candidate.sha)).catch(() => void 0);
+    await turn?.clearRecovery().catch(() => void 0);
+    const { pendingRef: _recorded, ...published } = base({ ...tip ? { remoteTip: tip } : {} });
+    return result("published", published);
+  };
+  try {
+    for (let attempt = 1; attempt <= MAX_PUBLISH_ATTEMPTS; attempt += 1) {
+      attempts = attempt;
+      const refused = fetchRefusal(await fetchStorageBranch(ctx, "always"));
+      if (refused) return pending(refused);
+      const tip = await resolveRevision(ctx.projectRoot, trackingRef(ctx));
+      if (tip && await isAncestor(ctx.projectRoot, candidate.sha, tip)) {
+        return await accept(tip);
+      }
+      if (tip && candidate.base && tip !== candidate.base) {
+        const conflicts = await divergedPaths(
+          ctx.projectRoot,
+          candidate.base,
+          tip,
+          candidate.stagedPaths
+        );
+        if (conflicts.length > 0) {
+          return pending(`conflict: ${conflicts.join(", ")}`);
+        }
+        const unsuitable = await refuseUnsuitableTip(ctx, tip);
+        if (unsuitable) return pending(unsuitable);
+        const previous = candidate;
+        const rebuilt = await scope.local(async (lock) => {
+          await fenced(() => lock.assertOwned(), "planning storage lock");
+          const sha = await rebuildOnto(ctx, previous, tip);
+          await writePendingRef(ctx.projectRoot, previous.pendingRef, sha, previous.sha);
+          await retargetWorktreeHead(ctx.storageRoot, previous.sha, sha);
+          return sha;
+        });
+        candidate = { ...candidate, sha: rebuilt, base: tip };
+      }
+      await scope.assertOwned();
+      await turn?.retainPush(candidate.sha).catch(() => void 0);
+      const push = await pushCandidate(ctx, candidate.sha);
+      if (push.exitCode !== 0) {
+        lastRejection = push.detail;
+        const definitive = push.exitCode !== void 0;
+        if (definitive && isNonFastForward(push.output) && attempt < MAX_PUBLISH_ATTEMPTS) {
+          continue;
+        }
+        const presence2 = await remotePresence(ctx, candidate.sha, timeoutMs);
+        if (presence2.state === "present") return await accept(presence2.tip);
+        if (presence2.state === "absent" && definitive) {
+          await turn?.clearRecovery().catch(() => void 0);
+          return pending(`push failed: ${push.detail}`);
+        }
+        return pending(
+          `push outcome unknown: ${push.detail}; ` + (presence2.state === "absent" ? "the remote does not show the commit yet" : "the remote could not be checked")
+        );
+      }
+      const verifyRefresh = rewoundRefusal(await fetchStorageBranch(ctx, "always"));
+      const presence = await remotePresence(ctx, candidate.sha, timeoutMs);
+      if (presence.state === "present") return await accept(presence.tip);
+      if (verifyRefresh) return pending(verifyRefresh);
+      return result(
+        "unverified",
+        base({
+          reason: presence.state === "absent" ? `push reported success but ${remote}/${ctx.branch} does not contain ${candidate.sha}` : `push reported success but ${remote}/${ctx.branch} could not be checked for ${candidate.sha}`
+        })
+      );
+    }
+  } catch (error) {
+    if (!(error instanceof PublicationOwnershipError)) throw error;
+    scope.lost = error.message;
+    return pending(error.message);
+  }
+  return pending(
+    `push rejected after ${MAX_PUBLISH_ATTEMPTS} attempts: ${lastRejection || "non-fast-forward"}`
+  );
+}
+async function recordCandidate(ctx, request) {
+  const opId = request.opId ?? generateOpId();
+  const pendingRef = pendingRefFor(opId);
+  const message = storageCommitMessage(request.message, opId);
+  return await withStorageLock(ctx.storageRoot, async (lock) => {
+    if (!await isLinkedWorktree(ctx.storageRoot)) {
+      throw new PlanningStoragePublishError(
+        `Planning storage is not materialized at ${ctx.storageRoot}; nothing was published`
+      );
+    }
+    const recovered = await recoverStorageCandidates(ctx);
+    const plan = await planAllowlist(ctx, request.touchedPaths);
+    const localOnly = () => result("local-only", {
+      stagedPaths: [],
+      localByPolicyPaths: plan.localByPolicy,
+      attempts: 0,
+      ...plan.localByPolicy.length > 0 ? { reason: "all touched paths are local by policy on the storage branch" } : { reason: "nothing to publish" }
+    });
+    if (plan.staged.length === 0) return localOnly();
+    const priorIndex = await snapshotIndexEntries(ctx.storageRoot, plan.staged);
+    const sha = await withIndexRestoredOnFailure(
+      ctx.storageRoot,
+      plan.staged,
+      priorIndex,
+      async () => {
+        await stageAllowlist(ctx.storageRoot, plan.staged);
+        if (!await hasStagedChanges(ctx.storageRoot)) return void 0;
+        await lock.assertOwned();
+        return (await commitCandidate(ctx, message, request.backlogGatePassed)).sha;
+      }
+    );
+    if (!sha) {
+      const head = await resolveRevision(ctx.storageRoot, "HEAD");
+      const retry = recovered.find((candidate) => candidate.sha === head);
+      return retry ? {
+        sha: retry.sha,
+        message: await readCommitMessage(ctx.projectRoot, retry.sha),
+        stagedPaths: await candidateTouchedPaths(ctx.projectRoot, retry.sha),
+        localByPolicyPaths: plan.localByPolicy,
+        pendingRef: retry.ref
+      } : localOnly();
+    }
+    await writePendingRef(ctx.projectRoot, pendingRef, sha);
+    return {
+      sha,
+      message,
+      stagedPaths: plan.staged,
+      localByPolicyPaths: plan.localByPolicy,
+      pendingRef
+    };
+  });
+}
+async function publishRecorded(ctx, own) {
+  const unpublished = (reason) => reconcileOwnCandidate(ctx, own, reason);
+  try {
+    return await withPublicationOwnership(ctx, async (scope) => {
+      const refused = await publicationBoundaryRefusal(ctx);
+      if (refused) return await unpublished(refused);
+      const { ordered: refs, parents } = closureOf(
+        await orderByDependency(ctx.projectRoot, await listPendingRefs(ctx.projectRoot)),
+        [own.pendingRef]
+      );
+      const index = refs.findIndex((entry) => entry.ref === own.pendingRef);
+      if (index < 0) return await unpublished("the pending ref disappeared while this waited");
+      const results = await publishInOrder(ctx, scope, refs, parents, own);
+      return results[index] ?? await unpublished("publication produced no result for it");
+    });
+  } catch (error) {
+    const reason = error instanceof PublicationOwnershipError ? error.message : `publication failed: ${describeError(error)}`;
+    return await unpublished(reason).catch(
+      (lookup) => result("unverified", {
+        reason: `${reason}; recorded ${own.pendingRef} at ${own.sha}, but its current state could not be read: ${describeError(lookup)}`,
+        stagedPaths: own.stagedPaths,
+        localByPolicyPaths: own.localByPolicyPaths,
+        attempts: 0
+      })
+    );
+  }
+}
+async function reconcileOwnCandidate(ctx, own, reason) {
+  const fields = {
+    stagedPaths: own.stagedPaths,
+    localByPolicyPaths: own.localByPolicyPaths,
+    attempts: 0
+  };
+  const ref = await execGit(["rev-parse", "--verify", "--quiet", `${own.pendingRef}^{commit}`], {
+    cwd: ctx.projectRoot
+  });
+  if (ref.exitCode > 1) throw new Error(`cannot read ${own.pendingRef}: ${firstLine(ref.stderr)}`);
+  const current = ref.exitCode === 0 ? ref.stdout.trim() : "";
+  if (current) {
+    return result("pending", { reason, commitSha: current, pendingRef: own.pendingRef, ...fields });
+  }
+  const presence = await remotePresence(ctx, own.sha, resolveFetchTimeoutMs());
+  if (presence.state === "present") {
+    const tip = presence.tip ? { remoteTip: presence.tip } : {};
+    return result("published", { commitSha: own.sha, ...tip, ...fields });
+  }
+  const checked = presence.state === "absent" ? "does not contain" : "could not be checked for";
+  return result("unverified", {
+    reason: `${reason}; ${own.pendingRef} is gone and ${ctx.remote}/${ctx.branch} ${checked} ${own.sha}`,
+    ...fields
+  });
+}
+async function publishManagedChange(ctx, request) {
+  assertPublishable(ctx);
+  const recorded = await recordCandidate(ctx, request);
+  if ("outcome" in recorded) return recorded;
+  return await publishRecorded(ctx, recorded);
+}
+async function recordManagedChange(ctx, request) {
+  assertPublishable(ctx);
+  const recorded = await recordCandidate(ctx, request);
+  if ("outcome" in recorded) return recorded;
+  return result("pending", {
+    reason: "publication deferred; nothing was fetched or pushed",
+    commitSha: recorded.sha,
+    pendingRef: recorded.pendingRef,
+    stagedPaths: recorded.stagedPaths,
+    localByPolicyPaths: recorded.localByPolicyPaths,
+    attempts: 0
+  });
+}
+async function candidateTouchedPaths(projectRoot, sha) {
+  const outcome = await execGit(
+    ["diff-tree", "-z", "-r", "--no-commit-id", "--no-renames", "--name-only", sha],
+    { cwd: projectRoot }
+  );
+  if (outcome.exitCode !== 0) {
+    throw new PlanningStoragePublishError(
+      `Cannot read the changes of pending candidate ${sha}: ${outcome.stderr.trim()}`
+    );
+  }
+  return outcome.stdout.split("\0").filter(Boolean);
+}
+async function readCommitMessage(projectRoot, sha) {
+  const outcome = await execGit(["log", "-1", "--format=%B", sha], { cwd: projectRoot });
+  return outcome.exitCode === 0 ? outcome.stdout.replace(/\n+$/, "") : "";
+}
+async function publishInOrder(ctx, scope, refs, parents, own) {
+  const results = [];
+  const unpublished = /* @__PURE__ */ new Set();
+  for (const { ref, sha } of refs) {
+    const mine = own?.pendingRef === ref ? own : void 0;
+    const stagedPaths = mine?.stagedPaths ?? await candidateTouchedPaths(ctx.projectRoot, sha);
+    const localByPolicyPaths = mine?.localByPolicyPaths ?? [];
+    const blocker = [...parents.get(ref) ?? []].find((parent2) => unpublished.has(parent2));
+    const held = scope.lost ?? (blocker ? `pending operation ${blocker} must publish first` : "");
+    if (held) {
+      results.push(
+        result("pending", {
+          reason: held,
+          commitSha: sha,
+          pendingRef: ref,
+          stagedPaths,
+          localByPolicyPaths,
+          attempts: 0
+        })
+      );
+      unpublished.add(ref);
+      continue;
+    }
+    const parent = await resolveRevision(ctx.projectRoot, `${sha}^`);
+    const finalized = await finalizeCandidate(
+      ctx,
+      {
+        sha,
+        ...parent ? { base: parent } : {},
+        message: mine?.message ?? await readCommitMessage(ctx.projectRoot, sha),
+        stagedPaths,
+        localByPolicyPaths,
+        pendingRef: ref
+      },
+      scope
+    );
+    if (finalized.outcome !== "published") unpublished.add(ref);
+    results.push(finalized);
+  }
+  return results;
+}
+async function publishPending(ctx, select) {
+  if (ctx.backend !== "git-branch") return [];
+  assertPublishable(ctx);
+  if (!select) await withStorageLock(ctx.storageRoot, () => recoverStorageCandidates(ctx));
+  if ((await listPendingRefs(ctx.projectRoot)).length === 0) return [];
+  const retainedAll = async (reason, refs) => {
+    const results = [];
+    for (const { ref, sha } of refs) {
+      results.push(
+        result("pending", {
+          reason,
+          commitSha: sha,
+          pendingRef: ref,
+          stagedPaths: await candidateTouchedPaths(ctx.projectRoot, sha),
+          localByPolicyPaths: [],
+          attempts: 0
+        })
+      );
+    }
+    return results;
+  };
+  try {
+    return await withPublicationOwnership(ctx, async (scope) => {
+      const snapshot = await orderByDependency(
+        ctx.projectRoot,
+        await listPendingRefs(ctx.projectRoot)
+      );
+      const { ordered, parents } = select ? closureOf(snapshot, await select(snapshot.ordered)) : snapshot;
+      if (ordered.length === 0) return [];
+      const refused = await publicationBoundaryRefusal(ctx);
+      if (refused) return await retainedAll(refused, ordered);
+      return await publishInOrder(ctx, scope, ordered, parents);
+    });
+  } catch (error) {
+    if (!(error instanceof PublicationOwnershipError)) throw error;
+    return await retainedAll(error.message, await listPendingRefs(ctx.projectRoot));
+  }
+}
+async function publishReplacement(ctx, ref, prepare) {
+  assertPublishable(ctx);
+  try {
+    return await withPublicationOwnership(ctx, async (scope) => {
+      await prepare(scope.local);
+      const { ordered, parents } = closureOf(
+        await orderByDependency(ctx.projectRoot, await listPendingRefs(ctx.projectRoot)),
+        [ref]
+      );
+      const refused = await publicationBoundaryRefusal(ctx);
+      if (!refused) return await publishInOrder(ctx, scope, ordered, parents);
+      return ordered.map(
+        ({ ref: pendingRef, sha }) => result("pending", {
+          reason: refused,
+          commitSha: sha,
+          pendingRef,
+          stagedPaths: [],
+          localByPolicyPaths: [],
+          attempts: 0
+        })
+      );
+    });
+  } catch (error) {
+    if (!(error instanceof PublicationOwnershipError)) throw error;
+    throw new PlanningStoragePublishError(`${error.message}; nothing was resolved`);
+  }
+}
+
+// src/planning/storage/pending-resolution.ts
+var CONFLICT_CHOICES = ["candidate", "remote"];
+var RESOLVED_PREFIX = "Resolved conflict: ";
+function replacedCommits(message) {
+  return message.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.startsWith(RESOLVED_PREFIX)).map((line) => /; replaces ([0-9a-f]{40,64})$/.exec(line)?.[1]).filter((sha) => sha !== void 0);
+}
+async function candidateChanges(cwd, sha) {
+  const outcome = await execGit(
+    ["diff-tree", "-z", "-r", "--no-commit-id", "--no-renames", "--name-only", sha],
+    { cwd }
+  );
+  if (outcome.exitCode !== 0) {
+    throw new PlanningStoragePublishError(
+      `Cannot read the changes of pending candidate ${sha}: ${outcome.stderr.trim()}`
+    );
+  }
+  return outcome.stdout.split("\0").filter(Boolean);
+}
+function dependentsOf(order, ref) {
+  return order.ordered.filter((entry) => order.parents.get(entry.ref)?.has(ref)).map((entry) => entry.ref);
+}
+async function conflictsWithTip(cwd, sha, paths, tip) {
+  if (!tip || await isAncestor(cwd, sha, tip)) return [];
+  const base = await resolveRevision(cwd, `${sha}^`);
+  if (!base || base === tip) return [];
+  return await divergedPaths(cwd, base, tip, paths);
+}
+async function inspectPendingCandidates(ctx, refs) {
+  if (refs.length === 0) return [];
+  const cwd = ctx.projectRoot;
+  const order = await orderByDependency(cwd, refs);
+  const tip = await resolveRevision(cwd, trackingRef(ctx));
+  const details = [];
+  for (const { ref, sha } of order.ordered) {
+    const dependsOn = [...order.parents.get(ref) ?? []];
+    const paths = await candidateChanges(cwd, sha).catch(() => []);
+    const conflicts = dependsOn.length > 0 ? [] : await conflictsWithTip(cwd, sha, paths, tip);
+    details.push({ ref, sha, paths, conflicts, dependsOn, dependents: dependentsOf(order, ref) });
+  }
+  return details;
+}
+function pendingRefArgument(input) {
+  const opId = input.startsWith(PENDING_REF_PREFIX) ? input.slice(PENDING_REF_PREFIX.length) : input;
+  return pendingRefFor(opId);
+}
+async function resolvePendingConflict(ctx, refInput, take) {
+  const ref = pendingRefArgument(refInput);
+  const cwd = ctx.projectRoot;
+  const refuse = (why) => {
+    throw new PlanningStoragePublishError(`Cannot resolve ${ref}: ${why}`);
+  };
+  const state = { dependents: [] };
+  const publication = await publishReplacement(ctx, ref, async (local) => {
+    const fetched = await fetchStorageBranch(ctx, "always");
+    if (!fetched.fetched) {
+      refuse(
+        fetched.rewound ? `remote storage branch was rewound (${fetched.rewound.previous}..${fetched.rewound.remote})` : `required fetch failed: ${fetched.reason ?? "no reason reported"}`
+      );
+    }
+    const tip = await resolveRevision(cwd, trackingRef(ctx)) ?? refuse("no remote tip");
+    const order = await orderByDependency(cwd, await listPendingRefs(cwd));
+    const entry = order.ordered.find((candidate) => candidate.ref === ref) ?? refuse("no such pending candidate; inspect with: build plan storage status");
+    const parents = [...order.parents.get(ref) ?? []];
+    if (parents.length > 0) {
+      refuse(`it depends on pending ${parents.join(", ")}; resolve or publish that first`);
+    }
+    state.dependents = dependentsOf(order, ref);
+    if (await isAncestor(cwd, entry.sha, tip)) {
+      refuse("the remote already contains it; finish with: build plan storage sync");
+    }
+    const paths = await candidateChanges(cwd, entry.sha);
+    const conflicts = await conflictsWithTip(cwd, entry.sha, paths, tip);
+    if (conflicts.length === 0) {
+      refuse("it does not conflict with the remote tip; publish it with: build plan storage sync");
+    }
+    const unsuitable = await refuseUnsuitableTip(ctx, tip);
+    if (unsuitable) refuse(unsuitable);
+    const message = await execGit(["log", "-1", "--format=%B", entry.sha], { cwd });
+    if (message.exitCode !== 0) refuse(`cannot read the message of ${entry.sha}`);
+    const kept = new Set(take === "remote" ? conflicts : []);
+    const replacementMessage = `${message.stdout.replace(/\s+$/, "")}
+
+${RESOLVED_PREFIX}kept the ${take} version of ${conflicts.join(", ")}; replaces ${entry.sha}`;
+    const outcome = await local(async (lock) => {
+      await lock.assertOwned();
+      const stagedPaths = paths.filter((file) => !kept.has(file));
+      const replacement = await rebuildOnto(
+        ctx,
+        { sha: entry.sha, stagedPaths, message: replacementMessage },
+        tip
+      );
+      await writePendingRef(cwd, ref, replacement, entry.sha);
+      const viewKept = await retargetWorktreeHead(ctx.storageRoot, entry.sha, replacement);
+      return { replacement, viewKept };
+    });
+    state.recorded = {
+      ref,
+      original: entry.sha,
+      replacement: outcome.replacement,
+      take,
+      conflicts,
+      ...outcome.viewKept ? { viewKept: outcome.viewKept } : {}
+    };
+  });
+  const recorded = state.recorded ?? refuse("no replacement was recorded");
+  const remaining = new Set((await listPendingRefs(cwd)).map((entry) => entry.ref));
+  return {
+    ...recorded,
+    publication,
+    dependents: state.dependents.filter((dependent) => remaining.has(dependent))
+  };
+}
+
+// src/planning/storage/work-branch.ts
+async function ensureMaterialized(ctx, opts) {
+  if (ctx.backend !== "git-branch") {
+    return { materialized: true, created: false };
+  }
+  const run = async () => materializeUnlocked(ctx, opts?.fetch ?? "stale");
+  if (opts?.skipWhenBusy && await hasCompletedCheckout(ctx.storageRoot)) {
+    try {
+      return await withStorageLock(ctx.storageRoot, run, { wait: false });
+    } catch (error) {
+      if (isStorageLockBusyError(error)) return { materialized: true, created: false };
+      throw error;
+    }
+  }
+  return await withStorageLock(ctx.storageRoot, run);
+}
+async function getStorageStatus(ctx) {
+  const hold = isPlanningStorageHeld();
+  let pendingRefs = [];
+  let pendingRefsError;
+  try {
+    pendingRefs = await listPendingRefs(ctx.projectRoot);
+  } catch (error) {
+    pendingRefsError = error instanceof Error ? error.message : String(error);
+  }
+  if (ctx.backend !== "git-branch") {
+    return {
+      backend: ctx.backend,
+      projectRoot: ctx.projectRoot,
+      storageRoot: ctx.storageRoot,
+      materialized: true,
+      available: true,
+      pendingRefs,
+      ...pendingRefsError ? { pendingRefsError } : {},
+      hold
+    };
+  }
+  const materialized = await pathExists(ctx.storageRoot);
+  const available = materialized && await isLinkedWorktree(ctx.storageRoot);
+  const remoteTipSha = await resolveRevision(ctx.projectRoot, trackingRef(ctx));
+  const remoteTipFetchedAt = remoteTipSha ? await readLastFetchTime(ctx) : void 0;
+  const headSha = available ? await resolveRevision(ctx.storageRoot, "HEAD") : void 0;
+  const worktreeId = available ? await readWorktreeId(ctx.storageRoot) : void 0;
+  const behind = available && headSha && remoteTipSha ? await countBehind(ctx.storageRoot, headSha, remoteTipSha) : void 0;
+  const publicationTurn = await inspectStorageTurn(ctx);
+  const pendingDetails = pendingRefsError ? void 0 : await inspectPendingCandidates(ctx, pendingRefs).catch(() => void 0);
+  const uncommitted = available ? await inspectUncommittedStoragePaths(ctx.storageRoot) : {};
+  return {
+    backend: ctx.backend,
+    projectRoot: ctx.projectRoot,
+    storageRoot: ctx.storageRoot,
+    ...ctx.branch ? { branch: ctx.branch } : {},
+    ...ctx.remote ? { remote: ctx.remote } : {},
+    materialized,
+    available,
+    ...available ? {} : {
+      unavailableReason: materialized ? `${ctx.storageRoot} exists but is not a linked git worktree` : `${ctx.storageRoot} is not materialized`
+    },
+    ...headSha ? { headSha } : {},
+    ...remoteTipSha ? { remoteTipSha } : {},
+    ...remoteTipFetchedAt ? { remoteTipFetchedAt } : {},
+    ...behind === void 0 ? {} : { behind },
+    pendingRefs,
+    ...pendingRefsError ? { pendingRefsError } : {},
+    ...pendingDetails?.length ? { pendingDetails } : {},
+    ...uncommitted,
+    hold,
+    ...worktreeId ? { worktreeId } : {},
+    ...publicationTurn ? { publicationTurn } : {}
+  };
+}
+async function inspectUncommittedStoragePaths(storageRoot) {
+  try {
+    const porcelain = await readPorcelainStatus(storageRoot, { untracked: true });
+    return { uncommittedPaths: parseGitStatusPaths(porcelain) };
+  } catch (error) {
+    return { uncommittedPathsError: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function countBehind(storageRoot, headSha, tip) {
+  if (headSha === tip) return 0;
+  const result2 = await execGit(["rev-list", "--count", `${headSha}..${tip}`], { cwd: storageRoot });
+  if (result2.exitCode !== 0) return void 0;
+  const count = Number.parseInt(result2.stdout.trim(), 10);
+  return Number.isFinite(count) ? count : void 0;
+}
+
+export {
+  resolveLegacyBucketLayout,
+  assertNoPlanningStorageHold,
+  assertNoStorageDrift,
+  recoverRetainedTurn,
+  publishManagedChange,
+  recordManagedChange,
+  publishPending,
+  CONFLICT_CHOICES,
+  replacedCommits,
+  resolvePendingConflict,
+  ensureMaterialized,
+  getStorageStatus,
+  inspectUncommittedStoragePaths
+};
+//# sourceMappingURL=chunk-SNGM452K.js.map