@agentproto/worktree 0.9.0 → 0.12.0

package/dist/index.d.ts

@@ -245,6 +245,86 @@ declare function execArgv(command: string, args: readonly string[], cwd: string,
 declare function execShell(cmd: string, cwd: string, opts?: ExecOptions): Promise<ExecResult>;
 declare function execGit(repoRoot: string, args: readonly string[]): Promise<ExecResult>;
 
+/**
+ * Fast worktree removal: `rename` to a same-volume trash dir + `git worktree
+ * prune`, with the bytes deleted by a detached background child.
+ *
+ * WHY THIS EXISTS: `git worktree remove` deletes the worktree tree in
+ * process, one file at a time — on a pnpm worktree (its own `node_modules` /
+ * `.pnpm-vstores`, hundreds of thousands of files) on an external SSD that
+ * measured ~10 minutes PER WORKTREE. Every part of the removal that callers
+ * actually wait on is instant:
+ *
+ *   1. `rename` the worktree directory to `<dirname(path)>/.trash/<base>-
+ *      <timestamp>` — same volume by construction, so it's a metadata
+ *      operation, not a copy. `git worktree remove`'s per-file refusals have
+ *      already run (see `removeWorktreeFast`), so at this point the bytes
+ *      are authorized to die; only the cost is being moved.
+ *   2. `git worktree prune` — git forgets the (now missing) registration.
+ *      The worktree disappears from `git worktree list` immediately.
+ *   3. `rm -rf` on the trash dir runs in a DETACHED child
+ *      (`spawn("rm", ["-rf", trashDir], { detached: true, stdio: "ignore" })`
+ *      + `.unref()`) — the parent never waits for the hundreds of thousands
+ *      of unlinks, and survives its own exit. The next `gc` apply also
+ *      sweeps stale `.trash` dirs (`sweepWorktreeTrash`) so nothing leaks
+ *      even if a child is killed mid-delete.
+ *
+ * SAFETY — the plain/forced `git worktree remove` semantics this must not
+ * weaken, verified empirically against git (see the brief):
+ *   - A non-force removal must refuse a dirty tree: the caller passes
+ *     `force: false` only for a tree already checked clean, and
+ *     `removeWorktreeFast` re-checks `git status --porcelain` itself and
+ *     throws (leaving the worktree in place) rather than renaming dirt away.
+ *   - A forced removal is only ever passed after a salvage snapshot or an
+ *     explicit user-granted discard flag upstream — this module doesn't
+ *     loosen that; it just performs the same destruction instantly.
+ *
+ * Fallback: if the `rename` fails for any reason (cross-device, permissions,
+ * the trash parent unmountable), the function falls back to today's plain
+ * `git worktree remove [--force]` — behavior identical to before, just slow.
+ */
+/** Directory (inside the worktrees root's repo bucket) background-delete leftovers land in. */
+declare const WORKTREE_TRASH_DIRNAME = ".trash";
+interface RemoveWorktreeFastOptions {
+    /**
+     * `false` (default): re-verify the tree is clean via `git status
+     * --porcelain` and refuse (throw) on any dirt — the same refusal a plain
+     * `git worktree remove` performs. `true`: skip the cleanliness gate,
+     * exactly like `git worktree remove --force` — only pass this when dirt
+     * has been authorized (salvage snapshot durable / discard flags granted)
+     * upstream.
+     */
+    force?: boolean;
+    /**
+     * Injectable clock for the trash dir's timestamp suffix — tests freeze it
+     * so the dir name is deterministic. Defaults to `Date.now`.
+     */
+    now?: () => number;
+    /**
+     * Test seam — overrides the detached `rm -rf` child (e.g. an in-process
+     * spy). Receives the trash dir path. Default: a detached
+     * `spawn("rm", ["-rf", …])` the parent never waits on.
+     */
+    spawnRemoval?: (trashDir: string) => void;
+}
+/**
+ * Remove a linked git worktree instantly: validate → rename to trash →
+ * prune → delete the trash in the background. Throws the same *shape* of
+ * error `execGit` would on refusal (message carries git's own stderr where
+ * git produced one) so callers' existing error handling keeps working.
+ */
+declare function removeWorktreeFast(repoRoot: string, path: string, options?: RemoveWorktreeFastOptions): Promise<void>;
+/**
+ * Delete every leftover `.trash/*` dir under `root` in the background — the
+ * sweep that keeps rename-removal self-cleaning when a detached `rm` child
+ * was killed before finishing (or a host rebooted mid-delete). Called at the
+ * start of a `gc` apply, where seconds of stale bytes are harmless. Missing
+ * root is a no-op, not an error.
+ */
+declare function sweepWorktreeTrash(root: string, options?: {
+    spawnRemoval?: (dir: string) => void;
+}): void;
+
 /** Compile a `/`-separated glob (supporting `*`, `?`, `**`) into an anchored regex. */
 declare function globToRegExp(pattern: string): RegExp;
 /** Expand a glob against `root`, returning root-relative posix paths of matching files. */
@@ -413,11 +493,29 @@ interface HookRun {
     command: string;
     result: ExecResult;
 }
-/** Raised when a `setup` hook exits non-zero — carries the captured output. */
+/** Raised when a `setup` hook exits non-zero — carries the captured output
+ *  (see {@link result}) plus a short, noise-filtered tail in `message` for
+ *  callers that only surface a single string (e.g.
+ *  `SessionDescriptor.lastError`).
+ *
+ *  Incident (2026-09-27): three back-to-back `agent_start` worktree
+ *  provisions all failed at `pnpm build`, but every `lastError` showed only
+ *  the `.npmrc`/`NODE_AUTH_TOKEN` warning + turbo's one-line run summary —
+ *  never the actual tsup/tsc error. Root cause: the OLD message used
+ *  `(run.result.stderr || run.result.stdout).trim()` — since that WARN line
+ *  (and turbo's failure banner) land on stderr, ANY non-empty stderr threw
+ *  away stdout WHOLESALE, and stdout is exactly where a failing package's
+ *  own build error prints. Fixed by combining both streams, filtering only
+ *  the known-noise lines (not a whole stream), and keeping a real tail of
+ *  the combined output instead of picking one stream whole. */
 declare class HookError extends Error {
     readonly command: string;
     readonly result: ExecResult;
-    constructor(phase: "setup" | "teardown", run: HookRun);
+    /** Path to the full, unfiltered stdout+stderr log for this and every
+     *  other hook command in the same run, when the caller asked for one to
+     *  be persisted (see {@link runSetup}'s `opts.logPath`). */
+    readonly logPath?: string;
+    constructor(phase: "setup" | "teardown", run: HookRun, logPath?: string);
 }
 /**
  * Run the `worktree.setup` hooks sequentially in the worktree, with the
@@ -429,14 +527,41 @@ declare class HookError extends Error {
  * setup hook that doesn't use turbo simply never reads the var. The first
  * non-zero exit throws {@link HookError} (setup failure must fail
  * provisioning). No-op when the repo declares no setup.
+ *
+ * `opts.logPath`, when given, gets every command's FULL stdout+stderr
+ * appended (success or failure) — see {@link appendHookLog}. Callers that
+ * know the failure will surface through a single short string (the daemon's
+ * `agent_start` path, via `SessionDescriptor.lastError`) should pass a path
+ * under that session's own directory so the full log outlives a
+ * subsequently-reclaimed worktree.
+ *
+ * `opts.retryOnFailure` (default `false`) re-runs a failing command exactly
+ * ONCE before giving up — a COMPLEMENT to, never a substitute for, an actual
+ * root-cause fix. It exists for the unattended `agent_start` path: a caller
+ * with no human watching has no way to retry a transient failure itself
+ * short of minting an entirely new worktree (a fresh `git worktree add`,
+ * paying the full setup cost again) — see `session-spawn.ts`'s
+ * `worktreeSetupLogPath` call sites, which both opt in. Left `false` for the
+ * default (`agentproto worktree new`, and this function's own default): an
+ * interactive human watching a genuine, deterministic build failure gets it
+ * on the first try instead of waiting through an identical, doomed rerun.
+ * Both attempts are logged (when `logPath` is given); the thrown
+ * `HookError` carries the RETRY's own result, since that's the one the
+ * caller is actually giving up on.
  */
-declare function runSetup(config: AgentprotoConfig, ctx: WorktreeEnvContext): Promise<HookRun[]>;
+declare function runSetup(config: AgentprotoConfig, ctx: WorktreeEnvContext, opts?: {
+    logPath?: string;
+    retryOnFailure?: boolean;
+}): Promise<HookRun[]>;
 /**
  * Run the `worktree.teardown` hooks sequentially. Unlike setup, a failing
  * teardown hook does NOT throw — cleanup must proceed — so failures are
  * returned for the caller to log. No-op when no teardown is declared.
+ * `opts.logPath` mirrors {@link runSetup}'s — best-effort, full output.
  */
-declare function runTeardown(config: AgentprotoConfig, ctx: WorktreeEnvContext): Promise<HookRun[]>;
+declare function runTeardown(config: AgentprotoConfig, ctx: WorktreeEnvContext, opts?: {
+    logPath?: string;
+}): Promise<HookRun[]>;
 
 /**
  * The proxy routing table: `<hostname>` → local service port.
@@ -849,6 +974,15 @@ type TreeState = {
      * a liveness-independent "someone touched this a moment ago" signal.
      */
     newestMtimeMs: number | null;
+    /**
+     * Set to `.plans/` when every non-noise dirty path starts with it —
+     * i.e. the ENTIRE tree's dirt lives under `.plans/`. `undefined`
+     * otherwise (mixed dirt, or dirt outside `.plans/` entirely). Feeds
+     * gc's plans-only salvage rule (`classifyForGc`, gc.ts): `.plans/`
+     * holds the user's plan files, never to be discarded, but also never a
+     * reason to hold a no-commit worktree forever.
+     */
+    onlyUnder?: string;
 };
 interface ComputeTreeStateOptions {
     /**
@@ -1282,10 +1416,21 @@ interface ClassifyForGcOptions {
 }
 /**
  * gc's own classifier, layered on top of `classify` (status.ts) rather than
- * reimplementing it — reuse first (AGENTS.md, PLAN.md §0.6). The one thing
- * `classify` cannot know is `--include-detached`, a gc-specific flag; that
- * override lives here, not in the read-only status engine `ls --status`
- * also depends on.
+ * reimplementing it — reuse first (AGENTS.md, PLAN.md §0.6). `classify`
+ * itself never lets a `fresh` worktree salvage, clean or not — that
+ * invariant is load-bearing for `ls --status` and every other caller (see
+ * its 2026-07-15 note) and stays untouched here. What `classify` cannot know
+ * is gc-specific archival policy; two overrides live here instead:
+ *   - `--include-detached`: a clean, idle DETACHED worktree moves `hold` →
+ *     `reclaim`.
+ *   - the "plans-only" rule below: a no-commit worktree (`fresh`, or
+ *     `detached` when `includeDetached` is set — same gate, since a detached
+ *     HEAD's commit safety is exactly as unproven either way) whose ONLY
+ *     dirt is untracked files under `.plans/` moves `hold` → `salvage`, so
+ *     `--salvage-dirty` archives the plan files (never discards them) instead
+ *     of holding the worktree forever. Narrow on purpose: any OTHER dirt
+ *     (even one non-`.plans/` file, or a tracked/staged change) leaves this
+ *     untouched and `classify`'s ordinary `hold` stands.
  */
 declare function classifyForGc(tree: TreeState, integration: IntegrationState, liveness: LivenessState, options?: ClassifyForGcOptions): GcClass;
 /**
@@ -1453,6 +1598,16 @@ interface ApplyGcOptions {
     protectedPaths?: string[];
     /** See `PlanGcInput.noisePaths`. */
     noisePaths?: readonly string[];
+    /**
+     * The bucket directory this repo's worktrees are provisioned under — the
+     * same value `planGc` takes. When passed, apply first fires
+     * `sweepWorktreeTrash(worktreesRoot)` (fast-remove.ts): every leftover
+     * `.trash/*` dir left behind by an interrupted background delete is
+     * handed to a fresh detached `rm -rf` child, so a killed mid-delete
+     * removal (crash, reboot) still converges — seconds of stale bytes at
+     * apply time are harmless, and the sweep never blocks on the deletes.
+     */
+    worktreesRoot?: string;
 }
 type GcApplyOutcome = {
     path: string;
@@ -1694,6 +1849,8 @@ interface BranchGcPlan {
     generatedAt: string;
     /** Refs of OTHER configured remotes: never classified, never touched. */
     otherRemoteRefs: number;
+    /** true = `git fetch --prune` of the base remote succeeded; false = it failed; null = skipped (opt-out or no remote). */
+    fetched: boolean | null;
     entries: BranchGcPlanEntry[];
 }
 /** Base content index, built once per base: path→blob, every blob, every basename. */
@@ -1713,6 +1870,13 @@ interface LadderContext {
      *  plan's anchor detection asks the same question of every tip) — saves
      *  the ladder's first `merge-base` per tip. */
     related?: ReadonlyMap<string, boolean>;
+    /**
+     * Memoized set of every commit reachable from `cmp` (at most two distinct
+     * values: `baseSha` and the anchor) — ONE `git rev-list <cmp>` replaces one
+     * `merge-base --is-ancestor` per tip. `null` above 500 000 commits (or on a
+     * git failure) = fall back to the per-tip call.
+     */
+    ancestorsOf?: (cmp: string) => Promise<Set<string> | null>;
 }
 declare function createLadderContext(repoRoot: string, baseRef: string, anchor: string | null, related?: ReadonlyMap<string, boolean>): Promise<LadderContext>;
 /**
@@ -1760,6 +1924,8 @@ interface PlanBranchGcInput {
     nowMs?: number;
     /** Parallel ladder runs. Default 8. */
     concurrency?: number;
+    /** Run `git fetch --prune <baseRemote>` before classifying. Default true. */
+    fetch?: boolean;
 }
 /** The dry-run plan: classify every ref in `scopes`, mutate nothing. */
 declare function planBranchGc(input: PlanBranchGcInput): Promise<BranchGcPlan>;
@@ -1873,6 +2039,8 @@ interface ApplyBranchGcOptions {
     nowMs?: number;
     /** Remote refs per `git push --delete`. Default 50. */
     remoteBatchSize?: number;
+    /** Run `git fetch --prune <baseRemote>` before re-deriving entries. Default true. */
+    fetch?: boolean;
 }
 interface BranchGcApplyResult {
     outcomes: BranchGcApplyOutcome[];
@@ -1989,4 +2157,4 @@ declare function recordBranchVerdict(input: {
     now?: () => string;
 }): Promise<BranchVerdictRecord>;
 
-export { type AgentprotoConfig, type ApplyBranchGcOptions, type ApplyGcOptions, BRANCH_GC_SCOPES, BRANCH_GC_STATE_DIR, BRANCH_TRIAGE_VERDICTS, BRANCH_VERDICTS_PATH, type BaseDivergence, type BranchCoverage, type BranchGcApplyOutcome, type BranchGcApplyResult, type BranchGcClass, type BranchGcHoldReason, type BranchGcPlan, type BranchGcPlanEntry, type BranchGcReclaimReason, type BranchGcRestoreEntry, type BranchGcRestoreLog, type BranchGcSummary, type BranchHistory, type BranchPushState, type BranchRef, type BranchRefKind, type BranchReviewCandidate, type BranchReviewQueue, type BranchStatus, type BranchTriageVerdict, type BranchVerdict, BranchVerdictError, type BranchVerdictRecord, type BranchVerdictStore, type BranchVerdictSummary, CONFIG_FILENAME, type Classification, type ClassifyForGcOptions, type ComputeProvenanceOptions, type ComputeTreeStateOptions, type ComputeWorktreeStatusInput, ConfigError, DEFAULT_BRANCH_GC_MIN_AGE_DAYS, DEFAULT_GC_NOISE_PATHS, DEFAULT_PROXY_PORT, type DaemonAgentSessionHost, type DaemonClient, ENV_VARS, type ExecOptions, type ExecResult, FileBranchVerdictStore, FileVerdictMemoStore, type ForgeClient, type ForgePullRequestRef, ForgeUnavailableError, type GateState, type GcApplyOutcome, type GcClass, type GcHoldReason, type GcPlanEntry, type GcReclaimReason, GhCliForgeClient, type GitWorktreeRef, HookError, type HookRun, type HostnameParts, type InBaseReclaimReason, InMemoryBranchVerdictStore, InMemoryVerdictMemoStore, type IntegrationState, type LadderContext, type ListWorktreeStatusesInput, type LivenessState, type NamedScript, type PeerService, type PlanBranchGcInput, type PlanGcInput, type ProvenanceConfidence, type ProvenanceInfo, ProxyTable, type ReconcileIntegrationInput, type ResolveGcClassOptions, type ResolveSupervisorInput, type ResolvedGcClass, type ResolvedWorktreeRuntime, RestForgeClient, type RunningProxy, SALVAGE_ROOT, SESSIONS_BUCKETS_ROOT, SESSIONS_FILE_PATH, type SalvageManifest, type SalvageResult, type SalvageWorktreeInput, type ScriptConfig, type ServiceRuntime, type ServiceStatus, ServiceSupervisor, type SessionRef, type SupervisorOptions, type TipClassification, type TreeIndex, type TreeState, UnreachableForgeClient, VERDICT_MEMO_PATH, type VerdictMemoRecord, type VerdictMemoStore, WORKTREES_TURBO_CACHE_DIR_ENV, type WorktreeAgentInput, type WorktreeClass, type WorktreeEnvContext, type WorktreeMarker, WorktreeNotRemovableError, type WorktreeStatusEntry, allocatePort, applyBranchGc, applyGc, branchReviewQueue, branchVerdictSchema, classify, classifyForGc, classifyTip, classifyTipAgainstBase, computeBaseDivergence, computeLiveness, computeProvenance, computeTreeState, computeWorktreeStatus, connectDaemonAgentSessionHost, createForgeClient, createLadderContext, createProxyServer, detectAnchor, detectDefaultBranch, disposeSupervisor, ephemeralPort, execArgv, execGit, execShell, expandGlob, getScript, getSupervisor, globToRegExp, hookEnv, isMechanicalDepBumpRange, isPortFree, listGitWorktrees, listScripts, listServices, listWorktreeStatuses, loadConfigFromBase, makeDaemonAgentSessionHost, normalizeHook, parseConfig, parseGithubOwnerRepo, peerEnv, peerEnvKey, planBranchGc, planGc, readBranchGcRestoreLog, readSessionsRegistry, readWorktreeMarker, reclaimOneWorktree, reconcileIntegration, recordBranchVerdict, repoLabel, resolveGcClass, resolveSupervisor, resolveWorktreesTurboCacheDir, runSetup, runTeardown, salvageWorktree, serviceEnv, serviceEnvToken, serviceHostname, serviceUrl, sessionInWorktree, sharedProxyTable, slugify, startProxy, stripPort, summarizeBranchGcPlan, worktreeAgentInputSchema, worktreeAgentWorkflow, writeWorktreeMarker };
+export { type AgentprotoConfig, type ApplyBranchGcOptions, type ApplyGcOptions, BRANCH_GC_SCOPES, BRANCH_GC_STATE_DIR, BRANCH_TRIAGE_VERDICTS, BRANCH_VERDICTS_PATH, type BaseDivergence, type BranchCoverage, type BranchGcApplyOutcome, type BranchGcApplyResult, type BranchGcClass, type BranchGcHoldReason, type BranchGcPlan, type BranchGcPlanEntry, type BranchGcReclaimReason, type BranchGcRestoreEntry, type BranchGcRestoreLog, type BranchGcSummary, type BranchHistory, type BranchPushState, type BranchRef, type BranchRefKind, type BranchReviewCandidate, type BranchReviewQueue, type BranchStatus, type BranchTriageVerdict, type BranchVerdict, BranchVerdictError, type BranchVerdictRecord, type BranchVerdictStore, type BranchVerdictSummary, CONFIG_FILENAME, type Classification, type ClassifyForGcOptions, type ComputeProvenanceOptions, type ComputeTreeStateOptions, type ComputeWorktreeStatusInput, ConfigError, DEFAULT_BRANCH_GC_MIN_AGE_DAYS, DEFAULT_GC_NOISE_PATHS, DEFAULT_PROXY_PORT, type DaemonAgentSessionHost, type DaemonClient, ENV_VARS, type ExecOptions, type ExecResult, FileBranchVerdictStore, FileVerdictMemoStore, type ForgeClient, type ForgePullRequestRef, ForgeUnavailableError, type GateState, type GcApplyOutcome, type GcClass, type GcHoldReason, type GcPlanEntry, type GcReclaimReason, GhCliForgeClient, type GitWorktreeRef, HookError, type HookRun, type HostnameParts, type InBaseReclaimReason, InMemoryBranchVerdictStore, InMemoryVerdictMemoStore, type IntegrationState, type LadderContext, type ListWorktreeStatusesInput, type LivenessState, type NamedScript, type PeerService, type PlanBranchGcInput, type PlanGcInput, type ProvenanceConfidence, type ProvenanceInfo, ProxyTable, type ReconcileIntegrationInput, type RemoveWorktreeFastOptions, type ResolveGcClassOptions, type ResolveSupervisorInput, type ResolvedGcClass, type ResolvedWorktreeRuntime, RestForgeClient, type RunningProxy, SALVAGE_ROOT, SESSIONS_BUCKETS_ROOT, SESSIONS_FILE_PATH, type SalvageManifest, type SalvageResult, type SalvageWorktreeInput, type ScriptConfig, type ServiceRuntime, type ServiceStatus, ServiceSupervisor, type SessionRef, type SupervisorOptions, type TipClassification, type TreeIndex, type TreeState, UnreachableForgeClient, VERDICT_MEMO_PATH, type VerdictMemoRecord, type VerdictMemoStore, WORKTREES_TURBO_CACHE_DIR_ENV, WORKTREE_TRASH_DIRNAME, type WorktreeAgentInput, type WorktreeClass, type WorktreeEnvContext, type WorktreeMarker, WorktreeNotRemovableError, type WorktreeStatusEntry, allocatePort, applyBranchGc, applyGc, branchReviewQueue, branchVerdictSchema, classify, classifyForGc, classifyTip, classifyTipAgainstBase, computeBaseDivergence, computeLiveness, computeProvenance, computeTreeState, computeWorktreeStatus, connectDaemonAgentSessionHost, createForgeClient, createLadderContext, createProxyServer, detectAnchor, detectDefaultBranch, disposeSupervisor, ephemeralPort, execArgv, execGit, execShell, expandGlob, getScript, getSupervisor, globToRegExp, hookEnv, isMechanicalDepBumpRange, isPortFree, listGitWorktrees, listScripts, listServices, listWorktreeStatuses, loadConfigFromBase, makeDaemonAgentSessionHost, normalizeHook, parseConfig, parseGithubOwnerRepo, peerEnv, peerEnvKey, planBranchGc, planGc, readBranchGcRestoreLog, readSessionsRegistry, readWorktreeMarker, reclaimOneWorktree, reconcileIntegration, recordBranchVerdict, removeWorktreeFast, repoLabel, resolveGcClass, resolveSupervisor, resolveWorktreesTurboCacheDir, runSetup, runTeardown, salvageWorktree, serviceEnv, serviceEnvToken, serviceHostname, serviceUrl, sessionInWorktree, sharedProxyTable, slugify, startProxy, stripPort, summarizeBranchGcPlan, sweepWorktreeTrash, worktreeAgentInputSchema, worktreeAgentWorkflow, writeWorktreeMarker };

package/dist/index.mjs

@@ -1,9 +1,9 @@
-export { connectDaemonAgentSessionHost, makeDaemonAgentSessionHost, worktreeAgentInputSchema, worktreeAgentWorkflow } from './chunk-6EV7WP2U.mjs';
+export { connectDaemonAgentSessionHost, makeDaemonAgentSessionHost, worktreeAgentInputSchema, worktreeAgentWorkflow } from './chunk-5SDH2V6M.mjs';
 import './chunk-E3EM24BS.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 { computeProvenance, execArgv, classify, computeWorktreeStatus, sweepWorktreeTrash, listGitWorktrees, execGit, worktreeProvider } from './chunk-EVHLUKC7.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, WORKTREE_TRASH_DIRNAME, 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, removeWorktreeFast, repoLabel, resolveSupervisor, resolveWorktreesTurboCacheDir, runSetup, runTeardown, serviceEnv, serviceEnvToken, serviceHostname, serviceUrl, sessionInWorktree, sharedProxyTable, slugify, stripPort, sweepWorktreeTrash, worktreeProvider, writeWorktreeMarker } from './chunk-EVHLUKC7.mjs';
+import { cleanupWorktreeTool } from './chunk-EK5BH2YL.mjs';
+export { cleanupWorktreeTool, listServicesTool, provisionWorktreeTool, runGateTool, runScriptTool, serviceStatusSchema, startServiceTool, stopServiceTool } from './chunk-EK5BH2YL.mjs';
 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';
@@ -507,12 +507,28 @@ 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;
+  const ancestors = /* @__PURE__ */ new Map();
+  const ancestorsOf = (cmp) => {
+    let p = ancestors.get(cmp);
+    if (!p) {
+      p = (async () => {
+        const res = await git(repoRoot, ["rev-list", cmp]);
+        if (res.exitCode !== 0) return null;
+        const shas = res.stdout.split("\n");
+        if (shas.length > 5e5) return null;
+        return new Set(shas.filter(Boolean));
+      })();
+      ancestors.set(cmp, p);
+    }
+    return p;
+  };
   return {
     repoRoot,
     baseSha,
     baseTree,
     anchor,
     index: () => idx ??= indexTree(repoRoot, baseSha),
+    ancestorsOf,
     ...related ? { related } : {}
   };
 }
@@ -580,7 +596,9 @@ async function classifyTip(ctx, 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) {
+  const ancestors = ctx.ancestorsOf ? await ctx.ancestorsOf(cmp) : null;
+  const isAncestor = ancestors ? ancestors.has(tip) : (await git(repoRoot, ["merge-base", "--is-ancestor", tip, cmp])).exitCode === 0;
+  if (isAncestor) {
     return { status: "merged", history, ahead: 0, behind: null };
   }
   const counts = (await gitOk(repoRoot, ["rev-list", "--left-right", "--count", `${cmp}...${tip}`])).trim().split(/\s+/);
@@ -736,12 +754,19 @@ async function pushStateOf(b, env) {
   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";
+      const reachable = env.remoteReachable ? await env.remoteReachable() : null;
+      if (reachable) {
+        if (reachable.has(b.sha)) return "contained-in-remote";
+      } else {
+        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 reachable = env.localOrRemoteReachable ? await env.localOrRemoteReachable() : null;
+    if (reachable) return reachable.has(b.sha) ? "contained-elsewhere" : "only-copy";
     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";
@@ -797,6 +822,10 @@ async function classifyRef(b, env) {
 async function snapshot(input) {
   const remotes = await configuredRemotes(input.repoRoot);
   const remote = baseRemoteOf(input.base, remotes);
+  let fetched = null;
+  if (remote && input.fetch !== false) {
+    fetched = (await git(input.repoRoot, ["fetch", "--prune", "--quiet", remote])).exitCode === 0;
+  }
   const [{ refs, otherRemoteRefs }, worktrees, prs, mergedPrs] = await Promise.all([
     listBranchRefs(input.repoRoot, remote, remotes),
     worktreeBranches(input.repoRoot),
@@ -811,9 +840,20 @@ async function snapshot(input) {
   else anchor = null;
   const ctx = await createLadderContext(input.repoRoot, baseSha, anchor, related);
   const remoteRefs = refs.filter((r) => r.kind === "remote");
+  const MAX_REACHABLE = 5e5;
+  const revListSet = async (args) => {
+    const res = await git(input.repoRoot, ["rev-list", ...args]);
+    if (res.exitCode !== 0) return null;
+    const shas = res.stdout.split("\n");
+    if (shas.length > MAX_REACHABLE) return null;
+    return new Set(shas.filter(Boolean));
+  };
+  let remoteReachableP = null;
+  let localOrRemoteP = null;
   return {
     refs,
     otherRemoteRefs,
+    fetched,
     env: {
       ctx,
       tips: /* @__PURE__ */ new Map(),
@@ -824,6 +864,10 @@ async function snapshot(input) {
       mergedPrShas: mergedPrs,
       remoteShas: new Set(remoteRefs.map((r) => r.sha)),
       remoteNames: new Set(remoteRefs.map((r) => r.name)),
+      ...remote ? {
+        remoteReachable: () => remoteReachableP ??= revListSet([`--glob=refs/remotes/${remote}/*`]),
+        localOrRemoteReachable: () => localOrRemoteP ??= revListSet(["--branches", `--glob=refs/remotes/${remote}/*`])
+      } : {},
       minAgeDays: input.minAgeDays,
       includeReviewed: input.includeReviewed,
       ...input.verdicts ? { verdicts: input.verdicts } : {},
@@ -857,7 +901,8 @@ async function planBranchGc(input) {
     ...input.verdicts ? { verdicts: input.verdicts } : {},
     minAgeDays,
     includeReviewed,
-    nowMs
+    nowMs,
+    ...input.fetch === false ? { fetch: false } : {}
   });
   const inScope = snap.refs.filter((r) => scopes.includes(r.kind));
   const entries = await pool(inScope, input.concurrency ?? 8, (r) => classifyRef(r, snap.env));
@@ -875,6 +920,7 @@ async function planBranchGc(input) {
     includeReviewed,
     generatedAt: new Date(nowMs).toISOString(),
     otherRemoteRefs: snap.otherRemoteRefs,
+    fetched: snap.fetched,
     entries
   };
 }
@@ -963,7 +1009,8 @@ async function applyBranchGc(plan, options) {
     ...options.verdicts ? { verdicts: options.verdicts } : {},
     minAgeDays: plan.minAgeDays,
     includeReviewed: plan.includeReviewed,
-    nowMs: options.nowMs ?? Date.now()
+    nowMs: options.nowMs ?? Date.now(),
+    ...options.fetch === false ? { fetch: false } : {}
   });
   const current = new Map(snap.refs.map((r) => [r.ref, r]));
   const outcomes = [];
@@ -1025,23 +1072,34 @@ async function applyBranchGc(plan, options) {
   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)]);
+      const res = await git(repoRoot, ["push", "--no-verify", 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;
+    const stillThere = [];
     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 ((await git(repoRoot, ["rev-parse", "--verify", "--quiet", e.ref])).exitCode === 0) stillThere.push(e);
+        else results.set(e.ref, { ok: true });
       }
     }
+    const failedAgain = [];
+    for (const batch of chunk(stillThere, options.remoteBatchSize ?? 50)) {
+      const retry = await git(repoRoot, ["push", "--no-verify", remote, "--delete", ...batch.map((e) => e.name)]);
+      if (retry.exitCode === 0) for (const e of batch) results.set(e.ref, { ok: true });
+      else failedAgain.push(...batch);
+    }
+    const retried = failedAgain.length > 0;
+    if (retried) await git(repoRoot, ["fetch", "--prune", "--quiet", remote]);
+    for (const e of failedAgain) {
+      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", "--no-verify", remote, "--delete", e.name]);
+      results.set(e.ref, one.exitCode === 0 ? { ok: true } : fail(one));
+    }
     if (retried) await git(repoRoot, ["fetch", "--prune", "--quiet", remote]);
   }
   for (const e of confirmed.filter((c) => c.kind === "orphan")) {
@@ -1157,13 +1215,22 @@ async function recordBranchVerdict(input) {
 // src/gc.ts
 var candidates = [worktreeProvider];
 function classifyForGc(tree, integration, liveness, options = {}) {
+  const idleOrUnreachable = liveness.state === "idle" || liveness.state === "daemon-unreachable";
   if (options.includeDetached && integration.state === "detached") {
-    const idleOrUnreachable = liveness.state === "idle" || liveness.state === "daemon-unreachable";
     if (tree.state === "clean" && idleOrUnreachable) return "reclaim";
   }
+  const noCommitsOfItsOwn = integration.state === "fresh" || Boolean(options.includeDetached) && integration.state === "detached";
+  if (noCommitsOfItsOwn && idleOrUnreachable && tree.state === "dirty" && tree.modified === 0 && tree.staged === 0 && tree.untracked > 0 && tree.onlyUnder === ".plans/") {
+    return "salvage";
+  }
   return classify(tree, integration, liveness, options.nowMs).class;
 }
-var DEFAULT_GC_NOISE_PATHS = [".opencode/package-lock.json"];
+var DEFAULT_GC_NOISE_PATHS = [
+  "pnpm-lock.yaml",
+  "package-lock.json",
+  ".opencode/package-lock.json",
+  ".claude/launch.json"
+];
 function isProtectedPath(worktreePath, protectedPaths) {
   if (!protectedPaths || protectedPaths.length === 0) return false;
   return protectedPaths.some((p) => p === worktreePath || p.startsWith(worktreePath + sep));
@@ -1588,6 +1655,7 @@ async function applyOne(entry, options) {
   return salvageOne(options, fresh);
 }
 async function applyGc(plan, options) {
+  if (options.worktreesRoot) sweepWorktreeTrash(options.worktreesRoot);
   const outcomes = [];
   for (const entry of plan) {
     outcomes.push(await applyOne(entry, options));