@fitchmultz/pi-subagents 0.44.7 → 0.46.0

package/dist/runs/shared/worktree.js

@@ -1,96 +1,27 @@
-import { spawn, spawnSync } from "node:child_process";
-import { addAbortListener } from "node:events";
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
-import { TEMP_ROOT_DIR } from "../../shared/types.js";
+import { errorMessage as getErrorMessage, hasErrorCode } from "../../shared/unknown.js";
+import { markWorktreesForPreservation } from "./worktree-preservation.js";
+import { buildWorktreeBranch, buildWorktreePath } from "./worktree-location.js";
+export { findWorktreeTaskCwdConflict, formatWorktreeTaskCwdConflict, resolveExpectedWorktreeAgentCwd, } from "./worktree-location.js";
 import { ensureTempRoot } from "../../shared/temp-root.js";
-import { trySignalChildTree } from "../../shared/post-exit-stdio-guard.js";
+import { runGitChecked, runSetupCommand, runSetupGit } from "./worktree-process.js";
+import { DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS, resolveWorktreeSetupHook, runWorktreeSetupHook, } from "./worktree-hook.js";
 export class WorktreeCleanupError extends Error {
 }
-const DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS = 30000;
-function runGit(cwd, args) {
-    const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8" });
-    return {
-        stdout: result.stdout ?? "",
-        stderr: result.stderr ?? "",
-        status: result.status,
-    };
-}
-function runGitChecked(cwd, args) {
-    const result = runGit(cwd, args);
-    if (result.status !== 0) {
-        const command = `git -C ${cwd} ${args.join(" ")}`;
-        const message = result.stderr.trim() || result.stdout.trim() || `${command} failed`;
-        throw new Error(message);
-    }
-    return result.stdout;
-}
-function runSetupCommand(command, args, cwd, signal, input, timeoutMs) {
-    signal?.throwIfAborted();
-    return new Promise((resolve, reject) => {
-        let stdout = "";
-        let stderr = "";
-        let outputBytes = 0;
-        let failure;
-        const child = spawn(command, args, { cwd, detached: true, stdio: "pipe" });
-        const terminate = () => { trySignalChildTree(child, "SIGKILL"); };
-        const abortListener = signal && addAbortListener(signal, terminate);
-        const timer = timeoutMs === undefined ? undefined : setTimeout(() => {
-            failure = new Error(`worktree setup hook timed out after ${timeoutMs}ms`);
-            terminate();
-        }, timeoutMs);
-        timer?.unref();
-        for (const stream of [child.stdout, child.stderr]) {
-            stream.setEncoding("utf8");
-            stream.on("data", (chunk) => {
-                outputBytes += Buffer.byteLength(chunk);
-                // Keep the previous spawnSync output bound.
-                if (outputBytes > 1024 * 1024) {
-                    failure ??= new Error(`${command} output exceeded 1048576 bytes`);
-                    terminate();
-                }
-                else if (stream === child.stdout)
-                    stdout += chunk;
-                else
-                    stderr += chunk;
-            });
-        }
-        child.on("error", (error) => { failure = error; terminate(); });
-        child.on("exit", (status) => { if (status !== 0)
-            terminate(); });
-        child.on("close", (status) => {
-            clearTimeout(timer);
-            abortListener?.[Symbol.dispose]();
-            if (signal?.aborted)
-                reject(signal.reason);
-            else if (failure)
-                reject(failure);
-            else
-                resolve({ stdout, stderr, status });
-        });
-        child.stdin.on("error", (error) => {
-            if (error.code === "EPIPE")
-                return; // The hook can exit without reading its payload.
-            failure = error;
-            terminate();
-        });
-        child.stdin.end(input);
-    });
-}
-async function runSetupGit(cwd, args, signal) {
-    const result = await runSetupCommand("git", ["-C", cwd, ...args], cwd, signal);
-    if (result.status !== 0) {
-        throw new Error(result.stderr.trim() || result.stdout.trim() || `git -C ${cwd} ${args.join(" ")} failed`);
-    }
-    return result.stdout;
-}
 async function resolveRepoState(cwd, signal) {
-    const repoCheck = await runSetupCommand("git", ["-C", cwd, "rev-parse", "--is-inside-work-tree"], cwd, signal);
+    const repoCheck = await runSetupCommand({
+        command: "git",
+        args: ["-C", cwd, "rev-parse", "--is-inside-work-tree"],
+        cwd,
+        signal,
+    });
     if (repoCheck.status !== 0 || repoCheck.stdout.trim() !== "true") {
         throw new Error("worktree isolation requires a git repository");
     }
-    const cwdRelative = (await runSetupGit(cwd, ["rev-parse", "--show-prefix"], signal)).trim().replace(/[\\/]+$/, "");
+    const cwdRelative = (await runSetupGit(cwd, ["rev-parse", "--show-prefix"], signal))
+        .trim()
+        .replace(/[\\/]+$/, "");
     const toplevel = (await runSetupGit(cwd, ["rev-parse", "--show-toplevel"], signal)).trim();
     const status = await runSetupGit(toplevel, ["status", "--porcelain"], signal);
     if (status.trim().length > 0) {
@@ -99,184 +30,37 @@ async function resolveRepoState(cwd, signal) {
     const baseCommit = (await runSetupGit(toplevel, ["rev-parse", "HEAD"], signal)).trim();
     return { toplevel, cwdRelative, baseCommit };
 }
-function normalizeComparableCwd(cwd) {
-    const resolved = path.resolve(cwd);
-    try {
-        return fs.realpathSync(resolved);
-    }
-    catch {
-        // Use the unresolved absolute path when realpath resolution is unavailable.
-        return resolved;
-    }
-}
-export function findWorktreeTaskCwdConflict(tasks, sharedCwd) {
-    const normalizedSharedCwd = normalizeComparableCwd(sharedCwd);
-    for (let index = 0; index < tasks.length; index++) {
-        const task = tasks[index];
-        if (!task.cwd)
-            continue;
-        const taskCwd = path.isAbsolute(task.cwd) ? task.cwd : path.resolve(sharedCwd, task.cwd);
-        if (normalizeComparableCwd(taskCwd) === normalizedSharedCwd)
-            continue;
-        return { index, agent: task.agent, cwd: task.cwd };
-    }
-    return undefined;
-}
-export function formatWorktreeTaskCwdConflict(conflict, sharedCwd) {
-    return `worktree isolation uses the shared cwd (${sharedCwd}); task ${conflict.index + 1} (${conflict.agent}) sets cwd to ${conflict.cwd}. Remove task-level cwd overrides or disable worktree.`;
-}
 function safePatchAgentName(agent) {
     return agent.replace(/[^\w.-]/g, "_");
 }
-function buildWorktreeBranch(runId, index) {
-    return `pi-parallel-${runId}-${index}`;
-}
-function buildWorktreePath(runId, index) {
-    return path.join(TEMP_ROOT_DIR, "worktrees", `pi-worktree-${runId}-${index}`);
+function escapesRoot(relative) {
+    return relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative);
 }
-function resolveRepoCwdRelative(cwd) {
-    const repoCheck = runGit(cwd, ["rev-parse", "--is-inside-work-tree"]);
-    if (repoCheck.status !== 0 || repoCheck.stdout.trim() !== "true") {
-        throw new Error("worktree isolation requires a git repository");
-    }
-    const rawPrefix = runGitChecked(cwd, ["rev-parse", "--show-prefix"]).trim();
-    const normalizedPrefix = rawPrefix
-        ? path.normalize(rawPrefix.replace(/[\\/]+$/, ""))
-        : "";
-    return normalizedPrefix === "." ? "" : normalizedPrefix;
-}
-export function resolveExpectedWorktreeAgentCwd(cwd, runId, index) {
-    const cwdRelative = resolveRepoCwdRelative(cwd);
-    const worktreePath = buildWorktreePath(runId, index);
-    return cwdRelative ? path.join(worktreePath, cwdRelative) : worktreePath;
-}
-function parseHookTimeout(timeoutMs) {
-    if (timeoutMs === undefined)
-        return DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS;
-    if (!Number.isInteger(timeoutMs) || timeoutMs <= 0) {
-        throw new Error("worktree setup hook timeout must be an integer greater than 0");
-    }
-    return timeoutMs;
-}
-function resolveWorktreeSetupHook(repoRoot, config) {
-    if (!config)
-        return undefined;
-    const hookPath = config.hookPath.trim();
-    if (!hookPath) {
-        throw new Error("worktree setup hook path cannot be empty");
-    }
-    const expandedHookPath = hookPath.startsWith("~/") ? path.join(os.homedir(), hookPath.slice(2)) : hookPath;
-    let resolvedPath;
-    if (path.isAbsolute(expandedHookPath)) {
-        resolvedPath = expandedHookPath;
-    }
-    else if (expandedHookPath.includes("/") || expandedHookPath.includes("\\")) {
-        resolvedPath = path.resolve(repoRoot, expandedHookPath);
-    }
-    else {
-        throw new Error("worktree setup hook must be an absolute path or a repo-relative path");
-    }
-    if (!fs.existsSync(resolvedPath)) {
-        throw new Error(`worktree setup hook not found: ${resolvedPath}`);
-    }
-    if (fs.statSync(resolvedPath).isDirectory()) {
-        throw new Error(`worktree setup hook must be a file, got directory: ${resolvedPath}`);
-    }
-    return {
-        hookPath: resolvedPath,
-        timeoutMs: parseHookTimeout(config.timeoutMs),
-    };
-}
-function normalizeSyntheticPath(worktreePath, rawPath) {
-    const trimmed = rawPath.trim();
-    if (!trimmed)
-        throw new Error("synthetic path cannot be empty");
-    if (path.isAbsolute(trimmed))
-        throw new Error(`synthetic path must be relative: ${rawPath}`);
-    const resolved = path.resolve(worktreePath, trimmed);
-    const relative = path.relative(worktreePath, resolved);
-    if (!relative || relative === ".") {
-        throw new Error(`synthetic path cannot target the worktree root: ${rawPath}`);
-    }
-    if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
-        throw new Error(`synthetic path escapes the worktree root: ${rawPath}`);
-    }
-    return path.normalize(relative);
-}
-async function hasTrackedEntries(worktreePath, relativePath, signal) {
-    const result = await runSetupCommand("git", ["-C", worktreePath, "ls-files", "--", relativePath], worktreePath, signal);
-    return result.status === 0 && result.stdout.trim().length > 0;
-}
-function parseWorktreeSetupHookOutput(rawStdout) {
-    const trimmed = rawStdout.trim();
-    if (!trimmed) {
-        throw new Error("worktree setup hook returned empty stdout; expected JSON object");
-    }
-    let parsed;
+function readSyntheticStat(resolved) {
     try {
-        parsed = JSON.parse(trimmed);
+        return fs.lstatSync(resolved);
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`worktree setup hook returned invalid JSON: ${message}`);
-    }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-        throw new Error("worktree setup hook stdout must be a JSON object");
-    }
-    return parsed;
-}
-async function runWorktreeSetupHook(hook, input, signal) {
-    let result;
-    try {
-        result = await runSetupCommand(hook.hookPath, [], input.worktreePath, signal, JSON.stringify(input), hook.timeoutMs);
-    }
-    catch (error) {
-        signal?.throwIfAborted();
-        throw new Error(`worktree setup hook failed: ${getErrorMessage(error)}`);
-    }
-    if (result.status !== 0) {
-        const details = result.stderr.trim() || result.stdout.trim() || "no output";
-        throw new Error(`worktree setup hook failed with exit code ${result.status}: ${details}`);
-    }
-    const output = parseWorktreeSetupHookOutput(result.stdout);
-    if (output.syntheticPaths === undefined)
-        return [];
-    if (!Array.isArray(output.syntheticPaths)) {
-        throw new Error("worktree setup hook output field 'syntheticPaths' must be an array of relative paths");
-    }
-    const uniquePaths = new Set();
-    for (const candidate of output.syntheticPaths) {
-        if (typeof candidate !== "string") {
-            throw new Error("worktree setup hook output field 'syntheticPaths' must contain only strings");
+        if (hasErrorCode(error, "ENOENT")) {
+            return undefined;
         }
-        const normalizedPath = normalizeSyntheticPath(input.worktreePath, candidate);
-        if (await hasTrackedEntries(input.worktreePath, normalizedPath, signal)) {
-            throw new Error(`worktree setup hook cannot mark tracked paths as synthetic: ${normalizedPath}`);
-        }
-        uniquePaths.add(normalizedPath);
+        throw error;
     }
-    return [...uniquePaths];
 }
 function removeSyntheticPath(worktree, syntheticPath) {
     const resolved = path.resolve(worktree.path, syntheticPath);
     const relative = path.relative(worktree.path, resolved);
-    if (!relative || relative === "." || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+    if (relative.length === 0 || relative === "." || escapesRoot(relative)) {
         return;
     }
-    let stat;
-    try {
-        stat = fs.lstatSync(resolved);
-    }
-    catch (error) {
-        const code = error && typeof error === "object" && "code" in error ? error.code : undefined;
-        if (code === "ENOENT")
-            return;
-        throw error;
+    const stat = readSyntheticStat(resolved);
+    if (!stat) {
+        return;
     }
     const realRoot = fs.realpathSync(worktree.path);
     const realParent = fs.realpathSync(path.dirname(resolved));
     const parentRelative = path.relative(realRoot, realParent);
-    if (parentRelative === ".." || parentRelative.startsWith(`..${path.sep}`) || path.isAbsolute(parentRelative)) {
+    if (escapesRoot(parentRelative)) {
         throw new Error(`synthetic path resolves outside the worktree: ${syntheticPath}`);
     }
     if (stat.isSymbolicLink()) {
@@ -290,28 +74,25 @@ function removeSyntheticPath(worktree, syntheticPath) {
     fs.rmSync(resolved, { force: true });
 }
 function removeSyntheticPathsBeforeDiff(worktree) {
-    if (worktree.syntheticPaths.length === 0)
+    if (worktree.syntheticPaths.length === 0) {
         return;
+    }
     const seen = new Set();
     for (const syntheticPath of worktree.syntheticPaths) {
-        if (seen.has(syntheticPath))
+        if (seen.has(syntheticPath)) {
             continue;
+        }
         seen.add(syntheticPath);
         removeSyntheticPath(worktree, syntheticPath);
     }
 }
-function emptyDiff(index, agent, branch, patchPath, worktreePath, captureError) {
+function emptyDiff(input) {
     return {
-        index,
-        agent,
-        branch,
+        ...input,
         diffStat: "",
         filesChanged: 0,
         insertions: 0,
         deletions: 0,
-        patchPath,
-        ...(worktreePath ? { worktreePath } : {}),
-        ...(captureError ? { captureError } : {}),
     };
 }
 function parseNumstat(numstat) {
@@ -323,26 +104,48 @@ function parseNumstat(numstat) {
     let insertions = 0;
     let deletions = 0;
     for (const line of lines) {
-        const [rawInsertions, rawDeletions] = line.split("\t");
-        if (rawInsertions === undefined || rawDeletions === undefined)
+        const columns = line.split("\t");
+        if (columns.length < 2) {
             continue;
+        }
+        const [rawInsertions, rawDeletions] = columns;
         filesChanged++;
-        if (/^\d+$/.test(rawInsertions))
+        if (/^\d+$/.test(rawInsertions)) {
             insertions += parseInt(rawInsertions, 10);
-        if (/^\d+$/.test(rawDeletions))
+        }
+        if (/^\d+$/.test(rawDeletions)) {
             deletions += parseInt(rawDeletions, 10);
+        }
     }
     return { filesChanged, insertions, deletions };
 }
 function captureWorktreeDiff(setup, worktree, agent, patchPath) {
     removeSyntheticPathsBeforeDiff(worktree);
     runGitChecked(worktree.path, ["add", "-A"]);
-    const diffStat = runGitChecked(worktree.path, ["diff", "--cached", "--stat", setup.baseCommit]).trim();
-    const patch = runGitChecked(worktree.path, ["diff", "--cached", "--binary", "--no-textconv", "--no-ext-diff", setup.baseCommit]);
+    const diffStat = runGitChecked(worktree.path, [
+        "diff",
+        "--cached",
+        "--stat",
+        setup.baseCommit,
+    ]).trim();
+    const patch = runGitChecked(worktree.path, [
+        "diff",
+        "--cached",
+        "--binary",
+        "--no-textconv",
+        "--no-ext-diff",
+        setup.baseCommit,
+    ]);
     const numstat = runGitChecked(worktree.path, ["diff", "--cached", "--numstat", setup.baseCommit]);
     fs.writeFileSync(patchPath, patch, "utf-8");
-    if (!patch.trim()) {
-        return emptyDiff(worktree.index, agent, worktree.branch, patchPath, worktree.path);
+    if (patch.trim().length === 0) {
+        return emptyDiff({
+            index: worktree.index,
+            agent,
+            branch: worktree.branch,
+            patchPath,
+            worktreePath: worktree.path,
+        });
     }
     const parsed = parseNumstat(numstat);
     return {
@@ -380,67 +183,102 @@ function cleanupSingleWorktree(repoCwd, worktree) {
     }
 }
 function hasWorktreeChanges(diff) {
-    return Boolean(diff.captureError) || diff.filesChanged > 0 || diff.insertions > 0 || diff.deletions > 0 || diff.diffStat.trim().length > 0;
-}
-function getErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
+    return (Boolean(diff.captureError) ||
+        diff.filesChanged > 0 ||
+        diff.insertions > 0 ||
+        diff.deletions > 0 ||
+        diff.diffStat.trim().length > 0);
+}
+async function reserveWorktree(plan, index) {
+    const { repo, signal } = plan;
+    const branch = buildWorktreeBranch(plan.runId, index);
+    const worktreePath = buildWorktreePath(plan.runId, index);
+    ensureTempRoot();
+    const pathExisted = fs.existsSync(worktreePath);
+    const branchExisted = (await runSetupGit(repo.toplevel, ["branch", "--list", branch], signal)).trim().length > 0;
+    // Reserve only resources this attempt can create, before Git can partially initialize them.
+    const agentCwd = repo.cwdRelative.length > 0 ? path.join(worktreePath, repo.cwdRelative) : worktreePath;
+    return {
+        worktree: { path: worktreePath, agentCwd, branch, index, syntheticPaths: [] },
+        reservation: {
+            path: pathExisted ? undefined : worktreePath,
+            branch: branchExisted ? undefined : branch,
+        },
+    };
 }
-function markWorktreesForPreservation(setup, reason) {
-    setup.preserveOnCleanup = true;
-    setup.preservationReason = setup.preservationReason
-        ? `${setup.preservationReason}; ${reason}`
-        : reason;
+async function initializeWorktree(plan, worktree) {
+    const { repo, signal } = plan;
+    const { path: worktreePath, agentCwd, branch, index } = worktree;
+    await runSetupGit(repo.toplevel, ["worktree", "add", worktreePath, "-b", branch, "HEAD"], signal);
+    const syntheticPaths = plan.hook
+        ? await runWorktreeSetupHook(plan.hook, {
+            version: 1,
+            repoRoot: repo.toplevel,
+            worktreePath,
+            agentCwd,
+            branch,
+            index,
+            runId: plan.runId,
+            baseCommit: repo.baseCommit,
+            agent: plan.agents?.[index],
+        }, signal)
+        : [];
+    return { path: worktreePath, agentCwd, branch, index, syntheticPaths };
+}
+async function rollbackWorktree(repoCwd, entry, signal) {
+    const failures = [];
+    if (entry.path !== undefined && fs.existsSync(entry.path)) {
+        try {
+            // An interrupted checkout can leave Git's initializing lock on this newly owned path.
+            await runSetupGit(repoCwd, ["worktree", "remove", "--force", "--force", entry.path], signal);
+        }
+        catch (error) {
+            failures.push(`Could not remove worktree '${entry.path}': ${getErrorMessage(error)}`);
+        }
+    }
+    if (entry.branch !== undefined) {
+        try {
+            const exists = (await runSetupGit(repoCwd, ["branch", "--list", entry.branch], signal)).trim();
+            if (exists.length > 0) {
+                await runSetupGit(repoCwd, ["branch", "-D", entry.branch], signal);
+            }
+        }
+        catch (error) {
+            failures.push(`Could not delete worktree branch '${entry.branch}': ${getErrorMessage(error)}`);
+        }
+    }
+    return failures;
 }
 export async function createWorktrees(cwd, runId, count, options) {
     const signal = options?.signal;
     const repo = await resolveRepoState(cwd, signal);
-    const setupHook = resolveWorktreeSetupHook(repo.toplevel, options?.setupHook);
+    const hook = resolveWorktreeSetupHook(repo.toplevel, options?.setupHook);
+    const plan = { repo, runId, hook, signal, agents: options?.agents };
     const worktrees = [];
-    const rollback = [];
+    const reservations = [];
     try {
         for (let index = 0; index < count; index++) {
-            const branch = buildWorktreeBranch(runId, index);
-            const worktreePath = buildWorktreePath(runId, index);
-            ensureTempRoot();
-            const pathExisted = fs.existsSync(worktreePath);
-            const branchExisted = (await runSetupGit(repo.toplevel, ["branch", "--list", branch], signal)).trim().length > 0;
-            rollback.push({ path: pathExisted ? undefined : worktreePath, branch: branchExisted ? undefined : branch });
-            await runSetupGit(repo.toplevel, ["worktree", "add", worktreePath, "-b", branch, "HEAD"], signal);
-            const agentCwd = repo.cwdRelative ? path.join(worktreePath, repo.cwdRelative) : worktreePath;
-            const syntheticPaths = setupHook ? await runWorktreeSetupHook(setupHook, {
-                version: 1, repoRoot: repo.toplevel, worktreePath, agentCwd, branch, index, runId,
-                baseCommit: repo.baseCommit, agent: options?.agents?.[index],
-            }, signal) : [];
-            worktrees.push({ path: worktreePath, agentCwd, branch, index, syntheticPaths });
+            // Git modifies a shared repository; finish setup before reserving the next worktree.
+            // oxlint-disable-next-line no-await-in-loop
+            const { worktree, reservation } = await reserveWorktree(plan, index);
+            reservations.push(reservation);
+            // Register rollback authority before Git can partially initialize this worktree.
+            // oxlint-disable-next-line no-await-in-loop
+            worktrees.push(await initializeWorktree(plan, worktree));
         }
     }
     catch (error) {
-        // Rollback still runs after Stop, but its own Git hooks must not hang the owner.
-        const cleanupSignal = AbortSignal.timeout(setupHook?.timeoutMs ?? DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS);
+        // Rollback remains owned after cancellation and has its own bounded lifetime.
+        const cleanupSignal = AbortSignal.timeout(hook?.timeoutMs ?? DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS);
         const failures = [];
-        for (const entry of rollback.reverse()) {
-            if (entry.path && fs.existsSync(entry.path)) {
-                try {
-                    // Interrupted checkout can leave Git's "initializing" lock on this new worktree.
-                    await runSetupGit(repo.toplevel, ["worktree", "remove", "--force", "--force", entry.path], cleanupSignal);
-                }
-                catch (cleanupError) {
-                    failures.push(`Could not remove worktree '${entry.path}': ${getErrorMessage(cleanupError)}`);
-                }
-            }
-            if (entry.branch) {
-                try {
-                    const exists = (await runSetupGit(repo.toplevel, ["branch", "--list", entry.branch], cleanupSignal)).trim();
-                    if (exists)
-                        await runSetupGit(repo.toplevel, ["branch", "-D", entry.branch], cleanupSignal);
-                }
-                catch (cleanupError) {
-                    failures.push(`Could not delete worktree branch '${entry.branch}': ${getErrorMessage(cleanupError)}`);
-                }
-            }
+        for (const entry of reservations.reverse()) {
+            // Reverse-order resource release must finish before removing the preceding reservation.
+            // oxlint-disable-next-line no-await-in-loop
+            failures.push(...(await rollbackWorktree(repo.toplevel, entry, cleanupSignal)));
+        }
+        if (failures.length > 0) {
+            throw new WorktreeCleanupError(`${getErrorMessage(error)}\n\nWorktree rollback incomplete:\n${failures.join("\n")}`, { cause: error });
         }
-        if (failures.length)
-            throw new WorktreeCleanupError(`${getErrorMessage(error)}\n\nWorktree rollback incomplete:\n${failures.join("\n")}`);
         throw error;
     }
     return { cwd: repo.toplevel, worktrees, baseCommit: repo.baseCommit };
@@ -455,7 +293,14 @@ export function diffWorktrees(setup, agents, diffsDir) {
         return setup.worktrees.map((worktree, index) => {
             const agent = agents[index] ?? `task-${index + 1}`;
             const patchPath = path.join(diffsDir, `task-${index}-${safePatchAgentName(agent)}.patch`);
-            return emptyDiff(index, agent, worktree.branch, patchPath, worktree.path, message);
+            return emptyDiff({
+                index,
+                agent,
+                branch: worktree.branch,
+                patchPath,
+                worktreePath: worktree.path,
+                captureError: message,
+            });
         });
     }
     const diffs = [];
@@ -470,14 +315,22 @@ export function diffWorktrees(setup, agents, diffsDir) {
             const message = `failed to capture worktree diff for task ${index + 1} (${agent}) at '${worktree.path}': ${getErrorMessage(error)}`;
             markWorktreesForPreservation(setup, message);
             writeEmptyPatch(patchPath);
-            diffs.push(emptyDiff(index, agent, worktree.branch, patchPath, worktree.path, message));
+            diffs.push(emptyDiff({
+                index,
+                agent,
+                branch: worktree.branch,
+                patchPath,
+                worktreePath: worktree.path,
+                captureError: message,
+            }));
         }
     }
     return diffs;
 }
 export function cleanupWorktrees(setup) {
-    if (setup.preserveOnCleanup)
+    if (setup.preserveOnCleanup === true) {
         return;
+    }
     for (let index = setup.worktrees.length - 1; index >= 0; index--) {
         cleanupSingleWorktree(setup.cwd, setup.worktrees[index]);
     }
@@ -488,26 +341,33 @@ export function cleanupWorktrees(setup) {
         console.error(`Failed to prune worktrees in '${setup.cwd}': ${getErrorMessage(error)}`);
     }
 }
+function worktreeRecoveryLines(diff) {
+    if (diff.captureError === undefined || diff.captureError.length === 0) {
+        return [];
+    }
+    const lines = [`Diff capture failed: ${diff.captureError}`];
+    if (diff.worktreePath !== undefined && diff.worktreePath.length > 0) {
+        lines.push(`Preserved worktree: ${diff.worktreePath}`);
+    }
+    lines.push(`Preserved branch: ${diff.branch}`);
+    return lines;
+}
 export function formatWorktreeDiffSummary(diffs) {
     const changed = diffs.filter(hasWorktreeChanges);
-    if (changed.length === 0)
+    if (changed.length === 0) {
         return "";
+    }
     const lines = ["=== Worktree Changes ===", ""];
     for (const diff of changed) {
         lines.push(`--- Task ${diff.index + 1} (${diff.agent}): ${diff.filesChanged} files changed, +${diff.insertions} -${diff.deletions} ---`);
-        if (diff.captureError) {
-            lines.push(`Diff capture failed: ${diff.captureError}`);
-            if (diff.worktreePath)
-                lines.push(`Preserved worktree: ${diff.worktreePath}`);
-            lines.push(`Preserved branch: ${diff.branch}`);
-        }
+        lines.push(...worktreeRecoveryLines(diff));
         if (diff.diffStat.trim().length > 0) {
             lines.push(diff.diffStat);
         }
         lines.push("");
     }
-    const patchesDir = path.dirname(changed[0].patchPath);
-    if (changed.some((diff) => !diff.captureError)) {
+    const patchesDir = path.dirname(changed[0]?.patchPath ?? "");
+    if (changed.some((diff) => (diff.captureError ?? "").length === 0)) {
         lines.push(`Full patches: ${patchesDir}`);
     }
     else {
@@ -516,10 +376,11 @@ export function formatWorktreeDiffSummary(diffs) {
     return lines.join("\n").trimEnd();
 }
 export function formatParallelWorktreeSummary(worktreeSetup, diffsDir, agents) {
-    if (!worktreeSetup)
+    if (!worktreeSetup) {
         return "";
+    }
     return formatWorktreeDiffSummary(diffWorktrees(worktreeSetup, agents, diffsDir));
 }
 export function appendWorktreeSummary(output, worktreeSummary) {
-    return worktreeSummary ? `${output}\n\n${worktreeSummary}` : output;
+    return worktreeSummary.length > 0 ? `${output}\n\n${worktreeSummary}` : output;
 }