Preserve a worktree instead of silently dropping its stash entry

git status never reports a git stash the sub-agent ran mid-task, so a
worktree holding one looked clean and got removed automatically — the
stash entry survives in the repo's shared refs/stash either way, but
went silently orphaned with no indication of which worktree it came
from. createSubAgentWorktree now captures the stash list as a baseline;
cleanup diffs the current list against it and preserves the worktree
with a notice naming the new stash entries instead of removing it.

Also preserves the caught error as "cause" on both WorktreeError throw
sites in this file, and collapses two stray double blank lines.

Author: TheGreatAxios

src/subagent/task-tool-worktree.test.ts

@@ -169,4 +169,45 @@ describe("createTaskTool worktree isolation", () => {
     const { stdout } = await run("git", ["worktree", "list"], { cwd: repo });
     expect(stdout).toContain(worktreePath!);
   });
+
+  test("preserves a worktree the sub-agent left stashed, with a notice naming the stash", async () => {
+    const repo = await makeRepo();
+    tempDirs.push(repo);
+    const workdirBase = await mkdtemp(join(tmpdir(), "corbits-workdir-"));
+    tempDirs.push(workdirBase);
+
+    let worktreePath: string | undefined;
+    const tool = createTaskTool({
+      permissionGate: testPermissionGate,
+      cwd: repo,
+      getWorkdirBase: () => workdirBase,
+      provider,
+      useWorktree: true,
+      run: async (params) => {
+        worktreePath = params.cwd;
+        // Simulate the sub-agent stashing mid-task: `git status` reports
+        // clean afterward even though the work is not actually gone — it is
+        // parked in the repo's shared refs/stash.
+        await writeFile(join(params.cwd, "wip.txt"), "half-finished change");
+        await run("git", ["add", "."], { cwd: params.cwd });
+        await run("git", ["stash"], { cwd: params.cwd });
+        return "done";
+      },
+    });
+
+    const result = await callTask(tool, { description: "Stashing job", prompt: "Do the work" });
+
+    expect(result).toContain("done");
+    expect(result).toContain("stash");
+    expect(worktreePath).toBeDefined();
+
+    // The worktree itself is preserved rather than silently removed —
+    // `git status` alone would have called this clean.
+    const { stdout } = await run("git", ["worktree", "list"], { cwd: repo });
+    expect(stdout).toContain(worktreePath!);
+
+    // The stash entry the sub-agent created is still recoverable.
+    const { stdout: stashList } = await run("git", ["stash", "list"], { cwd: repo });
+    expect(stashList).toContain("stash@{0}");
+  });
 });

src/subagent/task-tool.ts

@@ -490,11 +490,13 @@ export function createTaskTool(deps: TaskToolDeps): AgentTool {
       }
 
       let worktreeCwd: string | undefined;
+      let worktreeStashBaseline: readonly string[] = [];
       if (deps.useWorktree === true) {
         const worktreePath = join(deps.getWorkdirBase(), "worktrees", generateSessionId());
         try {
           const worktree = await createSubAgentWorktree(deps.cwd, worktreePath);
           worktreeCwd = worktree.path;
+          worktreeStashBaseline = worktree.stashBaseline;
         } catch (err) {
           // Admit already happened and the strip session may be "running" —
           // release the ledger slot and fail the session so a worktree setup
@@ -514,7 +516,7 @@ export function createTaskTool(deps: TaskToolDeps): AgentTool {
       // (or preserved with a notice) rather than leaked.
       const finishWithWorktree = async (result: ToolResult): Promise<ToolResult> => {
         if (worktreeCwd === undefined) return result;
-        const cleanup = await cleanupSubAgentWorktree(deps.cwd, worktreeCwd);
+        const cleanup = await cleanupSubAgentWorktree(deps.cwd, worktreeCwd, worktreeStashBaseline);
         if (cleanup.status === "preserved") {
           return { ...result, content: `${result.content}\n\n${cleanup.notice}` };
         }
@@ -583,7 +585,6 @@ const reported = appendSubAgentParentHints(result, hintOptions);
           taskToolResult(call.id, `Sub-agent "${description}" reported:\n\n${reported}`),
         );
 
-
       } catch (err) {
         if (
           isSubAgentCancelError(err, childCtl.signal) ||

src/subagent/worktree.test.ts

@@ -26,15 +26,28 @@ describe("createSubAgentWorktree", () => {
     const { exec, calls } = recordingExec({
       "rev-parse": { stdout: "/repo\n" },
       worktree: { stdout: "" },
+      stash: { stdout: "" },
     });
     const result = await createSubAgentWorktree("/repo", "/repo/.worktrees/abc", exec);
     expect(result.path).toBe("/repo/.worktrees/abc");
+    expect(result.stashBaseline).toEqual([]);
     expect(calls).toEqual([
       ["rev-parse", "--show-toplevel"],
       ["worktree", "add", "--detach", "/repo/.worktrees/abc", "HEAD"],
+      ["stash", "list"],
     ]);
   });
 
+  test("captures the current stash list as a baseline", async () => {
+    const { exec } = recordingExec({
+      "rev-parse": { stdout: "/repo\n" },
+      worktree: { stdout: "" },
+      stash: { stdout: "stash@{0}: WIP on main: abc1234 pre-existing stash\n" },
+    });
+    const result = await createSubAgentWorktree("/repo", "/repo/.worktrees/abc", exec);
+    expect(result.stashBaseline).toEqual(["stash@{0}: WIP on main: abc1234 pre-existing stash"]);
+  });
+
   test("fails closed when repoCwd is not a git repository", async () => {
     const { exec } = recordingExec({
       "rev-parse": { error: new Error("not a git repository") },
@@ -56,15 +69,17 @@ describe("createSubAgentWorktree", () => {
 });
 
 describe("cleanupSubAgentWorktree", () => {
-  test("removes a clean worktree", async () => {
+  test("removes a clean worktree with no new stash entries", async () => {
     const { exec, calls } = recordingExec({
       status: { stdout: "" },
+      stash: { stdout: "" },
       worktree: { stdout: "" },
     });
-    const result = await cleanupSubAgentWorktree("/repo", "/repo/.worktrees/abc", exec);
+    const result = await cleanupSubAgentWorktree("/repo", "/repo/.worktrees/abc", [], exec);
     expect(result).toEqual({ status: "removed", path: "/repo/.worktrees/abc" });
     expect(calls).toEqual([
       ["status", "--porcelain", "--ignored"],
+      ["stash", "list"],
       ["worktree", "remove", "/repo/.worktrees/abc"],
     ]);
   });
@@ -73,7 +88,7 @@ describe("cleanupSubAgentWorktree", () => {
     const { exec, calls } = recordingExec({
       status: { stdout: "!! dist/output.txt\n" },
     });
-    const result = await cleanupSubAgentWorktree("/repo", "/repo/.worktrees/abc", exec);
+    const result = await cleanupSubAgentWorktree("/repo", "/repo/.worktrees/abc", [], exec);
     expect(result.status).toBe("preserved");
     if (result.status === "preserved") {
       expect(result.notice).toContain("uncommitted changes");
@@ -85,7 +100,7 @@ describe("cleanupSubAgentWorktree", () => {
     const { exec, calls } = recordingExec({
       status: { stdout: " M src/index.ts\n" },
     });
-    const result = await cleanupSubAgentWorktree("/repo", "/repo/.worktrees/abc", exec);
+    const result = await cleanupSubAgentWorktree("/repo", "/repo/.worktrees/abc", [], exec);
     expect(result.status).toBe("preserved");
     expect(result).toMatchObject({ path: "/repo/.worktrees/abc" });
     if (result.status === "preserved") {
@@ -99,19 +114,45 @@ describe("cleanupSubAgentWorktree", () => {
     const { exec } = recordingExec({
       status: { error: new Error("no such directory") },
     });
-    const result = await cleanupSubAgentWorktree("/repo", "/repo/.worktrees/abc", exec);
+    const result = await cleanupSubAgentWorktree("/repo", "/repo/.worktrees/abc", [], exec);
     expect(result.status).toBe("preserved");
   });
 
   test("preserves the worktree when removal fails", async () => {
-    const { exec } = recordingExec({
+    const { exec, calls } = recordingExec({
       status: { stdout: "" },
+      stash: { stdout: "" },
       worktree: { error: new Error("worktree is locked") },
     });
-    const result = await cleanupSubAgentWorktree("/repo", "/repo/.worktrees/abc", exec);
+    const result = await cleanupSubAgentWorktree("/repo", "/repo/.worktrees/abc", [], exec);
     expect(result.status).toBe("preserved");
     if (result.status === "preserved") {
       expect(result.notice).toContain("could not be removed automatically");
     }
   });
+
+  test("preserves a clean worktree that created a new stash entry", async () => {
+    const { exec, calls } = recordingExec({
+      status: { stdout: "" },
+      stash: { stdout: "stash@{0}: WIP on (no branch): abc1234 sub-agent work\n" },
+    });
+    const result = await cleanupSubAgentWorktree("/repo", "/repo/.worktrees/abc", [], exec);
+    expect(result.status).toBe("preserved");
+    if (result.status === "preserved") {
+      expect(result.notice).toContain("stash entry");
+      expect(result.notice).toContain("stash@{0}");
+    }
+    expect(calls.some((call) => call[0] === "worktree")).toBe(false);
+  });
+
+  test("does not flag a stash entry that predates this worktree", async () => {
+    const preexisting = "stash@{0}: WIP on main: abc1234 unrelated older stash";
+    const { exec } = recordingExec({
+      status: { stdout: "" },
+      stash: { stdout: `${preexisting}\n` },
+      worktree: { stdout: "" },
+    });
+    const result = await cleanupSubAgentWorktree("/repo", "/repo/.worktrees/abc", [preexisting], exec);
+    expect(result).toEqual({ status: "removed", path: "/repo/.worktrees/abc" });
+  });
 });

src/subagent/worktree.ts

@@ -20,8 +20,26 @@ export class WorktreeError extends Error {}
 
 export type SubAgentWorktree = {
   path: string;
+  // The repo's `git stash list` output at the moment this worktree was
+  // created (see stashList). Stash refs live on the shared repo, not the
+  // worktree, so cleanup diffs against this baseline to notice stash entries
+  // the sub-agent created while it ran — see cleanupSubAgentWorktree.
+  stashBaseline: string[];
 };
 
+// The repo's stash list as an array of "stash@{N}: <message>" lines (empty
+// when there are none, or when the lookup itself fails — a failed lookup
+// must never make cleanup MORE willing to remove a worktree, so it degrades
+// to "no visible change" rather than to "worktree is clean").
+async function stashList(repoCwd: string, exec: WorktreeExec): Promise<string[]> {
+  try {
+    const { stdout } = await exec(["stash", "list"], { cwd: repoCwd });
+    return stdout.split("\n").filter((line) => line.trim().length > 0);
+  } catch {
+    return [];
+  }
+}
+
 // Creates a fresh git worktree at `path`, detached at the current HEAD of
 // `repoCwd`. Fails closed: `repoCwd` must be inside a git working tree and
 // `git worktree add` must succeed, or this throws WorktreeError with a
@@ -33,31 +51,41 @@ export async function createSubAgentWorktree(
 ): Promise<SubAgentWorktree> {
   try {
     await exec(["rev-parse", "--show-toplevel"], { cwd: repoCwd });
-  } catch {
+  } catch (err) {
     throw new WorktreeError(
       `Cannot create an isolated sub-agent worktree: "${repoCwd}" is not inside a git repository.`,
+      { cause: err },
     );
   }
   try {
     await exec(["worktree", "add", "--detach", path, "HEAD"], { cwd: repoCwd });
   } catch (err) {
     throw new WorktreeError(
       `Failed to create sub-agent worktree at "${path}": ${err instanceof Error ? err.message : String(err)}`,
+      { cause: err },
     );
   }
-  return { path };
+  const stashBaseline = await stashList(repoCwd, exec);
+  return { path, stashBaseline };
 }
 
 export type WorktreeCleanupResult =
   | { status: "removed"; path: string }
   | { status: "preserved"; path: string; notice: string };
 
-// Removes the worktree if it has no uncommitted changes; otherwise leaves it
-// in place (the sub-agent's work is not ours to discard) and returns a
-// notice the caller should surface to the operator.
+// Removes the worktree if it has no uncommitted changes and no new stash
+// entries; otherwise leaves it in place (the sub-agent's work is not ours to
+// discard) and returns a notice the caller should surface to the operator.
+// `git status` never reports a `git stash` the sub-agent ran mid-task — the
+// stash itself survives in the repo's shared refs/stash either way, but
+// without this check it goes silently orphaned with no indication of which
+// worktree it came from. `stashBaseline` (from createSubAgentWorktree) is
+// diffed against the current stash list so only entries created since this
+// worktree was checked out are attributed to it.
 export async function cleanupSubAgentWorktree(
   repoCwd: string,
   path: string,
+  stashBaseline: readonly string[] = [],
   exec: WorktreeExec = defaultExec,
 ): Promise<WorktreeCleanupResult> {
   let dirty: boolean;
@@ -79,6 +107,18 @@ export async function cleanupSubAgentWorktree(
       notice: `Sub-agent worktree at ${path} has uncommitted changes and was left in place.`,
     };
   }
+  const currentStashes = await stashList(repoCwd, exec);
+  const baselineSet = new Set(stashBaseline);
+  const newStashes = currentStashes.filter((entry) => !baselineSet.has(entry));
+  if (newStashes.length > 0) {
+    return {
+      status: "preserved",
+      path,
+      notice: `Sub-agent worktree at ${path} was left in place: it created ${
+        newStashes.length === 1 ? "a stash entry" : `${newStashes.length} stash entries`
+      } that would otherwise go unrecovered (${newStashes.join("; ")}).`,
+    };
+  }
   try {
     await exec(["worktree", "remove", path], { cwd: repoCwd });
   } catch (err) {

src/tui/components/operator-modal.tsx

@@ -44,7 +44,6 @@ function renderMarkdownLines(lines: readonly StyledSegment[][]): ReactNode {
   );
 }
 
-
 // Two-column layout when all options are short enough to fit side by side.
 // Each column gets half the inner width minus a small gap for the number prefix.
 function renderOptionsGrid(options: string[], selected: number, innerWidth: number): ReactNode {