@iowarp/clio-coder 0.4.6 → 0.4.8

package/dist/chunk-K53E2PTW.js

@@ -0,0 +1,1289 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  describeWriteBoundary,
+  normalizeWriteBoundary,
+  normalizeWriteBoundaryEntry,
+  writeBoundaryCovers
+} from "./chunk-7QQRPB2E.js";
+import {
+  asDirectoryPathBoundary,
+  pathBoundaryEntryCovers
+} from "./chunk-R2P2U3ZS.js";
+import {
+  buildSafeToolEnv
+} from "./chunk-GJ24ODAX.js";
+import {
+  atomicWrite
+} from "./chunk-36XSBPXL.js";
+import {
+  clioStateDir
+} from "./chunk-CTTI7G3T.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/tools/compete-worktrees.ts
+init_esm_shims();
+import { execFileSync as execFileSync3 } from "node:child_process";
+import { randomBytes as randomBytes2 } from "node:crypto";
+import {
+  existsSync as existsSync2,
+  lstatSync,
+  mkdirSync as mkdirSync2,
+  readdirSync,
+  readFileSync as readFileSync2,
+  realpathSync as realpathSync2,
+  renameSync,
+  rmdirSync,
+  rmSync as rmSync3,
+  unlinkSync,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { hostname } from "node:os";
+import { join as join3, relative as relative2, resolve as resolve2 } from "node:path";
+
+// src/domains/dispatch/workspace-checkpoint.ts
+init_esm_shims();
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+function workspaceCheckpointRef(kind, identity) {
+  return `refs/clio-coder/${kind}/${createHash("sha256").update(identity).digest("hex")}`;
+}
+function captureWorkspaceCheckpoint(cwd, ref, message) {
+  if (!/^refs\/clio-coder\/(loop|compete)\/[a-f0-9]{64}$/.test(ref)) throw new Error("invalid workspace checkpoint ref");
+  const directory = mkdtempSync(join(tmpdir(), "clio-coder-checkpoint-index-"));
+  const env = buildSafeToolEnv({
+    GIT_INDEX_FILE: join(directory, "index"),
+    GIT_AUTHOR_NAME: "Clio checkpoint",
+    GIT_AUTHOR_EMAIL: "checkpoint@clio.invalid",
+    GIT_COMMITTER_NAME: "Clio checkpoint",
+    GIT_COMMITTER_EMAIL: "checkpoint@clio.invalid"
+  });
+  const config = ["-c", "core.hooksPath=/dev/null", "-c", "core.fsmonitor=false"];
+  const git4 = (args) => execFileSync("git", ["-C", cwd, ...config, ...args], {
+    env,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 3e4,
+    maxBuffer: 1024 * 1024
+  }).trim();
+  try {
+    try {
+      git4(["rev-parse", "--verify", ref]);
+      return ref;
+    } catch {
+    }
+    const head = git4(["rev-parse", "HEAD"]);
+    const filterKeys = git4(["config", "--null", "--name-only", "--list"]).split("\0").filter((key) => /^filter\..*\.(?:clean|process|required)$/.test(key));
+    for (const key of filterKeys) config.push("-c", `${key}=${key.endsWith(".required") ? "false" : ""}`);
+    git4(["read-tree", head]);
+    git4(["add", "-A", "--", "."]);
+    const tree = git4(["write-tree"]);
+    const commit = git4(["commit-tree", tree, "-p", head, "-m", message]);
+    git4(["update-ref", ref, commit, ""]);
+    return ref;
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+}
+
+// src/tools/task-worktree.ts
+init_esm_shims();
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { createHash as createHash2, randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync as rmSync2, writeFileSync } from "node:fs";
+import { isAbsolute, join as join2, relative, resolve, sep } from "node:path";
+var SAFE_RUN_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u;
+var OWNER_FILE_SUFFIX = ".task-owner.json";
+var TASK_WORKTREE_KIND = "clio-coder-task-worktree";
+var LEGACY_TASK_WORKTREE_KIND = "clio-task-worktree";
+var COMMIT_IDENTITY = "clio-coder-task";
+function gitBytes(root, args) {
+  return execFileSync2("git", ["-C", root, ...args], {
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 3e4
+  });
+}
+function git(root, args) {
+  return gitBytes(root, args).toString("utf8").trim();
+}
+function isCanonicalWorktreePathInside(parent, candidate) {
+  let canonicalParent;
+  let canonicalCandidate;
+  try {
+    canonicalParent = realpathSync(parent);
+  } catch {
+    canonicalParent = resolve(parent);
+  }
+  try {
+    canonicalCandidate = realpathSync(candidate);
+  } catch {
+    canonicalCandidate = resolve(candidate);
+  }
+  const rel = relative(canonicalParent, canonicalCandidate);
+  return rel.length > 0 && rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+}
+function commitWorktreePath(path, identity, message, excludedPaths = []) {
+  if (excludedPaths.length > 0) {
+    git(path, ["reset", "-q", "HEAD", "--", ...excludedPaths.map((entry) => `:(top,literal)${entry}`)]);
+  }
+  git(path, ["add", "-A", "--", ".", ...excludedPaths.map((entry) => `:(top,exclude,literal)${entry}`)]);
+  if (git(path, ["diff", "--cached", "--name-only", "-z"]).length === 0) return false;
+  git(path, [
+    "-c",
+    `user.name=${identity}`,
+    "-c",
+    `user.email=${identity}@local`,
+    "commit",
+    "-m",
+    message,
+    "--no-verify"
+  ]);
+  return true;
+}
+function worktreeBranchDiffStat(root, branch) {
+  try {
+    return git(root, ["diff", "--shortstat", `HEAD...${branch}`]) || "no changes";
+  } catch {
+    return "diff unavailable";
+  }
+}
+function protectedPathsChangedByWorktreeBranch(root, branch, protectedPaths) {
+  const canonical = realpathSync(root);
+  const protectedInside = protectedPaths.map((path) => resolve(path)).filter((path) => {
+    const rel = relative(canonical, path);
+    return rel.length > 0 && rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+  });
+  if (protectedInside.length === 0) return [];
+  const changed = git(canonical, ["diff", "--name-only", "-z", "--no-renames", `HEAD...${branch}`]).split("\0").filter((path) => path.length > 0).map((path) => resolve(canonical, path));
+  const blocked = /* @__PURE__ */ new Set();
+  for (const candidate of changed) {
+    for (const protectedPath of protectedInside) {
+      const rel = relative(protectedPath, candidate);
+      if (candidate === protectedPath || rel.length > 0 && rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel)) {
+        blocked.add(protectedPath);
+      }
+    }
+  }
+  return [...blocked].sort();
+}
+function mergeWorktreeBranch(root, branch, identity) {
+  try {
+    git(root, [
+      "-c",
+      `user.name=${identity}`,
+      "-c",
+      `user.email=${identity}@local`,
+      "merge",
+      "--no-edit",
+      "--no-verify",
+      branch
+    ]);
+    return { ok: true };
+  } catch (error) {
+    try {
+      git(root, ["merge", "--abort"]);
+    } catch {
+    }
+    return {
+      ok: false,
+      reason: error instanceof Error ? error.message.split("\n")[0] ?? "merge failed" : String(error)
+    };
+  }
+}
+function validateRunId(runId) {
+  if (!SAFE_RUN_ID.test(runId) || runId === "." || runId === "..")
+    throw new Error(`invalid task worktree run id '${runId}'`);
+}
+function gitCheckoutRoot(cwd) {
+  try {
+    return realpathSync(git(cwd, ["rev-parse", "--show-toplevel"]));
+  } catch {
+    return null;
+  }
+}
+function createTaskWorktree(root, runId, base) {
+  validateRunId(runId);
+  const canonical = realpathSync(root);
+  const resolvedBase = base ?? git(canonical, ["rev-parse", "HEAD"]);
+  const parent = join2(canonical, ".clio-coder", "worktrees");
+  const path = join2(parent, runId);
+  const branch = `clio-coder/task/${runId}`;
+  mkdirSync(parent, { recursive: true });
+  if (!isCanonicalWorktreePathInside(parent, path))
+    throw new Error(`task worktree path escapes its parent for run ${runId}`);
+  git(canonical, ["worktree", "add", "-b", branch, path, resolvedBase]);
+  const ownerToken = randomBytes(16).toString("hex");
+  writeFileSync(
+    `${path}${OWNER_FILE_SUFFIX}`,
+    `${JSON.stringify({ version: 1, kind: TASK_WORKTREE_KIND, root: canonical, runId, branch, base: resolvedBase, ownerToken }, null, 2)}
+`,
+    { encoding: "utf8", flag: "wx" }
+  );
+  return { root: canonical, runId, path, branch, base: resolvedBase, ownerToken };
+}
+function assertOwnership(worktree) {
+  const expected = join2(worktree.root, ".clio-coder", "worktrees", worktree.runId);
+  if (resolve(worktree.path) !== resolve(expected) || !isCanonicalWorktreePathInside(join2(worktree.root, ".clio-coder", "worktrees"), worktree.path)) {
+    throw new Error(`task worktree ${worktree.runId} has an invalid ownership path`);
+  }
+  const ownerPath = `${worktree.path}${OWNER_FILE_SUFFIX}`;
+  if (!existsSync(ownerPath)) throw new Error(`task worktree ${worktree.runId} has no ownership file`);
+  let marker;
+  try {
+    const value = JSON.parse(readFileSync(ownerPath, "utf8"));
+    if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("not an object");
+    marker = value;
+  } catch {
+    throw new Error(`task worktree ${worktree.runId} has an invalid ownership file`);
+  }
+  if (marker.version !== 1 || marker.kind !== TASK_WORKTREE_KIND && marker.kind !== LEGACY_TASK_WORKTREE_KIND || marker.root !== worktree.root || marker.runId !== worktree.runId || marker.branch !== worktree.branch || marker.base !== worktree.base || marker.ownerToken !== worktree.ownerToken) {
+    throw new Error(`task worktree ${worktree.runId} ownership facts do not match`);
+  }
+}
+function commitTaskWorktree(worktree, message = `Clio Coder task ${worktree.runId}`) {
+  assertOwnership(worktree);
+  return commitWorktreePath(worktree.path, COMMIT_IDENTITY, message);
+}
+function taskWorktreeDiffHash(worktree) {
+  const bytes = gitBytes(worktree.root, ["diff", `${worktree.base}..${worktree.branch}`]);
+  return createHash2("sha256").update(bytes).digest("hex");
+}
+function protectedPathsChangedByTaskBranch(worktree, protectedPaths) {
+  return protectedPathsChangedByWorktreeBranch(worktree.root, worktree.branch, protectedPaths);
+}
+function applyTaskWorktree(input) {
+  assertOwnership(input.worktree);
+  commitTaskWorktree(input.worktree);
+  const receipt = {
+    path: input.worktree.path,
+    branch: input.worktree.branch,
+    diffHash: taskWorktreeDiffHash(input.worktree),
+    apply: input.apply,
+    applied: false
+  };
+  if (input.apply === "preserve") return receipt;
+  const protectedChanges = protectedPathsChangedByTaskBranch(input.worktree, input.protectedPaths ?? []);
+  if (protectedChanges.length > 0) return { ...receipt, reason: "protected_artifact_changed" };
+  const merged = mergeWorktreeBranch(input.worktree.root, input.worktree.branch, COMMIT_IDENTITY);
+  if (!merged.ok) return { ...receipt, reason: "worktree_merge_conflict" };
+  return { ...receipt, applied: true };
+}
+function cleanupTaskWorktree(worktree, deleteBranch) {
+  assertOwnership(worktree);
+  try {
+    git(worktree.root, ["worktree", "remove", "--force", worktree.path]);
+  } catch {
+    if (existsSync(worktree.path)) rmSync2(worktree.path, { recursive: true, force: true });
+    git(worktree.root, ["worktree", "prune"]);
+  }
+  if (deleteBranch) git(worktree.root, ["branch", "-D", worktree.branch]);
+  rmSync2(`${worktree.path}${OWNER_FILE_SUFFIX}`, { force: true });
+}
+
+// src/tools/compete-worktrees.ts
+var COMPETE_PARENT_SEGMENTS = [".clio-coder", "worktrees"];
+var COMPETE_MANIFEST_FILE = ".clio-coder-compete-owner.json";
+var COMPETE_MANIFEST_KIND = "clio-coder-compete-group";
+var LEGACY_COMPETE_MANIFEST_KIND = "clio-compete-group";
+var COMPETE_COMMIT_IDENTITY = "clio-coder-compete";
+var SAFE_GROUP = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+var PROCESS_EXIT_GRACE_MS = 750;
+var PROCESS_POLL_MS = 25;
+function git2(root, args) {
+  return execFileSync3("git", ["-C", root, ...args], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 3e4
+  }).trim();
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function processSnapshot(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0) return { alive: false, birthToken: null };
+  try {
+    process.kill(pid, 0);
+  } catch (err) {
+    if (err.code !== "EPERM") return { alive: false, birthToken: null };
+  }
+  try {
+    const stat = readFileSync2(`/proc/${pid}/stat`, "utf8").trim();
+    const close = stat.lastIndexOf(")");
+    if (close > 0) {
+      const fields = stat.slice(close + 1).trim().split(/\s+/u);
+      if (fields[0] === "Z") return { alive: false, birthToken: fields[19] ?? null };
+      const startTicks = fields[19];
+      if (startTicks !== void 0 && /^\d+$/u.test(startTicks)) {
+        return { alive: true, birthToken: `linux:${startTicks}` };
+      }
+    }
+  } catch {
+  }
+  try {
+    const started = execFileSync3("ps", ["-o", "lstart=", "-p", String(pid)], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 2e3
+    }).trim();
+    if (started.length > 0) return { alive: true, birthToken: `ps:${started}` };
+  } catch {
+  }
+  return { alive: true, birthToken: null };
+}
+function currentProcessLease() {
+  return {
+    host: hostname(),
+    pid: process.pid,
+    birthToken: processSnapshot(process.pid).birthToken
+  };
+}
+function validProcessLease(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const lease = value;
+  return typeof lease.host === "string" && lease.host.length > 0 && typeof lease.pid === "number" && Number.isSafeInteger(lease.pid) && lease.pid > 0 && (lease.birthToken === null || typeof lease.birthToken === "string");
+}
+function validRunLease(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const lease = value;
+  return typeof lease.runId === "string" && lease.runId.length > 0 && (lease.pid === null || typeof lease.pid === "number" && Number.isSafeInteger(lease.pid) && lease.pid > 0) && (lease.birthToken === null || typeof lease.birthToken === "string") && typeof lease.processGroup === "boolean";
+}
+function ownerIsAlive(owner) {
+  if (owner.host !== hostname()) return true;
+  const snapshot = processSnapshot(owner.pid);
+  if (!snapshot.alive) return false;
+  if (owner.birthToken === null || snapshot.birthToken === null) return true;
+  return owner.birthToken === snapshot.birthToken;
+}
+function waitForProcessExit(pid, birthToken) {
+  const deadline = Date.now() + PROCESS_EXIT_GRACE_MS;
+  const sleeper = new Int32Array(new SharedArrayBuffer(4));
+  while (Date.now() < deadline) {
+    const snapshot = processSnapshot(pid);
+    if (!snapshot.alive || snapshot.birthToken !== birthToken) return true;
+    Atomics.wait(sleeper, 0, 0, PROCESS_POLL_MS);
+  }
+  const finalSnapshot = processSnapshot(pid);
+  return !finalSnapshot.alive || finalSnapshot.birthToken !== birthToken;
+}
+function terminateRunLease(lease) {
+  if (lease.pid === null) return true;
+  const snapshot = processSnapshot(lease.pid);
+  if (!snapshot.alive) return true;
+  if (lease.birthToken === null || snapshot.birthToken === null) return false;
+  if (lease.birthToken !== snapshot.birthToken) return true;
+  const target = lease.processGroup && process.platform !== "win32" ? -lease.pid : lease.pid;
+  try {
+    process.kill(target, "SIGTERM");
+  } catch (err) {
+    if (err.code === "ESRCH") return true;
+    return false;
+  }
+  if (waitForProcessExit(lease.pid, lease.birthToken)) return true;
+  try {
+    process.kill(target, "SIGKILL");
+  } catch (err) {
+    if (err.code === "ESRCH") return true;
+    return false;
+  }
+  return waitForProcessExit(lease.pid, lease.birthToken);
+}
+function validateGroup(group) {
+  if (!SAFE_GROUP.test(group) || group === "." || group === "..") {
+    throw new Error(`invalid compete group '${group}'`);
+  }
+}
+function canonicalRoot(root) {
+  return realpathSync2(root);
+}
+function competeParent(root) {
+  return join3(root, ...COMPETE_PARENT_SEGMENTS);
+}
+function groupDirectory(root, group) {
+  validateGroup(group);
+  return join3(competeParent(root), group);
+}
+function manifestPath(directory) {
+  return join3(directory, COMPETE_MANIFEST_FILE);
+}
+function isPlainDirectory(path) {
+  try {
+    const stat = lstatSync(path);
+    return stat.isDirectory() && !stat.isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function isCanonicalDirectoryAt(path) {
+  if (!isPlainDirectory(path)) return false;
+  try {
+    return relative2(realpathSync2(path), resolve2(path)) === "";
+  } catch {
+    return false;
+  }
+}
+function isCanonicalPathInside(parent, candidate) {
+  return isCanonicalWorktreePathInside(parent, candidate);
+}
+function manifestFromUnknown(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const manifest = value;
+  if (manifest.version !== 2 || manifest.kind !== COMPETE_MANIFEST_KIND && manifest.kind !== LEGACY_COMPETE_MANIFEST_KIND || typeof manifest.root !== "string" || typeof manifest.group !== "string" || typeof manifest.token !== "string" || manifest.token.length === 0 || manifest.state !== "active" && manifest.state !== "cleanup-ready" && manifest.state !== "winner-preserved" || typeof manifest.createdAt !== "string" || typeof manifest.updatedAt !== "string") {
+    return null;
+  }
+  if (!validProcessLease(manifest.owner) || !Array.isArray(manifest.runs) || !manifest.runs.every(validRunLease) || new Set(manifest.runs.map((run) => run.runId)).size !== manifest.runs.length) {
+    return null;
+  }
+  if (manifest.winnerIndex !== void 0 && (typeof manifest.winnerIndex !== "number" || !Number.isInteger(manifest.winnerIndex) || manifest.winnerIndex < 1)) {
+    return null;
+  }
+  return manifest;
+}
+function readManifest(root, group) {
+  const canonical = canonicalRoot(root);
+  const directory = groupDirectory(canonical, group);
+  if (!isCanonicalDirectoryAt(directory)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync2(manifestPath(directory), "utf8"));
+    const manifest = manifestFromUnknown(parsed);
+    if (manifest === null || manifest.root !== canonical || manifest.group !== group) return null;
+    return manifest;
+  } catch {
+    return null;
+  }
+}
+function ownershipFromManifest(manifest) {
+  return {
+    root: manifest.root,
+    group: manifest.group,
+    directory: groupDirectory(manifest.root, manifest.group),
+    token: manifest.token,
+    state: manifest.state,
+    ...manifest.winnerIndex !== void 0 ? { winnerIndex: manifest.winnerIndex } : {}
+  };
+}
+function assertOwnership2(ownership) {
+  const manifest = readManifest(ownership.root, ownership.group);
+  if (manifest === null || manifest.token !== ownership.token) {
+    throw new Error(`compete group ${ownership.group} has no matching ownership manifest; refusing cleanup`);
+  }
+  if (resolve2(ownership.directory) !== resolve2(groupDirectory(manifest.root, manifest.group))) {
+    throw new Error(`compete group ${ownership.group} ownership path changed; refusing cleanup`);
+  }
+  return manifest;
+}
+function replaceManifest(ownership, manifest) {
+  assertOwnership2(ownership);
+  const destination = manifestPath(ownership.directory);
+  const temporary = `${destination}.${randomBytes2(6).toString("hex")}.tmp`;
+  try {
+    writeFileSync2(temporary, `${JSON.stringify(manifest, null, 2)}
+`, { encoding: "utf8", flag: "wx" });
+    renameSync(temporary, destination);
+  } finally {
+    if (existsSync2(temporary)) rmSync3(temporary, { force: true });
+  }
+}
+function isGitRepository(root) {
+  try {
+    return git2(root, ["rev-parse", "--is-inside-work-tree"]) === "true";
+  } catch {
+    return false;
+  }
+}
+function competeBranch(group, index, legacy = false) {
+  validateGroup(group);
+  if (!Number.isInteger(index) || index < 1) throw new Error(`invalid compete candidate index ${index}`);
+  return `${legacy ? "clio" : "clio-coder"}/compete/${group}/${index}`;
+}
+function competeBranchMatches(branch, group, index) {
+  return branch === competeBranch(group, index) || branch === competeBranch(group, index, true);
+}
+function claimCompeteGroup(root, group) {
+  const canonical = canonicalRoot(root);
+  const directory = groupDirectory(canonical, group);
+  const parent = competeParent(canonical);
+  mkdirSync2(parent, { recursive: true });
+  if (!isCanonicalDirectoryAt(parent)) {
+    throw new Error(`compete parent ${parent} is not a canonical local directory`);
+  }
+  mkdirSync2(directory);
+  if (!isCanonicalDirectoryAt(directory)) {
+    throw new Error(`compete group directory ${directory} is not canonical`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const manifest = {
+    version: 2,
+    kind: COMPETE_MANIFEST_KIND,
+    root: canonical,
+    group,
+    token: randomBytes2(16).toString("hex"),
+    state: "active",
+    createdAt: now,
+    updatedAt: now,
+    owner: currentProcessLease(),
+    runs: []
+  };
+  try {
+    writeFileSync2(manifestPath(directory), `${JSON.stringify(manifest, null, 2)}
+`, {
+      encoding: "utf8",
+      flag: "wx"
+    });
+  } catch (err) {
+    try {
+      rmdirSync(directory);
+    } catch {
+    }
+    throw err;
+  }
+  return ownershipFromManifest(manifest);
+}
+function loadCompeteGroup(root, group) {
+  validateGroup(group);
+  const manifest = readManifest(root, group);
+  return manifest === null ? null : ownershipFromManifest(manifest);
+}
+function registerCompeteGroupRun(ownership, admission) {
+  const current = assertOwnership2(ownership);
+  if (current.state !== "active") {
+    throw new Error(`compete group ${ownership.group} is ${current.state}; refusing new run ${admission.runId}`);
+  }
+  if (admission.runId.length === 0) throw new Error("worktree transaction run id cannot be empty");
+  if (admission.pid !== null && (!Number.isSafeInteger(admission.pid) || admission.pid <= 0)) {
+    throw new Error(`worktree transaction run ${admission.runId} has invalid pid ${admission.pid}`);
+  }
+  const lease = {
+    runId: admission.runId,
+    pid: admission.pid,
+    birthToken: admission.pid === null ? null : processSnapshot(admission.pid).birthToken,
+    processGroup: admission.runtimeKind === "acp-delegation" && process.platform !== "win32"
+  };
+  const next = {
+    ...current,
+    runs: [...current.runs.filter((run) => run.runId !== admission.runId), lease],
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  replaceManifest(ownership, next);
+}
+function settleCompeteGroupRun(ownership, runId) {
+  const current = assertOwnership2(ownership);
+  if (current.state !== "active") return;
+  if (!current.runs.some((run) => run.runId === runId)) return;
+  const next = {
+    ...current,
+    runs: current.runs.filter((run) => run.runId !== runId),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  replaceManifest(ownership, next);
+}
+function markCompeteGroupCleanupReady(ownership) {
+  const current = assertOwnership2(ownership);
+  const next = {
+    ...current,
+    state: "cleanup-ready",
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  Reflect.deleteProperty(next, "winnerIndex");
+  replaceManifest(ownership, next);
+  return ownershipFromManifest(next);
+}
+function markCompeteGroupWinnerPreserved(ownership, winnerIndex) {
+  competeBranch(ownership.group, winnerIndex);
+  const current = assertOwnership2(ownership);
+  const next = {
+    ...current,
+    state: "winner-preserved",
+    winnerIndex,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  replaceManifest(ownership, next);
+  return ownershipFromManifest(next);
+}
+function createCandidateWorktree(ownership, index, baseline) {
+  assertOwnership2(ownership);
+  const branch = competeBranch(ownership.group, index);
+  const path = join3(ownership.directory, `candidate-${index}`);
+  if (!isCanonicalPathInside(ownership.directory, path)) {
+    throw new Error(`candidate ${index} path escapes compete group ${ownership.group}`);
+  }
+  git2(ownership.root, ["worktree", "add", "-b", branch, path, baseline]);
+  return { index, branch, path };
+}
+async function createCandidateWorktreeMapped(ownership, index, baseline, mux) {
+  assertOwnership2(ownership);
+  const branch = competeBranch(ownership.group, index);
+  const path = join3(ownership.directory, `candidate-${index}`);
+  if (!isCanonicalPathInside(ownership.directory, path)) {
+    throw new Error(`candidate ${index} path escapes compete group ${ownership.group}`);
+  }
+  let fallback = "mux-unavailable";
+  if (mux?.available()) {
+    const created = await mux.worktreeCreate({
+      cwd: ownership.root,
+      branch,
+      base: baseline,
+      path,
+      label: `clio-coder compete ${ownership.group} candidate ${index}`,
+      focus: false
+    }).catch(() => null);
+    if (created !== null) {
+      if (resolve2(created.worktree.path) !== resolve2(path) || created.worktree.branch !== branch) {
+        throw new Error(`herdr created candidate ${index} at an unexpected path or branch`);
+      }
+      return {
+        index,
+        branch,
+        path,
+        provenance: { backend: "herdr", path, branch, workspaceId: created.workspaceId }
+      };
+    }
+    fallback = "mux-operation-failed";
+  }
+  const native = createCandidateWorktree(ownership, index, baseline);
+  return { ...native, provenance: { backend: "native", path, branch, fallback } };
+}
+function commitCandidateWork(worktree, message) {
+  return commitWorktreePath(worktree.path, COMPETE_COMMIT_IDENTITY, message, [
+    ".clio-coder/codewiki.json",
+    ".clio-coder/state.json"
+  ]);
+}
+function candidateDiffStat(root, branch) {
+  return worktreeBranchDiffStat(root, branch);
+}
+function protectedPathsChangedByCompeteBranch(root, branch, protectedPaths) {
+  return protectedPathsChangedByWorktreeBranch(root, branch, protectedPaths);
+}
+function registeredWorktreePaths(root) {
+  const listing = git2(root, ["worktree", "list", "--porcelain", "-z"]);
+  return listing.split("\0").filter((entry) => entry.startsWith("worktree ")).map((entry) => entry.slice("worktree ".length)).filter((path) => path !== void 0 && path.length > 0);
+}
+function exactGroupBranches(root, group) {
+  return git2(root, ["branch", "--list", "--format=%(refname:short)"]).split("\n").filter((branch) => {
+    const parts = branch.split("/");
+    return parts.length === 4 && (parts[0] === "clio-coder" || parts[0] === "clio") && parts[1] === "compete" && parts[2] === group && /^\d+$/.test(parts[3] ?? "");
+  });
+}
+function competeBranchForCandidate(root, group, index) {
+  const branches = exactGroupBranches(root, group);
+  return branches.find((branch) => branch === competeBranch(group, index)) ?? branches.find((branch) => branch === competeBranch(group, index, true)) ?? competeBranch(group, index);
+}
+function removeRegisteredWorktree(root, path) {
+  try {
+    git2(root, ["worktree", "remove", "--force", path]);
+  } catch {
+    if (existsSync2(path)) rmSync3(path, { recursive: true, force: true });
+    git2(root, ["worktree", "prune"]);
+  }
+}
+function preserveCandidateWorktree(ownership, path, index) {
+  if (resolve2(path) !== resolve2(join3(ownership.directory, `candidate-${index}`)) || !isCanonicalPathInside(ownership.directory, path))
+    throw new Error("candidate checkpoint path is outside its proven group");
+  const ref = workspaceCheckpointRef("compete", `${ownership.group}:${index}`);
+  if (existsSync2(path)) captureWorkspaceCheckpoint(path, ref, `Compete ${ownership.group} candidate ${index}`);
+  else {
+    const branch = competeBranchForCandidate(ownership.root, ownership.group, index);
+    if (exactGroupBranches(ownership.root, ownership.group).includes(branch)) {
+      try {
+        git2(ownership.root, ["rev-parse", "--verify", ref]);
+      } catch {
+        git2(ownership.root, ["update-ref", ref, branch, ""]);
+      }
+    }
+  }
+}
+function removeCandidateWorktree(ownership, worktree, deleteBranch) {
+  assertOwnership2(ownership);
+  const expectedPath = join3(ownership.directory, `candidate-${worktree.index}`);
+  if (resolve2(worktree.path) !== resolve2(expectedPath) || !competeBranchMatches(worktree.branch, ownership.group, worktree.index) || !isCanonicalPathInside(ownership.directory, worktree.path)) {
+    throw new Error(`candidate ${worktree.index} does not belong to compete group ${ownership.group}`);
+  }
+  preserveCandidateWorktree(ownership, worktree.path, worktree.index);
+  removeRegisteredWorktree(ownership.root, worktree.path);
+  if (deleteBranch && exactGroupBranches(ownership.root, ownership.group).includes(worktree.branch)) {
+    git2(ownership.root, ["branch", "-D", worktree.branch]);
+  }
+  const stillRegistered = registeredWorktreePaths(ownership.root).some(
+    (path) => resolve2(path) === resolve2(worktree.path)
+  );
+  const branchRemains = deleteBranch && exactGroupBranches(ownership.root, ownership.group).includes(worktree.branch);
+  if (stillRegistered || existsSync2(worktree.path) || branchRemains) {
+    throw new Error(`failed to remove candidate ${worktree.index} from compete group ${ownership.group}`);
+  }
+}
+async function removeCandidateWorktreeMapped(ownership, worktree, deleteBranch, mux) {
+  assertOwnership2(ownership);
+  preserveCandidateWorktree(ownership, worktree.path, worktree.index);
+  const workspaceId = worktree.provenance?.backend === "herdr" ? worktree.provenance.workspaceId : void 0;
+  if (workspaceId && mux?.available()) {
+    await mux.worktreeRemove(workspaceId, { force: true }).catch(() => false);
+  }
+  removeCandidateWorktree(ownership, worktree, deleteBranch);
+}
+function mergeWinnerBranch(root, branch) {
+  return mergeWorktreeBranch(root, branch, COMPETE_COMMIT_IDENTITY);
+}
+function cleanupWorktreeGroup(ownership) {
+  assertOwnership2(ownership);
+  for (const path of registeredWorktreePaths(ownership.root)) {
+    if (!isCanonicalPathInside(ownership.directory, path)) continue;
+    const index = Number.parseInt(path.split(/[\\/]/).at(-1)?.replace("candidate-", "") ?? "", 10);
+    if (Number.isInteger(index)) preserveCandidateWorktree(ownership, path, index);
+    removeRegisteredWorktree(ownership.root, path);
+  }
+  git2(ownership.root, ["worktree", "prune"]);
+  const registeredRemain = registeredWorktreePaths(ownership.root).filter(
+    (path) => isCanonicalPathInside(ownership.directory, path)
+  );
+  if (registeredRemain.length > 0) {
+    throw new Error(
+      `failed to remove ${registeredRemain.length} registered worktree(s) for compete group ${ownership.group}`
+    );
+  }
+  for (const branch of exactGroupBranches(ownership.root, ownership.group)) {
+    const index = Number.parseInt(branch.split("/").at(-1) ?? "", 10);
+    const ref = workspaceCheckpointRef("compete", `${ownership.group}:${index}`);
+    try {
+      git2(ownership.root, ["rev-parse", "--verify", ref]);
+    } catch {
+      git2(ownership.root, ["update-ref", ref, branch, ""]);
+    }
+    git2(ownership.root, ["branch", "-D", branch]);
+  }
+  const branchesRemain = exactGroupBranches(ownership.root, ownership.group);
+  if (branchesRemain.length > 0) {
+    throw new Error(`failed to remove ${branchesRemain.length} branch(es) for compete group ${ownership.group}`);
+  }
+  assertOwnership2(ownership);
+  for (const entry of readdirSync(ownership.directory)) {
+    if (entry === COMPETE_MANIFEST_FILE) continue;
+    rmSync3(join3(ownership.directory, entry), { recursive: true, force: true });
+  }
+  assertOwnership2(ownership);
+  const unexpected = readdirSync(ownership.directory).filter((entry) => entry !== COMPETE_MANIFEST_FILE);
+  if (unexpected.length > 0) {
+    throw new Error(`compete group ${ownership.group} changed during cleanup; ownership is preserved`);
+  }
+  unlinkSync(manifestPath(ownership.directory));
+  rmdirSync(ownership.directory);
+  try {
+    rmdirSync(competeParent(ownership.root));
+  } catch {
+  }
+}
+function cleanupCompeteGroup(ownership) {
+  cleanupWorktreeGroup(ownership);
+}
+function settleRecoveredCompeteDecision(root, group, winnerIndex) {
+  let ownership = loadCompeteGroup(root, group);
+  if (ownership === null) return null;
+  if (ownership.state === "cleanup-ready") {
+    cleanupWorktreeGroup(ownership);
+    return null;
+  }
+  if (ownership.state === "winner-preserved") {
+    if (winnerIndex !== null && ownership.winnerIndex === winnerIndex) return ownership;
+    throw new Error(`compete group ${group} was already preserved with a different winner`);
+  }
+  const manifest = assertOwnership2(ownership);
+  if (ownerIsAlive(manifest.owner)) {
+    throw new Error(`compete group ${group} still has a live coordinator; refusing restart settlement`);
+  }
+  const unterminated = manifest.runs.filter((run) => !terminateRunLease(run));
+  if (unterminated.length > 0) {
+    throw new Error(`could not safely terminate ${unterminated.length} leased compete worker(s) for ${group}`);
+  }
+  if (winnerIndex === null) {
+    ownership = markCompeteGroupCleanupReady(ownership);
+    cleanupWorktreeGroup(ownership);
+    return null;
+  }
+  const branches = exactGroupBranches(ownership.root, group);
+  const winnerBranch = competeBranchForCandidate(ownership.root, group, winnerIndex);
+  const winnerPath = join3(ownership.directory, `candidate-${winnerIndex}`);
+  if (!branches.includes(winnerBranch) || !registeredWorktreePaths(ownership.root).some((path) => resolve2(path) === resolve2(winnerPath))) {
+    throw new Error(`recovered winner ${winnerBranch} has no intact candidate worktree`);
+  }
+  ownership = markCompeteGroupWinnerPreserved(ownership, winnerIndex);
+  for (const branch of branches) {
+    const index = Number.parseInt(branch.split("/").at(-1) ?? "", 10);
+    if (index === winnerIndex) continue;
+    removeCandidateWorktree(ownership, { index, branch, path: join3(ownership.directory, `candidate-${index}`) }, true);
+  }
+  return ownership;
+}
+function recoverCleanupReadyCompeteGroups(root, options = {}) {
+  const canonical = canonicalRoot(root);
+  const parent = competeParent(canonical);
+  const result = { cleaned: [], preserved: [], failed: [] };
+  if (!isPlainDirectory(parent)) return result;
+  for (const entry of readdirSync(parent, { withFileTypes: true })) {
+    if (!entry.isDirectory() || entry.isSymbolicLink()) {
+      result.preserved.push(entry.name);
+      continue;
+    }
+    let ownership = null;
+    let manifest = null;
+    try {
+      manifest = readManifest(canonical, entry.name);
+      ownership = manifest === null ? null : ownershipFromManifest(manifest);
+    } catch {
+    }
+    if (ownership === null || manifest === null) {
+      result.preserved.push(entry.name);
+      continue;
+    }
+    if (ownership.state === "winner-preserved") {
+      result.preserved.push(entry.name);
+      continue;
+    }
+    if (ownership.state === "active") {
+      if (ownerIsAlive(manifest.owner)) {
+        result.preserved.push(entry.name);
+        continue;
+      }
+      const unterminated = manifest.runs.filter((run) => !terminateRunLease(run));
+      if (unterminated.length > 0) {
+        result.failed.push({
+          group: entry.name,
+          message: `could not safely terminate ${unterminated.length} leased compete worker(s)`
+        });
+        continue;
+      }
+      if (options.preserveAllActive === true || options.preserveActiveGroups?.has(entry.name) === true) {
+        result.preserved.push(entry.name);
+        continue;
+      }
+      try {
+        ownership = markCompeteGroupCleanupReady(ownership);
+      } catch (err) {
+        result.failed.push({ group: entry.name, message: errorMessage(err) });
+        continue;
+      }
+    }
+    try {
+      cleanupWorktreeGroup(ownership);
+      result.cleaned.push(entry.name);
+    } catch (err) {
+      result.failed.push({ group: entry.name, message: errorMessage(err) });
+    }
+  }
+  return result;
+}
+
+// src/domains/dispatch/write-boundary.ts
+init_esm_shims();
+import { execFileSync as execFileSync4 } from "node:child_process";
+import { createHash as createHash3 } from "node:crypto";
+import { existsSync as existsSync3, lstatSync as lstatSync2, mkdirSync as mkdirSync3, readlinkSync, realpathSync as realpathSync3, rmSync as rmSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname, isAbsolute as isAbsolute2, join as join4, relative as relative3, resolve as resolve3, sep as sep2 } from "node:path";
+var WRITE_BOUNDARY_VIOLATION_REASON = "writes_boundary_violation";
+var ABSENT = "absent";
+var GIT_TIMEOUT_MS = 3e4;
+function git3(root, args, input) {
+  return execFileSync4("git", ["-C", root, ...args], {
+    encoding: "utf8",
+    stdio: ["pipe", "pipe", "pipe"],
+    timeout: GIT_TIMEOUT_MS,
+    maxBuffer: 64 * 1024 * 1024,
+    ...input === void 0 ? {} : { input }
+  });
+}
+function gitBytes2(root, args) {
+  return execFileSync4("git", ["-C", root, ...args], {
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: GIT_TIMEOUT_MS,
+    maxBuffer: 256 * 1024 * 1024
+  });
+}
+function dirtyPaths(root) {
+  const raw = git3(root, ["status", "--porcelain=v1", "-z", "-uall", "--no-renames"]);
+  const journal = repoRelative(root, clioStateDir());
+  return raw.split("\0").filter((entry) => entry.length > 3).map((entry) => entry.slice(3)).filter((path) => journal === null || !(path === journal || path.startsWith(`${journal}/`)));
+}
+function contentTokens(root, paths) {
+  const tokens = /* @__PURE__ */ new Map();
+  const hashable = [];
+  for (const path of paths) {
+    const full = join4(root, path);
+    let stat;
+    try {
+      stat = lstatSync2(full);
+    } catch {
+      tokens.set(path, ABSENT);
+      continue;
+    }
+    if (stat.isSymbolicLink()) {
+      tokens.set(path, `link:${readlinkSync(full)}`);
+      continue;
+    }
+    if (stat.isDirectory()) {
+      tokens.set(path, "dir");
+      continue;
+    }
+    if (!stat.isFile()) {
+      tokens.set(path, `special:${stat.mode}`);
+      continue;
+    }
+    if (path.includes("\n")) {
+      tokens.set(path, `blob:${git3(root, ["hash-object", "--", full]).trim()}`);
+      continue;
+    }
+    hashable.push(path);
+  }
+  if (hashable.length > 0) {
+    const hashes = git3(root, ["hash-object", "--stdin-paths"], `${hashable.map((path) => join4(root, path)).join("\n")}
+`).split("\n").filter((line) => line.length > 0);
+    hashable.forEach((path, index) => {
+      tokens.set(path, `blob:${hashes[index] ?? "unknown"}`);
+    });
+  }
+  return tokens;
+}
+function baselineTokens(root, head, paths) {
+  const tokens = /* @__PURE__ */ new Map();
+  if (paths.length === 0) return tokens;
+  const query = paths.map((path) => `${head}:${path}`).join("\n");
+  const answered = git3(root, ["cat-file", "--batch-check=%(objectname) %(objecttype)"], `${query}
+`).split("\n").filter((line) => line.length > 0);
+  paths.forEach((path, index) => {
+    const line = answered[index] ?? "";
+    const [objectName, objectType] = line.split(" ");
+    if (objectType === "blob" && objectName !== void 0) tokens.set(path, `blob:${objectName}`);
+    else if (objectType === "tree") tokens.set(path, "dir");
+    else tokens.set(path, ABSENT);
+  });
+  return tokens;
+}
+function captureWorkspaceSnapshot(root) {
+  const absolute = resolve3(root);
+  if (!isGitRepository(absolute)) {
+    throw new Error(
+      `write boundary: ${absolute} is not a git repository, so a declared boundary cannot be verified (enforcement fails closed)`
+    );
+  }
+  const head = git3(absolute, ["rev-parse", "HEAD"]).trim();
+  const paths = dirtyPaths(absolute);
+  return { root: absolute, head, entries: contentTokens(absolute, paths), capturedAt: (/* @__PURE__ */ new Date()).toISOString() };
+}
+function diffWorkspace(snapshot) {
+  const candidates = [.../* @__PURE__ */ new Set([...snapshot.entries.keys(), ...dirtyPaths(snapshot.root)])].sort();
+  if (candidates.length === 0) return [];
+  const unknownBefore = candidates.filter((path) => !snapshot.entries.has(path));
+  const baseline = baselineTokens(snapshot.root, snapshot.head, unknownBefore);
+  const now = contentTokens(snapshot.root, candidates);
+  const changes = [];
+  for (const path of candidates) {
+    const before = snapshot.entries.get(path) ?? baseline.get(path) ?? ABSENT;
+    const after = now.get(path) ?? ABSENT;
+    if (before !== after) changes.push({ path, before, after });
+  }
+  return changes;
+}
+function describeWriteBoundaryAttributionDowngrade(downgrade) {
+  if (downgrade.reason === "opaque_tool_succeeded") {
+    const tool = downgrade.tool ?? "unknown";
+    const call = downgrade.toolCallId === null ? "" : ` (call ${downgrade.toolCallId})`;
+    return `a successful '${tool}' call${call} can write paths its arguments do not name`;
+  }
+  if (downgrade.reason === "incomplete_tool_telemetry") {
+    return downgrade.runId === null ? "tool telemetry was incomplete" : `run '${downgrade.runId}' reported incomplete tool telemetry`;
+  }
+  if (downgrade.reason === "code_step_untracked") {
+    return downgrade.stepId === null ? "a code step ran through the untracked command runner" : `code step '${downgrade.stepId}' ran through the untracked command runner`;
+  }
+  return downgrade.stepId === null ? "no usable write record was available" : `step '${downgrade.stepId}' supplied no usable write record`;
+}
+function canonicalVerdict(verdict) {
+  return JSON.stringify(verdict);
+}
+function rollbackPath(snapshot, change) {
+  const full = join4(snapshot.root, change.path);
+  if (snapshot.entries.has(change.path)) {
+    return {
+      unrecoverable: {
+        path: change.path,
+        reason: `path was already modified or untracked before the step, so its prior content is not recorded anywhere`
+      }
+    };
+  }
+  if (change.before === ABSENT) {
+    try {
+      rmSync4(full, { force: true, recursive: false });
+    } catch (error) {
+      return {
+        unrecoverable: { path: change.path, reason: `could not remove: ${error.message}` }
+      };
+    }
+    return { rolledBack: { path: change.path, action: "removed", restoredFrom: "did not exist at baseline" } };
+  }
+  if (!change.before.startsWith("blob:")) {
+    return {
+      unrecoverable: {
+        path: change.path,
+        reason: `baseline state '${change.before}' is not a regular file and is not restorable in place`
+      }
+    };
+  }
+  try {
+    const content = gitBytes2(snapshot.root, ["cat-file", "blob", `${snapshot.head}:${change.path}`]);
+    mkdirSync3(dirname(full), { recursive: true });
+    writeFileSync3(full, content);
+  } catch (error) {
+    return {
+      unrecoverable: { path: change.path, reason: `could not restore from baseline: ${error.message}` }
+    };
+  }
+  return { rolledBack: { path: change.path, action: "restored", restoredFrom: `${snapshot.head}:${change.path}` } };
+}
+function withinRecordedWrite(recorded, path) {
+  if (recorded.has(path)) return true;
+  for (const target of recorded) {
+    if (path.startsWith(`${target}/`)) return true;
+  }
+  return false;
+}
+function enforceWriteBoundary(input) {
+  const allow = normalizeWriteBoundary(input.allow);
+  const changes = diffWorkspace(input.snapshot);
+  const outside = changes.filter((change) => !writeBoundaryCovers(allow, change.path));
+  const attributionComplete = input.attribution?.complete === true;
+  const attributionDowngrades = attributionComplete ? [] : input.attribution?.downgrades !== void 0 && input.attribution.downgrades.length > 0 ? input.attribution.downgrades.map((entry) => ({ ...entry })) : [
+    {
+      reason: "write_record_unavailable",
+      tool: null,
+      toolCallId: null,
+      runId: null,
+      stepId: input.stepIds.length === 1 ? input.stepIds[0] ?? null : null
+    }
+  ];
+  const recorded = /* @__PURE__ */ new Set();
+  for (const target of input.attribution?.recorded ?? []) {
+    const relativeTarget = repoRelative(input.snapshot.root, target);
+    if (relativeTarget !== null) recorded.add(relativeTarget);
+  }
+  const violations = attributionComplete ? outside.filter((change) => withinRecordedWrite(recorded, change.path)) : outside;
+  const unattributed = attributionComplete ? outside.filter((change) => !withinRecordedWrite(recorded, change.path)) : [];
+  const rolledBack = [];
+  const unrecoverable = [];
+  for (const change of violations) {
+    const outcome = rollbackPath(input.snapshot, change);
+    if (outcome.rolledBack !== void 0) rolledBack.push(outcome.rolledBack);
+    if (outcome.unrecoverable !== void 0) unrecoverable.push(outcome.unrecoverable);
+  }
+  const status = violations.length === 0 ? "clean" : unrecoverable.length === 0 ? "rolled-back" : "rollback-incomplete";
+  const who = input.stepIds.length === 1 ? `step '${input.stepIds[0]}'` : `steps ${input.stepIds.map((id) => `'${id}'`).join(", ")} ran concurrently in one checkout, so the write cannot be attributed to one of them`;
+  const violationDetail = violations.length === 0 ? [] : [
+    `${who} wrote outside its declared boundary.`,
+    `Unauthorized paths: ${violations.map((change) => change.path).join(", ")}.`,
+    `Declared writes: ${describeWriteBoundary(allow)}.`,
+    status === "rolled-back" ? "Those paths were rolled back to the baseline commit." : `Rollback is incomplete; the working tree is left as the step made it. Unrestorable: ${unrecoverable.map((entry) => `${entry.path} (${entry.reason})`).join("; ")}.`,
+    attributionComplete ? "Each was blamed on this window because a run in it recorded writing that path." : `Attribution was incomplete because ${attributionDowngrades.map(describeWriteBoundaryAttributionDowngrade).join("; ")}, so every change outside the declaration was blamed on this window.`,
+    "If the change was legitimate, widen the step's `writes:` declaration to cover it."
+  ];
+  const concurrentDetail = unattributed.length === 0 ? [] : [
+    `Concurrent changes were seen in this window that no run in it recorded writing: ${unattributed.map((change) => change.path).join(", ")}.`,
+    "They were left untouched, because a path this window did not write is not this window's to restore."
+  ];
+  const detail = [...violationDetail, ...concurrentDetail];
+  const body = {
+    version: 1,
+    window: input.window,
+    stepIds: [...input.stepIds],
+    allow,
+    baselineHead: input.snapshot.head,
+    capturedAt: input.snapshot.capturedAt,
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    changedPaths: changes.map((change) => change.path),
+    violations: violations.map((change) => change.path),
+    unattributed: unattributed.map((change) => change.path),
+    attributionComplete,
+    attributionDowngrades,
+    rolledBack,
+    unrecoverable,
+    status,
+    reason: violations.length === 0 ? null : WRITE_BOUNDARY_VIOLATION_REASON,
+    detail: detail.length === 0 ? null : detail.join(" ")
+  };
+  return { ...body, digest: createHash3("sha256").update(canonicalVerdict(body), "utf8").digest("hex") };
+}
+function assertWriteBoundaryInsideRoot(root, allow) {
+  const realRoot = realpathSync3(resolve3(root));
+  for (const entry of allow) {
+    const relativeEntry = entry.endsWith("/") ? entry.slice(0, -1) : entry;
+    let probe = join4(realRoot, relativeEntry);
+    while (probe !== realRoot && !existsSync3(probe)) probe = dirname(probe);
+    const resolved = realpathSync3(probe);
+    if (resolved !== realRoot && !pathBoundaryEntryCovers(asDirectoryPathBoundary(realRoot), resolved)) {
+      throw new Error(`write boundary: entry '${entry}' resolves to ${resolved}, outside the workspace at ${realRoot}`);
+    }
+  }
+}
+function assertWriteBoundaryVisibleToGit(root, allow) {
+  const entries = [...new Set(allow.map(normalizeWriteBoundaryEntry))].sort();
+  if (entries.length === 0) return;
+  const absolute = resolve3(root);
+  let raw;
+  try {
+    raw = git3(absolute, ["check-ignore", "-v", "-z", "--stdin"], `${entries.join("\0")}\0`);
+  } catch (error) {
+    const status = error.status;
+    if (status === 1) return;
+    throw new Error(
+      `write boundary: could not determine whether ${describeWriteBoundary(entries)} is ignored by git in ${absolute}: ${error.message}`
+    );
+  }
+  const fields = raw.split("\0");
+  const refusals = [];
+  for (let index = 0; index + 3 < fields.length; index += 4) {
+    const [source, line, pattern, path] = fields.slice(index, index + 4);
+    if (path === void 0 || path.length === 0) continue;
+    refusals.push(`'${path}' is ignored by ${source}:${line}:${pattern}`);
+  }
+  if (refusals.length === 0) return;
+  throw new Error(
+    `write boundary: ${refusals.join(", ")}. git status never reports an ignored path, so a boundary declared over one is verified against nothing and every window would be certified clean without an observation. Declare a path the repository tracks, or stop ignoring this one.`
+  );
+}
+function repoRelative(root, path) {
+  const base = resolve3(root);
+  const rel = relative3(base, resolve3(base, path));
+  if (rel.length === 0 || rel === ".." || rel.startsWith(`..${sep2}`) || isAbsolute2(rel)) return null;
+  return rel.split(sep2).join("/");
+}
+function writeBoundaryDir(rootId) {
+  return join4(clioStateDir(), "write-boundaries", rootId);
+}
+function writeBoundaryVerdictPath(rootId, window) {
+  return join4(writeBoundaryDir(rootId), `${window.replace(/[^A-Za-z0-9._-]/gu, "_")}.json`);
+}
+function writeWriteBoundaryVerdict(rootId, verdict) {
+  const path = writeBoundaryVerdictPath(rootId, verdict.window);
+  atomicWrite(path, `${JSON.stringify(verdict, null, 2)}
+`);
+  return path;
+}
+
+// src/domains/dispatch/write-boundary-enforcer.ts
+init_esm_shims();
+import { existsSync as existsSync4 } from "node:fs";
+function preflightWriteBoundaries(plan, root) {
+  const declared = plan.steps.filter((step) => step.writes !== void 0);
+  if (declared.length === 0) return;
+  if (!existsSync4(root) || !isGitRepository(root)) {
+    throw new Error(
+      `write boundaries are declared but ${root} is not a git repository; boundary enforcement compares the checkout before and after each step and fails closed without one`
+    );
+  }
+  for (const step of declared) assertWriteBoundaryInsideRoot(root, step.writes ?? []);
+  assertWriteBoundaryVisibleToGit(root, [...new Set(declared.flatMap((step) => [...step.writes ?? []]))]);
+}
+function createWriteBoundaryEnforcer(input) {
+  const open = /* @__PURE__ */ new Map();
+  const allowFor = (stepIds) => {
+    const allow = /* @__PURE__ */ new Set();
+    for (const stepId of stepIds) for (const entry of input.boundaryFor(stepId) ?? []) allow.add(entry);
+    return [...allow].sort();
+  };
+  const attributionFor = (stepIds) => {
+    const recordedWritesFor = input.recordedWritesFor;
+    if (recordedWritesFor === void 0) return void 0;
+    const recorded = /* @__PURE__ */ new Set();
+    const downgrades = [];
+    let complete = true;
+    for (const stepId of stepIds) {
+      const observed = recordedWritesFor(stepId);
+      if (observed === null) {
+        complete = false;
+        downgrades.push({
+          reason: "write_record_unavailable",
+          tool: null,
+          toolCallId: null,
+          runId: null,
+          stepId
+        });
+        continue;
+      }
+      if (!("recorded" in observed)) {
+        for (const target of observed) recorded.add(target);
+        continue;
+      }
+      for (const target of observed.recorded) recorded.add(target);
+      if (!observed.complete) complete = false;
+      for (const downgrade of observed.downgrades ?? []) {
+        downgrades.push({ ...downgrade, stepId: downgrade.stepId ?? stepId });
+      }
+    }
+    return { recorded: [...recorded].sort(), complete, downgrades };
+  };
+  return {
+    begin(window, stepIds) {
+      const allow = allowFor(stepIds);
+      assertWriteBoundaryInsideRoot(input.root, allow);
+      assertWriteBoundaryVisibleToGit(input.root, allow);
+      open.set(window, { snapshot: captureWorkspaceSnapshot(input.root), allow });
+    },
+    async verify(window, stepIds) {
+      const pending = open.get(window);
+      if (pending === void 0) {
+        throw new Error(`write boundary: window '${window}' was verified without a snapshot`);
+      }
+      open.delete(window);
+      const attribution = attributionFor(stepIds);
+      const verdict = enforceWriteBoundary({
+        snapshot: pending.snapshot,
+        window,
+        stepIds,
+        allow: pending.allow,
+        ...attribution === void 0 ? {} : { attribution }
+      });
+      const path = writeWriteBoundaryVerdict(input.rootId, verdict);
+      input.onVerdict?.(verdict, path);
+      return {
+        window,
+        violated: verdict.reason !== null,
+        // Every step in the window is named. With one step that is exact;
+        // with several it is the honest answer, because one checkout cannot
+        // tell the scheduler which of them wrote the path.
+        failedStepIds: verdict.reason === null ? [] : [...stepIds],
+        detail: verdict.detail
+      };
+    }
+  };
+}
+
+export {
+  gitCheckoutRoot,
+  createTaskWorktree,
+  applyTaskWorktree,
+  cleanupTaskWorktree,
+  workspaceCheckpointRef,
+  captureWorkspaceCheckpoint,
+  isGitRepository,
+  claimCompeteGroup,
+  loadCompeteGroup,
+  registerCompeteGroupRun,
+  settleCompeteGroupRun,
+  markCompeteGroupCleanupReady,
+  markCompeteGroupWinnerPreserved,
+  createCandidateWorktreeMapped,
+  commitCandidateWork,
+  candidateDiffStat,
+  protectedPathsChangedByCompeteBranch,
+  competeBranchForCandidate,
+  removeCandidateWorktreeMapped,
+  mergeWinnerBranch,
+  cleanupCompeteGroup,
+  settleRecoveredCompeteDecision,
+  recoverCleanupReadyCompeteGroups,
+  WRITE_BOUNDARY_VIOLATION_REASON,
+  captureWorkspaceSnapshot,
+  describeWriteBoundaryAttributionDowngrade,
+  preflightWriteBoundaries,
+  createWriteBoundaryEnforcer
+};
+//# sourceMappingURL=chunk-K53E2PTW.js.map