@letrquan/book 0.2.0 → 0.3.0

package/dist/chunk-YC6W4EJH.js

@@ -0,0 +1,947 @@
+import {
+  HARDENED_DIFF_ARGS,
+  hardenedGitArgs,
+  hardenedGitEnv
+} from "./chunk-C7ADUNPR.js";
+import {
+  systemClock
+} from "./chunk-RT5SATF7.js";
+import {
+  buildChildEnv
+} from "./chunk-XHAO3K7I.js";
+import {
+  resolveBookHome
+} from "./chunk-ZPSZZUWF.js";
+
+// src/jobs/persistent-store.ts
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  readdirSync,
+  renameSync,
+  rmSync as rmSync2,
+  writeFileSync
+} from "fs";
+import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
+import { dirname as dirname2, join as join2 } from "path";
+
+// src/agents/git-isolation.ts
+import { createHash, randomUUID } from "crypto";
+import { execFile, spawn } from "child_process";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { dirname, join, resolve } from "path";
+
+// src/agents/git-signing.ts
+var SIGNING_KEY_PATTERN = "^(commit\\.gpgsign|gpg\\..*|user\\.signingkey)$";
+var MINIMUM_GIT = "2.26";
+var READ_TIMEOUT_MS = 3e4;
+var USER_SCOPES = /* @__PURE__ */ new Set(["system", "global", "command"]);
+var REPOSITORY_SCOPES = /* @__PURE__ */ new Set(["local", "worktree"]);
+var BUILT_IN = {
+  "commit.gpgsign": "false",
+  "gpg.format": "openpgp",
+  gpg: "gpg",
+  "gpg.x509.program": "gpgsm",
+  "gpg.ssh.program": "ssh-keygen"
+};
+var PIN_UNITS = [
+  { keys: ["commit.gpgsign"], fallback: BUILT_IN["commit.gpgsign"] },
+  { keys: ["gpg.format"], fallback: BUILT_IN["gpg.format"] },
+  { keys: ["gpg.program", "gpg.openpgp.program"], fallback: BUILT_IN.gpg },
+  { keys: ["gpg.x509.program"], fallback: BUILT_IN["gpg.x509.program"] },
+  { keys: ["gpg.ssh.program"], fallback: BUILT_IN["gpg.ssh.program"] },
+  { keys: ["gpg.ssh.defaultkeycommand"], fallback: "" },
+  { keys: ["gpg.ssh.allowedsignersfile"], fallback: "" },
+  { keys: ["gpg.ssh.revocationfile"], fallback: "" }
+];
+async function readSigningConfig(repoRoot, run2) {
+  const result = await run2(
+    "git",
+    ["config", "--show-scope", "-z", "--get-regexp", SIGNING_KEY_PATTERN],
+    { cwd: repoRoot, allowExitCodes: [1, 129], timeoutMs: READ_TIMEOUT_MS }
+  );
+  if (result.code === 129 || /unknown option/i.test(result.stderr)) {
+    throw new Error(
+      `Applying an agent's result needs git ${MINIMUM_GIT} or later (for \`git config --show-scope\`); this git is ${await gitVersion(run2, repoRoot)}`
+    );
+  }
+  return parseSigningConfig(result.stdout);
+}
+async function gitVersion(run2, repoRoot) {
+  try {
+    return (await run2("git", ["--version"], { cwd: repoRoot, timeoutMs: READ_TIMEOUT_MS })).stdout.trim();
+  } catch {
+    return "of an unknown version";
+  }
+}
+function parseSigningConfig(stdout) {
+  const fields = stdout.split("\0");
+  const entries = [];
+  for (let index = 0; index + 1 < fields.length; index += 2) {
+    const separator = fields[index + 1].indexOf("\n");
+    entries.push({
+      scope: fields[index].toLowerCase(),
+      key: canonicalConfigKey(
+        separator === -1 ? fields[index + 1] : fields[index + 1].slice(0, separator)
+      ),
+      // Git's own reading of a key with no value: a boolean true.
+      value: separator === -1 ? "true" : fields[index + 1].slice(separator + 1)
+    });
+  }
+  return entries;
+}
+function canonicalConfigKey(raw) {
+  const nameStart = raw.lastIndexOf(".");
+  if (nameStart === -1) return raw.toLowerCase();
+  const head = raw.slice(0, nameStart);
+  const name = raw.slice(nameStart + 1).toLowerCase();
+  const subsectionStart = head.indexOf(".");
+  if (subsectionStart === -1) return `${head.toLowerCase()}.${name}`;
+  const section = head.slice(0, subsectionStart).toLowerCase();
+  return `${section}.${head.slice(subsectionStart + 1)}.${name}`;
+}
+function signingFacts(entries) {
+  const operatorEntries = [];
+  const repositoryKeys = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (USER_SCOPES.has(entry.scope)) operatorEntries.push(entry);
+    else if (REPOSITORY_SCOPES.has(entry.scope)) repositoryKeys.add(entry.key);
+  }
+  return {
+    operatorEntries,
+    repositoryKeys,
+    signingOn: configBool(operatorValue(operatorEntries, ["commit.gpgsign"])),
+    format: (operatorValue(operatorEntries, ["gpg.format"]) ?? BUILT_IN["gpg.format"]).trim().toLowerCase()
+  };
+}
+function operatorValue(operatorEntries, keys) {
+  let value;
+  for (const entry of operatorEntries) {
+    if (keys.includes(entry.key)) value = entry.value;
+  }
+  return value;
+}
+function lastOperatorValue(facts, keys) {
+  return operatorValue(facts.operatorEntries, keys);
+}
+function configBool(value) {
+  return ["true", "yes", "on", "1"].includes((value ?? "").trim().toLowerCase());
+}
+function signingKeySource(facts) {
+  if (!facts.repositoryKeys.has("user.signingkey") || !facts.signingOn) return "none";
+  if (lastOperatorValue(facts, ["user.signingkey"]) !== void 0) return "operator";
+  if (facts.format === "ssh") {
+    return lastOperatorValue(facts, ["gpg.ssh.defaultkeycommand"]) === void 0 ? "none" : "ssh-default-key-command";
+  }
+  return "committer";
+}
+function pinsFor(facts, inputs) {
+  const fallbacks = [];
+  const operatorValues = [];
+  const pin = (into, key, value) => {
+    into.push("-c", `${key}=${value}`);
+  };
+  const pinned = /* @__PURE__ */ new Set();
+  for (const unit of PIN_UNITS) {
+    for (const key of unit.keys) pinned.add(key);
+    const operatorValue2 = lastOperatorValue(facts, unit.keys);
+    for (const key of unit.keys) {
+      pin(fallbacks, key, unit.fallback);
+      if (operatorValue2 !== void 0) pin(operatorValues, key, operatorValue2);
+    }
+  }
+  if (facts.repositoryKeys.has("user.signingkey")) {
+    pin(fallbacks, "user.signingkey", derivedSigningKey(facts, inputs));
+    const operatorValue2 = lastOperatorValue(facts, ["user.signingkey"]);
+    if (operatorValue2 !== void 0) pin(operatorValues, "user.signingkey", operatorValue2);
+  }
+  for (const key of facts.repositoryKeys) {
+    if (pinned.has(key) || !key.startsWith("gpg.")) continue;
+    pin(fallbacks, key, "");
+    const operatorValue2 = lastOperatorValue(facts, [key]);
+    if (operatorValue2 !== void 0) pin(operatorValues, key, operatorValue2);
+  }
+  return [...fallbacks, ...operatorValues];
+}
+function derivedSigningKey(facts, inputs) {
+  switch (signingKeySource(facts)) {
+    case "operator":
+      return "";
+    case "committer":
+      return committerSigningIdentity(inputs.committerIdent);
+    case "ssh-default-key-command":
+      return inputs.sshDefaultKey;
+    default:
+      return "";
+  }
+}
+function committerSigningIdentity(ident) {
+  return ident.trim().replace(/\s+\d+\s+[+-]\d{4}$/, "");
+}
+async function signingPinArgs(repoRoot, run2) {
+  const entries = await readSigningConfig(repoRoot, run2);
+  const facts = signingFacts(entries);
+  const inputs = { committerIdent: "", sshDefaultKey: "" };
+  const source = signingKeySource(facts);
+  if (source === "committer") {
+    inputs.committerIdent = (await run2("git", ["var", "GIT_COMMITTER_IDENT"], {
+      cwd: repoRoot,
+      timeoutMs: READ_TIMEOUT_MS
+    })).stdout;
+  } else if (source === "ssh-default-key-command") {
+    inputs.sshDefaultKey = await sshDefaultSigningKey(facts, repoRoot, run2);
+  }
+  return pinsFor(facts, inputs);
+}
+async function sshDefaultSigningKey(facts, repoRoot, run2) {
+  const command = lastOperatorValue(facts, ["gpg.ssh.defaultkeycommand"])?.trim();
+  if (!command) return "";
+  const [program, ...args] = command.split(/\s+/);
+  try {
+    const result = await run2(program, args, { cwd: repoRoot, timeoutMs: READ_TIMEOUT_MS });
+    const first = result.stdout.split(/\r?\n/)[0]?.trim() ?? "";
+    return first.startsWith("key::") ? first : "";
+  } catch {
+    return "";
+  }
+}
+
+// src/agents/git-isolation.ts
+function run(command, args, options) {
+  const env = internalGitEnv(options.env);
+  const timeoutMs = options.timeoutMs ?? DEFAULT_GIT_TIMEOUT_MS;
+  const signal = options.signal;
+  if (signal?.aborted) {
+    return Promise.reject(new Error(stoppedDescription(command, args, "aborted", null, timeoutMs)));
+  }
+  if (options.input !== void 0) {
+    return new Promise((resolvePromise, reject) => {
+      const child = spawn(command, args, {
+        cwd: options.cwd,
+        env,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      let settled = false;
+      let cancelEscalation;
+      const settle = (outcome) => {
+        if (settled) return;
+        settled = true;
+        if (timer) clearTimeout(timer);
+        cancelEscalation?.();
+        outcome();
+      };
+      let stoppedBy;
+      const stopChild = (reason) => {
+        if (stoppedBy === void 0) stoppedBy = reason;
+        cancelEscalation = stopEscalating(
+          child,
+          () => settle(
+            () => reject(
+              new Error(stoppedDescription(command, args, stoppedBy, child.signalCode, timeoutMs))
+            )
+          )
+        );
+      };
+      const onAbort = () => stopChild("aborted");
+      const timer = timeoutMs > 0 ? setTimeout(() => stopChild("timeout"), timeoutMs) : void 0;
+      timer?.unref?.();
+      signal?.addEventListener("abort", onAbort, { once: true });
+      let stdinError;
+      child.stdout.on("data", (chunk) => stdout += chunk.toString());
+      child.stderr.on("data", (chunk) => stderr += chunk.toString());
+      let outputError;
+      child.stdout.on("error", (error) => outputError ??= error);
+      child.stderr.on("error", (error) => outputError ??= error);
+      child.on("error", (error) => {
+        if (timer) clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
+        settle(() => reject(error));
+      });
+      child.on("close", (codeValue, closedBySignal) => {
+        if (timer) clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
+        settle(() => {
+          const code = typeof codeValue === "number" ? codeValue : void 0;
+          if (code === void 0) {
+            reject(
+              new Error(
+                stderr.trim() || stdout.trim() || outputError?.message || stdinError?.message || stoppedDescription(command, args, stoppedBy, closedBySignal, timeoutMs)
+              )
+            );
+            return;
+          }
+          if (code === 0 || options.allowExitCodes?.includes(code)) {
+            resolvePromise({ stdout, stderr, code });
+            return;
+          }
+          reject(
+            new Error(
+              stderr.trim() || stdout.trim() || stdinError?.message || `${command} ${subcommandOf(args)} failed (${code})`
+            )
+          );
+        });
+      });
+      child.stdin.on("error", (error) => {
+        if (error.code === "EPIPE" || error.code === "EOF") return;
+        stdinError ??= error;
+      });
+      child.stdin.end(options.input);
+    });
+  }
+  return new Promise((resolvePromise, reject) => {
+    let settled = false;
+    let cancelEscalation;
+    const settle = (outcome) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      cancelEscalation?.();
+      outcome();
+    };
+    let stoppedBy;
+    const stopCall = (reason) => {
+      if (stoppedBy === void 0) stoppedBy = reason;
+      cancelEscalation = stopEscalating(
+        child,
+        () => settle(
+          () => reject(
+            new Error(
+              failureDescription(
+                { killed: true },
+                "",
+                command,
+                args,
+                timeoutMs,
+                reason === "aborted"
+              )
+            )
+          )
+        )
+      );
+    };
+    const onAbort = () => stopCall("aborted");
+    const child = execFile(
+      command,
+      args,
+      {
+        cwd: options.cwd,
+        env,
+        encoding: "utf8",
+        // One buffer for every call: a signing read that overruns it has to fail rather than
+        // resolve on a prefix, and this size is what makes that impractical rather than what makes
+        // it correct.
+        maxBuffer: 50 * 1024 * 1024
+        // No `timeout` and no `signal` option here. `execFile`'s own timeout kills the child but
+        // still waits for its output to close, and a grandchild holding that pipe — a shell script,
+        // a `credential.helper` that started something of its own — means it never does, so the
+        // callback that would report the timeout may never arrive; its `signal` sends SIGTERM and
+        // then stops looking. The timer below bounds the call and `stopEscalating` ends the child.
+      },
+      (error, stdout, stderr) => {
+        const code = exitCodeOf(error);
+        if (code === void 0) {
+          settle(
+            () => reject(
+              new Error(
+                failureDescription(
+                  error,
+                  stderr || stdout,
+                  command,
+                  args,
+                  timeoutMs,
+                  stoppedBy === "aborted"
+                )
+              )
+            )
+          );
+          return;
+        }
+        if (code === 0 || options.allowExitCodes?.includes(code)) {
+          settle(() => resolvePromise({ stdout, stderr, code }));
+          return;
+        }
+        settle(
+          () => reject(
+            new Error(
+              // git's own words first, because they are the ones that say what went wrong. Then the
+              // composed message, and not Node's: with no output to prefer, Node's is the whole argv
+              // — hardening pairs included — which names `-c` where a reader needs the subcommand,
+              // and says nothing that the exit code does not (#357).
+              stderr.trim() || stdout.trim() || `${command} ${subcommandOf(args)} failed (${code})`
+            )
+          )
+        );
+      }
+    );
+    const timer = timeoutMs > 0 ? setTimeout(() => stopCall("timeout"), timeoutMs) : void 0;
+    timer?.unref?.();
+    signal?.addEventListener("abort", onAbort, { once: true });
+    child.stdin?.end();
+  });
+}
+var DEFAULT_GIT_TIMEOUT_MS = 12e4;
+var KILL_GRACE_MS = 2e3;
+function stopEscalating(child, settled) {
+  child.kill("SIGTERM");
+  if (child.exitCode !== null || child.signalCode !== null) {
+    return () => {
+    };
+  }
+  const escalation = setTimeout(() => {
+    if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+    settled();
+  }, KILL_GRACE_MS);
+  escalation.unref?.();
+  return () => clearTimeout(escalation);
+}
+function subcommandOf(args) {
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "-c" || arg === "-C") {
+      index++;
+      continue;
+    }
+    if (arg.startsWith("-")) continue;
+    return arg;
+  }
+  return "(no subcommand)";
+}
+function stoppedDescription(command, args, stoppedBy, closedBySignal, timeoutMs) {
+  const invocation = `${command} ${subcommandOf(args)}`;
+  if (stoppedBy === "timeout") {
+    return `${invocation} timed out after ${timeoutMs}ms and was killed`;
+  }
+  if (stoppedBy === "aborted") return `${invocation} was cancelled`;
+  if (closedBySignal) return `${invocation} was killed with ${closedBySignal}`;
+  return `${invocation} was killed and produced no result`;
+}
+function exitCodeOf(error) {
+  if (!error) return 0;
+  if (error.killed || error.signal) return void 0;
+  if (isAbortError(error)) return void 0;
+  return typeof error.code === "number" ? error.code : void 0;
+}
+function isAbortError(error) {
+  return error?.name === "AbortError" || error?.code === "ABORT_ERR";
+}
+function failureDescription(error, output, command, args, timeoutMs, aborted) {
+  const invocation = `${command} ${subcommandOf(args)}`;
+  if (aborted || isAbortError(error)) return `${invocation} was cancelled`;
+  if (error?.killed) return `${invocation} timed out after ${timeoutMs}ms and was killed`;
+  if (error?.signal) return `${invocation} was killed with ${error.signal}`;
+  if (typeof error?.code === "string") return `${invocation} failed: ${error.code}`;
+  return output.trim() || error?.message || `${invocation} failed`;
+}
+var GIT_REPOSITORY_SELECTION_VARIABLES = /* @__PURE__ */ new Set([
+  "GIT_DIR",
+  "GIT_WORK_TREE",
+  "GIT_INDEX_FILE",
+  // The index *format* rather than the index's location, and kept in this list for the same
+  // reason as the index itself: a snapshot stages into a temporary index of its own, and an
+  // ambient version would have git write that index in a format the operator's own git may refuse
+  // to read back.
+  "GIT_INDEX_VERSION",
+  "GIT_OBJECT_DIRECTORY",
+  "GIT_ALTERNATE_OBJECT_DIRECTORIES",
+  "GIT_COMMON_DIR",
+  "GIT_NAMESPACE",
+  "GIT_PREFIX"
+]);
+function internalGitEnv(overrides) {
+  const ambient = buildChildEnv(process.env);
+  for (const name of GIT_REPOSITORY_SELECTION_VARIABLES) delete ambient[name];
+  return { ...ambient, ...overrides, ...hardenedGitEnv() };
+}
+function git(cwd, args, options = {}) {
+  return run("git", hardenedGitArgs(args), { ...options, cwd });
+}
+var hardenedRunner = run;
+function cherryPickFailureResult(facts) {
+  const conflicted = facts.unmergedPaths.length > 0;
+  if (facts.abortError) {
+    return {
+      // Not `conflicted ? 'conflicted' : 'not_applied'`, which is what the conflict claim alone
+      // decides: a pick whose rollback did not run is not retryable whether or not it conflicted,
+      // and reporting the narrower of the two claims is what made an operator commit into a
+      // repository that was still mid-pick.
+      status: "conflicted",
+      error: `Cherry-pick failed (${facts.pickError}) and the rollback did not complete (${facts.abortError}), so this repository may be left mid-cherry-pick: finish it with git cherry-pick --continue or undo it with git cherry-pick --abort.`
+    };
+  }
+  return {
+    status: conflicted ? "conflicted" : "not_applied",
+    error: `Cherry-pick failed and was rolled back: ${facts.pickError}`
+  };
+}
+function gitIdentityEnv() {
+  return {
+    GIT_AUTHOR_NAME: "Book Agent",
+    GIT_AUTHOR_EMAIL: "agents@book.local",
+    GIT_COMMITTER_NAME: "Book Agent",
+    GIT_COMMITTER_EMAIL: "agents@book.local"
+  };
+}
+function tempIndex() {
+  const dir = mkdtempSync(join(tmpdir(), "book-index-"));
+  return { dir, path: join(dir, "index") };
+}
+async function findGitRoot(workspace, signal) {
+  try {
+    return (await git(workspace, ["rev-parse", "--show-toplevel"], { signal })).stdout.trim();
+  } catch {
+    return void 0;
+  }
+}
+function repositoryHash(repoRoot) {
+  return createHash("sha256").update(resolve(repoRoot).toLowerCase()).digest("hex").slice(0, 20);
+}
+async function writeWorkspaceTree(repoRoot, includeUntracked, signal) {
+  const index = tempIndex();
+  try {
+    const env = { GIT_INDEX_FILE: index.path };
+    const head = (await git(repoRoot, ["rev-parse", "HEAD"], { signal })).stdout.trim();
+    await git(repoRoot, ["read-tree", head], { env, signal });
+    await git(repoRoot, includeUntracked ? ["add", "-A", "--", "."] : ["add", "-u", "--", "."], {
+      env,
+      signal
+    });
+    const tree = (await git(repoRoot, ["write-tree"], { env, signal })).stdout.trim();
+    const status = (await git(repoRoot, ["status", "--porcelain=v1", "--untracked-files=all"], { signal })).stdout;
+    return { head, tree, status };
+  } finally {
+    rmSync(index.dir, { recursive: true, force: true });
+  }
+}
+async function currentWorkspaceFingerprint(repoRoot, includeUntracked, signal) {
+  const { head, tree } = await writeWorkspaceTree(repoRoot, includeUntracked, signal);
+  return `${head}:${tree}`;
+}
+async function createSyntheticSnapshot(workspace, includeUntracked = true, signal) {
+  const repoRoot = await findGitRoot(workspace, signal);
+  if (!repoRoot) {
+    throw new Error(
+      "Managed agents require a Git workspace with at least one commit. Use --agents off for this workspace."
+    );
+  }
+  const id = randomUUID();
+  const { head, tree, status } = await writeWorkspaceTree(repoRoot, includeUntracked, signal);
+  const commit = (await git(repoRoot, ["commit-tree", tree, "-p", head, "-m", `book synthetic snapshot ${id}`], {
+    env: gitIdentityEnv(),
+    signal
+  })).stdout.trim();
+  const repoHash = repositoryHash(repoRoot);
+  const ref = `refs/book/snapshots/${repoHash}/${id}`;
+  await git(repoRoot, ["update-ref", ref, commit], { signal });
+  const manifestOutput = (await git(
+    repoRoot,
+    [
+      "-c",
+      "core.quotepath=false",
+      "diff-tree",
+      "--no-commit-id",
+      "--name-status",
+      "-r",
+      "-M",
+      head,
+      commit
+    ],
+    { signal }
+  )).stdout;
+  const manifest = manifestOutput.split(/\r?\n/).filter(Boolean).map((line) => {
+    const [statusCode, ...paths] = line.split("	");
+    return { status: statusCode, path: paths.join(" -> ") };
+  });
+  return {
+    id,
+    repoRoot,
+    repoHash,
+    baseHead: head,
+    commit,
+    tree,
+    ref,
+    fingerprint: `${head}:${tree}`,
+    dirty: status.trim().length > 0,
+    includeUntracked,
+    manifest,
+    createdAt: Date.now()
+  };
+}
+function defaultWorktreeRoot() {
+  return join(resolveBookHome(), "worktrees");
+}
+async function branchExists(repoRoot, branch, signal) {
+  const result = await git(repoRoot, ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], {
+    allowExitCodes: [1],
+    signal
+  });
+  return result.code === 0;
+}
+async function deleteBranchBookCreated(repoRoot, branch, existed) {
+  if (existed) return;
+  await git(repoRoot, ["branch", "-D", branch], { allowExitCodes: [1, 128] }).catch(() => {
+  });
+}
+async function worktreeIsComplete(path, signal) {
+  if (!existsSync(join(path, ".git"))) return false;
+  try {
+    const administrative = (await git(path, ["rev-parse", "--absolute-git-dir"], { signal })).stdout.trim();
+    if (!existsSync(join(administrative, "index"))) return false;
+    await git(path, ["rev-parse", "--verify", "HEAD"], { signal });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function removeWorktree(repoRoot, path) {
+  await git(repoRoot, ["worktree", "remove", "--force", path], { allowExitCodes: [128] }).catch(
+    () => {
+    }
+  );
+  await git(repoRoot, ["worktree", "prune"], { allowExitCodes: [128] }).catch(() => {
+  });
+  if (pointsAtWorktree(path)) rmSync(path, { recursive: true, force: true });
+}
+function pointsAtWorktree(path) {
+  return existsSync(join(path, ".git"));
+}
+async function createAgentWorktree(snapshot, agentId, worktreeRoot = defaultWorktreeRoot(), startCommit = snapshot.commit, signal) {
+  const path = join(worktreeRoot, snapshot.repoHash, agentId);
+  const branch = `book-agent/${snapshot.repoHash}/${agentId}`;
+  if (await worktreeIsComplete(path, signal)) return { path, branch };
+  const existed = await branchExists(snapshot.repoRoot, branch, signal);
+  if (pointsAtWorktree(path)) {
+    await removeWorktree(snapshot.repoRoot, path);
+    await deleteBranchBookCreated(snapshot.repoRoot, branch, false);
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  try {
+    await git(snapshot.repoRoot, ["worktree", "add", "-b", branch, path, startCommit], { signal });
+  } catch (error) {
+    await removeWorktree(snapshot.repoRoot, path);
+    await deleteBranchBookCreated(snapshot.repoRoot, branch, existed);
+    throw error;
+  }
+  if (!await worktreeIsComplete(path, signal)) {
+    await removeWorktree(snapshot.repoRoot, path);
+    await deleteBranchBookCreated(snapshot.repoRoot, branch, existed);
+    throw new Error(
+      `git worktree add reported success but ${path} is not a usable worktree; it was removed so the next attempt starts clean.`
+    );
+  }
+  return { path, branch };
+}
+function removalRoot(record, repoRoot) {
+  if (repoRoot && resolve(repoRoot) !== resolve(record.worktree)) return repoRoot;
+  const pointed = repositoryOfWorktree(record.worktree);
+  if (pointed && existsSync(pointed)) return pointed;
+  return dirname(record.worktree);
+}
+function repositoryOfWorktree(worktree) {
+  try {
+    const pointer = readFileSync(join(worktree, ".git"), "utf8").trim();
+    const match = /^gitdir:\s*(.+)$/m.exec(pointer);
+    const gitdir = match?.[1]?.trim();
+    if (!gitdir) return void 0;
+    return dirname(dirname(resolve(worktree, gitdir)));
+  } catch {
+    return void 0;
+  }
+}
+async function removeAgentWorktree(record, repoRoot) {
+  if (!record.worktree || !record.branch) return;
+  const root = removalRoot(record, repoRoot);
+  await git(root, ["worktree", "remove", "--force", record.worktree], {
+    allowExitCodes: [128]
+  }).catch(() => {
+  });
+  await git(root, ["branch", "-D", record.branch], { allowExitCodes: [1, 128] }).catch(() => {
+  });
+}
+async function removeSnapshotRef(snapshot) {
+  await git(snapshot.repoRoot, ["update-ref", "-d", snapshot.ref], { allowExitCodes: [1] }).catch(
+    () => {
+    }
+  );
+}
+async function checkoutAgentCommit(worktree, commit) {
+  await git(worktree, ["reset", "--hard", commit]);
+}
+async function commitAgentWork(record, snapshot) {
+  if (!record.worktree || !record.branch) return void 0;
+  await git(record.worktree, ["add", "-A", "--", "."]);
+  const diff = await git(record.worktree, ["diff", ...HARDENED_DIFF_ARGS, "--cached", "--quiet"], {
+    allowExitCodes: [1]
+  });
+  if (diff.code === 0) return void 0;
+  await git(
+    record.worktree,
+    ["commit", "--no-verify", "--no-gpg-sign", "-m", `book agent ${record.id}: ${record.name}`],
+    {
+      env: gitIdentityEnv()
+    }
+  );
+  const headCommit = (await git(record.worktree, ["rev-parse", "HEAD"])).stdout.trim();
+  return {
+    baseCommit: snapshot.commit,
+    headCommit,
+    branch: record.branch,
+    agentId: record.id
+  };
+}
+async function candidateDelta(snapshot, candidate, signal) {
+  return (await git(
+    snapshot.repoRoot,
+    [
+      "diff",
+      ...HARDENED_DIFF_ARGS,
+      "--binary",
+      "--full-index",
+      candidate.baseCommit,
+      candidate.headCommit,
+      "--"
+    ],
+    { signal }
+  )).stdout;
+}
+async function precheckDelta(snapshot, patch, signal) {
+  const index = tempIndex();
+  try {
+    const env = { GIT_INDEX_FILE: index.path };
+    await git(snapshot.repoRoot, ["read-tree", snapshot.commit], { env, signal });
+    await git(snapshot.repoRoot, ["apply", "--3way", "--check", "--cached", "-"], {
+      env,
+      input: patch,
+      signal
+    });
+    await git(snapshot.repoRoot, ["apply", "--check", "-"], { input: patch, signal });
+  } finally {
+    rmSync(index.dir, { recursive: true, force: true });
+  }
+}
+var CHERRY_PICK_TIMEOUT_MS = 3e5;
+async function hasPendingCherryPick(repoRoot, signal) {
+  const result = await git(repoRoot, ["rev-parse", "-q", "--verify", "CHERRY_PICK_HEAD"], {
+    allowExitCodes: [1],
+    signal
+  });
+  return result.code === 0;
+}
+async function unmergedPathsAfterFailure(repoRoot) {
+  try {
+    const result = await git(repoRoot, [
+      "diff",
+      ...HARDENED_DIFF_ARGS,
+      "--name-only",
+      "--diff-filter=U"
+    ]);
+    return result.stdout.split(/\r?\n/).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+async function applyVerifiedCandidate(snapshot, candidate, signal) {
+  if (candidate.baseCommit !== snapshot.commit) {
+    return {
+      status: "conflicted",
+      error: "Patch candidate base does not match the task snapshot."
+    };
+  }
+  const actualHead = (await git(snapshot.repoRoot, ["rev-parse", candidate.headCommit])).stdout.trim();
+  if (actualHead !== candidate.headCommit) {
+    return { status: "conflicted", error: "Patch candidate commit no longer resolves exactly." };
+  }
+  if (await hasPendingCherryPick(snapshot.repoRoot, signal)) {
+    return {
+      status: "conflicted",
+      error: "A cherry-pick is already in progress in this repository. Book did not start it and will not abort it; finish it (git cherry-pick --continue) or undo it (git cherry-pick --abort), then apply the agent result again."
+    };
+  }
+  const current = await currentWorkspaceFingerprint(
+    snapshot.repoRoot,
+    snapshot.includeUntracked,
+    signal
+  );
+  if (current !== snapshot.fingerprint) {
+    return {
+      status: "conflicted",
+      error: "Parent workspace drifted after the agent snapshot; no changes were applied."
+    };
+  }
+  const patch = await candidateDelta(snapshot, candidate, signal);
+  try {
+    await precheckDelta(snapshot, patch, signal);
+  } catch (error) {
+    return {
+      status: "conflicted",
+      error: `Patch pre-check failed; no changes were applied: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  if (!snapshot.dirty) {
+    let signingPins;
+    try {
+      signingPins = await signingPinArgs(snapshot.repoRoot, hardenedRunner);
+    } catch (error) {
+      return {
+        status: "conflicted",
+        error: `Could not read the signing configuration for the cherry-pick: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+    try {
+      await git(snapshot.repoRoot, [...signingPins, "cherry-pick", candidate.headCommit], {
+        timeoutMs: CHERRY_PICK_TIMEOUT_MS,
+        signal
+      });
+      const appliedCommit = (await git(snapshot.repoRoot, ["rev-parse", "HEAD"], { signal })).stdout.trim();
+      return { status: "applied", commit: appliedCommit };
+    } catch (error) {
+      const unmergedPaths = await unmergedPathsAfterFailure(snapshot.repoRoot);
+      let abortError;
+      try {
+        await git(snapshot.repoRoot, ["cherry-pick", "--abort"], { allowExitCodes: [128] });
+      } catch (abortFailure) {
+        abortError = abortFailure instanceof Error ? abortFailure.message : String(abortFailure);
+      }
+      return cherryPickFailureResult({
+        pickError: error instanceof Error ? error.message : String(error),
+        abortError,
+        unmergedPaths
+      });
+    }
+  }
+  try {
+    await git(snapshot.repoRoot, ["apply", "-"], { input: patch, signal });
+    return { status: "applied", commit: candidate.headCommit };
+  } catch (error) {
+    return {
+      status: "conflicted",
+      error: `Patch application failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+
+// src/fs-contention.ts
+var FILE_CONTENTION_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES"]);
+function sleepSync(milliseconds) {
+  if (milliseconds <= 0) return;
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
+}
+
+// src/jobs/persistent-store.ts
+function persistentJobPaths(workspace, root = join2(resolveBookHome(), "jobs")) {
+  const repositoryRoot = join2(root, repositoryHash(workspace));
+  return {
+    root: repositoryRoot,
+    records: join2(repositoryRoot, "records"),
+    controls: join2(repositoryRoot, "controls"),
+    logs: join2(repositoryRoot, "logs"),
+    specs: join2(repositoryRoot, "specs")
+  };
+}
+function ensurePersistentJobPaths(paths) {
+  for (const path of [paths.root, paths.records, paths.controls, paths.logs, paths.specs]) {
+    mkdirSync2(path, { recursive: true });
+  }
+}
+var DEFAULT_RENAME_RETRY_BUDGET_MS = 100;
+var RENAME_RETRY_STEP_MS = 10;
+function renameWithContentionRetry(from, to, options = {}) {
+  const rename = options.rename ?? renameSync;
+  const platform = options.platform ?? process.platform;
+  const clock = options.clock ?? systemClock;
+  const sleep = options.sleep ?? sleepSync;
+  const deadline = clock.monotonicNowMs() + (options.budgetMs ?? DEFAULT_RENAME_RETRY_BUDGET_MS);
+  for (; ; ) {
+    try {
+      rename(from, to);
+      return;
+    } catch (error) {
+      const code = error.code ?? "";
+      const remainingMs = deadline - clock.monotonicNowMs();
+      if (platform !== "win32" || !FILE_CONTENTION_CODES.has(code) || remainingMs <= 0) {
+        throw error;
+      }
+      sleep(Math.min(RENAME_RETRY_STEP_MS, remainingMs));
+    }
+  }
+}
+function writeJsonAtomic(path, value, options = {}) {
+  mkdirSync2(dirname2(path), { recursive: true });
+  const temporary = `${path}.${process.pid}.${randomUUID2()}.tmp`;
+  try {
+    writeFileSync(temporary, JSON.stringify(value, null, 2), { encoding: "utf8", mode: 384 });
+    renameWithContentionRetry(temporary, path, { budgetMs: options.renameRetryBudgetMs });
+  } catch (error) {
+    try {
+      rmSync2(temporary, { force: true });
+    } catch {
+    }
+    throw error;
+  }
+}
+function readJsonFile(path) {
+  try {
+    return JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function loadPersistentShellSpec(path) {
+  const spec = readJsonFile(path);
+  if (!spec || spec.version !== 1 || typeof spec.token !== "string" || typeof spec.tokenHash !== "string" || createHash2("sha256").update(spec.token).digest("hex") !== spec.tokenHash) {
+    return { error: "Invalid persistent shell specification." };
+  }
+  if (spec.sandboxed && !spec.exec) {
+    return {
+      error: "Invalid persistent shell specification: sandboxed is set but no sandboxed argv is present."
+    };
+  }
+  return { spec };
+}
+function listPersistentStates(paths) {
+  if (!existsSync2(paths.records)) return [];
+  return readdirSync(paths.records).filter((name) => name.endsWith(".json")).map((name) => readJsonFile(join2(paths.records, name))).filter((state) => state?.version === 1);
+}
+function removePersistentJobFiles(paths, id) {
+  for (const path of [
+    join2(paths.records, `${id}.json`),
+    join2(paths.controls, `${id}.json`),
+    join2(paths.logs, `${id}.log`),
+    join2(paths.specs, `${id}.json`)
+  ]) {
+    rmSync2(path, { force: true });
+  }
+}
+function removePersistentRunnerFiles(paths, id) {
+  for (const path of [join2(paths.controls, `${id}.json`), join2(paths.specs, `${id}.json`)]) {
+    rmSync2(path, { force: true });
+  }
+}
+
+export {
+  findGitRoot,
+  repositoryHash,
+  createSyntheticSnapshot,
+  defaultWorktreeRoot,
+  createAgentWorktree,
+  removeAgentWorktree,
+  removeSnapshotRef,
+  checkoutAgentCommit,
+  commitAgentWork,
+  applyVerifiedCandidate,
+  FILE_CONTENTION_CODES,
+  sleepSync,
+  persistentJobPaths,
+  ensurePersistentJobPaths,
+  writeJsonAtomic,
+  readJsonFile,
+  loadPersistentShellSpec,
+  listPersistentStates,
+  removePersistentJobFiles,
+  removePersistentRunnerFiles
+};
+//# sourceMappingURL=chunk-YC6W4EJH.js.map