@agentproto/worktree 0.8.0 → 0.9.0

package/dist/index.mjs

@@ -1,16 +1,17 @@
-export { connectDaemonAgentSessionHost, makeDaemonAgentSessionHost, worktreeAgentInputSchema, worktreeAgentWorkflow } from './chunk-AGIUUFLI.mjs';
+export { connectDaemonAgentSessionHost, makeDaemonAgentSessionHost, worktreeAgentInputSchema, worktreeAgentWorkflow } from './chunk-6EV7WP2U.mjs';
 import './chunk-E3EM24BS.mjs';
-import { computeProvenance, execArgv, classify, computeWorktreeStatus, listGitWorktrees, execGit, worktreeProvider } from './chunk-AFS6W62Z.mjs';
-export { CONFIG_FILENAME, ConfigError, DEFAULT_PROXY_PORT, ENV_VARS, FileVerdictMemoStore, HookError, InMemoryVerdictMemoStore, ProxyTable, SESSIONS_BUCKETS_ROOT, SESSIONS_FILE_PATH, ServiceSupervisor, VERDICT_MEMO_PATH, WORKTREES_TURBO_CACHE_DIR_ENV, WorktreeNotRemovableError, allocatePort, classify, computeLiveness, computeProvenance, computeTreeState, computeWorktreeStatus, detectDefaultBranch, disposeSupervisor, ephemeralPort, execArgv, execGit, execShell, expandGlob, getScript, getSupervisor, globToRegExp, hookEnv, isPortFree, listGitWorktrees, listScripts, listServices, listWorktreeStatuses, loadConfigFromBase, normalizeHook, parseConfig, peerEnv, peerEnvKey, readSessionsRegistry, readWorktreeMarker, reconcileIntegration, repoLabel, resolveSupervisor, resolveWorktreesTurboCacheDir, runSetup, runTeardown, serviceEnv, serviceEnvToken, serviceHostname, serviceUrl, sessionInWorktree, sharedProxyTable, slugify, stripPort, worktreeProvider, writeWorktreeMarker } from './chunk-AFS6W62Z.mjs';
+import { computeProvenance, execArgv, classify, computeWorktreeStatus, listGitWorktrees, execGit, worktreeProvider } from './chunk-KRQFVJPK.mjs';
+export { CONFIG_FILENAME, ConfigError, DEFAULT_PROXY_PORT, ENV_VARS, FileVerdictMemoStore, HookError, InMemoryVerdictMemoStore, ProxyTable, SESSIONS_BUCKETS_ROOT, SESSIONS_FILE_PATH, ServiceSupervisor, VERDICT_MEMO_PATH, WORKTREES_TURBO_CACHE_DIR_ENV, WorktreeNotRemovableError, allocatePort, classify, computeBaseDivergence, computeLiveness, computeProvenance, computeTreeState, computeWorktreeStatus, detectDefaultBranch, disposeSupervisor, ephemeralPort, execArgv, execGit, execShell, expandGlob, getScript, getSupervisor, globToRegExp, hookEnv, isPortFree, listGitWorktrees, listScripts, listServices, listWorktreeStatuses, loadConfigFromBase, normalizeHook, parseConfig, peerEnv, peerEnvKey, readSessionsRegistry, readWorktreeMarker, reconcileIntegration, repoLabel, resolveSupervisor, resolveWorktreesTurboCacheDir, runSetup, runTeardown, serviceEnv, serviceEnvToken, serviceHostname, serviceUrl, sessionInWorktree, sharedProxyTable, slugify, stripPort, worktreeProvider, writeWorktreeMarker } from './chunk-KRQFVJPK.mjs';
 import { cleanupWorktreeTool } from './chunk-IKCBL2UN.mjs';
 export { cleanupWorktreeTool, listServicesTool, provisionWorktreeTool, runGateTool, runScriptTool, serviceStatusSchema, startServiceTool, stopServiceTool } from './chunk-IKCBL2UN.mjs';
-import { mkdir, copyFile, writeFile, open, readdir, realpath, rm, readFile, stat } from 'fs/promises';
+import { mkdir, copyFile, readFile, writeFile, open, rename, readdir, realpath, rm, stat } from 'fs/promises';
 import { homedir } from 'os';
 import { resolve, join, dirname, basename, sep, relative, isAbsolute } from 'path';
 import http from 'http';
 import { connect } from 'net';
 import { z } from 'zod';
 import { runTool } from '@agentproto/driver';
+import { spawn } from 'child_process';
 
 /**
  * @agentproto/worktree v0.1.0
@@ -149,12 +150,12 @@ function startProxy(table, port = 0) {
     sockets.add(socket);
     socket.once("close", () => sockets.delete(socket));
   });
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     server.once("error", reject);
     server.listen(port, () => {
       const address = server.address();
       const boundPort = address && typeof address === "object" ? address.port : port;
-      resolve3({
+      resolve4({
         port: boundPort,
         server,
         close: () => new Promise((res) => {
@@ -186,6 +187,12 @@ var UnreachableForgeClient = class {
   async ensurePullHeadFetched() {
     throw new ForgeUnavailableError(this.reason);
   }
+  async listOpenPullRequests() {
+    throw new ForgeUnavailableError(this.reason);
+  }
+  async listMergedPullRequests() {
+    throw new ForgeUnavailableError(this.reason);
+  }
 };
 var ghPrListItemSchema = z.object({
   number: z.number(),
@@ -290,6 +297,16 @@ var GhCliForgeClient = class {
     }
     return this.parseOutput(result.stdout, ghApiCommitPullListSchema, args).map(normalizeGhApiCommitPull);
   }
+  async listOpenPullRequests() {
+    const args = ["pr", "list", "--state", "open", "--limit", "1000", "--json", "number,state,headRefName,headRefOid,mergedAt"];
+    const stdout = await this.run(args);
+    return this.parseOutput(stdout, ghPrListSchema, args).map(normalizeGhPrListItem);
+  }
+  async listMergedPullRequests() {
+    const args = ["pr", "list", "--state", "merged", "--limit", "1000", "--json", "number,state,headRefName,headRefOid,mergedAt"];
+    const stdout = await this.run(args);
+    return this.parseOutput(stdout, ghPrListSchema, args).map(normalizeGhPrListItem);
+  }
   async ensurePullHeadFetched(prNumber, oid) {
     const check = await execArgv("git", ["-C", this.repoRoot, "cat-file", "-e", `${oid}^{commit}`], this.repoRoot);
     if (check.exitCode === 0) return;
@@ -323,7 +340,7 @@ function normalizeRestPr(item) {
   };
 }
 function parseGithubOwnerRepo(remoteUrl) {
-  const ssh = remoteUrl.match(/^git@github\.com:([^/]+)\/(.+?)(\.git)?$/);
+  const ssh = remoteUrl.match(/^git@github\.com(?:-[\w.-]+)?:([^/]+)\/(.+?)(\.git)?$/);
   if (ssh?.[1] && ssh[2]) return { owner: ssh[1], repo: ssh[2] };
   const https = remoteUrl.match(/^https:\/\/github\.com\/([^/]+)\/(.+?)(\.git)?\/?$/);
   if (https?.[1] && https[2]) return { owner: https[1], repo: https[2] };
@@ -385,6 +402,32 @@ var RestForgeClient = class {
     }
     return this.pullRequestList(res);
   }
+  async listOpenPullRequests() {
+    const all = [];
+    for (let page = 1; page <= 10; page++) {
+      const res = await this.get(`/repos/${this.owner}/${this.repo}/pulls?state=open&per_page=100&page=${page}`);
+      if (!res.ok) {
+        throw new ForgeUnavailableError(`GitHub REST pulls?state=open failed: ${res.status} ${res.statusText}`);
+      }
+      const batch = await this.pullRequestList(res);
+      all.push(...batch);
+      if (batch.length < 100) break;
+    }
+    return all;
+  }
+  async listMergedPullRequests() {
+    const all = [];
+    for (let page = 1; page <= 10; page++) {
+      const res = await this.get(`/repos/${this.owner}/${this.repo}/pulls?state=closed&per_page=100&page=${page}`);
+      if (!res.ok) {
+        throw new ForgeUnavailableError(`GitHub REST pulls?state=closed failed: ${res.status} ${res.statusText}`);
+      }
+      const batch = await this.pullRequestList(res);
+      all.push(...batch);
+      if (batch.length < 100) break;
+    }
+    return all.filter((pr) => pr.merged);
+  }
   async ensurePullHeadFetched(prNumber, oid) {
     const check = await execArgv("git", ["-C", this.repoRoot, "cat-file", "-e", `${oid}^{commit}`], this.repoRoot);
     if (check.exitCode === 0) return;
@@ -420,6 +463,698 @@ async function createForgeClient(repoRoot) {
     "no usable forge client: `gh` is not installed/authenticated and GITHUB_TOKEN is not set (or origin isn't a GitHub remote)"
   );
 }
+var BRANCH_GC_SCOPES = ["local", "remote", "orphan"];
+function git(repoRoot, args, env) {
+  return execArgv("git", ["-C", repoRoot, ...args], repoRoot, {});
+}
+async function gitOk(repoRoot, args) {
+  const res = await git(repoRoot, args);
+  if (res.exitCode !== 0) {
+    throw new Error(`git ${args.join(" ")} failed (exit ${res.exitCode}): ${res.stderr.trim() || res.stdout.trim()}`);
+  }
+  return res.stdout;
+}
+async function pool(items, n, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const i = next++;
+      results[i] = await fn(items[i]);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(n, items.length) }, worker));
+  return results;
+}
+function chunk(items, size) {
+  const out = [];
+  for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
+  return out;
+}
+var basenameOf = (p) => p.slice(p.lastIndexOf("/") + 1);
+async function indexTree(repoRoot, sha) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const rec of (await gitOk(repoRoot, ["ls-tree", "-r", "-z", sha])).split("\0")) {
+    const tab = rec.indexOf("	");
+    if (tab < 0) continue;
+    const blob = rec.slice(0, tab).split(" ")[2];
+    if (blob) byPath.set(rec.slice(tab + 1), blob);
+  }
+  const names = new Set([...byPath.keys()].map(basenameOf));
+  return { byPath, blobs: new Set(byPath.values()), names };
+}
+async function createLadderContext(repoRoot, baseRef, anchor, related) {
+  const baseSha = (await gitOk(repoRoot, ["rev-parse", "--verify", `${baseRef}^{commit}`])).trim();
+  const baseTree = (await gitOk(repoRoot, ["rev-parse", `${baseSha}^{tree}`])).trim();
+  let idx = null;
+  return {
+    repoRoot,
+    baseSha,
+    baseTree,
+    anchor,
+    index: () => idx ??= indexTree(repoRoot, baseSha),
+    ...related ? { related } : {}
+  };
+}
+async function sharesHistory(repoRoot, baseSha, tip) {
+  return (await git(repoRoot, ["merge-base", baseSha, tip])).exitCode === 0;
+}
+var NULL_SHA_RE = /^0+$/;
+async function changedBlobs(repoRoot, mergeBase, tip) {
+  const out = await gitOk(repoRoot, ["diff", "--raw", "-z", "--no-abbrev", "--no-renames", mergeBase, tip]);
+  const parts = out.split("\0");
+  const changed = /* @__PURE__ */ new Map();
+  for (let i = 0; i + 1 < parts.length; i += 2) {
+    const meta = parts[i] ?? "";
+    const path = parts[i + 1] ?? "";
+    if (!meta.startsWith(":") || !path) continue;
+    const dst = meta.slice(1).split(" ")[3] ?? "";
+    changed.set(path, NULL_SHA_RE.test(dst) ? null : dst);
+  }
+  return changed;
+}
+function gitWithInput(repoRoot, args, input) {
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn("git", ["-C", repoRoot, ...args], { cwd: repoRoot, stdio: ["pipe", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (d) => stdout += d.toString("utf8"));
+    child.stderr.on("data", (d) => stderr += d.toString("utf8"));
+    child.on("error", reject);
+    child.on("close", (code) => resolvePromise({ exitCode: code ?? -1, stdout, stderr }));
+    child.stdin.end(input);
+  });
+}
+async function ignoredPaths(repoRoot, paths) {
+  const res = await gitWithInput(repoRoot, ["check-ignore", "--no-index", "--stdin", "-z"], paths.join("\0") + "\0");
+  if (res.exitCode !== 0 && res.exitCode !== 1) return /* @__PURE__ */ new Set();
+  return new Set(res.stdout.split("\0").filter(Boolean));
+}
+async function coverage(ctx, tip, mergeBase) {
+  const idx = await ctx.index();
+  const changed = await changedBlobs(ctx.repoRoot, mergeBase, tip);
+  const c = { residual: 0, covered: 0, ignored: 0, evolved: 0, unique: 0, deletes: 0, evolvedFiles: [], uniqueFiles: [], deletedFiles: [] };
+  const pending = [];
+  for (const [p, tipBlob] of changed) {
+    const baseBlob = idx.byPath.get(p) ?? null;
+    if (tipBlob === baseBlob) continue;
+    c.residual++;
+    if (tipBlob === null) c.deletedFiles.push(p);
+    else if (idx.blobs.has(tipBlob)) c.covered++;
+    else pending.push(p);
+  }
+  const ignored = pending.length ? await ignoredPaths(ctx.repoRoot, pending) : /* @__PURE__ */ new Set();
+  for (const p of pending) {
+    if (ignored.has(p)) c.ignored++;
+    else if (idx.names.has(basenameOf(p))) c.evolvedFiles.push(p);
+    else c.uniqueFiles.push(p);
+  }
+  c.evolved = c.evolvedFiles.length;
+  c.unique = c.uniqueFiles.length;
+  c.deletes = c.deletedFiles.length;
+  return c;
+}
+async function classifyTip(ctx, tip) {
+  const { repoRoot, baseSha, baseTree, anchor } = ctx;
+  const related = ctx.related?.get(tip) ?? await sharesHistory(repoRoot, baseSha, tip);
+  if (!related && !anchor) return { status: "unmerged", history: "unrelated", conflicts: true, ahead: null, behind: null };
+  const history = related ? "current" : "pre-rewrite";
+  const cmp = related ? baseSha : anchor;
+  if ((await git(repoRoot, ["merge-base", "--is-ancestor", tip, cmp])).exitCode === 0) {
+    return { status: "merged", history, ahead: 0, behind: null };
+  }
+  const counts = (await gitOk(repoRoot, ["rev-list", "--left-right", "--count", `${cmp}...${tip}`])).trim().split(/\s+/);
+  const behind = Number(counts[0]);
+  const ahead = Number(counts[1]);
+  const mergeBase = (await git(repoRoot, ["merge-base", cmp, tip])).stdout.trim();
+  const mtArgs = related ? [baseSha, tip] : [`--merge-base=${mergeBase}`, baseSha, tip];
+  const mt = await git(repoRoot, ["merge-tree", "--write-tree", "--no-messages", ...mtArgs]);
+  const mergedTree = (mt.stdout.split("\n")[0] ?? "").trim();
+  const conflicts = mt.exitCode !== 0;
+  if (!conflicts && mergedTree === baseTree) return { status: "squash-merged", history, ahead, behind, conflicts };
+  if (conflicts) {
+    const cherry = await gitOk(repoRoot, ["cherry", cmp, tip]);
+    if (!cherry.split("\n").some((l) => l.startsWith("+"))) return { status: "patch-merged", history, ahead, behind, conflicts };
+  }
+  const cov = await coverage(ctx, tip, mergeBase);
+  const summary = {
+    residual: cov.residual,
+    covered: cov.covered,
+    ignored: cov.ignored,
+    evolved: cov.evolved,
+    unique: cov.unique,
+    deletes: cov.deletes
+  };
+  if (cov.evolved + cov.unique + cov.deletes === 0) {
+    return { status: "content-merged", history, ahead, behind, conflicts, coverage: summary };
+  }
+  const residualFiles = [...cov.uniqueFiles, ...cov.evolvedFiles, ...cov.deletedFiles];
+  return {
+    status: "unmerged",
+    history,
+    ahead,
+    behind,
+    conflicts,
+    compareBase: cmp,
+    mergeBase,
+    mergedTree: conflicts ? null : mergedTree,
+    coverage: summary,
+    residualFiles: residualFiles.slice(0, 200),
+    residualFileCount: residualFiles.length
+  };
+}
+var contextCache = /* @__PURE__ */ new Map();
+async function classifyTipAgainstBase(repoRoot, baseRef, tip) {
+  const baseSha = (await gitOk(repoRoot, ["rev-parse", "--verify", `${baseRef}^{commit}`])).trim();
+  const key = `${repoRoot}\0${baseSha}`;
+  let ctx = contextCache.get(key);
+  if (!ctx) {
+    ctx = createLadderContext(repoRoot, baseSha, null);
+    contextCache.set(key, ctx);
+    ctx.catch(() => contextCache.delete(key));
+  }
+  return classifyTip(await ctx, tip);
+}
+async function detectAnchor(repoRoot, baseSha, tips, related) {
+  const roots = (await gitOk(repoRoot, ["rev-list", "--max-parents=0", baseSha])).trim().split("\n").filter(Boolean);
+  if (roots.length !== 1) return null;
+  const root = roots[0];
+  const unique = [...new Set(tips)];
+  const shares = await pool(unique, 8, (sha) => sharesHistory(repoRoot, baseSha, sha));
+  const unrelated = unique.filter((_, i) => !shares[i]);
+  if (related) unique.forEach((sha, i) => related.set(sha, shares[i]));
+  if (!unrelated.length) return null;
+  const rootDate = (await gitOk(repoRoot, ["log", "-1", "--format=%cI", root])).trim();
+  const since = new Date(new Date(rootDate).getTime() - 3 * 864e5).toISOString();
+  const cands = (await gitOk(repoRoot, ["log", "--format=%H", `--since=${since}`, `--until=${rootDate}`, ...unrelated])).trim().split("\n").filter(Boolean).slice(0, 60);
+  let best = null;
+  for (const c of cands) {
+    const n = (await gitOk(repoRoot, ["diff", "--numstat", c, root])).trim().split("\n").filter(Boolean).length;
+    if (!best || n < best.n) best = { sha: c, n };
+  }
+  return best && best.n < 200 ? best.sha : null;
+}
+var PROTECTED_NAMES = /* @__PURE__ */ new Set(["main", "master", "develop", "HEAD", "gh-pages"]);
+async function configuredRemotes(repoRoot) {
+  return new Set((await gitOk(repoRoot, ["remote"])).trim().split("\n").filter(Boolean));
+}
+function baseRemoteOf(base, remotes) {
+  const slash = base.indexOf("/");
+  if (slash > 0 && remotes.has(base.slice(0, slash))) return base.slice(0, slash);
+  return remotes.has("origin") ? "origin" : null;
+}
+async function listBranchRefs(repoRoot, remote, remotes) {
+  const fmt = "%(refname)%09%(objectname)%09%(committerdate:iso-strict)%09%(authorname)%09%(subject)";
+  const out = await gitOk(repoRoot, ["for-each-ref", `--format=${fmt}`, "refs/heads", "refs/remotes"]);
+  const refs = [];
+  let otherRemoteRefs = 0;
+  for (const line of out.split("\n")) {
+    if (!line) continue;
+    const [ref = "", sha = "", date = "", author = "", ...subj] = line.split("	");
+    const rest = { ref, sha, date, author, subject: subj.join("	") };
+    let entry;
+    if (ref.startsWith("refs/heads/")) {
+      entry = { kind: "local", name: ref.slice("refs/heads/".length), ...rest };
+    } else {
+      const ns = ref.split("/")[2] ?? "";
+      if (remote && ns === remote) {
+        entry = { kind: "remote", name: ref.slice(`refs/remotes/${remote}/`.length), remote, ...rest };
+      } else if (remotes.has(ns)) {
+        otherRemoteRefs++;
+        continue;
+      } else {
+        entry = { kind: "orphan", name: ref.slice("refs/remotes/".length), ...rest };
+      }
+    }
+    if (entry.name === "HEAD" || entry.name.endsWith("/HEAD")) continue;
+    refs.push(entry);
+  }
+  return { refs, otherRemoteRefs };
+}
+async function worktreeBranches(repoRoot) {
+  const map = /* @__PURE__ */ new Map();
+  for (const w of await listGitWorktrees(repoRoot)) if (w.branch) map.set(w.branch, w.path);
+  return map;
+}
+async function openPrHeads(forge) {
+  if (!forge) return { available: false, reason: "no forge client", heads: /* @__PURE__ */ new Map() };
+  if (!forge.listOpenPullRequests) {
+    return { available: false, reason: "forge client cannot list open PRs", heads: /* @__PURE__ */ new Map() };
+  }
+  try {
+    const prs = await forge.listOpenPullRequests();
+    const heads = /* @__PURE__ */ new Map();
+    for (const pr of prs) if (pr.state === "open") heads.set(pr.headRefName, pr.number);
+    return { available: true, heads };
+  } catch (err) {
+    const reason = (err instanceof Error ? err.message : String(err)).split("\n")[0] ?? "forge error";
+    return { available: false, reason, heads: /* @__PURE__ */ new Map() };
+  }
+}
+async function mergedPrHeads(forge) {
+  if (!forge?.listMergedPullRequests) return /* @__PURE__ */ new Map();
+  try {
+    const heads = /* @__PURE__ */ new Map();
+    for (const pr of await forge.listMergedPullRequests()) heads.set(pr.headRefOid, pr.number);
+    return heads;
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+function holdFor(b, env) {
+  if (b.kind === "orphan") return null;
+  if (PROTECTED_NAMES.has(b.name) || b.name === env.baseName) return { holdReason: "protected" };
+  const wt = env.worktrees.get(b.name);
+  if (wt) return { holdReason: "worktree", holdDetail: wt };
+  const pr = env.prs.heads.get(b.name);
+  if (pr !== void 0) return { holdReason: "open-pr", holdDetail: `PR #${pr}` };
+  if (!env.prs.available) return { holdReason: "pr-check-unavailable", holdDetail: env.prs.reason };
+  return null;
+}
+async function pushStateOf(b, env) {
+  const { repoRoot } = env.ctx;
+  if (b.kind === "local") {
+    if (env.remoteShas.has(b.sha)) return "same-tip-on-remote";
+    if (env.remote) {
+      const contained = await git(repoRoot, ["for-each-ref", "--contains", b.sha, "--format=x", `refs/remotes/${env.remote}`]);
+      if (contained.stdout.trim()) return "contained-in-remote";
+    }
+    return env.remoteNames.has(b.name) ? "diverged-from-remote" : "local-only";
+  }
+  if (b.kind === "orphan") {
+    const scopes = ["refs/heads", ...env.remote ? [`refs/remotes/${env.remote}`] : []];
+    const contained = await git(repoRoot, ["for-each-ref", "--contains", b.sha, "--format=x", ...scopes]);
+    return contained.stdout.trim() ? "contained-elsewhere" : "only-copy";
+  }
+  return void 0;
+}
+async function classifyRef(b, env) {
+  let pending = env.tips.get(b.sha);
+  if (!pending) {
+    pending = classifyTip(env.ctx, b.sha);
+    env.tips.set(b.sha, pending);
+  }
+  const tip = await pending;
+  const ageDays = Math.floor((env.nowMs - new Date(b.date).getTime()) / 864e5);
+  const entry = { ...b, ...tip, ageDays, class: "hold" };
+  if (tip.status === "unmerged" && env.mergedPrShas.has(b.sha)) {
+    const pr = env.mergedPrShas.get(b.sha);
+    entry.status = "pr-merged";
+    entry.mergedPr = pr;
+  }
+  if (entry.status === "unmerged") {
+    const pushed = await pushStateOf(b, env);
+    if (pushed) entry.pushed = pushed;
+    const stored = env.verdicts ? await env.verdicts.get(env.repoName, b.sha) : null;
+    if (stored) {
+      entry.verdict = { triage: stored.triage.verdict, agree: stored.gate ? stored.gate.agree : null, reviewer: stored.reviewer };
+    }
+  }
+  const hold = holdFor(b, env);
+  if (hold) {
+    entry.holdReason = hold.holdReason;
+    if (hold.holdDetail) entry.holdDetail = hold.holdDetail;
+    return entry;
+  }
+  if (entry.status !== "unmerged") {
+    entry.class = "reclaim";
+    entry.reclaimReason = entry.status;
+    return entry;
+  }
+  if (ageDays < env.minAgeDays) {
+    entry.holdReason = "young";
+    entry.holdDetail = `${ageDays}d < ${env.minAgeDays}d`;
+    return entry;
+  }
+  if (env.includeReviewed && entry.verdict?.agree === true) {
+    entry.class = "reclaim";
+    entry.reclaimReason = "reviewed";
+    return entry;
+  }
+  entry.class = "review";
+  return entry;
+}
+async function snapshot(input) {
+  const remotes = await configuredRemotes(input.repoRoot);
+  const remote = baseRemoteOf(input.base, remotes);
+  const [{ refs, otherRemoteRefs }, worktrees, prs, mergedPrs] = await Promise.all([
+    listBranchRefs(input.repoRoot, remote, remotes),
+    worktreeBranches(input.repoRoot),
+    openPrHeads(input.forge),
+    mergedPrHeads(input.forge)
+  ]);
+  const baseSha = (await gitOk(input.repoRoot, ["rev-parse", "--verify", `${input.base}^{commit}`])).trim();
+  let anchor;
+  const related = /* @__PURE__ */ new Map();
+  if (input.anchor === "auto") anchor = await detectAnchor(input.repoRoot, baseSha, refs.map((r) => r.sha), related);
+  else if (input.anchor) anchor = (await gitOk(input.repoRoot, ["rev-parse", "--verify", `${input.anchor}^{commit}`])).trim();
+  else anchor = null;
+  const ctx = await createLadderContext(input.repoRoot, baseSha, anchor, related);
+  const remoteRefs = refs.filter((r) => r.kind === "remote");
+  return {
+    refs,
+    otherRemoteRefs,
+    env: {
+      ctx,
+      tips: /* @__PURE__ */ new Map(),
+      remote,
+      baseName: remote && input.base.startsWith(`${remote}/`) ? input.base.slice(remote.length + 1) : input.base,
+      worktrees,
+      prs,
+      mergedPrShas: mergedPrs,
+      remoteShas: new Set(remoteRefs.map((r) => r.sha)),
+      remoteNames: new Set(remoteRefs.map((r) => r.name)),
+      minAgeDays: input.minAgeDays,
+      includeReviewed: input.includeReviewed,
+      ...input.verdicts ? { verdicts: input.verdicts } : {},
+      repoName: input.repoName,
+      nowMs: input.nowMs
+    }
+  };
+}
+var DEFAULT_BRANCH_GC_MIN_AGE_DAYS = 3;
+function normalizeScopes(scopes) {
+  if (!scopes || scopes.length === 0) return [...BRANCH_GC_SCOPES];
+  for (const s of scopes) {
+    if (!BRANCH_GC_SCOPES.includes(s)) {
+      throw new Error(`branch gc: unknown scope "${s}" (expected ${BRANCH_GC_SCOPES.join(", ")})`);
+    }
+  }
+  return BRANCH_GC_SCOPES.filter((s) => scopes.includes(s));
+}
+async function planBranchGc(input) {
+  const base = input.base ?? "origin/main";
+  const scopes = normalizeScopes(input.scopes);
+  const minAgeDays = input.minAgeDays ?? DEFAULT_BRANCH_GC_MIN_AGE_DAYS;
+  const includeReviewed = Boolean(input.includeReviewed);
+  const nowMs = input.nowMs ?? Date.now();
+  const snap = await snapshot({
+    repoRoot: input.repoRoot,
+    repoName: input.repoName,
+    base,
+    anchor: input.anchor ?? "auto",
+    ...input.forge ? { forge: input.forge } : {},
+    ...input.verdicts ? { verdicts: input.verdicts } : {},
+    minAgeDays,
+    includeReviewed,
+    nowMs
+  });
+  const inScope = snap.refs.filter((r) => scopes.includes(r.kind));
+  const entries = await pool(inScope, input.concurrency ?? 8, (r) => classifyRef(r, snap.env));
+  return {
+    repoRoot: input.repoRoot,
+    repoName: input.repoName,
+    base,
+    baseSha: snap.env.ctx.baseSha,
+    baseTree: snap.env.ctx.baseTree,
+    remote: snap.env.remote,
+    anchor: snap.env.ctx.anchor,
+    prCheck: snap.env.prs.available ? { available: true } : { available: false, ...snap.env.prs.reason ? { reason: snap.env.prs.reason } : {} },
+    scopes,
+    minAgeDays,
+    includeReviewed,
+    generatedAt: new Date(nowMs).toISOString(),
+    otherRemoteRefs: snap.otherRemoteRefs,
+    entries
+  };
+}
+function summarizeBranchGcPlan(plan) {
+  const byClass = {};
+  const byStatus = {};
+  for (const k of BRANCH_GC_SCOPES) {
+    byClass[k] = { reclaim: 0, review: 0, hold: 0 };
+    byStatus[k] = {};
+  }
+  for (const e of plan.entries) {
+    byClass[e.kind][e.class]++;
+    const isProtected = e.holdReason === "protected" || e.holdReason === "worktree" || e.holdReason === "open-pr";
+    const key = isProtected ? "protected" : e.status;
+    byStatus[e.kind][key] = (byStatus[e.kind][key] ?? 0) + 1;
+  }
+  return { byClass, byStatus };
+}
+function branchReviewQueue(plan, options = {}) {
+  const bySha = /* @__PURE__ */ new Map();
+  for (const e of plan.entries) {
+    if (e.class !== "review") continue;
+    if (e.verdict && !options.all) continue;
+    const seen = bySha.get(e.sha);
+    if (seen) {
+      seen.refs.push(e.ref);
+      continue;
+    }
+    bySha.set(e.sha, {
+      name: e.name,
+      kind: e.kind,
+      sha: e.sha,
+      ageDays: e.ageDays,
+      author: e.author,
+      subject: e.subject,
+      history: e.history,
+      base: plan.baseSha,
+      ...e.compareBase ? { compareBase: e.compareBase } : {},
+      ...e.mergeBase ? { mergeBase: e.mergeBase } : {},
+      mergedTree: e.mergedTree ?? null,
+      ...e.conflicts !== void 0 ? { conflicts: e.conflicts } : {},
+      ahead: e.ahead,
+      behind: e.behind,
+      ...e.pushed ? { pushed: e.pushed } : {},
+      ...e.coverage ? { coverage: e.coverage } : {},
+      ...e.residualFiles ? { residualFiles: e.residualFiles } : {},
+      ...e.residualFileCount !== void 0 ? { residualFileCount: e.residualFileCount } : {},
+      refs: [e.ref],
+      ...e.verdict ? { verdict: e.verdict } : {}
+    });
+  }
+  return { base: plan.base, baseSha: plan.baseSha, anchor: plan.anchor, candidates: [...bySha.values()] };
+}
+var BRANCH_GC_STATE_DIR = () => resolve(homedir(), ".agentproto", "branch-gc");
+var shellQuote = (s) => /^[\w@%+=:,./-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`;
+function restoreEntry(repoRoot, e) {
+  const argv = e.kind === "local" ? ["branch", e.name, e.sha] : e.kind === "remote" ? ["push", e.remote, `${e.sha}:refs/heads/${e.name}`] : ["update-ref", e.ref, e.sha];
+  return {
+    kind: e.kind,
+    name: e.name,
+    ref: e.ref,
+    sha: e.sha,
+    ...e.remote ? { remote: e.remote } : {},
+    argv,
+    command: ["git", "-C", repoRoot, ...argv].map(shellQuote).join(" ")
+  };
+}
+async function writeJsonAtomic(path, value) {
+  await mkdir(dirname(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.tmp`;
+  await writeFile(tmp, JSON.stringify(value, null, 2) + "\n", "utf8");
+  await rename(tmp, path);
+}
+async function applyBranchGc(plan, options) {
+  if (!options.scopes || options.scopes.length === 0) {
+    throw new Error("branch gc apply: `scopes` is required (any of local, remote, orphan) \u2014 apply never defaults to every kind");
+  }
+  const scopes = normalizeScopes(options.scopes);
+  const { repoRoot } = plan;
+  const snap = await snapshot({
+    repoRoot,
+    repoName: plan.repoName,
+    base: plan.base,
+    anchor: plan.anchor,
+    ...options.forge ? { forge: options.forge } : {},
+    ...options.verdicts ? { verdicts: options.verdicts } : {},
+    minAgeDays: plan.minAgeDays,
+    includeReviewed: plan.includeReviewed,
+    nowMs: options.nowMs ?? Date.now()
+  });
+  const current = new Map(snap.refs.map((r) => [r.ref, r]));
+  const outcomes = [];
+  const confirmed = [];
+  for (const e of plan.entries) {
+    if (!scopes.includes(e.kind)) continue;
+    const id = { kind: e.kind, name: e.name, sha: e.sha };
+    if (e.class === "hold") {
+      outcomes.push({ ...id, result: "held", ...e.holdReason ? { holdReason: e.holdReason } : {} });
+      continue;
+    }
+    if (e.class === "review") {
+      outcomes.push({ ...id, result: "skipped-review" });
+      continue;
+    }
+    const fresh = current.get(e.ref);
+    if (!fresh) {
+      outcomes.push({ ...id, result: "aborted-vanished" });
+      continue;
+    }
+    if (fresh.sha !== e.sha) {
+      outcomes.push({ ...id, result: "aborted-moved", currentSha: fresh.sha });
+      continue;
+    }
+    const now = await classifyRef(fresh, snap.env);
+    if (now.class !== "reclaim") {
+      outcomes.push({
+        ...id,
+        result: "aborted-reclassified",
+        from: e.class,
+        to: now.class,
+        ...now.holdReason ? { holdReason: now.holdReason } : {}
+      });
+      continue;
+    }
+    confirmed.push(now);
+  }
+  if (confirmed.length === 0) return { outcomes, restoreLog: null };
+  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+  const log = {
+    schema: "branch-gc-restore/v1",
+    repoRoot,
+    base: plan.base,
+    baseSha: snap.env.ctx.baseSha,
+    createdAt,
+    entries: confirmed.map((e) => restoreEntry(repoRoot, e))
+  };
+  const logPath = join(options.stateDir ?? BRANCH_GC_STATE_DIR(), plan.repoName, `restore-${createdAt.replace(/[:.]/g, "-")}.json`);
+  await writeJsonAtomic(logPath, log);
+  const results = /* @__PURE__ */ new Map();
+  const fail = (res) => ({ ok: false, message: (res.stderr || res.stdout).trim() || `exit ${res.exitCode}` });
+  for (const e of confirmed.filter((c) => c.kind === "local")) {
+    const res = await git(repoRoot, ["branch", "-D", e.name]);
+    results.set(e.ref, res.exitCode === 0 ? { ok: true } : fail(res));
+  }
+  const remoteEntries = confirmed.filter((c) => c.kind === "remote");
+  const byRemote = /* @__PURE__ */ new Map();
+  for (const e of remoteEntries) byRemote.set(e.remote, [...byRemote.get(e.remote) ?? [], e]);
+  for (const [remote, list] of byRemote) {
+    const failedBatches = [];
+    for (const batch of chunk(list, options.remoteBatchSize ?? 50)) {
+      const res = await git(repoRoot, ["push", remote, "--delete", ...batch.map((e) => e.name)]);
+      if (res.exitCode === 0) for (const e of batch) results.set(e.ref, { ok: true });
+      else failedBatches.push({ batch, res });
+    }
+    await git(repoRoot, ["fetch", "--prune", "--quiet", remote]);
+    let retried = false;
+    for (const { batch } of failedBatches) {
+      for (const e of batch) {
+        if ((await git(repoRoot, ["rev-parse", "--verify", "--quiet", e.ref])).exitCode !== 0) {
+          results.set(e.ref, { ok: true });
+          continue;
+        }
+        const one = await git(repoRoot, ["push", remote, "--delete", e.name]);
+        results.set(e.ref, one.exitCode === 0 ? { ok: true } : fail(one));
+        retried = true;
+      }
+    }
+    if (retried) await git(repoRoot, ["fetch", "--prune", "--quiet", remote]);
+  }
+  for (const e of confirmed.filter((c) => c.kind === "orphan")) {
+    const res = await git(repoRoot, ["update-ref", "-d", e.ref, e.sha]);
+    results.set(e.ref, res.exitCode === 0 ? { ok: true } : fail(res));
+  }
+  for (const entry of log.entries) entry.deleted = results.get(entry.ref)?.ok === true;
+  await writeJsonAtomic(logPath, log);
+  for (const e of confirmed) {
+    const r = results.get(e.ref);
+    const id = { kind: e.kind, name: e.name, sha: e.sha };
+    if (r?.ok) outcomes.push({ ...id, result: "deleted", reclaimReason: e.reclaimReason });
+    else outcomes.push({ ...id, result: "failed", message: r && !r.ok ? r.message : "not attempted" });
+  }
+  return { outcomes, restoreLog: logPath };
+}
+async function readBranchGcRestoreLog(path) {
+  return JSON.parse(await readFile(path, "utf8"));
+}
+var BRANCH_TRIAGE_VERDICTS = ["obsolete", "superseded", "salvage", "in-progress", "unclear"];
+var branchVerdictSchema = z.object({
+  name: z.string().min(1),
+  sha: z.string().regex(/^[0-9a-f]{40}(?:[0-9a-f]{24})?$/, "sha must be a full 40- or 64-char lowercase hex object id"),
+  triage: z.object({
+    verdict: z.enum(BRANCH_TRIAGE_VERDICTS),
+    confidence: z.number().min(0).max(1),
+    reason: z.string().min(1),
+    salvage: z.string().optional()
+  }),
+  gate: z.object({
+    agree: z.boolean(),
+    verdict: z.enum(BRANCH_TRIAGE_VERDICTS),
+    reason: z.string().min(1),
+    evidence: z.array(z.string().min(1))
+  }).optional(),
+  reviewer: z.string().min(1)
+}).superRefine((v, ctx) => {
+  if (v.gate?.agree && v.gate.evidence.length === 0) {
+    ctx.addIssue({ code: "custom", path: ["gate", "evidence"], message: "gate.agree=true requires at least one evidence entry" });
+  }
+});
+var verdictKey = (repo, sha) => `${repo}\0${sha}`;
+var BRANCH_VERDICTS_PATH = () => resolve(homedir(), ".agentproto", "branch-gc-verdicts.json");
+var verdictRecordSchema = z.intersection(branchVerdictSchema, z.object({ repo: z.string(), recordedAt: z.string() }));
+var verdictFileSchema = z.object({ entries: z.array(z.unknown()) });
+var FileBranchVerdictStore = class {
+  constructor(path = BRANCH_VERDICTS_PATH()) {
+    this.path = path;
+  }
+  path;
+  cache = null;
+  async load() {
+    if (this.cache) return this.cache;
+    const map = /* @__PURE__ */ new Map();
+    this.cache = map;
+    let parsed;
+    try {
+      parsed = JSON.parse(await readFile(this.path, "utf8"));
+    } catch {
+      return map;
+    }
+    const file = verdictFileSchema.safeParse(parsed);
+    if (!file.success) return map;
+    for (const raw of file.data.entries) {
+      const rec = verdictRecordSchema.safeParse(raw);
+      if (rec.success) map.set(verdictKey(rec.data.repo, rec.data.sha), rec.data);
+    }
+    return map;
+  }
+  async get(repo, sha) {
+    return (await this.load()).get(verdictKey(repo, sha)) ?? null;
+  }
+  async set(record) {
+    const map = await this.load();
+    map.set(verdictKey(record.repo, record.sha), record);
+    await writeJsonAtomic(this.path, { entries: [...map.values()] });
+  }
+};
+var InMemoryBranchVerdictStore = class {
+  map = /* @__PURE__ */ new Map();
+  async get(repo, sha) {
+    return this.map.get(verdictKey(repo, sha)) ?? null;
+  }
+  async set(record) {
+    this.map.set(verdictKey(record.repo, record.sha), record);
+  }
+};
+var BranchVerdictError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BranchVerdictError";
+  }
+};
+async function recordBranchVerdict(input) {
+  const parsed = branchVerdictSchema.safeParse(input.verdict);
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; ");
+    throw new BranchVerdictError(`invalid branch verdict: ${issues}`);
+  }
+  const exists = await git(input.repoRoot, ["cat-file", "-e", `${parsed.data.sha}^{commit}`]);
+  if (exists.exitCode !== 0) {
+    throw new BranchVerdictError(`invalid branch verdict: ${parsed.data.sha} is not a commit in ${input.repoRoot}`);
+  }
+  const record = {
+    ...parsed.data,
+    repo: input.repoName,
+    recordedAt: (input.now ?? (() => (/* @__PURE__ */ new Date()).toISOString()))()
+  };
+  await input.store.set(record);
+  return record;
+}
+
+// src/gc.ts
 var candidates = [worktreeProvider];
 function classifyForGc(tree, integration, liveness, options = {}) {
   if (options.includeDetached && integration.state === "detached") {
@@ -428,6 +1163,7 @@ function classifyForGc(tree, integration, liveness, options = {}) {
   }
   return classify(tree, integration, liveness, options.nowMs).class;
 }
+var DEFAULT_GC_NOISE_PATHS = [".opencode/package-lock.json"];
 function isProtectedPath(worktreePath, protectedPaths) {
   if (!protectedPaths || protectedPaths.length === 0) return false;
   return protectedPaths.some((p) => p === worktreePath || p.startsWith(worktreePath + sep));
@@ -456,11 +1192,35 @@ async function isMechanicalDepBumpRange(repoRoot, baseRef, tipSha) {
 async function resolveGcClass(tree, integration, liveness, options) {
   const baseClass = classifyForGc(tree, integration, liveness, options);
   if (baseClass !== "hold") return { class: baseClass };
-  if (tree.state !== "clean" || integration.state !== "unpushed") return { class: "hold" };
+  if (tree.state !== "clean") return { class: "hold" };
   const baseRef = options.defaultBranchRef ?? "origin/main";
-  const isDepBump = await isMechanicalDepBumpRange(options.repoRoot, baseRef, options.tipSha);
-  if (!isDepBump) return { class: "hold" };
-  return { class: "reclaim", reclaimReason: "dep-bump" };
+  if (integration.state === "unpushed" && await isMechanicalDepBumpRange(options.repoRoot, baseRef, options.tipSha)) {
+    return { class: "reclaim", reclaimReason: "dep-bump" };
+  }
+  if (options.inBaseCheck !== false) {
+    const inBase = await provenInBase(integration, liveness, options.repoRoot, baseRef, options.tipSha);
+    if (inBase) return { class: "reclaim", reclaimReason: inBase };
+  }
+  return { class: "hold" };
+}
+var IN_BASE_PROMOTABLE = /* @__PURE__ */ new Set([
+  "partial",
+  "diverged",
+  "pushed-no-pr",
+  "unpushed",
+  "local-only",
+  "gone-unexplained"
+]);
+async function provenInBase(integration, liveness, repoRoot, baseRef, tipSha) {
+  if (!IN_BASE_PROMOTABLE.has(integration.state)) return null;
+  if (liveness.state !== "idle" && liveness.state !== "daemon-unreachable") return null;
+  try {
+    const tip = await classifyTipAgainstBase(repoRoot, baseRef, tipSha);
+    if (tip.status === "squash-merged" || tip.status === "patch-merged" || tip.status === "content-merged") return tip.status;
+    return null;
+  } catch {
+    return null;
+  }
 }
 async function linkedWorktreesOf(repoRoot) {
   const worktrees = await listGitWorktrees(repoRoot);
@@ -645,7 +1405,8 @@ async function planGc(input) {
       memo: input.memo,
       defaultBranchRef: input.defaultBranchRef,
       sessionsPath: input.sessionsPath,
-      now: input.now
+      now: input.now,
+      noisePaths: input.noisePaths ?? DEFAULT_GC_NOISE_PATHS
     });
     entries.push(
       await toPlanEntry(
@@ -669,8 +1430,19 @@ async function findWorktree(repoRoot, path) {
   const worktrees = await linkedWorktreesOf(repoRoot);
   return worktrees.find((w) => w.path === path) ?? null;
 }
-async function reclaimOne(options, worktree, reclaimReason) {
+async function discardNoise(repoRoot, worktreePath, noise) {
+  for (const path of noise) {
+    const tracked = await execArgv("git", ["-C", worktreePath, "ls-files", "--error-unmatch", "--", path], repoRoot);
+    if (tracked.exitCode === 0) {
+      await execGit(repoRoot, ["-C", worktreePath, "checkout", "HEAD", "--", path]);
+    } else {
+      await rm(join(worktreePath, path), { force: true });
+    }
+  }
+}
+async function reclaimOne(options, worktree, reclaimReason, tree) {
   try {
+    if (tree?.state === "clean" && tree.noise?.length) await discardNoise(options.repoRoot, worktree.path, tree.noise);
     await runTool({
       tool: cleanupWorktreeTool,
       candidates,
@@ -793,7 +1565,8 @@ async function applyOne(entry, options) {
     memo: options.memo,
     defaultBranchRef: options.defaultBranchRef,
     sessionsPath: options.sessionsPath,
-    now: options.now
+    now: options.now,
+    noisePaths: options.noisePaths ?? DEFAULT_GC_NOISE_PATHS
   });
   const resolved = await resolveGcClass(status.tree, status.integration, status.liveness, {
     repoRoot: options.repoRoot,
@@ -811,7 +1584,7 @@ async function applyOne(entry, options) {
       to: resolved.class
     };
   }
-  if (resolved.class === "reclaim") return reclaimOne(options, fresh, resolved.reclaimReason);
+  if (resolved.class === "reclaim") return reclaimOne(options, fresh, resolved.reclaimReason, status.tree);
   return salvageOne(options, fresh);
 }
 async function applyGc(plan, options) {
@@ -835,7 +1608,8 @@ async function reclaimOneWorktree(worktreePath, options) {
     memo: options.memo,
     defaultBranchRef: options.defaultBranchRef,
     sessionsPath: options.sessionsPath,
-    now: options.now
+    now: options.now,
+    noisePaths: options.noisePaths ?? DEFAULT_GC_NOISE_PATHS
   });
   const entry = await toPlanEntry(
     options.repoRoot,
@@ -849,6 +1623,6 @@ async function reclaimOneWorktree(worktreePath, options) {
   return applyOne(entry, options);
 }
 
-export { ForgeUnavailableError, GhCliForgeClient, RestForgeClient, SALVAGE_ROOT, UnreachableForgeClient, applyGc, classifyForGc, createForgeClient, createProxyServer, isMechanicalDepBumpRange, parseGithubOwnerRepo, planGc, reclaimOneWorktree, resolveGcClass, salvageWorktree, startProxy };
+export { BRANCH_GC_SCOPES, BRANCH_GC_STATE_DIR, BRANCH_TRIAGE_VERDICTS, BRANCH_VERDICTS_PATH, BranchVerdictError, DEFAULT_BRANCH_GC_MIN_AGE_DAYS, DEFAULT_GC_NOISE_PATHS, FileBranchVerdictStore, ForgeUnavailableError, GhCliForgeClient, InMemoryBranchVerdictStore, RestForgeClient, SALVAGE_ROOT, UnreachableForgeClient, applyBranchGc, applyGc, branchReviewQueue, branchVerdictSchema, classifyForGc, classifyTip, classifyTipAgainstBase, createForgeClient, createLadderContext, createProxyServer, detectAnchor, isMechanicalDepBumpRange, parseGithubOwnerRepo, planBranchGc, planGc, readBranchGcRestoreLog, reclaimOneWorktree, recordBranchVerdict, resolveGcClass, salvageWorktree, startProxy, summarizeBranchGcPlan };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map