@ricsam/r5d-worker 0.0.74 → 0.0.76

package/dist/cjs/workspace-sync.cjs

@@ -1,2469 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var workspace_sync_exports = {};
-__export(workspace_sync_exports, {
-  MAX_WORKSPACE_SYNC_DIFF_BYTES: () => MAX_WORKSPACE_SYNC_DIFF_BYTES,
-  WORKSPACE_BRANCH: () => WORKSPACE_BRANCH,
-  WORKSPACE_INTENT_REF_PREFIX: () => WORKSPACE_INTENT_REF_PREFIX,
-  WORKSPACE_NATIVE_PLANS_RELATIVE_PATH: () => WORKSPACE_NATIVE_PLANS_RELATIVE_PATH,
-  WORKSPACE_PUBLICATION_REF_PREFIX: () => WORKSPACE_PUBLICATION_REF_PREFIX,
-  WorkspaceSyncSingleFlight: () => WorkspaceSyncSingleFlight,
-  assertCanonicalCheckoutIndexMatchesWorktree: () => assertCanonicalCheckoutIndexMatchesWorktree,
-  assertWorkspaceQuarantineRef: () => assertWorkspaceQuarantineRef,
-  calculateWorkspaceDiffFingerprint: () => calculateWorkspaceDiffFingerprint,
-  calculateWorkspaceLocalDiffFingerprint: () => calculateWorkspaceLocalDiffFingerprint,
-  convergeWorkspaceHead: () => convergeWorkspaceHead,
-  encodeWorkspaceBranch: () => encodeWorkspaceBranch,
-  mirrorShadowWorkspaceToVisible: () => mirrorShadowWorkspaceToVisible,
-  mirrorVisibleWorkspaceToShadow: () => mirrorVisibleWorkspaceToShadow,
-  synchronizeWorkspace: () => synchronizeWorkspace,
-  visibleProjectBranchPath: () => visibleProjectBranchPath,
-  workspacePlansRelativePath: () => workspacePlansRelativePath,
-  workspaceProjectBranchRelativePath: () => workspaceProjectBranchRelativePath,
-  workspaceProjectsForSync: () => workspaceProjectsForSync
-});
-module.exports = __toCommonJS(workspace_sync_exports);
-var import_node_crypto = require("node:crypto");
-var import_node_fs = __toESM(require("node:fs"), 1);
-var import_node_path = __toESM(require("node:path"), 1);
-var import_managed_paths = require("./managed-paths.cjs");
-var import_workspace_mutation_gate = require("./workspace-mutation-gate.cjs");
-const WORKSPACE_BRANCH = "main";
-const WORKSPACE_INTENT_REF_PREFIX = "refs/r5d/workspace-intents/";
-const WORKSPACE_PUBLICATION_REF_PREFIX = "refs/r5d/workspace-publications/";
-const MAX_WORKSPACE_SYNC_DIFF_BYTES = 5 * 1024 * 1024;
-const MAX_REPORTED_WORKSPACE_PATHS = 2e3;
-const MAX_REPORTED_WORKSPACE_STATUS_BYTES = 256 * 1024;
-const MAX_MIRROR_COMPARISON_CACHE_ENTRIES = 2e5;
-const MIRROR_COMPARE_BUFFER_BYTES = 64 * 1024;
-const DESTRUCTIVE_CHECKOUT_MIN_TRACKED_FILES = 20;
-const DESTRUCTIVE_CHECKOUT_REMOVAL_RATIO = 0.8;
-const ACTIVE_GIT_LOCK_PATHS = ["index.lock", "HEAD.lock", "packed-refs.lock", "shallow.lock"];
-const mirrorComparisonCache = /* @__PURE__ */ new Map();
-const gitObjectFormatCache = /* @__PURE__ */ new Map();
-const hydrationEntryCache = /* @__PURE__ */ new Map();
-function gitArgs(input, args) {
-  const configArgs = ["-c", "submodule.recurse=false", "-c", "fetch.recurseSubmodules=false", "-c", "push.recurseSubmodules=false"];
-  return input.authHeader ? ["git", ...configArgs, "-c", `http.extraHeader=${input.authHeader}`, ...args] : ["git", ...configArgs, ...args];
-}
-function withoutSubmoduleRecursion(args) {
-  return args[0] === "fetch" || args[0] === "push" ? [args[0], "--no-recurse-submodules", ...args.slice(1)] : args[0] === "clone" ? ["clone", "--no-recurse-submodules", ...args.slice(1)] : args[0] === "checkout" || args[0] === "reset" || args[0] === "restore" ? [args[0], "--no-recurse-submodules", ...args.slice(1)] : args;
-}
-function runGitResult(input, cwd, args) {
-  const result = Bun.spawnSync(gitArgs(input, withoutSubmoduleRecursion(args)), {
-    cwd,
-    stdout: "pipe",
-    stderr: "pipe",
-    env: {
-      ...process.env,
-      GIT_TERMINAL_PROMPT: "0"
-    }
-  });
-  return {
-    exitCode: result.exitCode,
-    stdout: result.stdout.toString().trim(),
-    stderr: result.stderr.toString().trim()
-  };
-}
-function runGit(input, cwd, args, action) {
-  const result = runGitResult(input, cwd, args);
-  if (result.exitCode !== 0) {
-    throw new Error(`${action}: ${result.stderr || result.stdout || `git exited ${result.exitCode}`}`);
-  }
-  return result.stdout;
-}
-function tryGit(input, cwd, args) {
-  return runGitResult(input, cwd, args).exitCode === 0;
-}
-function encodeWorkspaceBranch(branchName) {
-  return encodeURIComponent(branchName);
-}
-function workspaceProjectsForSync(projects, trigger) {
-  if (trigger.canonicalCheckoutOnly) {
-    if (!trigger.projectId || !trigger.branchName) {
-      throw new Error("A canonical-checkout-only synchronization requires projectId and branchName");
-    }
-    const project = projects.find((candidate) => candidate.projectId === trigger.projectId);
-    const checkout = project?.canonicalCheckouts.find((candidate) => candidate.branchName === trigger.branchName);
-    if (!project || !project.branches.includes(trigger.branchName) || !checkout) {
-      throw new Error(`Canonical resolver checkout ${trigger.projectId}/${trigger.branchName} is not present in this worker manifest`);
-    }
-    return [
-      {
-        ...project,
-        branches: [trigger.branchName],
-        canonicalCheckouts: [checkout]
-      }
-    ];
-  }
-  return projects.flatMap((project) => {
-    const canonicalBranches = new Set(project.canonicalCheckouts.map((checkout) => checkout.branchName));
-    const branches = project.branches.filter((branchName) => !canonicalBranches.has(branchName));
-    return branches.length > 0 || project.canonicalCheckouts.length > 0 ? [
-      {
-        ...project,
-        branches
-      }
-    ] : [];
-  });
-}
-function workspaceProjectBranchRelativePath(projectId, branchName) {
-  return import_node_path.default.posix.join("projects", projectId, "branches", encodeWorkspaceBranch(branchName));
-}
-function workspacePlansRelativePath(projectId, branchName) {
-  return import_node_path.default.posix.join("plans", projectId, encodeWorkspaceBranch(branchName));
-}
-const WORKSPACE_NATIVE_PLANS_RELATIVE_PATH = "workspace-plans";
-function visibleProjectBranchPath(projectsRoot, manifest, branchName) {
-  return (0, import_managed_paths.managedBranchPath)(projectsRoot, manifest.checkoutPathSegments, branchName);
-}
-function localPlansBranchPath(plansRoot, projectId, branchName) {
-  return import_node_path.default.join(plansRoot, projectId, branchName);
-}
-function localWorkspacePlansPath(plansRoot) {
-  return import_node_path.default.join(plansRoot, "workspace");
-}
-function assertInside(root, candidate, label) {
-  const resolvedRoot = import_node_path.default.resolve(root);
-  const resolvedCandidate = import_node_path.default.resolve(candidate);
-  const relative = import_node_path.default.relative(resolvedRoot, resolvedCandidate);
-  if (relative === ".." || relative.startsWith(`..${import_node_path.default.sep}`) || import_node_path.default.isAbsolute(relative)) {
-    throw new Error(`${label} escapes its managed root: ${candidate}`);
-  }
-}
-function listGitEligibleFiles(checkoutPath) {
-  if (!import_node_fs.default.existsSync(import_node_path.default.join(checkoutPath, ".git"))) {
-    return [];
-  }
-  const result = Bun.spawnSync(
-    [
-      "git",
-      "-c",
-      "submodule.recurse=false",
-      "-c",
-      "fetch.recurseSubmodules=false",
-      "-c",
-      "push.recurseSubmodules=false",
-      "ls-files",
-      "-z",
-      "--cached",
-      "--others",
-      "--exclude-standard",
-      "--",
-      "."
-    ],
-    {
-      cwd: checkoutPath,
-      stdout: "pipe",
-      stderr: "pipe",
-      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
-    }
-  );
-  if (result.exitCode !== 0) {
-    throw new Error(`inspect eligible project files: ${result.stderr.toString().trim() || `git exited ${result.exitCode}`}`);
-  }
-  return result.stdout.toString().split("\0").filter((entry) => entry.length > 0 && entry !== ".git" && !entry.startsWith(".git/")).filter((entry) => {
-    try {
-      const stat = import_node_fs.default.lstatSync(import_node_path.default.join(checkoutPath, ...entry.split("/")));
-      return stat.isFile() || stat.isSymbolicLink();
-    } catch {
-      return false;
-    }
-  }).sort();
-}
-function runCheckoutGitRaw(checkoutPath, args, action) {
-  const result = Bun.spawnSync(
-    ["git", "-c", "submodule.recurse=false", "-c", "fetch.recurseSubmodules=false", "-c", "push.recurseSubmodules=false", ...args],
-    {
-      cwd: checkoutPath,
-      stdout: "pipe",
-      stderr: "pipe",
-      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
-    }
-  );
-  if (result.exitCode !== 0) {
-    throw new Error(`${action}: ${result.stderr.toString().trim() || `git exited ${result.exitCode}`}`);
-  }
-  return result.stdout.toString();
-}
-function stagedCheckoutPaths(checkoutPath) {
-  return runCheckoutGitRaw(
-    checkoutPath,
-    ["diff", "--cached", "--name-only", "--no-renames", "-z", "HEAD"],
-    "inspect staged canonical resolver paths"
-  ).split("\0").filter(Boolean).sort();
-}
-function parseGitIndexEntries(output) {
-  return output.split("\0").filter(Boolean).flatMap((entry) => {
-    const separator = entry.indexOf("	");
-    if (separator === -1) return [];
-    const [mode, objectId, stage] = entry.slice(0, separator).split(" ");
-    const filePath = entry.slice(separator + 1);
-    return mode && objectId && stage && filePath ? [{ mode, objectId, stage, filePath }] : [];
-  });
-}
-function indexEntriesForPath(checkoutPath, filePath) {
-  return parseGitIndexEntries(
-    runCheckoutGitRaw(
-      checkoutPath,
-      ["--literal-pathspecs", "ls-files", "--stage", "-z", "--", filePath],
-      `inspect canonical resolver index entry for ${JSON.stringify(filePath)}`
-    )
-  );
-}
-function checkoutIndexEntries(checkoutPath) {
-  return parseGitIndexEntries(runCheckoutGitRaw(checkoutPath, ["ls-files", "--stage", "-z", "--", "."], "inspect project Git index"));
-}
-function checkoutGitlinks(checkoutPath) {
-  const entries = checkoutIndexEntries(checkoutPath);
-  const unmergedPaths = [...new Set(entries.filter((entry) => entry.stage !== "0").map((entry) => entry.filePath))].sort();
-  if (unmergedPaths.length > 0) {
-    throw new Error(`Project checkout has unmerged Git index stages: ${JSON.stringify(unmergedPaths)}`);
-  }
-  return entries.filter((entry) => entry.mode === "160000").map(({ filePath, objectId }) => ({ filePath, objectId })).sort((left, right) => left.filePath.localeCompare(right.filePath));
-}
-function revisionGitlinks(checkoutPath, revision) {
-  const output = runCheckoutGitRaw(checkoutPath, ["ls-tree", "-r", "-z", revision, "--", "."], `inspect ${revision} project gitlinks`);
-  return output.split("\0").filter(Boolean).flatMap((entry) => {
-    const separator = entry.indexOf("	");
-    if (separator === -1) return [];
-    const [mode, type, objectId] = entry.slice(0, separator).split(" ");
-    const filePath = entry.slice(separator + 1);
-    return mode === "160000" && type === "commit" && objectId && filePath ? [{ filePath, objectId }] : [];
-  }).sort((left, right) => left.filePath.localeCompare(right.filePath));
-}
-function stagedDeletedGitlinkPaths(checkoutPath) {
-  const currentEntries = checkoutIndexEntries(checkoutPath);
-  return revisionGitlinks(checkoutPath, "HEAD").filter(
-    (entry) => !currentEntries.some((candidate) => candidate.filePath === entry.filePath || candidate.filePath.startsWith(`${entry.filePath}/`))
-  ).map((entry) => entry.filePath).sort();
-}
-function lstatOrNull(filePath) {
-  try {
-    return import_node_fs.default.lstatSync(filePath);
-  } catch (error) {
-    if (error.code === "ENOENT") return null;
-    throw error;
-  }
-}
-const UNSTABLE_VISIBLE_ENTRY = /* @__PURE__ */ Symbol("unstable-visible-entry");
-function hydrationEntriesEqual(left, right) {
-  if (!left || !right || left.kind !== right.kind || left.objectId !== right.objectId) return left === right;
-  return left.kind === "gitlink" || right.kind === "blob" && left.mode === right.mode;
-}
-function gitObjectFormat(input) {
-  const cached = gitObjectFormatCache.get(input.shadowRoot);
-  if (cached) return cached;
-  const format = runGit(input, input.shadowRoot, ["rev-parse", "--show-object-format"], "inspect workspace object format");
-  if (format !== "sha1" && format !== "sha256") throw new Error(`Unsupported Git object format ${JSON.stringify(format)}`);
-  gitObjectFormatCache.set(input.shadowRoot, format);
-  return format;
-}
-function hashGitBlobBuffer(input, content) {
-  return (0, import_node_crypto.createHash)(gitObjectFormat(input)).update(`blob ${content.byteLength}\0`).update(content).digest("hex");
-}
-function hashGitBlobFile(input, filePath, size) {
-  const hash = (0, import_node_crypto.createHash)(gitObjectFormat(input));
-  hash.update(`blob ${size}\0`);
-  const file = import_node_fs.default.openSync(filePath, "r");
-  const buffer = Buffer.allocUnsafe(Math.min(MIRROR_COMPARE_BUFFER_BYTES, Math.max(1, size)));
-  try {
-    let offset = 0;
-    while (offset < size) {
-      const bytesRead = import_node_fs.default.readSync(file, buffer, 0, Math.min(buffer.length, size - offset), offset);
-      if (bytesRead === 0) return null;
-      hash.update(buffer.subarray(0, bytesRead));
-      offset += bytesRead;
-    }
-    return hash.digest("hex");
-  } finally {
-    import_node_fs.default.closeSync(file);
-  }
-}
-function filesystemHydrationEntry(input, filePath) {
-  const before = lstatOrNull(filePath);
-  if (!before) return void 0;
-  if (!before.isFile() && !before.isSymbolicLink()) return UNSTABLE_VISIBLE_ENTRY;
-  const objectFormat = gitObjectFormat(input);
-  const signature = entrySignature(before);
-  const cached = hydrationEntryCache.get(filePath);
-  if (cached?.signature === signature && cached.objectFormat === objectFormat) return cached.entry;
-  let objectId = null;
-  if (before.isSymbolicLink()) {
-    try {
-      objectId = hashGitBlobBuffer(input, Buffer.from(import_node_fs.default.readlinkSync(filePath)));
-    } catch {
-      return UNSTABLE_VISIBLE_ENTRY;
-    }
-  } else {
-    try {
-      objectId = hashGitBlobFile(input, filePath, before.size);
-    } catch {
-      return UNSTABLE_VISIBLE_ENTRY;
-    }
-  }
-  const after = lstatOrNull(filePath);
-  if (!objectId || !after || entrySignature(before) !== entrySignature(after)) return UNSTABLE_VISIBLE_ENTRY;
-  const entry = {
-    kind: "blob",
-    mode: before.isSymbolicLink() ? "120000" : (before.mode & 73) !== 0 ? "100755" : "100644",
-    objectId
-  };
-  if (hydrationEntryCache.size >= MAX_MIRROR_COMPARISON_CACHE_ENTRIES) hydrationEntryCache.clear();
-  hydrationEntryCache.set(filePath, { signature, objectFormat, entry });
-  return entry;
-}
-function projectVisibleHydrationEntry(input, visibleRoot, filePath, gitlinks) {
-  if (!hasSafeDirectoryAncestors(visibleRoot, filePath, input.projectsRoot)) return UNSTABLE_VISIBLE_ENTRY;
-  const gitlink = gitlinks.get(filePath);
-  if (gitlink) {
-    const target = lstatOrNull(import_node_path.default.join(visibleRoot, ...filePath.split("/")));
-    if (target && !target.isDirectory()) return UNSTABLE_VISIBLE_ENTRY;
-    return { kind: "gitlink", objectId: gitlink.objectId };
-  }
-  return filesystemHydrationEntry(input, import_node_path.default.join(visibleRoot, ...filePath.split("/")));
-}
-function revisionHydrationPreimage(input, revision, relativeRoot) {
-  const result = runGitResult(input, input.shadowRoot, ["--literal-pathspecs", "ls-tree", "-r", "-z", revision, "--", relativeRoot]);
-  if (result.exitCode !== 0) {
-    throw new Error(
-      `Inspect workspace hydration baseline ${revision}:${relativeRoot}: ${result.stderr || `git exited ${result.exitCode}`}`
-    );
-  }
-  if (!result.stdout) return /* @__PURE__ */ new Map();
-  const prefix = `${relativeRoot}/`;
-  const preimage = /* @__PURE__ */ new Map();
-  for (const serialized of result.stdout.split("\0").filter(Boolean)) {
-    const separator = serialized.indexOf("	");
-    if (separator === -1) continue;
-    const [mode, type, objectId] = serialized.slice(0, separator).split(" ");
-    const workspacePath = serialized.slice(separator + 1);
-    if (!objectId || !workspacePath.startsWith(prefix)) continue;
-    const filePath = workspacePath.slice(prefix.length);
-    if (mode === "160000" && type === "commit") {
-      preimage.set(filePath, { kind: "gitlink", objectId });
-    } else if ((mode === "100644" || mode === "100755" || mode === "120000") && type === "blob") {
-      preimage.set(filePath, { kind: "blob", mode, objectId });
-    }
-  }
-  return preimage;
-}
-function indexHydrationPreimage(input, relativeRoot) {
-  const prefix = `${relativeRoot}/`;
-  const entries = parseGitIndexEntries(
-    runGit(input, input.shadowRoot, ["--literal-pathspecs", "ls-files", "--stage", "-z", "--", relativeRoot], "inspect hydrated workspace")
-  );
-  const unmergedPaths = entries.filter((entry) => entry.stage !== "0").map((entry) => entry.filePath);
-  if (unmergedPaths.length > 0) throw new Error(`Canonical workspace has unmerged Git index stages: ${JSON.stringify(unmergedPaths)}`);
-  const preimage = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    if (!entry.filePath.startsWith(prefix)) continue;
-    const filePath = entry.filePath.slice(prefix.length);
-    if (entry.mode === "160000") {
-      preimage.set(filePath, { kind: "gitlink", objectId: entry.objectId });
-    } else if (entry.mode === "100644" || entry.mode === "100755" || entry.mode === "120000") {
-      preimage.set(filePath, { kind: "blob", mode: entry.mode, objectId: entry.objectId });
-    }
-  }
-  return preimage;
-}
-function worktreeDiffersFromIndex(checkoutPath, filePath) {
-  const result = Bun.spawnSync(
-    ["git", "--literal-pathspecs", "-c", "core.fileMode=true", "diff", "--quiet", "--no-ext-diff", "--", filePath],
-    {
-      cwd: checkoutPath,
-      stdout: "ignore",
-      stderr: "pipe",
-      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
-    }
-  );
-  if (result.exitCode === 0) return false;
-  if (result.exitCode === 1) return true;
-  throw new Error(
-    `compare canonical resolver index and worktree for ${JSON.stringify(filePath)}: ${result.stderr.toString().trim() || `git exited ${result.exitCode}`}`
-  );
-}
-function indexEntryTypeMatchesWorktree(entry, stat) {
-  if (entry.mode === "120000") return stat.isSymbolicLink();
-  if (entry.mode !== "100644" && entry.mode !== "100755") return false;
-  if (!stat.isFile()) return false;
-  return entry.mode === "100755" === ((stat.mode & 73) !== 0);
-}
-function assertCanonicalCheckoutIndexMatchesWorktree(checkoutPath) {
-  checkoutGitlinks(checkoutPath);
-  const mismatchedPaths = [];
-  for (const filePath of stagedCheckoutPaths(checkoutPath)) {
-    const entries = indexEntriesForPath(checkoutPath, filePath);
-    const worktreeEntry = lstatOrNull(import_node_path.default.join(checkoutPath, ...filePath.split("/")));
-    if (entries.length === 0) {
-      if (worktreeEntry && !worktreeEntry.isDirectory()) mismatchedPaths.push(filePath);
-      continue;
-    }
-    if (entries.length === 1 && entries[0]?.stage === "0" && entries[0].mode === "160000") {
-      if (worktreeEntry && !worktreeEntry.isDirectory()) mismatchedPaths.push(filePath);
-      continue;
-    }
-    if (entries.length !== 1 || entries[0]?.stage !== "0" || !worktreeEntry || !indexEntryTypeMatchesWorktree(entries[0], worktreeEntry) || worktreeDiffersFromIndex(checkoutPath, filePath)) {
-      mismatchedPaths.push(filePath);
-    }
-  }
-  if (mismatchedPaths.length > 0) {
-    throw new Error(
-      `Canonical resolver checkout has staged Git index state that is not represented by its worktree: ${JSON.stringify(
-        mismatchedPaths
-      )}. Make the worktree match the index or unstage these paths before synchronizing.`
-    );
-  }
-}
-function checkoutGitSnapshot(checkoutPath) {
-  const gitPaths = Bun.spawnSync(
-    [
-      "git",
-      "-c",
-      "submodule.recurse=false",
-      "-c",
-      "fetch.recurseSubmodules=false",
-      "-c",
-      "push.recurseSubmodules=false",
-      "rev-parse",
-      "--git-path",
-      "index",
-      ...ACTIVE_GIT_LOCK_PATHS.flatMap((lock) => ["--git-path", lock])
-    ],
-    {
-      cwd: checkoutPath,
-      stdout: "pipe",
-      stderr: "ignore",
-      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
-    }
-  );
-  if (gitPaths.exitCode !== 0) return null;
-  const [indexPath, ...lockPaths] = gitPaths.stdout.toString().trim().split(/\r?\n/).map((gitPath) => import_node_path.default.resolve(checkoutPath, gitPath));
-  if (!indexPath || lockPaths.length !== ACTIVE_GIT_LOCK_PATHS.length || lockPaths.some((lockPath) => import_node_fs.default.existsSync(lockPath))) {
-    return null;
-  }
-  const head = Bun.spawnSync(
-    [
-      "git",
-      "-c",
-      "submodule.recurse=false",
-      "-c",
-      "fetch.recurseSubmodules=false",
-      "-c",
-      "push.recurseSubmodules=false",
-      "rev-parse",
-      "--verify",
-      "HEAD"
-    ],
-    {
-      cwd: checkoutPath,
-      stdout: "pipe",
-      stderr: "ignore",
-      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
-    }
-  );
-  let indexSignature = "missing";
-  try {
-    const stat = import_node_fs.default.statSync(indexPath);
-    indexSignature = entrySignature(stat);
-  } catch {
-  }
-  if (lockPaths.some((lockPath) => import_node_fs.default.existsSync(lockPath))) return null;
-  return `${head.exitCode === 0 ? head.stdout.toString().trim() : "unborn"}\0${indexSignature}`;
-}
-function listShadowTrackedFiles(input, relativeRoot) {
-  const normalizedRoot = relativeRoot.split(import_node_path.default.sep).join("/").replace(/^\/+|\/+$/g, "");
-  const output = runGit(input, input.shadowRoot, ["ls-files", "-z", "--cached", "--", normalizedRoot], "list canonical workspace files");
-  const prefix = `${normalizedRoot}/`;
-  return output.split("\0").filter((entry) => entry.startsWith(prefix)).map((entry) => entry.slice(prefix.length)).filter(Boolean).sort();
-}
-function pathIsWithinOpaqueRoot(relativePath, opaqueRoots) {
-  return opaqueRoots.some((root) => relativePath === root || relativePath.startsWith(`${root}/`));
-}
-function listFilesRecursively(root, filter, opaqueRoots = []) {
-  if (!import_node_fs.default.existsSync(root)) return [];
-  const files = [];
-  const visit = (current, relativeDir) => {
-    for (const entry of import_node_fs.default.readdirSync(current, { withFileTypes: true })) {
-      if (entry.name === ".git") continue;
-      const relativePath = relativeDir ? import_node_path.default.posix.join(relativeDir, entry.name) : entry.name;
-      const absolutePath = import_node_path.default.join(current, entry.name);
-      if (pathIsWithinOpaqueRoot(relativePath, opaqueRoots)) continue;
-      if (entry.isDirectory()) {
-        visit(absolutePath, relativePath);
-      } else if (!filter || filter(relativePath)) {
-        files.push(relativePath);
-      }
-    }
-  };
-  visit(root, "");
-  return files.sort();
-}
-function removeEmptyDirectories(root, opaqueRoots = []) {
-  if (!import_node_fs.default.existsSync(root)) return;
-  const visit = (current, relativeDir) => {
-    let empty = true;
-    for (const entry of import_node_fs.default.readdirSync(current, { withFileTypes: true })) {
-      const absolutePath = import_node_path.default.join(current, entry.name);
-      const relativePath = relativeDir ? import_node_path.default.posix.join(relativeDir, entry.name) : entry.name;
-      if (pathIsWithinOpaqueRoot(relativePath, opaqueRoots)) {
-        empty = false;
-        continue;
-      }
-      if (entry.isDirectory()) {
-        if (!visit(absolutePath, relativePath)) empty = false;
-      } else {
-        empty = false;
-      }
-    }
-    if (empty && current !== root) import_node_fs.default.rmdirSync(current);
-    return empty;
-  };
-  visit(root, "");
-}
-function copyEntry(sourceRoot, targetRoot, relativePath, trustedRoots = {}) {
-  const sourcePath = import_node_path.default.resolve(sourceRoot, ...relativePath.split("/"));
-  const targetPath = import_node_path.default.resolve(targetRoot, ...relativePath.split("/"));
-  assertInside(sourceRoot, sourcePath, "Workspace source path");
-  assertInside(targetRoot, targetPath, "Workspace target path");
-  if (!hasSafeDirectoryAncestors(sourceRoot, relativePath, trustedRoots.source ?? sourceRoot)) {
-    throw new Error(`Workspace source path has a symlink or non-directory ancestor: ${relativePath}`);
-  }
-  if (!hasSafeDirectoryAncestors(targetRoot, relativePath, trustedRoots.target ?? targetRoot)) {
-    throw new Error(`Workspace target path has a symlink or non-directory ancestor: ${relativePath}`);
-  }
-  const stat = import_node_fs.default.lstatSync(sourcePath);
-  import_node_fs.default.mkdirSync(import_node_path.default.dirname(targetPath), { recursive: true });
-  import_node_fs.default.rmSync(targetPath, { recursive: true, force: true });
-  if (stat.isSymbolicLink()) {
-    import_node_fs.default.symlinkSync(import_node_fs.default.readlinkSync(sourcePath), targetPath);
-    return;
-  }
-  if (stat.isFile()) {
-    import_node_fs.default.copyFileSync(sourcePath, targetPath);
-    import_node_fs.default.chmodSync(targetPath, stat.mode);
-  }
-}
-function hasSafeDirectoryAncestors(root, relativePath, trustedRoot = root) {
-  const resolvedTrustedRoot = import_node_path.default.resolve(trustedRoot);
-  const trustedRootStat = lstatOrNull(resolvedTrustedRoot);
-  if (trustedRootStat && (!trustedRootStat.isDirectory() || trustedRootStat.isSymbolicLink())) return false;
-  const resolvedRoot = import_node_path.default.resolve(root);
-  const targetParent = import_node_path.default.dirname(import_node_path.default.resolve(resolvedRoot, ...relativePath.split("/")));
-  const relativeParent = import_node_path.default.relative(resolvedTrustedRoot, targetParent);
-  if (relativeParent === ".." || relativeParent.startsWith(`..${import_node_path.default.sep}`) || import_node_path.default.isAbsolute(relativeParent)) return false;
-  let current = resolvedTrustedRoot;
-  for (const segment of relativeParent.split(import_node_path.default.sep).filter(Boolean)) {
-    current = import_node_path.default.join(current, segment);
-    const stat = lstatOrNull(current);
-    if (stat && (!stat.isDirectory() || stat.isSymbolicLink())) return false;
-  }
-  return true;
-}
-function entrySignature(stat) {
-  return [stat.dev, stat.ino, stat.mode, stat.size, stat.mtimeMs, stat.ctimeMs].join(":");
-}
-function regularFilesEqual(sourcePath, targetPath, size) {
-  const sourceFd = import_node_fs.default.openSync(sourcePath, "r");
-  const targetFd = import_node_fs.default.openSync(targetPath, "r");
-  const sourceBuffer = Buffer.allocUnsafe(Math.min(MIRROR_COMPARE_BUFFER_BYTES, Math.max(1, size)));
-  const targetBuffer = Buffer.allocUnsafe(sourceBuffer.length);
-  try {
-    let offset = 0;
-    while (offset < size) {
-      const length = Math.min(sourceBuffer.length, size - offset);
-      const sourceBytes = import_node_fs.default.readSync(sourceFd, sourceBuffer, 0, length, offset);
-      const targetBytes = import_node_fs.default.readSync(targetFd, targetBuffer, 0, length, offset);
-      if (sourceBytes === 0 || targetBytes === 0 || sourceBytes !== targetBytes || !sourceBuffer.subarray(0, sourceBytes).equals(targetBuffer.subarray(0, targetBytes))) {
-        return false;
-      }
-      offset += sourceBytes;
-    }
-    return true;
-  } finally {
-    import_node_fs.default.closeSync(sourceFd);
-    import_node_fs.default.closeSync(targetFd);
-  }
-}
-function entriesEqual(sourcePath, targetPath) {
-  let sourceStat;
-  let targetStat;
-  try {
-    sourceStat = import_node_fs.default.lstatSync(sourcePath);
-    targetStat = import_node_fs.default.lstatSync(targetPath);
-  } catch {
-    return false;
-  }
-  const cacheKey = `${sourcePath}\0${targetPath}`;
-  const signature = `${entrySignature(sourceStat)}\0${entrySignature(targetStat)}`;
-  if (mirrorComparisonCache.get(cacheKey) === signature) return true;
-  let equal = false;
-  if (sourceStat.isSymbolicLink() && targetStat.isSymbolicLink()) {
-    equal = import_node_fs.default.readlinkSync(sourcePath) === import_node_fs.default.readlinkSync(targetPath);
-  } else if (sourceStat.isFile() && targetStat.isFile()) {
-    equal = sourceStat.size === targetStat.size && (sourceStat.mode & 73) === (targetStat.mode & 73) && regularFilesEqual(sourcePath, targetPath, sourceStat.size);
-  }
-  if (equal) {
-    if (mirrorComparisonCache.size >= MAX_MIRROR_COMPARISON_CACHE_ENTRIES) mirrorComparisonCache.clear();
-    mirrorComparisonCache.set(cacheKey, signature);
-  } else {
-    mirrorComparisonCache.delete(cacheKey);
-  }
-  return equal;
-}
-function mirrorFileSet(sourceRoot, targetRoot, sourceFiles, targetFiles, opaqueTargetRoots = [], opaqueSourceRoots = [], trustedRoots = {}) {
-  if (!hasSafeDirectoryAncestors(targetRoot, ".r5d-mirror-root", trustedRoots.target ?? targetRoot)) {
-    throw new Error(`Workspace target root has a symlink or non-directory ancestor: ${targetRoot}`);
-  }
-  import_node_fs.default.mkdirSync(targetRoot, { recursive: true });
-  const sourceSet = new Set(sourceFiles);
-  for (const relativePath of targetFiles) {
-    if (pathIsWithinOpaqueRoot(relativePath, opaqueTargetRoots)) continue;
-    if (sourceSet.has(relativePath)) continue;
-    const targetPath = import_node_path.default.resolve(targetRoot, ...relativePath.split("/"));
-    assertInside(targetRoot, targetPath, "Workspace deletion path");
-    if (!hasSafeDirectoryAncestors(targetRoot, relativePath, trustedRoots.target ?? targetRoot)) {
-      throw new Error(`Workspace deletion path has a symlink or non-directory ancestor: ${relativePath}`);
-    }
-    import_node_fs.default.rmSync(targetPath, { recursive: true, force: true });
-  }
-  for (const relativePath of sourceFiles) {
-    if (pathIsWithinOpaqueRoot(relativePath, opaqueSourceRoots)) continue;
-    if (pathIsWithinOpaqueRoot(relativePath, opaqueTargetRoots)) continue;
-    if (!hasSafeDirectoryAncestors(sourceRoot, relativePath, trustedRoots.source ?? sourceRoot)) {
-      throw new Error(`Workspace source path has a symlink or non-directory ancestor: ${relativePath}`);
-    }
-    if (!hasSafeDirectoryAncestors(targetRoot, relativePath, trustedRoots.target ?? targetRoot)) {
-      throw new Error(`Workspace target path has a symlink or non-directory ancestor: ${relativePath}`);
-    }
-    const sourcePath = import_node_path.default.resolve(sourceRoot, ...relativePath.split("/"));
-    const stat = lstatOrNull(sourcePath);
-    if (!stat) continue;
-    if (!stat.isFile() && !stat.isSymbolicLink()) continue;
-    const targetPath = import_node_path.default.resolve(targetRoot, ...relativePath.split("/"));
-    if (entriesEqual(sourcePath, targetPath)) continue;
-    copyEntry(sourceRoot, targetRoot, relativePath, trustedRoots);
-  }
-  removeEmptyDirectories(targetRoot, opaqueTargetRoots);
-}
-function indexPathsUnderCheckoutPath(checkoutPath, filePath) {
-  return runCheckoutGitRaw(
-    checkoutPath,
-    ["--literal-pathspecs", "ls-files", "-z", "--", filePath],
-    `inspect index paths beneath ${JSON.stringify(filePath)}`
-  ).split("\0").filter(Boolean);
-}
-function replaceCheckoutIndexPathWithGitlink(checkoutPath, gitlink) {
-  const zeroObjectId = "0".repeat(gitlink.objectId.length);
-  const records = [
-    ...indexPathsUnderCheckoutPath(checkoutPath, gitlink.filePath).map((indexPath) => `0 ${zeroObjectId}	${indexPath}`),
-    `160000 ${gitlink.objectId}	${gitlink.filePath}`
-  ];
-  const result = Bun.spawnSync(
-    [
-      "git",
-      "-c",
-      "submodule.recurse=false",
-      "-c",
-      "fetch.recurseSubmodules=false",
-      "-c",
-      "push.recurseSubmodules=false",
-      "update-index",
-      "-z",
-      "--index-info"
-    ],
-    {
-      cwd: checkoutPath,
-      stdin: Buffer.from(`${records.join("\0")}\0`),
-      stdout: "pipe",
-      stderr: "pipe",
-      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
-    }
-  );
-  if (result.exitCode !== 0) {
-    throw new Error(
-      `record gitlink ${JSON.stringify(gitlink.filePath)}: ${result.stderr.toString().trim() || `git exited ${result.exitCode}`}`
-    );
-  }
-}
-function removeCheckoutIndexPath(checkoutPath, filePath) {
-  runCheckoutGitRaw(
-    checkoutPath,
-    ["--literal-pathspecs", "update-index", "--force-remove", "--", filePath],
-    `remove gitlink ${JSON.stringify(filePath)}`
-  );
-}
-function shadowProjectGitlinks(input, relativeRoot) {
-  const prefix = `${relativeRoot}/`;
-  const entries = parseGitIndexEntries(
-    runGit(input, input.shadowRoot, ["--literal-pathspecs", "ls-files", "--stage", "-z", "--", relativeRoot], "inspect workspace gitlinks")
-  );
-  const unmergedPaths = [...new Set(entries.filter((entry) => entry.stage !== "0").map((entry) => entry.filePath))].sort();
-  if (unmergedPaths.length > 0) {
-    throw new Error(`Canonical workspace has unmerged Git index stages: ${JSON.stringify(unmergedPaths)}`);
-  }
-  return entries.filter((entry) => entry.mode === "160000" && entry.filePath.startsWith(prefix)).map((entry) => ({ filePath: entry.filePath.slice(prefix.length), objectId: entry.objectId })).sort((left, right) => left.filePath.localeCompare(right.filePath));
-}
-function replaceShadowIndexPathWithGitlink(input, relativeRoot, gitlink) {
-  const workspacePath = import_node_path.default.posix.join(relativeRoot, gitlink.filePath);
-  const existingPaths = runGit(
-    input,
-    input.shadowRoot,
-    ["--literal-pathspecs", "ls-files", "-z", "--", workspacePath],
-    `inspect workspace index beneath gitlink ${JSON.stringify(workspacePath)}`
-  ).split("\0").filter(Boolean);
-  for (const indexPath of existingPaths) {
-    runGit(
-      input,
-      input.shadowRoot,
-      ["--literal-pathspecs", "update-index", "--force-remove", "--", indexPath],
-      `remove workspace index entry beneath gitlink ${JSON.stringify(workspacePath)}`
-    );
-  }
-  const placeholderPath = import_node_path.default.join(input.shadowRoot, ...workspacePath.split("/"));
-  import_node_fs.default.rmSync(placeholderPath, { recursive: true, force: true });
-  import_node_fs.default.mkdirSync(placeholderPath, { recursive: true });
-  runGit(
-    input,
-    input.shadowRoot,
-    ["--literal-pathspecs", "update-index", "--add", "--cacheinfo", "160000", gitlink.objectId, workspacePath],
-    `record workspace gitlink ${JSON.stringify(workspacePath)}`
-  );
-}
-function mirrorVisibleGitlinksToShadow(input, relativeRoot, visibleGitlinks) {
-  const desiredByPath = new Map(visibleGitlinks.map((entry) => [entry.filePath, entry]));
-  for (const current of shadowProjectGitlinks(input, relativeRoot)) {
-    if (desiredByPath.has(current.filePath)) continue;
-    const workspacePath = import_node_path.default.posix.join(relativeRoot, current.filePath);
-    runGit(
-      input,
-      input.shadowRoot,
-      ["--literal-pathspecs", "update-index", "--force-remove", "--", workspacePath],
-      `remove deleted workspace gitlink ${JSON.stringify(workspacePath)}`
-    );
-    import_node_fs.default.rmSync(import_node_path.default.join(input.shadowRoot, ...workspacePath.split("/")), { recursive: true, force: true });
-  }
-  for (const gitlink of visibleGitlinks) replaceShadowIndexPathWithGitlink(input, relativeRoot, gitlink);
-}
-function mirrorShadowGitlinksToVisible(desired, visibleRoot, trustedRoot) {
-  const desiredByPath = new Map(desired.map((entry) => [entry.filePath, entry]));
-  for (const current of checkoutGitlinks(visibleRoot)) {
-    if (!desiredByPath.has(current.filePath)) removeCheckoutIndexPath(visibleRoot, current.filePath);
-  }
-  for (const gitlink of desired) {
-    if (!hasSafeDirectoryAncestors(visibleRoot, gitlink.filePath, trustedRoot)) {
-      throw new Error(`Visible gitlink path has a symlink or non-directory ancestor: ${gitlink.filePath}`);
-    }
-    const visiblePath = import_node_path.default.join(visibleRoot, ...gitlink.filePath.split("/"));
-    const existing = lstatOrNull(visiblePath);
-    if (existing && !existing.isDirectory()) import_node_fs.default.rmSync(visiblePath, { recursive: true, force: true });
-    import_node_fs.default.mkdirSync(visiblePath, { recursive: true });
-    replaceCheckoutIndexPathWithGitlink(visibleRoot, gitlink);
-  }
-}
-function assertSafeVisibleGitlinkTransitions(visibleRoot, trustedRoot, currentGitlinks, desiredGitlinks, shadowFiles) {
-  const desiredGitlinkPaths = new Set(desiredGitlinks.map((entry) => entry.filePath));
-  for (const current of currentGitlinks) {
-    if (desiredGitlinkPaths.has(current.filePath)) continue;
-    const becomesOrdinaryPath = shadowFiles.some(
-      (filePath) => filePath === current.filePath || filePath.startsWith(`${current.filePath}/`)
-    );
-    if (!becomesOrdinaryPath) continue;
-    if (!hasSafeDirectoryAncestors(visibleRoot, current.filePath, trustedRoot)) {
-      throw new Error(`Visible gitlink path has a symlink or non-directory ancestor: ${current.filePath}`);
-    }
-    const existing = lstatOrNull(import_node_path.default.join(visibleRoot, ...current.filePath.split("/")));
-    if (!existing) continue;
-    if (existing.isDirectory() && import_node_fs.default.readdirSync(import_node_path.default.join(visibleRoot, ...current.filePath.split("/"))).length === 0) {
-      continue;
-    }
-    throw new Error(
-      `Cannot replace initialized or nonempty gitlink ${JSON.stringify(
-        current.filePath
-      )} with ordinary workspace content without deleting submodule data`
-    );
-  }
-}
-function restoreShadowProjectSnapshot(input, relativeRoot) {
-  const shadowRoot = import_node_path.default.join(input.shadowRoot, ...relativeRoot.split("/"));
-  const headFiles = runGitResult(input, input.shadowRoot, ["ls-tree", "-r", "--name-only", "-z", "HEAD", "--", relativeRoot]);
-  if (headFiles.exitCode === 0 && headFiles.stdout) {
-    runGit(
-      input,
-      input.shadowRoot,
-      ["restore", "--source=HEAD", "--staged", "--worktree", "--", relativeRoot],
-      "restore deferred checkout scan"
-    );
-    runGit(input, input.shadowRoot, ["clean", "-fd", "--", relativeRoot], "clean deferred checkout scan");
-    return;
-  }
-  runGitResult(input, input.shadowRoot, ["--literal-pathspecs", "rm", "-r", "-f", "--cached", "--ignore-unmatch", "--", relativeRoot]);
-  import_node_fs.default.rmSync(shadowRoot, { recursive: true, force: true });
-}
-function copiedHydrationPreimage(input, shadowRoot, ordinaryFiles, gitlinks = []) {
-  const preimage = new Map(
-    gitlinks.map((entry) => [entry.filePath, { kind: "gitlink", objectId: entry.objectId }])
-  );
-  for (const filePath of ordinaryFiles) {
-    const entry = filesystemHydrationEntry(input, import_node_path.default.join(shadowRoot, ...filePath.split("/")));
-    if (!entry || entry === UNSTABLE_VISIBLE_ENTRY) return null;
-    preimage.set(filePath, entry);
-  }
-  return preimage;
-}
-function visibleProjectMatchesCopiedPreimage(input, visibleRoot, ordinaryFiles, gitlinks, preimage, opaqueRoots) {
-  const currentFiles = listGitEligibleFiles(visibleRoot).filter((filePath) => !pathIsWithinOpaqueRoot(filePath, opaqueRoots));
-  if (currentFiles.length !== ordinaryFiles.length || currentFiles.some((filePath, index) => filePath !== ordinaryFiles[index]))
-    return false;
-  const currentGitlinks = checkoutGitlinks(visibleRoot);
-  if (currentGitlinks.length !== gitlinks.length || currentGitlinks.some((entry, index) => entry.filePath !== gitlinks[index]?.filePath || entry.objectId !== gitlinks[index]?.objectId)) {
-    return false;
-  }
-  const currentGitlinksByPath = new Map(currentGitlinks.map((entry) => [entry.filePath, entry]));
-  return ordinaryFiles.every((filePath) => {
-    const current = projectVisibleHydrationEntry(input, visibleRoot, filePath, currentGitlinksByPath);
-    return current !== UNSTABLE_VISIBLE_ENTRY && hydrationEntriesEqual(current, preimage.get(filePath));
-  });
-}
-function mirrorVisibleProjectToShadow(input, manifest, branchName) {
-  const visibleRoot = visibleProjectBranchPath(input.projectsRoot, manifest, branchName);
-  const unavailableProjection = () => ({
-    entries: [],
-    opaqueRoots: [],
-    visiblePreimages: /* @__PURE__ */ new Map([[visibleRoot, null]])
-  });
-  if (!hasSafeDirectoryAncestors(visibleRoot, ".r5d-project-scan", input.projectsRoot)) return unavailableProjection();
-  if (!import_node_fs.default.existsSync(import_node_path.default.join(visibleRoot, ".git"))) return unavailableProjection();
-  const isCanonicalCheckout = manifest.canonicalCheckouts?.some((checkout) => checkout.branchName === branchName);
-  if (isCanonicalCheckout) {
-    assertCanonicalCheckoutIndexMatchesWorktree(visibleRoot);
-  }
-  const beforeSnapshot = checkoutGitSnapshot(visibleRoot);
-  if (!beforeSnapshot) return unavailableProjection();
-  const visibleGitlinks = checkoutGitlinks(visibleRoot);
-  const visibleIndexEntries = checkoutIndexEntries(visibleRoot).filter((entry) => entry.stage === "0");
-  const indexedGitlinkPaths = new Set(visibleGitlinks.map((entry) => entry.filePath));
-  const stagedDeletedGitlinkRoots = stagedDeletedGitlinkPaths(visibleRoot);
-  const relativeRoot = workspaceProjectBranchRelativePath(manifest.projectId, branchName);
-  const shadowGitlinkRoots = shadowProjectGitlinks(input, relativeRoot).filter(
-    (entry) => !indexedGitlinkPaths.has(entry.filePath) && !visibleIndexEntries.some(
-      (candidate) => candidate.mode !== "160000" && (candidate.filePath === entry.filePath || candidate.filePath.startsWith(`${entry.filePath}/`))
-    )
-  ).map((entry) => entry.filePath);
-  const visibleGitlinkRoots = [.../* @__PURE__ */ new Set([...indexedGitlinkPaths, ...stagedDeletedGitlinkRoots, ...shadowGitlinkRoots])].sort();
-  const visibleFiles = listGitEligibleFiles(visibleRoot).filter((filePath) => !pathIsWithinOpaqueRoot(filePath, visibleGitlinkRoots));
-  const shadowRoot = import_node_path.default.join(input.shadowRoot, ...relativeRoot.split("/"));
-  mirrorVisibleGitlinksToShadow(input, relativeRoot, visibleGitlinks);
-  mirrorFileSet(visibleRoot, shadowRoot, visibleFiles, listFilesRecursively(shadowRoot), visibleGitlinkRoots, visibleGitlinkRoots, {
-    source: input.projectsRoot,
-    target: input.shadowRoot
-  });
-  const hydrationPreimage = copiedHydrationPreimage(input, shadowRoot, visibleFiles, visibleGitlinks);
-  if (!hydrationPreimage || checkoutGitSnapshot(visibleRoot) !== beforeSnapshot || !visibleProjectMatchesCopiedPreimage(input, visibleRoot, visibleFiles, visibleGitlinks, hydrationPreimage, visibleGitlinkRoots)) {
-    restoreShadowProjectSnapshot(input, relativeRoot);
-    return { entries: [], opaqueRoots: [], visiblePreimages: /* @__PURE__ */ new Map([[visibleRoot, null]]) };
-  }
-  return {
-    entries: visibleGitlinks.map((entry) => ({
-      filePath: import_node_path.default.posix.join(relativeRoot, entry.filePath),
-      objectId: entry.objectId
-    })),
-    opaqueRoots: visibleGitlinkRoots.map((filePath) => import_node_path.default.posix.join(relativeRoot, filePath)),
-    visiblePreimages: /* @__PURE__ */ new Map([[visibleRoot, hydrationPreimage]])
-  };
-}
-function pathDepth(filePath) {
-  return filePath.split("/").length;
-}
-function pathsOverlap(left, right) {
-  return left === right || left.startsWith(`${right}/`) || right.startsWith(`${left}/`);
-}
-function removeVisibleBlob(visibleRoot, filePath, trustedRoot) {
-  if (!hasSafeDirectoryAncestors(visibleRoot, filePath, trustedRoot)) return false;
-  const absolutePath = import_node_path.default.join(visibleRoot, ...filePath.split("/"));
-  const stat = lstatOrNull(absolutePath);
-  if (!stat || !stat.isFile() && !stat.isSymbolicLink()) return false;
-  import_node_fs.default.rmSync(absolutePath, { force: true });
-  return true;
-}
-function removeEmptyVisibleAncestors(visibleRoot, filePath, trustedRoot, opaqueRoots = []) {
-  if (!hasSafeDirectoryAncestors(visibleRoot, filePath, trustedRoot)) return;
-  const resolvedRoot = import_node_path.default.resolve(visibleRoot);
-  let current = import_node_path.default.dirname(import_node_path.default.join(resolvedRoot, ...filePath.split("/")));
-  while (current !== resolvedRoot) {
-    const relative = import_node_path.default.relative(resolvedRoot, current).split(import_node_path.default.sep).join("/");
-    if (!relative || pathIsWithinOpaqueRoot(relative, opaqueRoots)) return;
-    const stat = lstatOrNull(current);
-    if (!stat) {
-      current = import_node_path.default.dirname(current);
-      continue;
-    }
-    if (!stat.isDirectory() || stat.isSymbolicLink() || import_node_fs.default.readdirSync(current).length > 0) return;
-    try {
-      import_node_fs.default.rmdirSync(current);
-    } catch (error) {
-      if (error.code === "ENOTEMPTY" || error.code === "ENOENT") return;
-      throw error;
-    }
-    current = import_node_path.default.dirname(current);
-  }
-}
-function copyShadowBlobToVisible(shadowRoot, visibleRoot, filePath, trustedRoot) {
-  if (!hasSafeDirectoryAncestors(visibleRoot, filePath, trustedRoot)) return false;
-  const targetPath = import_node_path.default.join(visibleRoot, ...filePath.split("/"));
-  const existing = lstatOrNull(targetPath);
-  if (existing?.isDirectory()) {
-    if (import_node_fs.default.readdirSync(targetPath).length > 0) return false;
-    import_node_fs.default.rmdirSync(targetPath);
-  } else if (existing) {
-    import_node_fs.default.rmSync(targetPath, { force: true });
-  }
-  try {
-    copyEntry(shadowRoot, visibleRoot, filePath, { target: trustedRoot });
-    return true;
-  } catch (error) {
-    if (error.code === "EEXIST" || error.code === "ENOTDIR") return false;
-    throw error;
-  }
-}
-function hydrateProjectFromShadowOptimistically(input, relativeRoot, visibleRoot, preimage, opaqueVisibleGitlinks) {
-  const shadowRoot = import_node_path.default.join(input.shadowRoot, ...relativeRoot.split("/"));
-  const desired = indexHydrationPreimage(input, relativeRoot);
-  let expectedCheckoutSnapshot = checkoutGitSnapshot(visibleRoot);
-  if (!expectedCheckoutSnapshot) return;
-  const checkoutIndexIsStable = () => checkoutGitSnapshot(visibleRoot) === expectedCheckoutSnapshot;
-  const refreshCheckoutSnapshot = () => {
-    expectedCheckoutSnapshot = checkoutGitSnapshot(visibleRoot);
-    return expectedCheckoutSnapshot !== null;
-  };
-  const currentGitlinks = new Map(checkoutGitlinks(visibleRoot).map((entry) => [entry.filePath, entry]));
-  const changedPaths = [.../* @__PURE__ */ new Set([...preimage.keys(), ...desired.keys()])].filter(
-    (filePath) => !hydrationEntriesEqual(preimage.get(filePath), desired.get(filePath))
-  );
-  for (const filePath of changedPaths.filter((candidate) => !desired.has(candidate)).sort((left, right) => pathDepth(right) - pathDepth(left) || left.localeCompare(right))) {
-    const current = projectVisibleHydrationEntry(input, visibleRoot, filePath, currentGitlinks);
-    if (current === UNSTABLE_VISIBLE_ENTRY || !hydrationEntriesEqual(current, preimage.get(filePath))) continue;
-    const expected = preimage.get(filePath);
-    if (expected?.kind === "gitlink") {
-      if (!checkoutIndexIsStable()) return;
-      removeCheckoutIndexPath(visibleRoot, filePath);
-      if (!refreshCheckoutSnapshot()) return;
-      currentGitlinks.delete(filePath);
-    } else if (removeVisibleBlob(visibleRoot, filePath, input.projectsRoot)) {
-      removeEmptyVisibleAncestors(visibleRoot, filePath, input.projectsRoot, opaqueVisibleGitlinks);
-    }
-  }
-  for (const filePath of changedPaths.filter((candidate) => desired.has(candidate)).sort((left, right) => pathDepth(left) - pathDepth(right) || left.localeCompare(right))) {
-    const wanted = desired.get(filePath);
-    if (!wanted) continue;
-    const current = projectVisibleHydrationEntry(input, visibleRoot, filePath, currentGitlinks);
-    if (current === UNSTABLE_VISIBLE_ENTRY || hydrationEntriesEqual(current, wanted)) continue;
-    if (!hydrationEntriesEqual(current, preimage.get(filePath))) continue;
-    if (wanted.kind === "gitlink") {
-      if (!hasSafeDirectoryAncestors(visibleRoot, filePath, input.projectsRoot) || !checkoutIndexIsStable()) return;
-      const targetPath = import_node_path.default.join(visibleRoot, ...filePath.split("/"));
-      const existing = lstatOrNull(targetPath);
-      if (existing && !existing.isDirectory()) import_node_fs.default.rmSync(targetPath, { force: true });
-      import_node_fs.default.mkdirSync(targetPath, { recursive: true });
-      replaceCheckoutIndexPathWithGitlink(visibleRoot, { filePath, objectId: wanted.objectId });
-      if (!refreshCheckoutSnapshot()) return;
-      currentGitlinks.set(filePath, { filePath, objectId: wanted.objectId });
-      continue;
-    }
-    const expected = preimage.get(filePath);
-    if (expected?.kind === "gitlink") {
-      if (!hasSafeDirectoryAncestors(visibleRoot, filePath, input.projectsRoot) || !checkoutIndexIsStable()) return;
-      const targetPath = import_node_path.default.join(visibleRoot, ...filePath.split("/"));
-      const existing = lstatOrNull(targetPath);
-      if (existing?.isDirectory() && import_node_fs.default.readdirSync(targetPath).length > 0) continue;
-      removeCheckoutIndexPath(visibleRoot, filePath);
-      if (!refreshCheckoutSnapshot()) return;
-      currentGitlinks.delete(filePath);
-    }
-    copyShadowBlobToVisible(shadowRoot, visibleRoot, filePath, input.projectsRoot);
-  }
-}
-function mirrorShadowProjectToVisible(input, manifest, branchName, additionalOpaqueRoots = [], hydrationPreimage) {
-  const visibleRoot = visibleProjectBranchPath(input.projectsRoot, manifest, branchName);
-  if (hydrationPreimage === null) return;
-  if (!hasSafeDirectoryAncestors(visibleRoot, ".r5d-project-hydration", input.projectsRoot)) {
-    if (hydrationPreimage) return;
-    throw new Error(`Visible project root has a symlink or non-directory ancestor: ${visibleRoot}`);
-  }
-  if (!import_node_fs.default.existsSync(import_node_path.default.join(visibleRoot, ".git"))) return;
-  checkoutGitlinks(visibleRoot);
-  const relativeRoot = workspaceProjectBranchRelativePath(manifest.projectId, branchName);
-  const shadowRoot = import_node_path.default.join(input.shadowRoot, ...relativeRoot.split("/"));
-  const shadowFiles = listShadowTrackedFiles(input, relativeRoot);
-  const desiredGitlinks = shadowProjectGitlinks(input, relativeRoot);
-  const desiredGitlinkPaths = new Set(desiredGitlinks.map((entry) => entry.filePath));
-  const visibleGitlinks = checkoutGitlinks(visibleRoot);
-  const protectedGitlinkRoots = [
-    .../* @__PURE__ */ new Set([...visibleGitlinks.map((entry) => entry.filePath), ...stagedDeletedGitlinkPaths(visibleRoot), ...additionalOpaqueRoots])
-  ].sort();
-  assertSafeVisibleGitlinkTransitions(
-    visibleRoot,
-    input.projectsRoot,
-    protectedGitlinkRoots.map((filePath) => ({ filePath, objectId: "" })),
-    desiredGitlinks,
-    shadowFiles
-  );
-  const opaqueVisibleGitlinks = protectedGitlinkRoots.filter(
-    (filePath) => desiredGitlinkPaths.has(filePath) || !shadowFiles.some((shadowFile) => shadowFile === filePath || shadowFile.startsWith(`${filePath}/`))
-  );
-  if (hydrationPreimage) {
-    hydrateProjectFromShadowOptimistically(input, relativeRoot, visibleRoot, hydrationPreimage, opaqueVisibleGitlinks);
-    return;
-  }
-  mirrorFileSet(shadowRoot, visibleRoot, shadowFiles, listGitEligibleFiles(visibleRoot), opaqueVisibleGitlinks, [], {
-    source: input.shadowRoot,
-    target: input.projectsRoot
-  });
-  mirrorShadowGitlinksToVisible(desiredGitlinks, visibleRoot, input.projectsRoot);
-}
-function visibleRegularRootMatchesCopiedPreimage(input, visibleRoot, files, preimage, filter) {
-  const currentFiles = listFilesRecursively(visibleRoot, filter);
-  if (currentFiles.length !== files.length || currentFiles.some((filePath, index) => filePath !== files[index])) return false;
-  return files.every((filePath) => {
-    const current = hasSafeDirectoryAncestors(visibleRoot, filePath, input.plansRoot) ? filesystemHydrationEntry(input, import_node_path.default.join(visibleRoot, ...filePath.split("/"))) : UNSTABLE_VISIBLE_ENTRY;
-    return current !== UNSTABLE_VISIBLE_ENTRY && hydrationEntriesEqual(current, preimage.get(filePath));
-  });
-}
-function mirrorRegularRootToShadowWithPreimage(input, sourceRoot, targetRoot, relativeRoot, filter) {
-  if (!hasSafeDirectoryAncestors(sourceRoot, ".r5d-plan-scan", input.plansRoot)) return null;
-  if (!import_node_fs.default.existsSync(sourceRoot)) return /* @__PURE__ */ new Map();
-  const sourceFiles = listFilesRecursively(sourceRoot, filter);
-  mirrorFileSet(sourceRoot, targetRoot, sourceFiles, listFilesRecursively(targetRoot, filter), [], [], {
-    source: input.plansRoot,
-    target: input.shadowRoot
-  });
-  const preimage = copiedHydrationPreimage(input, targetRoot, sourceFiles);
-  if (!preimage || !visibleRegularRootMatchesCopiedPreimage(input, sourceRoot, sourceFiles, preimage, filter)) {
-    restoreShadowProjectSnapshot(input, relativeRoot);
-    return null;
-  }
-  return preimage;
-}
-function hydrateRegularRootOptimistically(input, relativeRoot, targetRoot, preimage, filter) {
-  const sourceRoot = import_node_path.default.join(input.shadowRoot, ...relativeRoot.split("/"));
-  if (!hasSafeDirectoryAncestors(targetRoot, ".r5d-plan-hydration", input.plansRoot)) return;
-  const desired = indexHydrationPreimage(input, relativeRoot);
-  for (const [filePath, entry] of desired) {
-    if (entry.kind === "gitlink" || filter && !filter(filePath)) desired.delete(filePath);
-  }
-  const changedPaths = [.../* @__PURE__ */ new Set([...preimage.keys(), ...desired.keys()])].filter(
-    (filePath) => !hydrationEntriesEqual(preimage.get(filePath), desired.get(filePath))
-  );
-  for (const filePath of changedPaths.filter((candidate) => !desired.has(candidate)).sort((left, right) => pathDepth(right) - pathDepth(left) || left.localeCompare(right))) {
-    const current = hasSafeDirectoryAncestors(targetRoot, filePath, input.plansRoot) ? filesystemHydrationEntry(input, import_node_path.default.join(targetRoot, ...filePath.split("/"))) : UNSTABLE_VISIBLE_ENTRY;
-    if (current !== UNSTABLE_VISIBLE_ENTRY && hydrationEntriesEqual(current, preimage.get(filePath))) {
-      if (removeVisibleBlob(targetRoot, filePath, input.plansRoot)) {
-        removeEmptyVisibleAncestors(targetRoot, filePath, input.plansRoot);
-      }
-    }
-  }
-  for (const filePath of changedPaths.filter((candidate) => desired.has(candidate)).sort((left, right) => pathDepth(left) - pathDepth(right) || left.localeCompare(right))) {
-    const current = hasSafeDirectoryAncestors(targetRoot, filePath, input.plansRoot) ? filesystemHydrationEntry(input, import_node_path.default.join(targetRoot, ...filePath.split("/"))) : UNSTABLE_VISIBLE_ENTRY;
-    const wanted = desired.get(filePath);
-    if (!wanted || current === UNSTABLE_VISIBLE_ENTRY || hydrationEntriesEqual(current, wanted)) continue;
-    if (!hydrationEntriesEqual(current, preimage.get(filePath))) continue;
-    copyShadowBlobToVisible(sourceRoot, targetRoot, filePath, input.plansRoot);
-  }
-}
-function mirrorLocalPlansToShadow(input, manifest, branchName) {
-  const sourceRoot = localPlansBranchPath(input.plansRoot, manifest.projectId, branchName);
-  const relativeRoot = workspacePlansRelativePath(manifest.projectId, branchName);
-  const targetRoot = import_node_path.default.join(input.shadowRoot, ...relativeRoot.split("/"));
-  const planFilter = (relativePath) => relativePath.endsWith(".plan.md");
-  return mirrorRegularRootToShadowWithPreimage(input, sourceRoot, targetRoot, relativeRoot, planFilter);
-}
-function mirrorShadowPlansToLocal(input, manifest, branchName, hydrationPreimage) {
-  if (hydrationPreimage === null) return;
-  const relativeRoot = workspacePlansRelativePath(manifest.projectId, branchName);
-  const sourceRoot = import_node_path.default.join(input.shadowRoot, ...relativeRoot.split("/"));
-  const targetRoot = localPlansBranchPath(input.plansRoot, manifest.projectId, branchName);
-  const planFilter = (relativePath) => relativePath.endsWith(".plan.md");
-  if (hydrationPreimage) {
-    hydrateRegularRootOptimistically(input, relativeRoot, targetRoot, hydrationPreimage, planFilter);
-    return;
-  }
-  if (!hasSafeDirectoryAncestors(targetRoot, ".r5d-plan-hydration", input.plansRoot)) {
-    throw new Error(`Visible plan root has a symlink or non-directory ancestor: ${targetRoot}`);
-  }
-  mirrorFileSet(
-    sourceRoot,
-    targetRoot,
-    listShadowTrackedFiles(input, relativeRoot).filter(planFilter),
-    listFilesRecursively(targetRoot, planFilter),
-    [],
-    [],
-    { source: input.shadowRoot, target: input.plansRoot }
-  );
-}
-function mirrorLocalWorkspacePlansToShadow(input) {
-  if (input.trigger.canonicalCheckoutOnly) return /* @__PURE__ */ new Map();
-  const sourceRoot = localWorkspacePlansPath(input.plansRoot);
-  const relativeRoot = WORKSPACE_NATIVE_PLANS_RELATIVE_PATH;
-  const targetRoot = import_node_path.default.join(input.shadowRoot, relativeRoot);
-  const planFilter = (relativePath) => relativePath.endsWith(".plan.md");
-  return mirrorRegularRootToShadowWithPreimage(input, sourceRoot, targetRoot, relativeRoot, planFilter);
-}
-function mirrorShadowWorkspacePlansToLocal(input, hydrationPreimage) {
-  if (input.trigger.canonicalCheckoutOnly) return;
-  if (hydrationPreimage === null) return;
-  const sourceRoot = import_node_path.default.join(input.shadowRoot, WORKSPACE_NATIVE_PLANS_RELATIVE_PATH);
-  const targetRoot = localWorkspacePlansPath(input.plansRoot);
-  const planFilter = (relativePath) => relativePath.endsWith(".plan.md");
-  if (hydrationPreimage) {
-    hydrateRegularRootOptimistically(input, WORKSPACE_NATIVE_PLANS_RELATIVE_PATH, targetRoot, hydrationPreimage, planFilter);
-    return;
-  }
-  if (!hasSafeDirectoryAncestors(targetRoot, ".r5d-plan-hydration", input.plansRoot)) {
-    throw new Error(`Visible workspace-plan root has a symlink or non-directory ancestor: ${targetRoot}`);
-  }
-  mirrorFileSet(
-    sourceRoot,
-    targetRoot,
-    listShadowTrackedFiles(input, WORKSPACE_NATIVE_PLANS_RELATIVE_PATH).filter(planFilter),
-    listFilesRecursively(targetRoot, planFilter),
-    [],
-    [],
-    { source: input.shadowRoot, target: input.plansRoot }
-  );
-}
-function reconcileWorkspaceNativePlans(input, projection) {
-  if (input.trigger.canonicalCheckoutOnly) return;
-  const localRoot = localWorkspacePlansPath(input.plansRoot);
-  projection.visiblePreimages ??= /* @__PURE__ */ new Map();
-  projection.visiblePreimages.set(localRoot, /* @__PURE__ */ new Map());
-  if (import_node_fs.default.existsSync(localWorkspacePlansPath(input.plansRoot))) {
-    projection.visiblePreimages.set(localRoot, mirrorLocalWorkspacePlansToShadow(input));
-    return;
-  }
-  if (listShadowTrackedFiles(input, WORKSPACE_NATIVE_PLANS_RELATIVE_PATH).length > 0 || restoreShadowRootFromRemote(input, WORKSPACE_NATIVE_PLANS_RELATIVE_PATH)) {
-    mirrorShadowWorkspacePlansToLocal(input, /* @__PURE__ */ new Map());
-    projection.visiblePreimages.set(localRoot, indexHydrationPreimage(input, WORKSPACE_NATIVE_PLANS_RELATIVE_PATH));
-  }
-}
-function mergeGitlinkProjection(target, source) {
-  target.entries.push(...source.entries);
-  target.opaqueRoots.push(...source.opaqueRoots);
-  if (source.visiblePreimages) {
-    target.visiblePreimages ??= /* @__PURE__ */ new Map();
-    for (const [visibleRoot, preimage] of source.visiblePreimages) target.visiblePreimages.set(visibleRoot, preimage);
-  }
-}
-function mirrorVisibleWorkspaceToShadow(input, excludedCheckouts = /* @__PURE__ */ new Set()) {
-  const projection = { entries: [], opaqueRoots: [], visiblePreimages: /* @__PURE__ */ new Map() };
-  reconcileWorkspaceNativePlans(input, projection);
-  for (const manifest of [...input.projects].sort((left, right) => left.projectId.localeCompare(right.projectId))) {
-    for (const branchName of [...new Set(manifest.branches)].sort()) {
-      if (excludedCheckouts.has(`${manifest.projectId}\0${branchName}`)) continue;
-      mergeGitlinkProjection(projection, mirrorVisibleProjectToShadow(input, manifest, branchName));
-      if (!input.trigger.canonicalCheckoutOnly) {
-        const localPlansRoot = localPlansBranchPath(input.plansRoot, manifest.projectId, branchName);
-        projection.visiblePreimages?.set(localPlansRoot, mirrorLocalPlansToShadow(input, manifest, branchName));
-      }
-    }
-  }
-  projection.opaqueRoots = [...new Set(projection.opaqueRoots)].sort();
-  return projection;
-}
-function visibleWorkspaceMatchesProjection(input, projection) {
-  const preimages = projection.visiblePreimages;
-  if (!preimages) return false;
-  const workspacePlansRoot = localWorkspacePlansPath(input.plansRoot);
-  const workspacePlansPreimage = preimages.get(workspacePlansRoot);
-  if (!workspacePlansPreimage || !visibleRegularRootMatchesCopiedPreimage(
-    input,
-    workspacePlansRoot,
-    [...workspacePlansPreimage.keys()].sort(),
-    workspacePlansPreimage,
-    (filePath) => filePath.endsWith(".plan.md")
-  )) {
-    return false;
-  }
-  for (const manifest of input.projects) {
-    for (const branchName of manifest.branches) {
-      const relativeRoot = workspaceProjectBranchRelativePath(manifest.projectId, branchName);
-      const visibleRoot = visibleProjectBranchPath(input.projectsRoot, manifest, branchName);
-      const projectPreimage = preimages.get(visibleRoot);
-      if (!projectPreimage) return false;
-      const gitlinks = [...projectPreimage].filter((entry) => entry[1].kind === "gitlink").map(([filePath, entry]) => ({ filePath, objectId: entry.objectId })).sort((left, right) => left.filePath.localeCompare(right.filePath));
-      const ordinaryFiles = [...projectPreimage].filter(([, entry]) => entry.kind === "blob").map(([filePath]) => filePath).sort();
-      const rootPrefix = `${relativeRoot}/`;
-      const opaqueRoots = projection.opaqueRoots.filter((root) => root.startsWith(rootPrefix)).map((root) => root.slice(rootPrefix.length));
-      if (!visibleProjectMatchesCopiedPreimage(input, visibleRoot, ordinaryFiles, gitlinks, projectPreimage, opaqueRoots)) {
-        return false;
-      }
-      const plansRoot = localPlansBranchPath(input.plansRoot, manifest.projectId, branchName);
-      const plansPreimage = preimages.get(plansRoot);
-      if (!plansPreimage || !visibleRegularRootMatchesCopiedPreimage(
-        input,
-        plansRoot,
-        [...plansPreimage.keys()].sort(),
-        plansPreimage,
-        (filePath) => filePath.endsWith(".plan.md")
-      )) {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-function reconcileNewVisibleCheckouts(input) {
-  const projection = { entries: [], opaqueRoots: [], visiblePreimages: /* @__PURE__ */ new Map() };
-  for (const target of input.newVisibleCheckouts ?? []) {
-    const manifest = input.projects.find((project) => project.projectId === target.projectId);
-    if (!manifest || !manifest.branches.includes(target.branchName)) continue;
-    const projectRoot = workspaceProjectBranchRelativePath(target.projectId, target.branchName);
-    if (input.trigger.canonicalCheckoutOnly) {
-      mergeGitlinkProjection(projection, mirrorVisibleProjectToShadow(input, manifest, target.branchName));
-    } else if (listShadowTrackedFiles(input, projectRoot).length > 0 || restoreShadowRootFromRemote(input, projectRoot)) {
-      mirrorShadowProjectToVisible(input, manifest, target.branchName);
-      projection.visiblePreimages?.set(
-        visibleProjectBranchPath(input.projectsRoot, manifest, target.branchName),
-        indexHydrationPreimage(input, projectRoot)
-      );
-    } else {
-      mergeGitlinkProjection(projection, mirrorVisibleProjectToShadow(input, manifest, target.branchName));
-    }
-    if (input.trigger.canonicalCheckoutOnly) continue;
-    const plansRoot = workspacePlansRelativePath(target.projectId, target.branchName);
-    if (listShadowTrackedFiles(input, plansRoot).length > 0 || restoreShadowRootFromRemote(input, plansRoot)) {
-      mirrorShadowPlansToLocal(input, manifest, target.branchName);
-      projection.visiblePreimages?.set(
-        localPlansBranchPath(input.plansRoot, manifest.projectId, target.branchName),
-        indexHydrationPreimage(input, plansRoot)
-      );
-    } else {
-      projection.visiblePreimages?.set(
-        localPlansBranchPath(input.plansRoot, manifest.projectId, target.branchName),
-        mirrorLocalPlansToShadow(input, manifest, target.branchName)
-      );
-    }
-  }
-  projection.opaqueRoots = [...new Set(projection.opaqueRoots)].sort();
-  return projection;
-}
-function mirrorShadowWorkspaceToVisible(input, opaqueWorkspaceRoots = [], hydrationPreimages) {
-  mirrorShadowWorkspacePlansToLocal(input, hydrationPreimages?.get(localWorkspacePlansPath(input.plansRoot)));
-  for (const manifest of [...input.projects].sort((left, right) => left.projectId.localeCompare(right.projectId))) {
-    for (const branchName of [...new Set(manifest.branches)].sort()) {
-      const relativeRoot = workspaceProjectBranchRelativePath(manifest.projectId, branchName);
-      const visibleRoot = visibleProjectBranchPath(input.projectsRoot, manifest, branchName);
-      const opaqueProjectRoots = opaqueWorkspaceRoots.filter((root) => root.startsWith(`${relativeRoot}/`)).map((root) => root.slice(relativeRoot.length + 1));
-      mirrorShadowProjectToVisible(input, manifest, branchName, opaqueProjectRoots, hydrationPreimages?.get(visibleRoot));
-      if (!input.trigger.canonicalCheckoutOnly) {
-        const localPlansRoot = localPlansBranchPath(input.plansRoot, manifest.projectId, branchName);
-        mirrorShadowPlansToLocal(input, manifest, branchName, hydrationPreimages?.get(localPlansRoot));
-      }
-    }
-  }
-}
-function hydrationPreimagesFromShadowRevision(input, revision) {
-  const preimages = /* @__PURE__ */ new Map();
-  const fromRevision = (relativeRoot) => revision ? revisionHydrationPreimage(input, revision, relativeRoot) : /* @__PURE__ */ new Map();
-  if (!input.trigger.canonicalCheckoutOnly) {
-    preimages.set(localWorkspacePlansPath(input.plansRoot), fromRevision(WORKSPACE_NATIVE_PLANS_RELATIVE_PATH));
-  }
-  for (const manifest of input.projects) {
-    for (const branchName of manifest.branches) {
-      preimages.set(
-        visibleProjectBranchPath(input.projectsRoot, manifest, branchName),
-        fromRevision(workspaceProjectBranchRelativePath(manifest.projectId, branchName))
-      );
-      if (!input.trigger.canonicalCheckoutOnly) {
-        preimages.set(
-          localPlansBranchPath(input.plansRoot, manifest.projectId, branchName),
-          fromRevision(workspacePlansRelativePath(manifest.projectId, branchName))
-        );
-      }
-    }
-  }
-  return preimages;
-}
-function visibleHydrationConflictPaths(input, preimages, desiredRevision) {
-  const conflicts = [];
-  const inspectRegularRoot = (visibleRoot, relativeRoot, filter) => {
-    const preimage = preimages.get(visibleRoot);
-    if (!preimage) return;
-    const desired = revisionHydrationPreimage(input, desiredRevision, relativeRoot);
-    for (const [filePath, entry] of desired) {
-      if (entry.kind === "gitlink" || filter && !filter(filePath)) desired.delete(filePath);
-    }
-    const changedPaths = [.../* @__PURE__ */ new Set([...preimage.keys(), ...desired.keys()])].filter(
-      (filePath) => !hydrationEntriesEqual(preimage.get(filePath), desired.get(filePath))
-    );
-    if (changedPaths.length === 0) return;
-    if (!hasSafeDirectoryAncestors(visibleRoot, ".r5d-hydration-scan", input.plansRoot)) {
-      conflicts.push(...changedPaths.map((filePath) => import_node_path.default.posix.join(relativeRoot, filePath)));
-      return;
-    }
-    const affectsChangedTree = (filePath) => changedPaths.some((changedPath) => pathsOverlap(filePath, changedPath));
-    const currentEntries = /* @__PURE__ */ new Map();
-    const unstablePaths = /* @__PURE__ */ new Set();
-    for (const filePath of listFilesRecursively(visibleRoot).filter(affectsChangedTree)) {
-      const current = hasSafeDirectoryAncestors(visibleRoot, filePath, input.plansRoot) ? filesystemHydrationEntry(input, import_node_path.default.join(visibleRoot, ...filePath.split("/"))) : UNSTABLE_VISIBLE_ENTRY;
-      if (current === UNSTABLE_VISIBLE_ENTRY || !current) unstablePaths.add(filePath);
-      else currentEntries.set(filePath, current);
-    }
-    for (const filePath of /* @__PURE__ */ new Set([...changedPaths, ...currentEntries.keys(), ...unstablePaths])) {
-      if (!affectsChangedTree(filePath)) continue;
-      const current = unstablePaths.has(filePath) ? UNSTABLE_VISIBLE_ENTRY : currentEntries.get(filePath);
-      if (current === UNSTABLE_VISIBLE_ENTRY || !hydrationEntriesEqual(current, preimage.get(filePath)) && !hydrationEntriesEqual(current, desired.get(filePath))) {
-        conflicts.push(import_node_path.default.posix.join(relativeRoot, filePath));
-      }
-    }
-  };
-  if (!input.trigger.canonicalCheckoutOnly) {
-    inspectRegularRoot(
-      localWorkspacePlansPath(input.plansRoot),
-      WORKSPACE_NATIVE_PLANS_RELATIVE_PATH,
-      (filePath) => filePath.endsWith(".plan.md")
-    );
-  }
-  for (const manifest of input.projects) {
-    for (const branchName of manifest.branches) {
-      const visibleRoot = visibleProjectBranchPath(input.projectsRoot, manifest, branchName);
-      const relativeRoot = workspaceProjectBranchRelativePath(manifest.projectId, branchName);
-      const preimage = preimages.get(visibleRoot);
-      if (preimage && import_node_fs.default.existsSync(import_node_path.default.join(visibleRoot, ".git"))) {
-        const desired = revisionHydrationPreimage(input, desiredRevision, relativeRoot);
-        const changedPaths = [.../* @__PURE__ */ new Set([...preimage.keys(), ...desired.keys()])].filter(
-          (filePath) => !hydrationEntriesEqual(preimage.get(filePath), desired.get(filePath))
-        );
-        if (!hasSafeDirectoryAncestors(visibleRoot, ".r5d-hydration-scan", input.projectsRoot)) {
-          conflicts.push(...changedPaths.map((filePath) => import_node_path.default.posix.join(relativeRoot, filePath)));
-          continue;
-        }
-        const affectsChangedTree = (filePath) => changedPaths.some((changedPath) => pathsOverlap(filePath, changedPath));
-        const currentGitlinks = new Map(checkoutGitlinks(visibleRoot).map((entry) => [entry.filePath, entry]));
-        const residualOpaqueGitlinks = [...preimage].filter(
-          ([filePath, entry]) => entry.kind === "gitlink" && !desired.has(filePath) && ![...desired.keys()].some((desiredPath) => desiredPath.startsWith(`${filePath}/`))
-        ).map(([filePath]) => filePath);
-        const opaqueRoots = [.../* @__PURE__ */ new Set([...currentGitlinks.keys(), ...residualOpaqueGitlinks])];
-        const currentEntries = /* @__PURE__ */ new Map();
-        const unstablePaths = /* @__PURE__ */ new Set();
-        for (const filePath of [...currentGitlinks.keys()].filter(affectsChangedTree)) {
-          const current = projectVisibleHydrationEntry(input, visibleRoot, filePath, currentGitlinks);
-          if (current === UNSTABLE_VISIBLE_ENTRY || !current) unstablePaths.add(filePath);
-          else currentEntries.set(filePath, current);
-        }
-        for (const filePath of listGitEligibleFiles(visibleRoot).filter(
-          (candidate) => affectsChangedTree(candidate) && !pathIsWithinOpaqueRoot(candidate, opaqueRoots)
-        )) {
-          const current = projectVisibleHydrationEntry(input, visibleRoot, filePath, currentGitlinks);
-          if (current === UNSTABLE_VISIBLE_ENTRY || !current) unstablePaths.add(filePath);
-          else currentEntries.set(filePath, current);
-        }
-        for (const filePath of /* @__PURE__ */ new Set([...changedPaths, ...currentEntries.keys(), ...unstablePaths])) {
-          if (!affectsChangedTree(filePath)) continue;
-          const current = unstablePaths.has(filePath) ? UNSTABLE_VISIBLE_ENTRY : currentEntries.get(filePath);
-          if (current === UNSTABLE_VISIBLE_ENTRY || !hydrationEntriesEqual(current, preimage.get(filePath)) && !hydrationEntriesEqual(current, desired.get(filePath))) {
-            conflicts.push(import_node_path.default.posix.join(relativeRoot, filePath));
-          }
-        }
-      }
-      if (!input.trigger.canonicalCheckoutOnly) {
-        inspectRegularRoot(
-          localPlansBranchPath(input.plansRoot, manifest.projectId, branchName),
-          workspacePlansRelativePath(manifest.projectId, branchName),
-          (filePath) => filePath.endsWith(".plan.md")
-        );
-      }
-    }
-  }
-  return [...new Set(conflicts)].sort();
-}
-function unavailableHydrationConflictPaths(input, preimages, baselineRevision, desiredRevision) {
-  const conflicts = [];
-  const inspectRoot = (visibleRoot, relativeRoot, filter) => {
-    if (preimages.get(visibleRoot) !== null) return;
-    const baseline = revisionHydrationPreimage(input, baselineRevision, relativeRoot);
-    const desired = revisionHydrationPreimage(input, desiredRevision, relativeRoot);
-    for (const filePath of /* @__PURE__ */ new Set([...baseline.keys(), ...desired.keys()])) {
-      if (filter && !filter(filePath)) continue;
-      if (!hydrationEntriesEqual(baseline.get(filePath), desired.get(filePath))) {
-        conflicts.push(import_node_path.default.posix.join(relativeRoot, filePath));
-      }
-    }
-  };
-  if (!input.trigger.canonicalCheckoutOnly) {
-    inspectRoot(
-      localWorkspacePlansPath(input.plansRoot),
-      WORKSPACE_NATIVE_PLANS_RELATIVE_PATH,
-      (filePath) => filePath.endsWith(".plan.md")
-    );
-  }
-  for (const manifest of input.projects) {
-    for (const branchName of manifest.branches) {
-      inspectRoot(
-        visibleProjectBranchPath(input.projectsRoot, manifest, branchName),
-        workspaceProjectBranchRelativePath(manifest.projectId, branchName)
-      );
-      if (!input.trigger.canonicalCheckoutOnly) {
-        inspectRoot(
-          localPlansBranchPath(input.plansRoot, manifest.projectId, branchName),
-          workspacePlansRelativePath(manifest.projectId, branchName),
-          (filePath) => filePath.endsWith(".plan.md")
-        );
-      }
-    }
-  }
-  return [...new Set(conflicts)].sort();
-}
-function hydrationConflictPaths(input, preimages, baselineRevision, desiredRevision) {
-  return [
-    .../* @__PURE__ */ new Set([
-      ...visibleHydrationConflictPaths(input, preimages, desiredRevision),
-      ...unavailableHydrationConflictPaths(input, preimages, baselineRevision, desiredRevision)
-    ])
-  ].sort();
-}
-function forceStageCanonicalCheckoutFiles(input, preservedGitlinks = [], opaqueRoots = []) {
-  for (const manifest of input.projects) {
-    for (const checkout of manifest.canonicalCheckouts ?? []) {
-      if (!manifest.branches.includes(checkout.branchName)) continue;
-      const relativeRoot = workspaceProjectBranchRelativePath(manifest.projectId, checkout.branchName);
-      const absoluteRoot = import_node_path.default.join(input.shadowRoot, ...relativeRoot.split("/"));
-      if (!import_node_fs.default.existsSync(absoluteRoot)) continue;
-      const scopedOpaqueRoots = opaqueRoots.filter((root) => root.startsWith(`${relativeRoot}/`)).map((root) => root.slice(relativeRoot.length + 1));
-      runGit(
-        input,
-        input.shadowRoot,
-        [
-          "add",
-          "-f",
-          "-A",
-          "--",
-          `:(literal)${relativeRoot}`,
-          ...scopedOpaqueRoots.map((root) => `:(exclude,literal)${import_node_path.default.posix.join(relativeRoot, root)}`)
-        ],
-        `force-stage canonical resolver checkout ${manifest.projectId}/${checkout.branchName}`
-      );
-    }
-  }
-  for (const gitlink of preservedGitlinks) {
-    replaceShadowIndexPathWithGitlink(input, "", gitlink);
-  }
-  const preservedPaths = new Set(preservedGitlinks.map((entry) => entry.filePath));
-  for (const opaqueRoot of opaqueRoots) {
-    if (preservedPaths.has(opaqueRoot)) continue;
-    runGit(
-      input,
-      input.shadowRoot,
-      ["--literal-pathspecs", "update-index", "--force-remove", "--", opaqueRoot],
-      `remove explicitly deleted workspace gitlink ${JSON.stringify(opaqueRoot)}`
-    );
-  }
-}
-function canonicalCheckoutRelativeRoots(input) {
-  const roots = /* @__PURE__ */ new Set();
-  for (const manifest of input.projects) {
-    for (const checkout of manifest.canonicalCheckouts) {
-      roots.add(workspaceProjectBranchRelativePath(manifest.projectId, checkout.branchName));
-    }
-  }
-  return [...roots].sort();
-}
-function restoreUnscopedCanonicalCheckoutSubtrees(input) {
-  if (input.trigger.canonicalCheckoutOnly) return;
-  const remoteHead = revParse(input, `origin/${WORKSPACE_BRANCH}`);
-  const emptyTree = emptyTreeHash(input);
-  for (const relativeRoot of canonicalCheckoutRelativeRoots(input)) {
-    const remoteTree = remoteHead ? workspaceSubtreeTreeHashAtRevision(input, remoteHead, relativeRoot) : emptyTree;
-    if (remoteTree === emptyTree) {
-      runGitResult(input, input.shadowRoot, ["--literal-pathspecs", "rm", "-r", "-f", "--cached", "--ignore-unmatch", "--", relativeRoot]);
-      import_node_fs.default.rmSync(import_node_path.default.join(input.shadowRoot, ...relativeRoot.split("/")), { recursive: true, force: true });
-      continue;
-    }
-    runGit(
-      input,
-      input.shadowRoot,
-      ["--literal-pathspecs", "restore", `--source=${remoteHead}`, "--staged", "--worktree", "--", relativeRoot],
-      `restore excluded canonical resolver subtree ${relativeRoot}`
-    );
-  }
-}
-function assertUnscopedCanonicalCheckoutSubtreesMatchRemote(input, revision) {
-  if (input.trigger.canonicalCheckoutOnly) return;
-  const remoteHead = revParse(input, `origin/${WORKSPACE_BRANCH}`);
-  const emptyTree = emptyTreeHash(input);
-  for (const relativeRoot of canonicalCheckoutRelativeRoots(input)) {
-    const candidateTree = workspaceSubtreeTreeHashAtRevision(input, revision, relativeRoot);
-    const remoteTree = remoteHead ? workspaceSubtreeTreeHashAtRevision(input, remoteHead, relativeRoot) : emptyTree;
-    if (candidateTree !== remoteTree) {
-      throw new Error(`Generic workspace synchronization cannot publish canonical resolver subtree ${relativeRoot}`);
-    }
-  }
-}
-function ensureShadowWorkspace(input) {
-  import_node_fs.default.mkdirSync(import_node_path.default.dirname(input.shadowRoot), { recursive: true });
-  let created = false;
-  if (!import_node_fs.default.existsSync(import_node_path.default.join(input.shadowRoot, ".git"))) {
-    created = true;
-    import_node_fs.default.rmSync(input.shadowRoot, { recursive: true, force: true });
-    const clone = runGitResult(input, import_node_path.default.dirname(input.shadowRoot), ["clone", "--origin", "origin", input.remoteUrl, input.shadowRoot]);
-    if (clone.exitCode !== 0) {
-      throw new Error(`clone canonical workspace: ${clone.stderr || clone.stdout || `git exited ${clone.exitCode}`}`);
-    }
-  }
-  if (tryGit(input, input.shadowRoot, ["remote", "get-url", "origin"])) {
-    runGit(input, input.shadowRoot, ["remote", "set-url", "origin", input.remoteUrl], "update canonical workspace remote");
-  } else {
-    runGit(input, input.shadowRoot, ["remote", "add", "origin", input.remoteUrl], "add canonical workspace remote");
-  }
-  runGit(input, input.shadowRoot, ["config", "user.name", "r5d.dev Worker"], "configure workspace Git name");
-  runGit(input, input.shadowRoot, ["config", "user.email", "worker@r5d.dev"], "configure workspace Git email");
-  runGit(input, input.shadowRoot, ["fetch", "origin", "--prune"], "fetch canonical workspace");
-  const hasHead = tryGit(input, input.shadowRoot, ["rev-parse", "--verify", "HEAD"]);
-  const hasRemoteMain = tryGit(input, input.shadowRoot, ["show-ref", "--verify", "--quiet", `refs/remotes/origin/${WORKSPACE_BRANCH}`]);
-  if (!hasHead && hasRemoteMain) {
-    runGit(input, input.shadowRoot, ["checkout", "-B", WORKSPACE_BRANCH, `origin/${WORKSPACE_BRANCH}`], "checkout canonical workspace");
-  } else if (!hasHead) {
-    runGit(input, input.shadowRoot, ["checkout", "--orphan", WORKSPACE_BRANCH], "create canonical workspace branch");
-  }
-  return created;
-}
-function revParse(input, revision) {
-  const result = runGitResult(input, input.shadowRoot, ["rev-parse", "--verify", revision]);
-  return result.exitCode === 0 ? result.stdout : null;
-}
-function emptyTreeHash(input) {
-  const result = Bun.spawnSync(gitArgs(input, ["mktree"]), {
-    cwd: input.shadowRoot,
-    stdin: Buffer.alloc(0),
-    stdout: "pipe",
-    stderr: "pipe",
-    env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
-  });
-  if (result.exitCode !== 0) {
-    throw new Error(`create empty workspace tree: ${result.stderr.toString().trim() || `git exited ${result.exitCode}`}`);
-  }
-  return result.stdout.toString().trim();
-}
-function workspaceSubtreeTreeHashAtRevision(input, revision, relativeRoot) {
-  const rootType = runGitResult(input, input.shadowRoot, ["cat-file", "-t", revision]);
-  if (rootType.exitCode !== 0 || rootType.stdout !== "commit" && rootType.stdout !== "tree") {
-    throw new Error(`Cannot inspect canonical resolver subtree at invalid workspace revision ${revision}`);
-  }
-  let treeHash = rootType.stdout === "commit" ? runGit(input, input.shadowRoot, ["rev-parse", "--verify", `${revision}^{tree}`], "resolve workspace root tree") : revision;
-  for (const segment of relativeRoot.split("/")) {
-    const entry = runGitResult(input, input.shadowRoot, ["--literal-pathspecs", "ls-tree", "-z", treeHash, "--", segment]);
-    if (entry.exitCode !== 0) {
-      throw new Error(`Inspect canonical resolver workspace path ${relativeRoot}: ${entry.stderr || entry.stdout}`);
-    }
-    if (!entry.stdout) return emptyTreeHash(input);
-    const separator = entry.stdout.indexOf("	");
-    const [mode, type, objectId] = separator === -1 ? [] : entry.stdout.slice(0, separator).split(" ");
-    const entryName = separator === -1 ? "" : entry.stdout.slice(separator + 1).replace(/\0+$/, "");
-    if (!mode || type !== "tree" || !objectId || entryName !== segment) {
-      throw new Error(`Canonical resolver workspace path ${relativeRoot} contains a non-tree component ${segment}`);
-    }
-    treeHash = objectId;
-  }
-  return treeHash;
-}
-function canonicalCheckoutTreeHashAtRevision(input, revision) {
-  if (!input.trigger.canonicalCheckoutOnly || !input.trigger.projectId || !input.trigger.branchName) {
-    throw new Error("Canonical checkout tree hashing requires an exact canonical-checkout-only trigger");
-  }
-  return workspaceSubtreeTreeHashAtRevision(
-    input,
-    revision,
-    workspaceProjectBranchRelativePath(input.trigger.projectId, input.trigger.branchName)
-  );
-}
-function sampleCanonicalCheckoutTree(input) {
-  if (!input.trigger.canonicalCheckoutOnly) return void 0;
-  const stagedWorkspaceTree = runGit(input, input.shadowRoot, ["write-tree"], "write canonical resolver workspace tree");
-  return canonicalCheckoutTreeHashAtRevision(input, stagedWorkspaceTree);
-}
-function assertPublishedCanonicalCheckoutTree(input, revision, sampledTreeHash) {
-  if (!input.trigger.canonicalCheckoutOnly) return;
-  if (!sampledTreeHash) throw new Error("Canonical resolver synchronization did not capture a staged subtree tree hash");
-  const publishedTreeHash = canonicalCheckoutTreeHashAtRevision(input, revision);
-  if (publishedTreeHash !== sampledTreeHash) {
-    throw new Error(`Canonical resolver subtree changed while synchronizing: sampled ${sampledTreeHash}, published ${publishedTreeHash}`);
-  }
-}
-function gitStatus(input) {
-  return runGit(input, input.shadowRoot, ["status", "--porcelain=v1", "--untracked-files=all"], "read workspace status");
-}
-function resetUncommittedShadowSnapshot(input) {
-  if (!gitStatus(input)) return;
-  if (tryGit(input, input.shadowRoot, ["rev-parse", "--verify", "HEAD"])) {
-    runGit(input, input.shadowRoot, ["reset", "--hard", "HEAD"], "reset interrupted workspace snapshot");
-  } else {
-    runGit(input, input.shadowRoot, ["read-tree", "--empty"], "reset interrupted unborn workspace snapshot");
-  }
-  runGit(input, input.shadowRoot, ["clean", "-fd"], "clean interrupted workspace snapshot");
-}
-function restoreShadowToVisibleBaseline(input, canonicalHead) {
-  if (input.skipVisibleMirror || input.trigger.canonicalCheckoutOnly) return void 0;
-  if (input.visibleBaselineHead === void 0) {
-    if (revParse(input, "HEAD") !== canonicalHead) {
-      throw new Error("visible_workspace_baseline_missing: shadow HEAD differs from canonical main");
-    }
-    return void 0;
-  }
-  const baselineHead = input.visibleBaselineHead;
-  const currentHead = revParse(input, "HEAD");
-  if (!baselineHead) {
-    if (canonicalHead) {
-      throw new Error("Visible workspace has an unborn baseline after canonical main was created");
-    }
-    if (!currentHead) return null;
-    resetUncommittedShadowSnapshot(input);
-    const symbolicHead = runGit(input, input.shadowRoot, ["symbolic-ref", "-q", "HEAD"], "resolve unborn workspace branch");
-    runGit(input, input.shadowRoot, ["update-ref", "-d", symbolicHead], "restore unborn visible workspace baseline");
-    runGit(input, input.shadowRoot, ["read-tree", "--empty"], "clear unborn visible workspace index");
-    runGit(input, input.shadowRoot, ["clean", "-fdx"], "clean unborn visible workspace baseline");
-    return null;
-  }
-  if (currentHead === baselineHead) return baselineHead;
-  if (revParse(input, `${baselineHead}^{commit}`) !== baselineHead) {
-    throw new Error(`Visible workspace baseline ${baselineHead} is not available in the shadow repository`);
-  }
-  resetUncommittedShadowSnapshot(input);
-  runGit(input, input.shadowRoot, ["reset", "--hard", baselineHead], "restore visible workspace publication baseline");
-  runGit(input, input.shadowRoot, ["clean", "-fd"], "clean restored visible workspace publication baseline");
-  return baselineHead;
-}
-function restoreCleanShadowToExpectedIncidentCandidate(input) {
-  const expectedHead = input.expectedIncidentCandidateHead;
-  if (expectedHead === void 0) return;
-  if (input.trigger.type !== "remediation" || input.trigger.canonicalCheckoutOnly || input.trigger.processRunId !== void 0 || input.trigger.toolCallId !== void 0 || input.skipVisibleMirror !== true || input.confirmedLargeDiff === true || input.resetToCanonical === true) {
-    throw new Error("An expected incident candidate may only be used for stable remediation preparation");
-  }
-  const status = gitStatus(input);
-  if (status) {
-    throw new Error("incident_candidate_shadow_dirty: refusing to replace a dirty remediation shadow checkout");
-  }
-  if (revParse(input, `${expectedHead}^{commit}`) !== expectedHead) {
-    throw new Error(`incident_candidate_unavailable: elected workspace candidate ${expectedHead} is not available`);
-  }
-  if (revParse(input, "HEAD") !== expectedHead) {
-    runGit(input, input.shadowRoot, ["reset", "--hard", expectedHead], "restore elected workspace incident candidate");
-  }
-}
-function activeWorkspaceRebase(input) {
-  for (const name of ["rebase-merge", "rebase-apply"]) {
-    const resolved = runGitResult(input, input.shadowRoot, ["rev-parse", "--git-path", name]);
-    if (resolved.exitCode !== 0 || !resolved.stdout) continue;
-    const gitPath = import_node_path.default.isAbsolute(resolved.stdout) ? resolved.stdout : import_node_path.default.resolve(input.shadowRoot, resolved.stdout);
-    if (import_node_fs.default.existsSync(gitPath)) return name;
-  }
-  return null;
-}
-function remediationRebaseInProgressResult(input, result) {
-  if (input.trigger.type !== "remediation" && input.trigger.type !== "remediation_confirm") return null;
-  const rebaseKind = activeWorkspaceRebase(input);
-  if (!rebaseKind) return null;
-  const conflictPaths = runGitResult(input, input.shadowRoot, ["diff", "--name-only", "--diff-filter=U", "-z"]).stdout.split("\0").filter(Boolean).sort();
-  const status = reportedStatus(gitStatus(input));
-  return {
-    ...result,
-    outcome: "conflict_blocked",
-    expectedHead: revParse(input, `origin/${WORKSPACE_BRANCH}`),
-    candidateHead: revParse(input, "ORIG_HEAD") ?? revParse(input, "HEAD") ?? void 0,
-    rebaseCount: 1,
-    gitStatus: status,
-    affectedProjects: affectedProjects(conflictPaths),
-    affectedPaths: reportedPaths(conflictPaths),
-    error: `Workspace conflict remediation has an in-progress ${rebaseKind}; the index and worktree were preserved until the resolver completes or aborts it.`
-  };
-}
-function fastForwardCleanShadowForNewCheckouts(input) {
-  if (!input.newVisibleCheckouts?.length) return null;
-  runGit(input, input.shadowRoot, ["add", "-A"], "stage existing workspace changes before checkout hydration");
-  if (gitStatus(input)) return null;
-  const localHead = revParse(input, "HEAD");
-  const remoteHead = revParse(input, `origin/${WORKSPACE_BRANCH}`);
-  if (!localHead || !remoteHead || localHead === remoteHead) return null;
-  if (!tryGit(input, input.shadowRoot, ["merge-base", "--is-ancestor", localHead, remoteHead])) return null;
-  runGit(input, input.shadowRoot, ["reset", "--hard", remoteHead], "fast-forward before checkout hydration");
-  return localHead;
-}
-function restoreShadowRootFromRemote(input, relativeRoot) {
-  const remoteRevision = `origin/${WORKSPACE_BRANCH}`;
-  const remoteFiles = runGitResult(input, input.shadowRoot, ["ls-tree", "-r", "--name-only", "-z", remoteRevision, "--", relativeRoot]);
-  if (remoteFiles.exitCode !== 0 || !remoteFiles.stdout) return false;
-  runGit(
-    input,
-    input.shadowRoot,
-    ["restore", `--source=${remoteRevision}`, "--staged", "--worktree", "--", relativeRoot],
-    `hydrate ${relativeRoot} from canonical workspace`
-  );
-  return true;
-}
-function candidateBaseRevision(input) {
-  const localHead = revParse(input, "HEAD");
-  if (!localHead) return null;
-  const remoteHead = revParse(input, `origin/${WORKSPACE_BRANCH}`);
-  if (!remoteHead) {
-    const emptyTree = Bun.spawnSync(gitArgs(input, ["mktree"]), {
-      cwd: input.shadowRoot,
-      stdin: Buffer.alloc(0),
-      stdout: "pipe",
-      stderr: "pipe",
-      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
-    });
-    if (emptyTree.exitCode !== 0) {
-      throw new Error(
-        `create empty workspace comparison tree: ${emptyTree.stderr.toString().trim() || `git exited ${emptyTree.exitCode}`}`
-      );
-    }
-    return emptyTree.stdout.toString().trim();
-  }
-  const mergeBase = runGitResult(input, input.shadowRoot, ["merge-base", localHead, remoteHead]);
-  return mergeBase.exitCode === 0 && mergeBase.stdout ? mergeBase.stdout : remoteHead;
-}
-function stagedPaths(input, baseRevision) {
-  return runGit(
-    input,
-    input.shadowRoot,
-    ["diff", "--cached", "--name-only", "-z", ...baseRevision ? [baseRevision] : []],
-    "list workspace changes"
-  ).split("\0").filter(Boolean).sort();
-}
-function stagedDeletedPaths(input, baseRevision) {
-  return runGit(
-    input,
-    input.shadowRoot,
-    ["diff", "--cached", "--diff-filter=D", "--name-only", "-z", ...baseRevision ? [baseRevision] : []],
-    "list workspace deletions"
-  ).split("\0").filter(Boolean).sort();
-}
-function managedCheckoutRoot(filePath) {
-  const projectMatch = /^projects\/([^/]+)\/branches\/([^/]+)\//.exec(filePath);
-  return projectMatch ? `projects/${projectMatch[1]}/branches/${projectMatch[2]}` : null;
-}
-function revisionTrackedFileCount(input, revision, relativeRoot) {
-  if (!revision) return 0;
-  const result = runGitResult(input, input.shadowRoot, ["ls-tree", "-r", "--name-only", "-z", revision, "--", relativeRoot]);
-  if (result.exitCode !== 0) return 0;
-  return result.stdout.split("\0").filter(Boolean).length;
-}
-function destructiveCheckoutReductions(input, baseRevision) {
-  const authoritativeRoot = input.trigger.canonicalCheckoutOnly && input.trigger.projectId && input.trigger.branchName ? workspaceProjectBranchRelativePath(input.trigger.projectId, input.trigger.branchName) : null;
-  const roots = new Set(
-    stagedDeletedPaths(input, baseRevision).map(managedCheckoutRoot).filter((root) => Boolean(root) && root !== authoritativeRoot)
-  );
-  const destructive = [];
-  for (const root of roots) {
-    const trackedBefore = revisionTrackedFileCount(input, baseRevision, root);
-    if (trackedBefore === 0) continue;
-    const trackedAfter = listShadowTrackedFiles(input, root).length;
-    const removedRatio = (trackedBefore - trackedAfter) / trackedBefore;
-    if (trackedAfter === 0 || trackedBefore >= DESTRUCTIVE_CHECKOUT_MIN_TRACKED_FILES && removedRatio >= DESTRUCTIVE_CHECKOUT_REMOVAL_RATIO) {
-      destructive.push({ root, trackedBefore, trackedAfter });
-    }
-  }
-  return destructive.sort((left, right) => left.root.localeCompare(right.root));
-}
-async function stagedDiffSizeBytes(input, baseRevision) {
-  const subprocess = Bun.spawn(gitArgs(input, ["diff", "--cached", "--binary", "--no-ext-diff", ...baseRevision ? [baseRevision] : []]), {
-    cwd: input.shadowRoot,
-    stdout: "pipe",
-    stderr: "pipe",
-    env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
-  });
-  const stderrPromise = new Response(subprocess.stderr).text();
-  const reader = subprocess.stdout.getReader();
-  let total = 0;
-  while (true) {
-    const chunk = await reader.read();
-    if (chunk.done) break;
-    total += chunk.value.byteLength;
-    if (total > MAX_WORKSPACE_SYNC_DIFF_BYTES) {
-      subprocess.kill();
-      await subprocess.exited;
-      await stderrPromise;
-      return MAX_WORKSPACE_SYNC_DIFF_BYTES + 1;
-    }
-  }
-  const exitCode = await subprocess.exited;
-  const stderr = (await stderrPromise).trim();
-  if (exitCode !== 0) throw new Error(`measure workspace diff: ${stderr || `git exited ${exitCode}`}`);
-  return total;
-}
-function reportedPaths(paths) {
-  if (paths.length <= MAX_REPORTED_WORKSPACE_PATHS) return paths;
-  return [
-    ...paths.slice(0, MAX_REPORTED_WORKSPACE_PATHS),
-    `[${paths.length - MAX_REPORTED_WORKSPACE_PATHS} additional paths omitted; inspect with git status]`
-  ];
-}
-function reportedStatus(status) {
-  const bytes = Buffer.from(status, "utf8");
-  if (bytes.length <= MAX_REPORTED_WORKSPACE_STATUS_BYTES) return status;
-  return `${new TextDecoder().decode(bytes.subarray(0, MAX_REPORTED_WORKSPACE_STATUS_BYTES))}
-[status truncated; inspect on the origin worker]`;
-}
-function affectedProjects(paths) {
-  const ids = /* @__PURE__ */ new Set();
-  for (const filePath of paths) {
-    const match = /^(?:projects|plans)\/([^/]+)\//.exec(filePath);
-    if (match?.[1]) ids.add(match[1]);
-  }
-  return [...ids].sort();
-}
-function commitMessage(input) {
-  return JSON.stringify({
-    type: "workspace_sync",
-    attemptId: input.attemptId,
-    worker: input.workerLabel,
-    trigger: input.trigger,
-    ...input.confirmedLargeDiff ? { confirmedLargeDiff: true, confirmationReason: input.confirmationReason } : {}
-  });
-}
-function assertWorkspaceQuarantineRef(quarantineRef) {
-  const prefix = quarantineRef.startsWith(WORKSPACE_PUBLICATION_REF_PREFIX) ? WORKSPACE_PUBLICATION_REF_PREFIX : WORKSPACE_INTENT_REF_PREFIX;
-  const suffix = quarantineRef.slice(prefix.length);
-  if (!quarantineRef.startsWith(prefix) || !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(suffix)) {
-    throw new Error(`Workspace candidate ref must be below ${WORKSPACE_PUBLICATION_REF_PREFIX} or ${WORKSPACE_INTENT_REF_PREFIX}`);
-  }
-  const result = Bun.spawnSync(["git", "check-ref-format", quarantineRef], {
-    stdout: "pipe",
-    stderr: "pipe",
-    env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
-  });
-  if (result.exitCode !== 0) {
-    throw new Error(`Invalid workspace candidate ref ${JSON.stringify(quarantineRef)}`);
-  }
-}
-function uploadWorkspaceCandidate(input, candidateHead) {
-  const quarantineRef = input.quarantineRef;
-  if (!quarantineRef) {
-    throw new Error("A server-issued workspace candidate ref is required before uploading a canonical workspace candidate");
-  }
-  assertWorkspaceQuarantineRef(quarantineRef);
-  return runGitResult(input, input.shadowRoot, ["push", "origin", `${candidateHead}:${quarantineRef}`]);
-}
-function resetShadowToRemote(input, opaqueWorkspaceRoots = []) {
-  runGit(input, input.shadowRoot, ["fetch", "origin", "--prune"], "fetch canonical workspace before reset");
-  const remoteHead = revParse(input, `origin/${WORKSPACE_BRANCH}`);
-  if (!remoteHead) return null;
-  runGitResult(input, input.shadowRoot, ["rebase", "--abort"]);
-  runGit(input, input.shadowRoot, ["reset", "--hard", `origin/${WORKSPACE_BRANCH}`], "reset workspace to canonical state");
-  runGit(input, input.shadowRoot, ["clean", "-fd"], "clean reset workspace");
-  if (!input.trigger.canonicalCheckoutOnly && !input.skipVisibleMirror) {
-    mirrorShadowWorkspaceToVisible(input, opaqueWorkspaceRoots);
-  }
-  return remoteHead;
-}
-function baseResult(input, startingHead) {
-  return {
-    type: "workspace_sync",
-    attemptId: input.attemptId ?? crypto.randomUUID(),
-    workerLabel: input.workerLabel,
-    trigger: input.trigger,
-    startingHead,
-    expectedHead: startingHead,
-    rebaseCount: 0,
-    diffSizeBytes: 0,
-    gitStatus: "",
-    affectedProjects: [],
-    affectedPaths: [],
-    discardedPaths: [],
-    localChangesDiscarded: false
-  };
-}
-function convergeRedundantInboundCandidate(input, result) {
-  if (input.trigger.type !== "inbound_head" || !input.skipVisibleMirror || input.trigger.canonicalCheckoutOnly) return null;
-  const remoteHead = revParse(input, `origin/${WORKSPACE_BRANCH}`);
-  if (!remoteHead) return null;
-  const stagedTree = runGit(input, input.shadowRoot, ["write-tree"], "write inbound workspace candidate tree");
-  const remoteTree = runGit(
-    input,
-    input.shadowRoot,
-    ["rev-parse", "--verify", `${remoteHead}^{tree}`],
-    "resolve authoritative workspace tree"
-  );
-  if (stagedTree !== remoteTree) return null;
-  const localHead = revParse(input, "HEAD");
-  if (localHead === remoteHead) return null;
-  runGit(input, input.shadowRoot, ["reset", "--hard", remoteHead], "converge redundant inbound workspace candidate");
-  runGit(input, input.shadowRoot, ["clean", "-fd"], "clean redundant inbound workspace candidate");
-  return {
-    ...result,
-    outcome: "updated",
-    publishedHead: remoteHead,
-    diffSizeBytes: 0,
-    gitStatus: gitStatus(input),
-    affectedProjects: [],
-    affectedPaths: []
-  };
-}
-function preserveWorkspaceConflictCandidate(input, observed, options) {
-  try {
-    if (!options.baseRevision) throw new Error("the preserved workspace does not have an old-base commit");
-    runGit(input, input.shadowRoot, ["reset", "--hard", options.baseRevision], "restore old-base workspace conflict candidate");
-    runGit(input, input.shadowRoot, ["clean", "-fd"], "clean old-base workspace conflict candidate");
-    if (!options.preserveShadowCandidate) {
-      const projection = mirrorVisibleWorkspaceToShadow(input);
-      restoreUnscopedCanonicalCheckoutSubtrees(input);
-      const stagePathspecs = projection.opaqueRoots.flatMap((root) => [`:(exclude,literal)${root}`]);
-      runGit(input, input.shadowRoot, ["add", "-A", "--", ".", ...stagePathspecs], "stage preserved workspace conflict candidate");
-      forceStageCanonicalCheckoutFiles(input, projection.entries, projection.opaqueRoots);
-      if (stagedPaths(input).length > 0) {
-        runGit(input, input.shadowRoot, ["commit", "-m", commitMessage(input)], "commit preserved workspace conflict candidate");
-      }
-    }
-    const candidateHead = revParse(input, "HEAD");
-    if (!candidateHead) throw new Error("the preserved workspace conflict candidate does not have a commit");
-    assertUnscopedCanonicalCheckoutSubtreesMatchRemote(input, candidateHead);
-    const upload = uploadWorkspaceCandidate(input, candidateHead);
-    if (upload.exitCode !== 0) {
-      throw new Error(upload.stderr || upload.stdout || "workspace conflict candidate upload failed");
-    }
-    const conflictPaths = [...new Set(options.conflictPaths)].sort();
-    return {
-      ...observed,
-      outcome: "conflict_blocked",
-      expectedHead: options.expectedHead,
-      candidateHead,
-      quarantineRef: input.quarantineRef,
-      ...options.publishedHead ? { publishedHead: options.publishedHead } : {},
-      rebaseCount: options.rebaseCount ?? 0,
-      affectedProjects: affectedProjects(conflictPaths),
-      affectedPaths: reportedPaths(conflictPaths),
-      error: options.error,
-      gitStatus: gitStatus(input)
-    };
-  } catch (error) {
-    return {
-      ...observed,
-      outcome: "failed",
-      rebaseCount: options.rebaseCount ?? 0,
-      affectedProjects: affectedProjects(options.conflictPaths),
-      affectedPaths: reportedPaths(options.conflictPaths),
-      error: `Workspace synchronization found a conflict but could not preserve a durable candidate: ${error instanceof Error ? error.message : String(error)}`,
-      gitStatus: gitStatus(input)
-    };
-  }
-}
-function preserveInProgressWorkspaceRebaseConflict(input, observed, options) {
-  try {
-    assertUnscopedCanonicalCheckoutSubtreesMatchRemote(input, options.candidateHead);
-    const upload = uploadWorkspaceCandidate(input, options.candidateHead);
-    if (upload.exitCode !== 0) {
-      throw new Error(upload.stderr || upload.stdout || "workspace rebase conflict candidate upload failed");
-    }
-    const conflictPaths = [...new Set(options.conflictPaths)].sort();
-    return {
-      ...observed,
-      outcome: "conflict_blocked",
-      expectedHead: options.expectedHead,
-      candidateHead: options.candidateHead,
-      quarantineRef: input.quarantineRef,
-      rebaseCount: options.rebaseCount,
-      affectedProjects: affectedProjects(conflictPaths),
-      affectedPaths: reportedPaths(conflictPaths),
-      error: options.error,
-      gitStatus: gitStatus(input)
-    };
-  } catch (error) {
-    runGitResult(input, input.shadowRoot, ["rebase", "--abort"]);
-    return {
-      ...observed,
-      outcome: "failed",
-      rebaseCount: options.rebaseCount,
-      affectedProjects: affectedProjects(options.conflictPaths),
-      affectedPaths: reportedPaths(options.conflictPaths),
-      error: `Workspace synchronization found a rebase conflict but could not preserve its durable candidate: ${error instanceof Error ? error.message : String(error)}`,
-      gitStatus: gitStatus(input)
-    };
-  }
-}
-function preserveLargeDiffCandidate(input, observed, error) {
-  try {
-    if (stagedPaths(input).length > 0) {
-      runGit(input, input.shadowRoot, ["commit", "-m", commitMessage(input)], "commit blocked workspace candidate");
-    }
-    const candidateHead = revParse(input, "HEAD");
-    if (!candidateHead) throw new Error("the blocked workspace candidate does not have a commit");
-    assertUnscopedCanonicalCheckoutSubtreesMatchRemote(input, candidateHead);
-    const upload = uploadWorkspaceCandidate(input, candidateHead);
-    if (upload.exitCode !== 0) {
-      throw new Error(upload.stderr || upload.stdout || "blocked workspace candidate upload failed");
-    }
-    return {
-      ...observed,
-      outcome: "large_diff_blocked",
-      expectedHead: revParse(input, `origin/${WORKSPACE_BRANCH}`),
-      candidateHead,
-      quarantineRef: input.quarantineRef,
-      error,
-      gitStatus: gitStatus(input)
-    };
-  } catch (candidateError) {
-    return {
-      ...observed,
-      outcome: "failed",
-      error: `Workspace safety guard blocked publication but could not preserve a durable candidate: ${candidateError instanceof Error ? candidateError.message : String(candidateError)}`,
-      gitStatus: gitStatus(input)
-    };
-  }
-}
-async function synchronizeWorkspace(rawInput) {
-  let input = { ...rawInput, attemptId: rawInput.attemptId ?? crypto.randomUUID() };
-  try {
-    input = { ...input, projects: workspaceProjectsForSync(input.projects, input.trigger) };
-    const isCanonicalRemediationSync = input.skipVisibleMirror === true && (input.trigger.type === "remediation" || input.trigger.type === "remediation_confirm");
-    let mirroredGitlinkProjection = { entries: [], opaqueRoots: [], visiblePreimages: /* @__PURE__ */ new Map() };
-    let fastForwardedFromHead = null;
-    const shadowWasCreated = ensureShadowWorkspace(input);
-    let hydrationPreimages = input.skipVisibleMirror ? hydrationPreimagesFromShadowRevision(input, shadowWasCreated ? null : revParse(input, "HEAD")) : /* @__PURE__ */ new Map();
-    const remoteHeadAtStart = revParse(input, `origin/${WORKSPACE_BRANCH}`);
-    const result = baseResult(input, remoteHeadAtStart);
-    if (input.expectedCanonicalHead !== void 0 && remoteHeadAtStart !== input.expectedCanonicalHead) {
-      return {
-        ...result,
-        outcome: "failed",
-        expectedHead: input.expectedCanonicalHead,
-        publishedHead: remoteHeadAtStart ?? void 0,
-        error: `canonical_head_advanced: expected ${input.expectedCanonicalHead ?? "unborn"}, fetched ${remoteHeadAtStart ?? "unborn"}`
-      };
-    }
-    const inProgressRemediation = remediationRebaseInProgressResult(input, result);
-    if (inProgressRemediation) return inProgressRemediation;
-    restoreCleanShadowToExpectedIncidentCandidate(input);
-    const visibleBaselineHead = restoreShadowToVisibleBaseline(input, remoteHeadAtStart);
-    const inboundConflictsAtStart = input.skipVisibleMirror && !isCanonicalRemediationSync && remoteHeadAtStart ? visibleHydrationConflictPaths(input, hydrationPreimages, `origin/${WORKSPACE_BRANCH}`) : [];
-    if (input.resetToCanonical) {
-      if (input.trigger.canonicalCheckoutOnly) {
-        throw new Error("A canonical-checkout-only synchronization cannot reset the authoritative resolver checkout");
-      }
-      const publishedHead = resetShadowToRemote(input);
-      return {
-        ...result,
-        outcome: "reset",
-        publishedHead: publishedHead ?? void 0,
-        localChangesDiscarded: true,
-        gitStatus: gitStatus(input)
-      };
-    }
-    if (!input.skipVisibleMirror) resetUncommittedShadowSnapshot(input);
-    restoreUnscopedCanonicalCheckoutSubtrees(input);
-    if (!input.skipVisibleMirror) {
-      const newCheckoutKeys = new Set((input.newVisibleCheckouts ?? []).map((target) => `${target.projectId}\0${target.branchName}`));
-      mirroredGitlinkProjection = mirrorVisibleWorkspaceToShadow(input, newCheckoutKeys);
-      fastForwardedFromHead = fastForwardCleanShadowForNewCheckouts(input);
-      mergeGitlinkProjection(mirroredGitlinkProjection, reconcileNewVisibleCheckouts(input));
-      mirroredGitlinkProjection.opaqueRoots = [...new Set(mirroredGitlinkProjection.opaqueRoots)].sort();
-      hydrationPreimages = mirroredGitlinkProjection.visiblePreimages ?? hydrationPreimages;
-      if (input.trigger.type === "remediation" && !visibleWorkspaceMatchesProjection(input, mirroredGitlinkProjection)) {
-        resetUncommittedShadowSnapshot(input);
-        throw new Error("visible_workspace_unstable: visible files changed while preparing the remediation snapshot");
-      }
-    }
-    const stagePathspecs = mirroredGitlinkProjection.opaqueRoots.flatMap((root) => [`:(exclude,literal)${root}`]);
-    runGit(input, input.shadowRoot, ["add", "-A", "--", ".", ...stagePathspecs], "stage workspace changes");
-    forceStageCanonicalCheckoutFiles(input, mirroredGitlinkProjection.entries, mirroredGitlinkProjection.opaqueRoots);
-    const redundantInboundCandidate = convergeRedundantInboundCandidate(input, result);
-    if (redundantInboundCandidate) return redundantInboundCandidate;
-    const sampledCanonicalCheckoutTreeHash = sampleCanonicalCheckoutTree(input);
-    const stagedWorkingPaths = stagedPaths(input);
-    const preservesDivergentVisibleSnapshot = input.confirmedLargeDiff === true || input.trigger.type === "remediation" || input.trigger.type === "remediation_confirm";
-    const baseRevision = preservesDivergentVisibleSnapshot ? remoteHeadAtStart : visibleBaselineHead !== void 0 ? visibleBaselineHead : candidateBaseRevision(input);
-    const paths = stagedPaths(input, baseRevision);
-    const diffSizeBytes = await stagedDiffSizeBytes(input, baseRevision);
-    const statusBeforeCommit = reportedStatus(gitStatus(input));
-    const observed = {
-      ...result,
-      diffSizeBytes,
-      gitStatus: statusBeforeCommit,
-      affectedPaths: reportedPaths(paths),
-      affectedProjects: affectedProjects(paths),
-      ...sampledCanonicalCheckoutTreeHash ? { sampledCanonicalCheckoutTreeHash } : {}
-    };
-    const destructiveReductions = destructiveCheckoutReductions(input, baseRevision);
-    let blockedDiffError;
-    if (destructiveReductions.length > 0 && !input.confirmedLargeDiff) {
-      const summary = destructiveReductions.map(({ root, trackedBefore, trackedAfter }) => `${root} (${trackedBefore} -> ${trackedAfter} tracked files)`).join(", ");
-      blockedDiffError = `Workspace safety guard blocked a destructive checkout reduction: ${summary}`;
-    } else if (paths.length > 0 && diffSizeBytes > MAX_WORKSPACE_SYNC_DIFF_BYTES && !input.confirmedLargeDiff && !input.trigger.canonicalCheckoutOnly) {
-      blockedDiffError = `Workspace safety guard blocked a ${diffSizeBytes}-byte diff above the ${MAX_WORKSPACE_SYNC_DIFF_BYTES}-byte automatic publication limit.`;
-    }
-    if (stagedWorkingPaths.length > 0) {
-      runGit(input, input.shadowRoot, ["commit", "-m", commitMessage(input)], "commit workspace changes");
-    }
-    let candidateHead = revParse(input, "HEAD");
-    const candidateHeadBeforeRebase = candidateHead;
-    if (candidateHead) assertUnscopedCanonicalCheckoutSubtreesMatchRemote(input, candidateHead);
-    const remoteHeadBeforeRebase = revParse(input, `origin/${WORKSPACE_BRANCH}`);
-    const hasRemoteMain = Boolean(remoteHeadBeforeRebase);
-    const hasCapturedVisibleDelta = visibleBaselineHead === void 0 || paths.length > 0;
-    const mustDropVisibleBaselinePrefix = !preservesDivergentVisibleSnapshot && visibleBaselineHead !== void 0 && visibleBaselineHead !== remoteHeadBeforeRebase && stagedWorkingPaths.length > 0;
-    const hasUnpushedCommit = candidateHead && hasCapturedVisibleDelta ? mustDropVisibleBaselinePrefix || !hasRemoteMain || !tryGit(input, input.shadowRoot, ["merge-base", "--is-ancestor", candidateHead, `origin/${WORKSPACE_BRANCH}`]) : false;
-    if (hasUnpushedCommit && inboundConflictsAtStart.length > 0) {
-      const conflictPaths = [.../* @__PURE__ */ new Set([...paths, ...inboundConflictsAtStart])].sort();
-      return preserveWorkspaceConflictCandidate(input, observed, {
-        baseRevision: candidateHead,
-        expectedHead: revParse(input, `origin/${WORKSPACE_BRANCH}`),
-        conflictPaths,
-        error: "Inbound workspace update overlaps local visible changes; the old-base candidate was preserved for reconciliation."
-      });
-    }
-    if (!hasUnpushedCommit) {
-      const localHead = revParse(input, "HEAD");
-      const currentRemoteHead = revParse(input, `origin/${WORKSPACE_BRANCH}`);
-      if (currentRemoteHead && localHead !== currentRemoteHead) {
-        runGit(input, input.shadowRoot, ["reset", "--hard", `origin/${WORKSPACE_BRANCH}`], "update workspace from canonical state");
-        runGit(input, input.shadowRoot, ["clean", "-fd"], "clean updated workspace");
-        assertPublishedCanonicalCheckoutTree(input, currentRemoteHead, sampledCanonicalCheckoutTreeHash);
-        if (!isCanonicalRemediationSync) {
-          mirrorShadowWorkspaceToVisible(input, mirroredGitlinkProjection.opaqueRoots, hydrationPreimages);
-        }
-        const inboundConflicts = input.trigger.canonicalCheckoutOnly || isCanonicalRemediationSync ? [] : localHead ? hydrationConflictPaths(input, hydrationPreimages, localHead, currentRemoteHead) : visibleHydrationConflictPaths(input, hydrationPreimages, currentRemoteHead);
-        if (inboundConflicts.length > 0 && localHead) {
-          runGit(input, input.shadowRoot, ["reset", "--hard", localHead], "preserve old workspace base after inbound conflict");
-          runGit(input, input.shadowRoot, ["clean", "-fd"], "clean preserved old workspace base");
-          const conflictPaths = [.../* @__PURE__ */ new Set([...paths, ...inboundConflicts])].sort();
-          return preserveWorkspaceConflictCandidate(input, observed, {
-            baseRevision: localHead,
-            expectedHead: currentRemoteHead,
-            publishedHead: currentRemoteHead,
-            conflictPaths,
-            error: "Inbound workspace update overlaps local visible changes; disjoint updates were hydrated and the old base was preserved for reconciliation."
-          });
-        }
-        return {
-          ...observed,
-          outcome: "updated",
-          candidateHead: candidateHead ?? void 0,
-          publishedHead: currentRemoteHead,
-          gitStatus: gitStatus(input)
-        };
-      }
-      const authoritativeHead = currentRemoteHead ?? localHead;
-      if (authoritativeHead) {
-        assertPublishedCanonicalCheckoutTree(input, authoritativeHead, sampledCanonicalCheckoutTreeHash);
-        if (!isCanonicalRemediationSync) {
-          mirrorShadowWorkspaceToVisible(input, mirroredGitlinkProjection.opaqueRoots, hydrationPreimages);
-        }
-        const hydrationConflicts2 = input.trigger.canonicalCheckoutOnly || isCanonicalRemediationSync ? [] : fastForwardedFromHead ? hydrationConflictPaths(input, hydrationPreimages, fastForwardedFromHead, authoritativeHead) : visibleHydrationConflictPaths(input, hydrationPreimages, authoritativeHead);
-        if (hydrationConflicts2.length > 0 && fastForwardedFromHead) {
-          runGit(
-            input,
-            input.shadowRoot,
-            ["reset", "--hard", fastForwardedFromHead],
-            "preserve old workspace base after new-checkout fast-forward conflict"
-          );
-          runGit(input, input.shadowRoot, ["clean", "-fd"], "clean preserved new-checkout workspace base");
-          return preserveWorkspaceConflictCandidate(input, observed, {
-            baseRevision: fastForwardedFromHead,
-            expectedHead: currentRemoteHead,
-            publishedHead: currentRemoteHead ?? void 0,
-            conflictPaths: hydrationConflicts2,
-            error: "Workspace fast-forward for a new checkout overlaps local visible changes; compatible updates were hydrated and the old base was preserved for reconciliation."
-          });
-        }
-      }
-      return {
-        ...observed,
-        outcome: "no_change",
-        candidateHead: candidateHead ?? void 0,
-        publishedHead: currentRemoteHead ?? localHead ?? void 0,
-        gitStatus: gitStatus(input)
-      };
-    }
-    let rebaseCount = 0;
-    const expectedHead = remoteHeadBeforeRebase;
-    if (mustDropVisibleBaselinePrefix && !expectedHead) {
-      return {
-        ...observed,
-        outcome: "failed",
-        candidateHead: candidateHead ?? void 0,
-        error: "Cannot normalize a visible workspace tail onto an unborn canonical workspace",
-        gitStatus: gitStatus(input)
-      };
-    }
-    if (candidateHead && expectedHead && (mustDropVisibleBaselinePrefix || !tryGit(input, input.shadowRoot, ["merge-base", "--is-ancestor", expectedHead, candidateHead]))) {
-      const rebase = runGitResult(
-        input,
-        input.shadowRoot,
-        mustDropVisibleBaselinePrefix && visibleBaselineHead ? ["rebase", "--onto", `origin/${WORKSPACE_BRANCH}`, visibleBaselineHead] : ["rebase", `origin/${WORKSPACE_BRANCH}`]
-      );
-      rebaseCount += 1;
-      if (rebase.exitCode !== 0) {
-        const conflicted = runGitResult(input, input.shadowRoot, ["diff", "--name-only", "--diff-filter=U", "-z"]);
-        const conflictPaths = [.../* @__PURE__ */ new Set([...paths, ...conflicted.stdout.split("\0").filter(Boolean)])].sort();
-        if (mustDropVisibleBaselinePrefix) {
-          const originalCandidateHead = revParse(input, "ORIG_HEAD") ?? candidateHead;
-          return preserveInProgressWorkspaceRebaseConflict(input, observed, {
-            candidateHead: originalCandidateHead,
-            expectedHead,
-            rebaseCount,
-            conflictPaths,
-            error: `Workspace tail conflicts with canonical head ${expectedHead}; local changes were preserved for reconciliation in the in-progress rebase.`
-          });
-        }
-        runGit(input, input.shadowRoot, ["rebase", "--abort"], "preserve workspace candidate after rebase conflict");
-        return preserveWorkspaceConflictCandidate(input, observed, {
-          baseRevision: candidateHead,
-          expectedHead,
-          rebaseCount,
-          preserveShadowCandidate: isCanonicalRemediationSync,
-          conflictPaths,
-          error: `Workspace candidate conflicts with canonical head ${expectedHead}; local changes were preserved for reconciliation.`
-        });
-      }
-      candidateHead = revParse(input, "HEAD");
-      assertPublishedCanonicalCheckoutTree(input, "HEAD", sampledCanonicalCheckoutTreeHash);
-      assertUnscopedCanonicalCheckoutSubtreesMatchRemote(input, "HEAD");
-    }
-    if (!candidateHead) {
-      return {
-        ...observed,
-        outcome: "failed",
-        rebaseCount,
-        error: "Workspace candidate does not have a commit",
-        gitStatus: gitStatus(input)
-      };
-    }
-    assertPublishedCanonicalCheckoutTree(input, candidateHead, sampledCanonicalCheckoutTreeHash);
-    if (!isCanonicalRemediationSync) {
-      mirrorShadowWorkspaceToVisible(input, mirroredGitlinkProjection.opaqueRoots, hydrationPreimages);
-    }
-    const hydrationConflicts = input.trigger.canonicalCheckoutOnly || isCanonicalRemediationSync ? [] : candidateHeadBeforeRebase ? hydrationConflictPaths(input, hydrationPreimages, candidateHeadBeforeRebase, "HEAD") : visibleHydrationConflictPaths(input, hydrationPreimages, "HEAD");
-    if (hydrationConflicts.length > 0 && candidateHeadBeforeRebase) {
-      runGit(
-        input,
-        input.shadowRoot,
-        ["reset", "--hard", candidateHeadBeforeRebase],
-        "preserve old-base workspace candidate after hydration conflict"
-      );
-      runGit(input, input.shadowRoot, ["clean", "-fd"], "clean old-base workspace candidate");
-      const conflictPaths = [.../* @__PURE__ */ new Set([...paths, ...hydrationConflicts])].sort();
-      return preserveWorkspaceConflictCandidate(input, observed, {
-        baseRevision: candidateHeadBeforeRebase,
-        expectedHead,
-        rebaseCount,
-        conflictPaths,
-        error: "Workspace changed while its candidate was reconciling; visible changes and the old-base candidate were preserved."
-      });
-    }
-    if (blockedDiffError) {
-      return preserveLargeDiffCandidate(input, { ...observed, rebaseCount }, blockedDiffError);
-    }
-    const upload = uploadWorkspaceCandidate(input, candidateHead);
-    if (upload.exitCode !== 0) {
-      return {
-        ...observed,
-        outcome: "failed",
-        candidateHead,
-        quarantineRef: input.quarantineRef,
-        rebaseCount,
-        error: upload.stderr || upload.stdout || "Workspace candidate upload failed",
-        gitStatus: gitStatus(input)
-      };
-    }
-    return {
-      ...observed,
-      outcome: "candidate_ready",
-      expectedHead,
-      candidateHead,
-      quarantineRef: input.quarantineRef,
-      rebaseCount,
-      gitStatus: gitStatus(input)
-    };
-  } catch (error) {
-    const result = baseResult(input, null);
-    return {
-      ...result,
-      outcome: "failed",
-      error: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-async function convergeWorkspaceHead(rawInput, options) {
-  const input = {
-    ...rawInput,
-    projects: workspaceProjectsForSync(rawInput.projects, rawInput.trigger)
-  };
-  if (input.trigger.canonicalCheckoutOnly) {
-    throw new Error("Ordinary inbound convergence cannot target a canonical resolver checkout");
-  }
-  ensureShadowWorkspace(input);
-  const fetchedLocalHead = revParse(input, "HEAD");
-  const fetchedCanonicalHead = revParse(input, `origin/${WORKSPACE_BRANCH}`);
-  if (!options.hydrateVisible) {
-    return {
-      localHead: fetchedLocalHead,
-      canonicalHead: fetchedCanonicalHead,
-      localChanges: false,
-      hydrated: false,
-      hydrationConflicts: []
-    };
-  }
-  resetUncommittedShadowSnapshot(input);
-  restoreUnscopedCanonicalCheckoutSubtrees(input);
-  const localHead = fetchedLocalHead;
-  const canonicalHead = fetchedCanonicalHead;
-  const projection = mirrorVisibleWorkspaceToShadow(input);
-  runGit(
-    input,
-    input.shadowRoot,
-    ["add", "-A", "--", ".", ...projection.opaqueRoots.map((root) => `:(exclude,literal)${root}`)],
-    "stage inbound workspace observation"
-  );
-  forceStageCanonicalCheckoutFiles(input, projection.entries, projection.opaqueRoots);
-  const stagedTree = runGit(input, input.shadowRoot, ["write-tree"], "write inbound workspace observation tree");
-  const headTree = localHead ? revParse(input, `${localHead}^{tree}`) : null;
-  const localChanges = stagedTree !== headTree;
-  if (!options.hydrateVisible || localChanges || !canonicalHead || localHead === canonicalHead) {
-    resetUncommittedShadowSnapshot(input);
-    return { localHead, canonicalHead, localChanges, hydrated: false, hydrationConflicts: [] };
-  }
-  const preimages = projection.visiblePreimages ?? hydrationPreimagesFromShadowRevision(input, localHead);
-  const hydrationConflicts = localHead ? hydrationConflictPaths(input, preimages, localHead, canonicalHead) : [];
-  if (hydrationConflicts.length > 0) {
-    resetUncommittedShadowSnapshot(input);
-    return { localHead, canonicalHead, localChanges: true, hydrated: false, hydrationConflicts };
-  }
-  runGit(input, input.shadowRoot, ["reset", "--hard", canonicalHead], "fast-forward workspace to available canonical head");
-  runGit(input, input.shadowRoot, ["clean", "-fd"], "clean fast-forwarded workspace");
-  mirrorShadowWorkspaceToVisible(input, projection.opaqueRoots, preimages);
-  return { localHead: canonicalHead, canonicalHead, localChanges: false, hydrated: true, hydrationConflicts: [] };
-}
-function calculateWorkspaceLocalDiffFingerprint(rawInput) {
-  const input = {
-    ...rawInput,
-    projects: workspaceProjectsForSync(rawInput.projects, rawInput.trigger)
-  };
-  if (!import_node_fs.default.existsSync(import_node_path.default.join(input.shadowRoot, ".git"))) {
-    throw new Error("Cannot inspect local workspace changes before first bootstrap");
-  }
-  resetUncommittedShadowSnapshot(input);
-  restoreUnscopedCanonicalCheckoutSubtrees(input);
-  const projection = mirrorVisibleWorkspaceToShadow(input);
-  runGit(
-    input,
-    input.shadowRoot,
-    ["add", "-A", "--", ".", ...projection.opaqueRoots.map((root) => `:(exclude,literal)${root}`)],
-    "stage local workspace fingerprint"
-  );
-  forceStageCanonicalCheckoutFiles(input, projection.entries, projection.opaqueRoots);
-  const stagedTree = runGit(input, input.shadowRoot, ["write-tree"], "write local workspace fingerprint tree");
-  const headTree = revParse(input, "HEAD^{tree}");
-  resetUncommittedShadowSnapshot(input);
-  return stagedTree === headTree ? (0, import_node_crypto.createHash)("sha256").update("").digest("hex") : (0, import_node_crypto.createHash)("sha256").update(stagedTree).digest("hex");
-}
-function calculateWorkspaceDiffFingerprint(rawInput) {
-  const input = {
-    ...rawInput,
-    projects: workspaceProjectsForSync(rawInput.projects, rawInput.trigger)
-  };
-  ensureShadowWorkspace(input);
-  let gitlinkProjection = { entries: [], opaqueRoots: [] };
-  if (!input.skipVisibleMirror) {
-    resetUncommittedShadowSnapshot(input);
-    restoreUnscopedCanonicalCheckoutSubtrees(input);
-    gitlinkProjection = mirrorVisibleWorkspaceToShadow(input);
-  } else {
-    restoreUnscopedCanonicalCheckoutSubtrees(input);
-  }
-  runGit(
-    input,
-    input.shadowRoot,
-    ["add", "-A", "--", ".", ...gitlinkProjection.opaqueRoots.map((root) => `:(exclude,literal)${root}`)],
-    "stage workspace fingerprint"
-  );
-  forceStageCanonicalCheckoutFiles(input, gitlinkProjection.entries, gitlinkProjection.opaqueRoots);
-  const stagedTree = runGit(input, input.shadowRoot, ["write-tree"], "write workspace fingerprint tree");
-  const headTree = revParse(input, "HEAD^{tree}");
-  const localHead = revParse(input, "HEAD");
-  const remoteHead = revParse(input, `origin/${WORKSPACE_BRANCH}`);
-  if (stagedTree === headTree && localHead === remoteHead) {
-    return (0, import_node_crypto.createHash)("sha256").update("").digest("hex");
-  }
-  return (0, import_node_crypto.createHash)("sha256").update(JSON.stringify({ stagedTree, localHead, remoteHead })).digest("hex");
-}
-class WorkspaceSyncSingleFlight {
-  mutationGate = new import_workspace_mutation_gate.WorkspaceMutationGate();
-  queue = Promise.resolve();
-  enqueue(task) {
-    const queued = this.mutationGate.runSync(task);
-    this.queue = queued.then(
-      () => void 0,
-      () => void 0
-    );
-    return queued;
-  }
-  run(input) {
-    return this.enqueue(() => synchronizeWorkspace(input));
-  }
-  runPrepared(prepare) {
-    return this.enqueue(() => synchronizeWorkspace(prepare()));
-  }
-  fingerprint(input) {
-    return this.enqueue(() => calculateWorkspaceDiffFingerprint(input));
-  }
-  fingerprintPrepared(prepare) {
-    return this.enqueue(() => calculateWorkspaceDiffFingerprint(prepare()));
-  }
-  runExclusive(operation) {
-    return this.enqueue(operation);
-  }
-  runMutation(operation) {
-    return this.mutationGate.runMutation(operation);
-  }
-  acquireMutation() {
-    return this.mutationGate.acquireMutation();
-  }
-  afterCurrent() {
-    return this.queue;
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  MAX_WORKSPACE_SYNC_DIFF_BYTES,
-  WORKSPACE_BRANCH,
-  WORKSPACE_INTENT_REF_PREFIX,
-  WORKSPACE_NATIVE_PLANS_RELATIVE_PATH,
-  WORKSPACE_PUBLICATION_REF_PREFIX,
-  WorkspaceSyncSingleFlight,
-  assertCanonicalCheckoutIndexMatchesWorktree,
-  assertWorkspaceQuarantineRef,
-  calculateWorkspaceDiffFingerprint,
-  calculateWorkspaceLocalDiffFingerprint,
-  convergeWorkspaceHead,
-  encodeWorkspaceBranch,
-  mirrorShadowWorkspaceToVisible,
-  mirrorVisibleWorkspaceToShadow,
-  synchronizeWorkspace,
-  visibleProjectBranchPath,
-  workspacePlansRelativePath,
-  workspaceProjectBranchRelativePath,
-  workspaceProjectsForSync
-});