@titan-design/worktree 0.0.0

package/dist/index.js

@@ -0,0 +1,877 @@
+// src/allocator.ts
+import { existsSync as existsSync5, rmSync as rmSync2 } from "fs";
+import path5 from "path";
+
+// src/add.ts
+import { spawn } from "child_process";
+import { existsSync, rmSync } from "fs";
+
+// src/git.ts
+import { execFile } from "child_process";
+import path from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var DEFAULT_STRIPPED_ENV_PREFIXES = ["AGENT_CHAT_"];
+function gitChildEnv(env = process.env, stripPrefixes = DEFAULT_STRIPPED_ENV_PREFIXES) {
+  const out = { ...env, GIT_TERMINAL_PROMPT: "0" };
+  for (const key of Object.keys(out)) {
+    if (stripPrefixes.some((prefix) => key.startsWith(prefix))) delete out[key];
+  }
+  return out;
+}
+async function gitText(args, cwd, timeout) {
+  const { stdout } = await execFileAsync("git", [...args], {
+    cwd,
+    encoding: "utf8",
+    env: gitChildEnv(),
+    ...timeout === void 0 ? {} : { timeout }
+  });
+  return stdout.trim();
+}
+async function gitOrNull(args, cwd, timeout) {
+  try {
+    return await gitText(args, cwd, timeout);
+  } catch {
+    return null;
+  }
+}
+var runGit = (args, cwd) => gitOrNull(args, cwd);
+async function findGitRoot(cwd, git = runGit) {
+  const commonDir = await git(["rev-parse", "--path-format=absolute", "--git-common-dir"], cwd);
+  return commonDir === null ? null : path.dirname(commonDir);
+}
+async function observedPresence(cwd, git = runGit) {
+  const [branch, toplevel, commonDir, gitDir] = await Promise.all([
+    git(["rev-parse", "--abbrev-ref", "HEAD"], cwd),
+    git(["rev-parse", "--show-toplevel"], cwd),
+    git(["rev-parse", "--path-format=absolute", "--git-common-dir"], cwd),
+    git(["rev-parse", "--path-format=absolute", "--git-dir"], cwd)
+  ]);
+  if (toplevel === null && commonDir === null) return void 0;
+  const observed = {
+    // 'HEAD' means detached, which is not a branch name.
+    ...branch !== null && branch !== "" && branch !== "HEAD" ? { gitBranch: branch } : {},
+    ...toplevel === null || toplevel === "" ? {} : { worktreePath: toplevel },
+    ...commonDir === null ? {} : { repoPath: path.dirname(path.resolve(commonDir)) },
+    ...commonDir === null || gitDir === null ? {} : { isLinkedWorktree: path.resolve(commonDir) !== path.resolve(gitDir) }
+  };
+  return Object.keys(observed).length === 0 ? void 0 : observed;
+}
+
+// src/process-group.ts
+var groupAlive = (pid) => {
+  try {
+    process.kill(-pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var signalGroup = (pid, signal) => {
+  try {
+    process.kill(-pid, signal);
+  } catch {
+  }
+};
+
+// src/add.ts
+var WORKTREE_ADD_TIMEOUT_MS = 3e5;
+var CLEANUP_TIMEOUT_MS = 3e4;
+var TERM_GRACE_MS = 1e3;
+var addQueues = /* @__PURE__ */ new Map();
+function addWorktree(gitRoot, args, run = gitText) {
+  const adding = (addQueues.get(gitRoot) ?? Promise.resolve()).then(() => run(args, gitRoot));
+  const tail = adding.catch(() => void 0);
+  addQueues.set(gitRoot, tail);
+  void tail.then(() => addQueues.get(gitRoot) === tail && addQueues.delete(gitRoot));
+  return adding;
+}
+var addTarget = (args) => args[2] === "-b" ? args[4] : args[2];
+var AddTimedOut = class extends Error {
+};
+async function reapGroup(pid) {
+  signalGroup(pid, "SIGKILL");
+  for (let i = 0; i < 100 && groupAlive(pid); i++) await new Promise((r) => setTimeout(r, 20));
+}
+function settleAdd(code, out, err) {
+  if (code === 0) return out.trim();
+  return Object.assign(new Error(err.trim() || `git exited with code ${code}`), { code, stderr: err });
+}
+function gitInGroup(args, cwd, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("git", [...args], { cwd, env: gitChildEnv(), detached: true });
+    const pid = child.pid;
+    let out = "";
+    let err = "";
+    let timedOut = false;
+    child.stdout.on("data", (chunk) => out += chunk);
+    child.stderr.on("data", (chunk) => err += chunk);
+    const term = setTimeout(() => {
+      timedOut = true;
+      if (pid !== void 0) signalGroup(pid, "SIGTERM");
+    }, timeoutMs);
+    const kill = setTimeout(() => pid !== void 0 && signalGroup(pid, "SIGKILL"), timeoutMs + TERM_GRACE_MS);
+    child.on("error", reject);
+    child.on("close", (code) => {
+      clearTimeout(term);
+      clearTimeout(kill);
+      void (pid === void 0 ? Promise.resolve() : reapGroup(pid)).then(() => {
+        const settled = timedOut ? new AddTimedOut() : settleAdd(code, out, err);
+        if (typeof settled === "string") resolve(settled);
+        else reject(settled);
+      });
+    });
+  });
+}
+async function discardHalfCreated(gitRoot, args, created) {
+  const target = addTarget(args);
+  if (created && target !== void 0) {
+    await gitOrNull(["worktree", "remove", "--force", target], gitRoot, CLEANUP_TIMEOUT_MS);
+    rmSync(target, { recursive: true, force: true });
+  }
+  await gitOrNull(["worktree", "prune"], gitRoot, CLEANUP_TIMEOUT_MS);
+}
+var latestAdd = /* @__PURE__ */ new Map();
+function boundedAdd(run, timeoutMs) {
+  return async (args, cwd) => {
+    const target = addTarget(args);
+    const created = target !== void 0 && !existsSync(target);
+    const mine = {};
+    if (target !== void 0) latestAdd.set(target, mine);
+    const timedOut = new Error(`git worktree add in ${cwd} timed out after ${timeoutMs}ms and was killed`);
+    try {
+      return await (run === void 0 ? gitInGroup(args, cwd, timeoutMs) : raceTimer(run(args, cwd), timeoutMs, () => cleanLate(cwd, args, created, mine)));
+    } catch (err) {
+      if (!(err instanceof AddTimedOut)) throw err;
+      await discardHalfCreated(cwd, args, created);
+      throw timedOut;
+    }
+  };
+}
+async function cleanLate(cwd, args, created, mine) {
+  const target = addTarget(args);
+  if (target === void 0 || latestAdd.get(target) !== mine) return;
+  await discardHalfCreated(cwd, args, created);
+}
+async function raceTimer(add, timeoutMs, onLate) {
+  let timer;
+  const expired = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new AddTimedOut()), timeoutMs);
+  });
+  try {
+    return await Promise.race([add, expired]);
+  } catch (err) {
+    if (err instanceof AddTimedOut) void add.then(onLate, () => void 0);
+    throw err;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/branch-base.ts
+async function defaultBranchCandidates(gitRoot) {
+  const head = await gitOrNull(["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"], gitRoot);
+  return head?.startsWith("origin/") ? [head.slice("origin/".length)] : ["main", "master"];
+}
+async function fetchTip(gitRoot, branch, timeoutMs) {
+  const tracking = `refs/remotes/origin/${branch}`;
+  const fetched = await gitOrNull(
+    ["fetch", "--quiet", "--no-tags", "origin", `+refs/heads/${branch}:${tracking}`],
+    gitRoot,
+    timeoutMs
+  );
+  return fetched === null ? null : gitOrNull(["rev-parse", "--verify", `${tracking}^{commit}`], gitRoot);
+}
+async function fetchDefaultTip(gitRoot, timeoutMs) {
+  if (await gitOrNull(["remote", "get-url", "origin"], gitRoot) === null)
+    return "the repository has no origin remote";
+  const deadline = Date.now() + timeoutMs;
+  const candidates = await defaultBranchCandidates(gitRoot);
+  for (const branch of candidates) {
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) break;
+    const sha = await fetchTip(gitRoot, branch, remaining);
+    if (sha !== null) return { sha, ref: `origin/${branch}` };
+  }
+  return `fetching ${candidates.map((b) => `origin/${b}`).join(" or ")} failed or timed out`;
+}
+var inflightBases = /* @__PURE__ */ new Map();
+function resolveBranchBase(gitRoot, timeoutMs) {
+  const pending = inflightBases.get(gitRoot);
+  if (pending !== void 0) return pending;
+  const resolving = resolveBranchBaseNow(gitRoot, timeoutMs).finally(() => inflightBases.delete(gitRoot));
+  inflightBases.set(gitRoot, resolving);
+  return resolving;
+}
+async function resolveBranchBaseNow(gitRoot, timeoutMs) {
+  const reason = await fetchDefaultTip(gitRoot, timeoutMs);
+  if (typeof reason !== "string") return reason;
+  const sha = await gitOrNull(["rev-parse", "HEAD"], gitRoot) ?? "HEAD";
+  return {
+    sha,
+    ref: "HEAD",
+    warning: `worktree branched from the local HEAD at ${sha} because ${reason}; it may lag origin or carry unpushed commits`
+  };
+}
+
+// src/errors.ts
+var WorktreeBudgetExhaustedError = class extends Error {
+  constructor(allocated, budget) {
+    super(`Worktree budget exhausted: ${allocated}/${budget} allocated`);
+    this.allocated = allocated;
+    this.budget = budget;
+    this.name = "WorktreeBudgetExhaustedError";
+  }
+  allocated;
+  budget;
+};
+var WorktreeInUseError = class extends Error {
+  constructor(branch, worktreePath) {
+    super(
+      `${worktreePath} is still on disk and holds branch ${branch}. Another agent of this name may be live. Release it, spawn under a different name, or force the allocation to discard it.`
+    );
+    this.branch = branch;
+    this.worktreePath = worktreePath;
+    this.name = "WorktreeInUseError";
+  }
+  branch;
+  worktreePath;
+};
+var OriginUnreachableError = class extends Error {
+  constructor(branch, detail) {
+    super(
+      `cannot reach origin to look for branch ${branch} (${detail}); it may still hold the agent's work, so the worktree was not re-created. Fix the remote and resume again.`
+    );
+    this.branch = branch;
+    this.name = "OriginUnreachableError";
+  }
+  branch;
+};
+
+// src/layout.ts
+import { cpSync, existsSync as existsSync2 } from "fs";
+import path2 from "path";
+async function allocatedPaths(gitRoot, basePath) {
+  const out = await gitOrNull(["worktree", "list", "--porcelain"], gitRoot);
+  if (out === null) return [];
+  const base = path2.resolve(gitRoot, basePath) + path2.sep;
+  return out.split("\n").filter((line) => line.startsWith("worktree ")).map((line) => path2.resolve(line.slice("worktree ".length).trim())).filter((dir) => dir.startsWith(base));
+}
+async function pruneStaleWorktrees(gitRoot) {
+  await gitOrNull(["worktree", "prune"], gitRoot);
+}
+async function checkoutOf(gitRoot, branch) {
+  const out = await gitOrNull(["worktree", "list", "--porcelain"], gitRoot) ?? "";
+  const holder = out.split("\n\n").find((block) => block.includes(`branch refs/heads/${branch}`));
+  const line = holder?.split("\n").find((l) => l.startsWith("worktree "));
+  return line ? path2.resolve(line.slice("worktree ".length).trim()) : null;
+}
+function copyClaudeDir(gitRoot, worktreePath) {
+  const source = path2.resolve(gitRoot, ".claude");
+  const target = path2.resolve(worktreePath, ".claude");
+  if (existsSync2(source) && !existsSync2(target)) cpSync(source, target, { recursive: true });
+}
+async function removeWorktree(gitRoot, worktreePath, branch) {
+  if (await gitOrNull(["worktree", "remove", worktreePath], gitRoot) === null) {
+    await gitOrNull(["worktree", "remove", "--force", worktreePath], gitRoot);
+  }
+  await gitOrNull(["branch", "-D", branch], gitRoot);
+  await pruneStaleWorktrees(gitRoot);
+}
+
+// src/options.ts
+var DEFAULT_WORKTREE_BUDGET = 3;
+var DEFAULT_BASE_PATH = ".worktrees";
+var BRANCH_PREFIX = "agent-chat/";
+var DEFAULT_FETCH_TIMEOUT_MS = 15e3;
+var RECLAIM_GRACE_MS = 12e4;
+var basePathOf = (opts) => opts.basePath ?? DEFAULT_BASE_PATH;
+var branchPrefixOf = (opts) => opts.branchPrefix ?? BRANCH_PREFIX;
+function budgetOf(opts) {
+  const { budget } = opts;
+  return typeof budget === "function" ? budget() : budget ?? DEFAULT_WORKTREE_BUDGET;
+}
+var slug = (name) => name.replace(/[^A-Za-z0-9._-]/g, "-").replace(/^[.-]+/, "") || "agent";
+var branchFor = (name, opts = {}) => `${branchPrefixOf(opts)}${slug(name)}`;
+
+// src/reattach.ts
+import { existsSync as existsSync3 } from "fs";
+import path4 from "path";
+
+// src/setup.ts
+import { execFile as execFile2, spawn as spawn2 } from "child_process";
+import { writeFileSync } from "fs";
+import path3 from "path";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+var SETUP_FILE = ".agent-chat/worktree.json";
+var SETUP_LOG = "agent-chat-setup.log";
+var DEFAULT_SETUP_TIMEOUT_MS = 3e5;
+var MAX_SETUP_TIMEOUT_MS = 18e5;
+var TERM_GRACE_MS2 = 2e3;
+var OUTPUT_TAIL_CHARS = 4e3;
+var SETUP_ENV_KEYS = /* @__PURE__ */ new Set([
+  "PATH",
+  "HOME",
+  "USER",
+  "LOGNAME",
+  "SHELL",
+  "TMPDIR",
+  "LANG",
+  "PNPM_HOME",
+  "NODE_EXTRA_CA_CERTS",
+  "XDG_CACHE_HOME",
+  "XDG_CONFIG_HOME",
+  "XDG_DATA_HOME",
+  "HTTP_PROXY",
+  "HTTPS_PROXY",
+  "NO_PROXY",
+  "http_proxy",
+  "https_proxy",
+  "no_proxy"
+]);
+var SETUP_ENV_PREFIXES = ["LC_", "npm_config_", "NPM_CONFIG_", "COREPACK_"];
+function setupEnv(env = process.env) {
+  const out = { GIT_TERMINAL_PROMPT: "0" };
+  for (const [key, value] of Object.entries(env)) {
+    if (SETUP_ENV_KEYS.has(key) || SETUP_ENV_PREFIXES.some((prefix) => key.startsWith(prefix))) out[key] = value;
+  }
+  return out;
+}
+var isCommand = (value) => Array.isArray(value) && value.length > 0 && value.every((part) => typeof part === "string" && part !== "");
+var isTimeout = (value) => typeof value === "number" && Number.isInteger(value) && value > 0 && value <= MAX_SETUP_TIMEOUT_MS;
+function parseSetupStep(text) {
+  if (text.trim() === "") return `${SETUP_FILE} is empty`;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (err) {
+    return `${SETUP_FILE} is not valid JSON (${err.message})`;
+  }
+  const setup = parsed?.setup;
+  if (setup === void 0) return null;
+  if (typeof setup !== "object" || setup === null) return `${SETUP_FILE} setup must be an object`;
+  const { command, timeoutMs } = setup;
+  if (!isCommand(command)) return `${SETUP_FILE} setup.command must be a non-empty array of strings`;
+  if (timeoutMs !== void 0 && !isTimeout(timeoutMs))
+    return `${SETUP_FILE} setup.timeoutMs must be a positive integer of at most ${MAX_SETUP_TIMEOUT_MS}`;
+  return { command, timeoutMs: timeoutMs ?? DEFAULT_SETUP_TIMEOUT_MS };
+}
+async function gitOutput(args, cwd) {
+  try {
+    const { stdout } = await execFileAsync2("git", [...args], { cwd, encoding: "utf8", env: gitChildEnv() });
+    return stdout;
+  } catch {
+    return null;
+  }
+}
+var declarationAt = (gitRoot, sha) => gitOutput(["cat-file", "blob", `${sha}:${SETUP_FILE}`], gitRoot);
+var runSetupCommand = (command, cwd, timeoutMs) => new Promise((resolve) => {
+  const [file, ...args] = command;
+  const child = spawn2(file ?? "", args, {
+    cwd,
+    env: setupEnv(),
+    detached: true,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  let output = "";
+  let timedOut = false;
+  const collect = (chunk) => {
+    output = (output + chunk.toString()).slice(-OUTPUT_TAIL_CHARS);
+  };
+  child.stdout.on("data", collect);
+  child.stderr.on("data", collect);
+  const term = setTimeout(() => {
+    timedOut = true;
+    if (child.pid !== void 0) signalGroup(child.pid, "SIGTERM");
+  }, timeoutMs);
+  const kill = setTimeout(
+    () => child.pid !== void 0 && signalGroup(child.pid, "SIGKILL"),
+    timeoutMs + TERM_GRACE_MS2
+  );
+  const settle = (exitCode, extra = "") => {
+    clearTimeout(term);
+    clearTimeout(kill);
+    resolve({ exitCode, timedOut, output: output + extra });
+  };
+  child.on("error", (err) => settle(null, err.message));
+  child.on("close", (code) => settle(code));
+});
+async function writeSetupLog(worktree, output) {
+  const gitDir = await gitOutput(["rev-parse", "--absolute-git-dir"], worktree);
+  if (gitDir === null) return null;
+  const file = path3.join(gitDir.trim(), SETUP_LOG);
+  try {
+    writeFileSync(file, output, { mode: 384 });
+    return file;
+  } catch {
+    return null;
+  }
+}
+function describeFailure(step, result, log) {
+  const name = step.command.join(" ");
+  const how = result.timedOut ? `timed out after ${step.timeoutMs}ms and was killed` : `exited with ${result.exitCode === null ? "no exit code" : `code ${result.exitCode}`}`;
+  const where = log === null ? "" : `; its output is in ${log}`;
+  return `worktree setup step \`${name}\` ${how}${where}; the worktree may be missing its dependencies`;
+}
+async function runWorktreeSetup(target, run = runSetupCommand) {
+  const declared = await declarationAt(target.gitRoot, target.baseSha);
+  if (declared === null) return [];
+  if (!target.fetched)
+    return [`worktree setup skipped: ${SETUP_FILE} is trusted only from origin's fetched default branch`];
+  const step = parseSetupStep(declared);
+  if (step === null) return [];
+  if (typeof step === "string") return [`worktree setup skipped: ${step}`];
+  const result = await run(step.command, target.worktree, step.timeoutMs).catch(
+    (err) => ({
+      exitCode: null,
+      timedOut: false,
+      output: String(err)
+    })
+  );
+  if (result.exitCode === 0 && !result.timedOut) return [];
+  return [describeFailure(step, result, await writeSetupLog(target.worktree, result.output))];
+}
+
+// src/reattach.ts
+var setupTarget = (gitRoot, worktree, base) => ({
+  gitRoot,
+  worktree,
+  baseSha: base.sha,
+  fetched: base.warning === void 0
+});
+async function originHasBranch(gitRoot, branch, timeoutMs) {
+  try {
+    await gitText(["ls-remote", "--exit-code", "--heads", "origin", `refs/heads/${branch}`], gitRoot, timeoutMs);
+    return true;
+  } catch (err) {
+    if (err.code === 2) return false;
+    throw new OriginUnreachableError(branch, firstLine(err));
+  }
+}
+var firstLine = (err) => String(err.stderr || err.message).trim().split("\n")[0] ?? "unknown error";
+async function branchSource(gitRoot, branch, timeoutMs) {
+  if (await gitOrNull(["rev-parse", "--verify", branch], gitRoot) !== null) return "local";
+  if (await gitOrNull(["remote", "get-url", "origin"], gitRoot) === null) return "fresh";
+  if (!await originHasBranch(gitRoot, branch, timeoutMs)) return "fresh";
+  if (await fetchTip(gitRoot, branch, timeoutMs) === null)
+    throw new OriginUnreachableError(branch, "origin lists it but fetching it failed");
+  return "origin";
+}
+function addArgs(record, source, base) {
+  const { worktree, branch } = record;
+  if (source === "local") return ["worktree", "add", worktree, branch];
+  return ["worktree", "add", "-b", branch, worktree, source === "origin" ? `origin/${branch}` : base];
+}
+async function addForSource(record, source, base, run) {
+  try {
+    await addWorktree(record.gitRoot, addArgs(record, source, base), run);
+  } catch (err) {
+    const holder = await checkoutOf(record.gitRoot, record.branch);
+    if (holder !== null || existsSync3(record.worktree))
+      throw new WorktreeInUseError(record.branch, holder ?? record.worktree);
+    throw err;
+  }
+}
+function reattachWarnings(record, source, base) {
+  const inherited = base.warning === void 0 ? [] : [base.warning];
+  if (source !== "fresh") return inherited;
+  const fresh = `branch ${record.branch} no longer exists locally or on origin (a squash merge deletes it), so ${record.worktree} was re-created on a fresh ${record.branch} from ${base.ref} ${base.sha}; commits the conversation mentions may be merged or gone`;
+  return [fresh, ...inherited];
+}
+function checkRecordPlacement(record, basePath) {
+  const base = path4.resolve(record.gitRoot, basePath) + path4.sep;
+  if (!path4.resolve(record.worktree).startsWith(base))
+    throw new Error(`recorded worktree ${record.worktree} is not under ${base}; not re-created`);
+}
+async function checkReattachable(record, opts) {
+  const { gitRoot, worktree, branch } = record;
+  checkRecordPlacement(record, basePathOf(opts));
+  if (existsSync3(worktree)) throw new WorktreeInUseError(branch, worktree);
+  await pruneStaleWorktrees(gitRoot);
+  const allocated = await allocatedPaths(gitRoot, basePathOf(opts));
+  const budget = budgetOf(opts);
+  if (allocated.length >= budget) throw new WorktreeBudgetExhaustedError(allocated.length, budget);
+  const holder = await checkoutOf(gitRoot, branch);
+  if (holder !== null) throw new WorktreeInUseError(branch, holder);
+}
+async function reattachWorktree(record, opts = {}, requireBranch = false) {
+  const { gitRoot, worktree, branch } = record;
+  await checkReattachable(record, opts);
+  const timeoutMs = opts.fetchTimeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS;
+  const base = await resolveBranchBase(gitRoot, timeoutMs);
+  const source = await branchSource(gitRoot, branch, timeoutMs);
+  if (source === "fresh" && requireBranch)
+    throw new Error(
+      `branch ${branch} no longer exists locally or on origin, so the adopted worktree ${worktree} was not re-created on a fresh one`
+    );
+  await addForSource(
+    record,
+    source,
+    base.sha,
+    boundedAdd(opts.runWorktreeAdd, opts.addTimeoutMs ?? WORKTREE_ADD_TIMEOUT_MS)
+  );
+  copyClaudeDir(gitRoot, worktree);
+  const warnings = [
+    ...reattachWarnings(record, source, base),
+    ...await runWorktreeSetup(setupTarget(gitRoot, worktree, base), opts.runSetup)
+  ];
+  return {
+    cwd: worktree,
+    note: `Your worktree at ${worktree} had been removed and was re-created on branch ${branch}. Commit your work there; nothing outside it is yours to change.`,
+    ref: { branch, worktree, gitRoot, base: base.sha, base_ref: base.ref, reattached: source },
+    ...warnings.length === 0 ? {} : { warnings }
+  };
+}
+async function readoptWorktree(record, opts) {
+  const allocation = await reattachWorktree(record, opts, true);
+  return {
+    ...allocation,
+    note: `The worktree assigned to this task at ${record.worktree} had been removed and was re-created on branch ${record.branch}. You may be sharing it with other agents, so stay inside the paths you were given.`,
+    ref: { ...allocation.ref, assigned: "true" }
+  };
+}
+function recreateWorktree(record, opts = {}) {
+  return record.adopted === true ? readoptWorktree(record, opts) : reattachWorktree(record, opts);
+}
+
+// src/release-safety.ts
+import { execFile as execFile3 } from "child_process";
+import { existsSync as existsSync4 } from "fs";
+import { promisify as promisify3 } from "util";
+var execFileAsync3 = promisify3(execFile3);
+async function landingTargets(gitRoot) {
+  const head = await gitOrNull(["symbolic-ref", "--quiet", "--short", "HEAD"], gitRoot);
+  const remoteHead = await gitOrNull(["rev-parse", "--verify", "--quiet", "origin/HEAD"], gitRoot);
+  return [head ?? "HEAD", ...remoteHead === null ? [] : ["origin/HEAD"]];
+}
+async function hasLanded(gitRoot, branch, target) {
+  if (await gitOrNull(["diff", "--quiet", target, branch], gitRoot) !== null) return true;
+  const base = await gitOrNull(["merge-base", target, branch], gitRoot);
+  if (base === null) return false;
+  const files = await gitOrNull(["diff", "--no-renames", "--name-only", base, branch], gitRoot);
+  if (files === null) return false;
+  const touched = files.split("\n").filter(Boolean);
+  if (touched.length === 0) return true;
+  return await gitOrNull(["diff", "--quiet", target, branch, "--", ...touched], gitRoot) !== null;
+}
+async function landedOn(gitRoot, branch, targets) {
+  for (const target of targets) {
+    if (await hasLanded(gitRoot, branch, target)) return target;
+  }
+  return null;
+}
+var GH_TIMEOUT_MS = 3e3;
+async function ghPrState(gitRoot, branch) {
+  try {
+    const { stdout } = await execFileAsync3("gh", ["pr", "view", branch, "--json", "state", "--jq", ".state"], {
+      cwd: gitRoot,
+      encoding: "utf8",
+      timeout: GH_TIMEOUT_MS
+    });
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+function dirtyCheck(dirty) {
+  return { name: "dirty", ok: !dirty, detail: dirty ? "uncommitted changes in the worktree" : "worktree clean" };
+}
+function pushedCheck(ahead, compareTo) {
+  if (ahead === null) return { name: "pushed", ok: false, detail: `could not count commits against ${compareTo}` };
+  return { name: "pushed", ok: ahead === 0, detail: `${ahead} commit(s) not on ${compareTo}` };
+}
+function landedCheck(target, targets) {
+  return target === null ? { name: "landed", ok: false, detail: `work not landed on ${targets.join(" or ")}` } : { name: "landed", ok: true, detail: `work landed on ${target}` };
+}
+async function commitsAhead(gitRoot, branch, baseRef) {
+  const remote = await gitOrNull(["rev-parse", "--verify", `origin/${branch}`], gitRoot);
+  const compareTo = remote === null ? baseRef : `origin/${branch}`;
+  const count = await gitOrNull(["rev-list", "--count", `${compareTo}..${branch}`], gitRoot);
+  return [count === null ? null : Number.parseInt(count, 10), compareTo];
+}
+async function inspectForRelease(gitRoot, worktreePath, branch, baseRef) {
+  const status = existsSync4(worktreePath) ? await gitOrNull(["status", "--porcelain"], worktreePath) : null;
+  const dirty = (status ?? "").length > 0;
+  const checked = [dirtyCheck(dirty)];
+  if (await gitOrNull(["rev-parse", "--verify", branch], gitRoot) === null)
+    return { dirty, unmerged: false, landed: false, ahead: 0, checked };
+  const [ahead, compareTo] = await commitsAhead(gitRoot, branch, baseRef);
+  checked.push(pushedCheck(ahead, compareTo));
+  if (ahead === 0) return { dirty, unmerged: false, landed: false, ahead, checked };
+  const targets = await landingTargets(gitRoot);
+  const target = await landedOn(gitRoot, branch, targets);
+  checked.push(landedCheck(target, targets));
+  if (target === null) {
+    const state = await ghPrState(gitRoot, branch);
+    if (state !== null) checked.push({ name: "gh", ok: true, detail: `gh reports the PR as ${state}` });
+  }
+  return { dirty, unmerged: target === null, landed: target !== null, ahead, checked };
+}
+function describeRefusal(safety) {
+  const failed = safety.checked.filter((c) => !c.ok && !(c.name === "pushed" && safety.landed));
+  const advisory = safety.checked.filter((c) => c.name === "gh").map((c) => c.detail);
+  return [...failed.map((c) => c.detail), ...advisory].join("; ");
+}
+
+// src/allocator.ts
+async function resetTo(gitRoot, branch, worktreePath, opts) {
+  await gitOrNull(["worktree", "remove", "--force", worktreePath], gitRoot);
+  rmSync2(worktreePath, { recursive: true, force: true });
+  await gitOrNull(["branch", "-D", branch], gitRoot);
+  await addWorktree(gitRoot, ["worktree", "add", "-b", branch, worktreePath, opts.base], opts.run);
+}
+async function attachWorktree(gitRoot, branch, worktreePath, opts) {
+  if (await gitOrNull(["rev-parse", "--verify", branch], gitRoot) === null) {
+    await addWorktree(gitRoot, ["worktree", "add", "-b", branch, worktreePath, opts.base], opts.run);
+    return false;
+  }
+  if (opts.force) {
+    await resetTo(gitRoot, branch, worktreePath, opts);
+    return false;
+  }
+  const holder = await checkoutOf(gitRoot, branch);
+  if (holder !== null || existsSync5(worktreePath)) throw new WorktreeInUseError(branch, holder ?? worktreePath);
+  const safety = await inspectForRelease(gitRoot, worktreePath, branch, opts.base);
+  if (safety.unmerged) await addWorktree(gitRoot, ["worktree", "add", worktreePath, branch], opts.run);
+  else await resetTo(gitRoot, branch, worktreePath, opts);
+  return safety.unmerged;
+}
+async function refuseRelease(exitedAt, ref) {
+  if (exitedAt !== void 0 && Date.now() - exitedAt < RECLAIM_GRACE_MS)
+    return `agent exited less than ${RECLAIM_GRACE_MS / 1e3}s ago; inside the reclaim grace window`;
+  const safety = await inspectForRelease(ref.gitRoot, ref.worktree, ref.branch, ref.base);
+  return safety.dirty || safety.unmerged ? describeRefusal(safety) : null;
+}
+function recreateAssigned(assigned, record, opts) {
+  if (record === void 0 || path5.resolve(record.worktree) !== assigned)
+    throw new Error(
+      `assigned worktree ${assigned} does not exist, and there is no record of allocating it to re-create it from. Not spawned`
+    );
+  return readoptWorktree(record, opts);
+}
+async function adoptAssigned(req, gitRoot, opts) {
+  const assigned = path5.resolve(req.assignedWorktree);
+  if (!existsSync5(assigned)) return recreateAssigned(assigned, req.assignedRecord, opts);
+  const branch = await gitOrNull(["rev-parse", "--abbrev-ref", "HEAD"], assigned) ?? "HEAD";
+  return {
+    cwd: assigned,
+    note: `You are in a worktree assigned to this task at ${assigned}, on branch ${branch}. You may be sharing it with other agents, so stay inside the paths you were given.`,
+    ref: { branch, worktree: assigned, gitRoot, assigned: "true" }
+  };
+}
+async function check(req, opts) {
+  const gitRoot = await findGitRoot(req.baseCwd);
+  if (gitRoot === null)
+    return { refusals: [`${req.baseCwd} is not a git repository; worktree isolation needs one`], warnings: [] };
+  await pruneStaleWorktrees(gitRoot);
+  const allocated = await allocatedPaths(gitRoot, basePathOf(opts));
+  const budget = budgetOf(opts);
+  const refusals = allocated.length >= budget ? [`worktree budget exhausted: ${allocated.length}/${budget} allocated under ${basePathOf(opts)}`] : [];
+  const branch = branchFor(req.agentName, opts);
+  const exists = await gitOrNull(["rev-parse", "--verify", branch], gitRoot) !== null;
+  const warnings = exists ? [`branch ${branch} already exists; it will be adopted if it holds commits, reset if it does not`] : [];
+  return { refusals, warnings };
+}
+async function allocate(req, opts) {
+  const gitRoot = await findGitRoot(req.baseCwd);
+  if (gitRoot === null) throw new Error(`${req.baseCwd} is not a git repository`);
+  if (req.assignedWorktree !== void 0) return adoptAssigned(req, gitRoot, opts);
+  await pruneStaleWorktrees(gitRoot);
+  const allocated = await allocatedPaths(gitRoot, basePathOf(opts));
+  const budget = budgetOf(opts);
+  if (allocated.length >= budget) throw new WorktreeBudgetExhaustedError(allocated.length, budget);
+  const branch = branchFor(req.agentName, opts);
+  const worktreePath = path5.resolve(gitRoot, basePathOf(opts), slug(req.agentName));
+  const base = await resolveBranchBase(gitRoot, opts.fetchTimeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS);
+  const reused = await attachWorktree(gitRoot, branch, worktreePath, {
+    base: base.sha,
+    force: req.forceReset === true,
+    run: boundedAdd(opts.runWorktreeAdd, opts.addTimeoutMs ?? WORKTREE_ADD_TIMEOUT_MS)
+  });
+  copyClaudeDir(gitRoot, worktreePath);
+  const warnings = [
+    ...base.warning === void 0 ? [] : [base.warning],
+    ...await runWorktreeSetup(setupTarget(gitRoot, worktreePath, base), opts.runSetup)
+  ];
+  const carried = reused ? " It already carries commits from an earlier run under this name." : "";
+  return {
+    cwd: worktreePath,
+    note: `You are on branch ${branch} in an isolated worktree at ${worktreePath}.${carried} Commit your work there; nothing outside it is yours to change.`,
+    ref: {
+      branch,
+      worktree: worktreePath,
+      gitRoot,
+      base: base.sha,
+      base_ref: base.ref,
+      ...reused ? { reused: "true" } : {}
+    },
+    ...warnings.length === 0 ? {} : { warnings }
+  };
+}
+async function release(req, alloc, opts = {}) {
+  const ref = alloc.ref;
+  if (!ref?.branch || !ref.worktree || !ref.gitRoot)
+    return { released: false, refusal: "allocation carries no worktree reference" };
+  const { branch, worktree, gitRoot } = ref;
+  if (ref.assigned === "true") return { released: true };
+  if (!opts.force) {
+    const refusal = await refuseRelease(req.exitedAt, { gitRoot, worktree, branch, base: ref.base ?? "HEAD" });
+    if (refusal !== null) return { released: false, refusal };
+  }
+  await removeWorktree(gitRoot, worktree, branch);
+  return { released: true };
+}
+function createWorktreeAllocator(opts = {}) {
+  return {
+    check: (req) => check(req, opts),
+    allocate: (req) => allocate(req, opts),
+    release
+  };
+}
+
+// src/park.ts
+async function unpushed(target) {
+  const { worktree, branch } = target;
+  if (await gitOrNull(["remote", "get-url", "origin"], worktree) === null) return void 0;
+  if (await gitOrNull(["rev-parse", "--verify", "--quiet", `origin/${branch}`], worktree) === null)
+    return `${branch} is not on origin; push it first`;
+  const ahead = await gitOrNull(["rev-list", `origin/${branch}..HEAD`], worktree);
+  if (ahead === null) return `could not compare ${worktree} with origin/${branch}`;
+  const count = ahead.split("\n").filter(Boolean).length;
+  return count === 0 ? void 0 : `${count} commit(s) in ${worktree} are not on origin/${branch}; push first`;
+}
+async function offBranch(target) {
+  const head = await gitOrNull(["symbolic-ref", "--quiet", "--short", "HEAD"], target.worktree);
+  if (head === target.branch) return void 0;
+  const where = head === null ? "detached" : `on ${head}`;
+  return `HEAD in ${target.worktree} is ${where}, not on ${target.branch}; check out ${target.branch} first`;
+}
+var REGENERABLE_DIRS = ["node_modules", "dist", "coverage", ".turbo"];
+var isRegenerable = (entry) => {
+  const segments = entry.split("/").filter(Boolean);
+  return segments[0] === ".claude" || segments.some((segment) => REGENERABLE_DIRS.includes(segment));
+};
+async function unsaved(worktree) {
+  const status = await gitOrNull(["status", "--porcelain", "-uall"], worktree);
+  if (status === null) return `could not read git status in ${worktree}`;
+  if (status !== "") return `uncommitted or untracked changes in ${worktree}`;
+  const ignored = await gitOrNull(["ls-files", "--others", "--ignored", "--exclude-standard", "--directory"], worktree);
+  if (ignored === null) return `could not list ignored files in ${worktree}`;
+  const kept = ignored.split("\n").filter((entry) => entry !== "" && !isRegenerable(entry));
+  if (kept.length === 0) return void 0;
+  return `ignored files in ${worktree} would be deleted (${kept.slice(0, 3).join(", ")}); park removes only ignored ${REGENERABLE_DIRS.join(", ")} and a top-level .claude`;
+}
+async function parkWorktree(target, recheck = () => void 0) {
+  const refusal = await offBranch(target) ?? await unsaved(target.worktree) ?? await unpushed(target);
+  if (refusal) return { ok: false, reason: refusal };
+  const head = await gitText(["rev-parse", "HEAD"], target.worktree);
+  const late = recheck();
+  if (late) return { ok: false, reason: late };
+  try {
+    await gitText(["worktree", "remove", target.worktree], target.gitRoot);
+  } catch (err) {
+    const detail = String(err.stderr || err.message).trim();
+    return { ok: false, reason: `git would not remove ${target.worktree}: ${detail.split("\n")[0]}` };
+  }
+  return { ok: true, head };
+}
+
+// src/sweep.ts
+import { execFileSync } from "child_process";
+import path6 from "path";
+var porcelain = async (gitRoot) => execFileSync("git", ["worktree", "list", "--porcelain"], { cwd: gitRoot, encoding: "utf8", env: gitChildEnv() });
+var parseBlock = (block) => ({
+  worktree: block.match(/^worktree (.+)$/m)?.[1]?.trim(),
+  branch: block.match(/^branch refs\/heads\/(.+)$/m)?.[1]?.trim(),
+  locked: /^locked/m.test(block)
+});
+async function agentWorktreesIn(gitRoot, list = porcelain, branchPrefix = branchPrefixOf({})) {
+  const out = await list(gitRoot).catch(() => "");
+  return out.split("\n\n").map(parseBlock).filter((e) => e.worktree !== void 0 && e.branch !== void 0).filter((e) => !e.locked && e.branch.startsWith(branchPrefix)).map(({ worktree, branch }) => ({ worktree: path6.resolve(worktree), branch }));
+}
+var isLive = (state) => state === "live" || state === "spawning";
+function classifyByOwner(owner, now) {
+  if (owner === void 0) return void 0;
+  if (isLive(owner.state)) return { status: "held", detail: `${owner.name} is ${owner.state}` };
+  const since = now - (owner.exitedAt ?? owner.lastEventAt);
+  if (since >= RECLAIM_GRACE_MS) return void 0;
+  return {
+    status: "in-grace",
+    detail: `${owner.name} stopped ${Math.round(since / 1e3)}s ago; reclaimable after ${RECLAIM_GRACE_MS / 1e3}s`
+  };
+}
+function idleDetail(owner) {
+  return owner === void 0 ? "no agent in the log claims this branch, and it holds nothing" : `${owner.name} is ${owner.state}, and it holds nothing`;
+}
+async function classify(found, owner, base, now) {
+  const agent = owner && {
+    agentId: owner.agentId,
+    name: owner.name,
+    state: owner.state,
+    lastEventAt: owner.lastEventAt
+  };
+  const withAgent = { ...found, ...agent ? { agent } : {} };
+  const byOwner = classifyByOwner(owner, now);
+  if (byOwner) return { ...withAgent, ...byOwner };
+  const safety = await inspectForRelease(found.gitRoot, found.worktree, found.branch, base);
+  if (!safety.dirty && !safety.unmerged) return { ...withAgent, status: "reclaimable", detail: idleDetail(owner) };
+  const detail = [safety.dirty && "uncommitted changes", safety.unmerged && "commits that exist nowhere else"].filter(Boolean).join(" and ");
+  return { ...withAgent, status: "holds-work", detail };
+}
+async function sweepWorktrees(options = {}) {
+  const now = (options.now ?? Date.now)();
+  const held = new Map((options.held ?? []).map((h) => [h.branch, h]));
+  const roots = /* @__PURE__ */ new Set([...options.roots ?? [], ...[...held.values()].map((h) => h.gitRoot)]);
+  const prefix = options.branchPrefix ?? branchPrefixOf({});
+  const swept = [];
+  for (const gitRoot of roots) {
+    for (const { worktree, branch } of await agentWorktreesIn(gitRoot, options.list ?? porcelain, prefix)) {
+      const found = { gitRoot, worktree, branch };
+      swept.push(await classify(found, options.ownerOf?.(found), held.get(branch)?.base ?? "HEAD", now));
+    }
+  }
+  return swept;
+}
+async function reclaimWorktree(entry, options = {}) {
+  if (entry.status !== "reclaimable" && options.force !== true)
+    return { ok: false, reason: `${entry.branch} is ${entry.status}: ${entry.detail}` };
+  await removeWorktree(entry.gitRoot, entry.worktree, entry.branch);
+  return { ok: true };
+}
+export {
+  BRANCH_PREFIX,
+  DEFAULT_BASE_PATH,
+  DEFAULT_FETCH_TIMEOUT_MS,
+  DEFAULT_SETUP_TIMEOUT_MS,
+  DEFAULT_STRIPPED_ENV_PREFIXES,
+  DEFAULT_WORKTREE_BUDGET,
+  OriginUnreachableError,
+  RECLAIM_GRACE_MS,
+  SETUP_FILE,
+  SETUP_LOG,
+  WORKTREE_ADD_TIMEOUT_MS,
+  WorktreeBudgetExhaustedError,
+  WorktreeInUseError,
+  agentWorktreesIn,
+  createWorktreeAllocator,
+  describeRefusal,
+  findGitRoot,
+  gitChildEnv,
+  inspectForRelease,
+  isLive,
+  observedPresence,
+  parkWorktree,
+  parseSetupStep,
+  pruneStaleWorktrees,
+  reattachWorktree,
+  reclaimWorktree,
+  recreateWorktree,
+  resolveBranchBase,
+  runGit,
+  runSetupCommand,
+  runWorktreeSetup,
+  setupEnv,
+  sweepWorktrees
+};
+//# sourceMappingURL=index.js.map