@agentproto/worktree 0.6.2 → 0.7.0

package/dist/index.d.ts

@@ -956,6 +956,15 @@ interface GitWorktreeRef {
     /** `null` for a detached HEAD. */
     branch: string | null;
     head: string;
+    /**
+     * Set to git's own reason string (e.g. `"gitdir file points to
+     * non-existent location"`) when `git worktree list --porcelain` itself
+     * marks this entry prunable — its working directory is gone, so no git
+     * command can be run with it as `-C` target. `undefined` for every
+     * ordinary, live entry. This is git's own signal, not re-derived via
+     * `existsSync` or any other filesystem check of our own.
+     */
+    prunable?: string;
 }
 /** Parses `git worktree list --porcelain` — every linked worktree of `repoRoot`, wherever it lives. */
 declare function listGitWorktrees(repoRoot: string): Promise<GitWorktreeRef[]>;
@@ -1205,14 +1214,22 @@ interface ClassifyForGcOptions {
 declare function classifyForGc(tree: TreeState, integration: IntegrationState, liveness: LivenessState, options?: ClassifyForGcOptions): GcClass;
 /**
  * The reclaim reasons this module can attach. `dep-bump` promotes a `hold`
- * to `reclaim` (see above). `orphan` is different in kind — it never starts
- * from a `hold` verdict at all, because an orphan was never classified in
- * the first place (see the "orphan reclaim" section below): a directory
- * physically present under the repo's worktree pool that `git worktree
- * list` no longer knows about, so none of `classify`'s three axes can be
- * computed for it.
+ * to `reclaim` (see above). `orphan` and `prunable` are both different in
+ * kind — neither ever starts from a `hold` verdict, because neither was
+ * classified via `classify`'s three axes in the first place:
+ *   - `orphan`: a directory physically present under the repo's worktree
+ *     pool that `git worktree list` no longer knows about at all (see the
+ *     "orphan reclaim" section below).
+ *   - `prunable`: the mirror image — `git worktree list` still has a
+ *     registration, but git itself already reports it `prunable` because
+ *     the working directory is gone. Distinct from `orphan` on purpose: an
+ *     orphan's directory is still there to lose (it just failed removal),
+ *     so `reclaimOrphan` does `rm -rf`; a prunable entry's directory is
+ *     already gone, so there's nothing to inspect and nothing to `rm` — the
+ *     only irreversible thing history nearly did to it (deleting the branch)
+ *     must not happen either. See "prunable reclaim" below.
  */
-type GcReclaimReason = "dep-bump" | "orphan";
+type GcReclaimReason = "dep-bump" | "orphan" | "prunable";
 /** The hold reasons this module can attach, distinct from `classify`'s snapshot-based holds. */
 type GcHoldReason = "live-session-cwd";
 /**
@@ -1255,17 +1272,19 @@ interface GcPlanEntry {
     branch: string | null;
     head: string;
     /**
-     * Absent only for an orphan entry (`orphan: true`) — git itself cannot
-     * answer the tree/integration/liveness questions for a directory it no
-     * longer recognizes as a worktree, so this module never fabricates a
-     * value for them rather than reporting a fact it can't actually check.
+     * Absent for an orphan entry (`orphan: true`) or a prunable entry
+     * (`prunable: true`) — git itself cannot answer the tree/integration/
+     * liveness questions for a directory it no longer recognizes as a
+     * worktree (orphan) or whose working directory is simply gone (prunable),
+     * so this module never fabricates a value for them rather than reporting
+     * a fact it can't actually check.
      */
     tree?: TreeState;
     integration?: IntegrationState;
     liveness?: LivenessState;
     /** Classification per PLAN.md §5.1, after `--include-detached` (if set). */
     class: GcClass;
-    /** Set only when `class === "reclaim"` via the dep-bump exemption or the orphan reclaim path — see `resolveGcClass` / `scanOrphanWorktreePaths`. */
+    /** Set only when `class === "reclaim"` via the dep-bump exemption, the orphan reclaim path, or the prunable reclaim path — see `resolveGcClass` / `scanOrphanWorktreePaths` / `toPlanEntry`. */
     reclaimReason?: GcReclaimReason;
     /** Set only when `class === "hold"` via `protectedPaths` (`isProtectedPath`) — distinguishes this from an ordinary snapshot-based hold. */
     holdReason?: GcHoldReason;
@@ -1278,6 +1297,14 @@ interface GcPlanEntry {
      * it classifies.
      */
     orphan?: boolean;
+    /**
+     * `true` only for a linked worktree `git worktree list --porcelain` itself
+     * already marked `prunable` — its working directory is gone, so none of
+     * `classify`'s three axes were computed (no git command was ever run
+     * against the dead path). Always paired with `class: "reclaim"` and
+     * `reclaimReason: "prunable"` — see "prunable reclaim" below `toPlanEntry`.
+     */
+    prunable?: boolean;
 }
 interface PlanGcInput {
     repoRoot: string;

package/dist/index.mjs

@@ -1,7 +1,7 @@
-export { connectDaemonAgentSessionHost, makeDaemonAgentSessionHost, worktreeAgentInputSchema, worktreeAgentWorkflow } from './chunk-5TEU6UGY.mjs';
+export { connectDaemonAgentSessionHost, makeDaemonAgentSessionHost, worktreeAgentInputSchema, worktreeAgentWorkflow } from './chunk-MKZ7BDGG.mjs';
 import './chunk-E3EM24BS.mjs';
-import { computeProvenance, execArgv, classify, computeWorktreeStatus, listGitWorktrees, worktreeProvider } from './chunk-Y337JFBG.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-Y337JFBG.mjs';
+import { computeProvenance, execArgv, classify, computeWorktreeStatus, listGitWorktrees, execGit, worktreeProvider } from './chunk-RQUJW75P.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-RQUJW75P.mjs';
 import { cleanupWorktreeTool } from './chunk-BBDKRTJK.mjs';
 export { cleanupWorktreeTool, listServicesTool, provisionWorktreeTool, runGateTool, runScriptTool, serviceStatusSchema, startServiceTool, stopServiceTool } from './chunk-BBDKRTJK.mjs';
 import { mkdir, copyFile, writeFile, open, readdir, realpath, rm, readFile, stat } from 'fs/promises';
@@ -563,6 +563,39 @@ async function reclaimOrphan(entry, options) {
   }
   return { path: entry.path, branch: null, result: "reclaimed", reclaimReason: "orphan" };
 }
+function makePrunablePlanEntry(worktree, protectedPaths) {
+  if (isProtectedPath(worktree.path, protectedPaths)) {
+    return { path: worktree.path, branch: worktree.branch, head: worktree.head, class: "hold", holdReason: "live-session-cwd" };
+  }
+  return {
+    path: worktree.path,
+    branch: worktree.branch,
+    head: worktree.head,
+    class: "reclaim",
+    reclaimReason: "prunable",
+    prunable: true
+  };
+}
+async function reclaimPrunable(entry, options) {
+  const fresh = await listGitWorktrees(options.repoRoot);
+  const stillThere = fresh.find((w) => w.path === entry.path);
+  if (stillThere && !stillThere.prunable) {
+    return { path: entry.path, branch: stillThere.branch, result: "aborted-reclassified", from: "reclaim", to: "hold" };
+  }
+  if (stillThere) {
+    try {
+      await execGit(options.repoRoot, ["worktree", "prune"]);
+    } catch (err) {
+      return {
+        path: entry.path,
+        branch: entry.branch,
+        result: "failed",
+        message: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  return { path: entry.path, branch: entry.branch, result: "reclaimed", reclaimReason: "prunable" };
+}
 async function toPlanEntry(repoRoot, defaultBranchRef, worktree, status, includeDetached, nowMs, protectedPaths) {
   if (isProtectedPath(worktree.path, protectedPaths)) {
     return {
@@ -600,6 +633,10 @@ async function planGc(input) {
   const worktrees = await linkedWorktreesOf(input.repoRoot);
   const entries = [];
   for (const worktree of worktrees) {
+    if (worktree.prunable) {
+      entries.push(makePrunablePlanEntry(worktree, input.protectedPaths));
+      continue;
+    }
     const status = await computeWorktreeStatus({
       repoRoot: input.repoRoot,
       repoName: input.repoName,
@@ -735,6 +772,9 @@ async function applyOne(entry, options) {
   if (entry.orphan) {
     return reclaimOrphan(entry, options);
   }
+  if (entry.prunable) {
+    return reclaimPrunable(entry, options);
+  }
   if (entry.class === "hold") {
     return { path: entry.path, branch: entry.branch, result: "held" };
   }
@@ -784,6 +824,9 @@ async function applyGc(plan, options) {
 async function reclaimOneWorktree(worktreePath, options) {
   const worktree = await findWorktree(options.repoRoot, worktreePath);
   if (!worktree) return null;
+  if (worktree.prunable) {
+    return applyOne(makePrunablePlanEntry(worktree, options.protectedPaths), options);
+  }
   const status = await computeWorktreeStatus({
     repoRoot: options.repoRoot,
     repoName: options.repoName,