oira666_pi-subagent 0.2.2 → 0.2.4

package/README.md

@@ -24,6 +24,7 @@ pi remove npm:oira666_pi-subagent
 
 Each subagent runs as a **separate `pi` process** — fully isolated memory, its own model/tool loop.
 Processes are spawned via the operating system and communicate through JSON-line stdout.
+Subagent sessions are persisted separately under a `sessions-subagents` directory (a sibling of Pi's normal `sessions` directory), so they can be resumed without mixing into the main session list.
 
 - Full OS-level isolation — a crashed subagent cannot affect the parent
 - True parallel execution across all CPU cores
@@ -119,6 +120,20 @@ pi --no-subagent-prevent-cycles   # allow cycles (not recommended)
 | `PI_SUBAGENT_MAX_PARALLEL_TASKS` | `16`    | Max tasks per single call                |
 | `PI_SUBAGENT_MAX_CONCURRENCY`    | `8`     | Max subagents running simultaneously     |
 
+## Subagent Session Resume
+
+Subagent subprocesses save sessions in `sessions-subagents`. When a main Pi session is resumed and its latest branch contains an unfinished `subagent` tool call (aborted, errored, or closed by Pi's synthetic unfinished-tool error), the extension can resume that delegation from the saved subagent sessions.
+
+- TUI mode asks: **Resume subagents?**
+- Non-UI modes (`pi -p`, JSON/RPC) resume automatically.
+- Already-finished subagents are reused as completed; unfinished ones continue from their own saved sessions.
+- Nested subagents use the same mechanism recursively.
+
+| Env Var | Default | Description |
+| --- | --- | --- |
+| `PI_SUBAGENT_RESUME_PROMPT` | `true` | Set to `false` to suppress the TUI yes/no prompt and auto-resume. |
+| `PI_SUBAGENT_DISABLE_RESUME` | `false` | Set to `true` to disable automatic subagent resume detection entirely. |
+
 ## Agent Discovery
 
 | Env Var                 | Description                                                  |

package/index.ts

@@ -13,6 +13,18 @@ import { Type } from "@sinclair/typebox";
 import { type AgentConfig, discoverAgents } from "./agents.js";
 import { renderCall, renderResult } from "./render.js";
 import { runAgentSubprocess, executeParallelSubprocess } from "./runner.js";
+import {
+  SUBAGENT_RESUME_DISABLE_ENV,
+  SUBAGENT_RESUME_PROMPT_ENV,
+  buildSubagentSessionDir,
+  ensureDir,
+  findLatestResumableSubagentCall,
+  getDefaultSubagentSessionRoot,
+  isFinishedResult,
+  parseBooleanEnv,
+  sameTasks,
+  type ResumableSubagentCall,
+} from "./resume.js";
 import {
   DEFAULT_MAX_PARALLEL_TASKS,
   SUBAGENT_MAX_PARALLEL_TASKS_ENV,
@@ -339,6 +351,21 @@ function getProjectAgentSessionKey(projectAgentsDir: string | null): string {
   return projectAgentsDir ?? "(unknown-project-agents-dir)";
 }
 
+function ensureSubagentToolActive(pi: ExtensionAPI): void {
+  const activeTools = pi.getActiveTools();
+  if (!activeTools.includes("subagent")) {
+    pi.setActiveTools([...activeTools, "subagent"]);
+  }
+}
+
+function hasCliInitialPrompt(argv: string[]): boolean {
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "-p" || arg === "--print") return true;
+  }
+  return false;
+}
+
 // ---------------------------------------------------------------------------
 // Extension entry point
 // ---------------------------------------------------------------------------
@@ -362,14 +389,19 @@ export default function (pi: ExtensionAPI) {
     DEFAULT_MAX_PARALLEL_TASKS;
 
   let discoveredAgents: AgentConfig[] = [];
+  let currentSessionId = "ephemeral";
+  let currentSubagentSessionRoot = "";
+  let pendingResumePlan: ResumableSubagentCall | null = null;
   const approvedProjectAgentDirsForSession = new Set<string>();
 
   // Auto-discover agents on session start
-  pi.on("session_start", async (_event, ctx) => {
+  pi.on("session_start", async (event, ctx) => {
     if (!canDelegate) return;
     try {
       const discovery = discoverAgents(ctx.cwd, "both");
       discoveredAgents = discovery.agents;
+      currentSessionId = ctx.sessionManager.getSessionId?.() ?? "ephemeral";
+      currentSubagentSessionRoot = getDefaultSubagentSessionRoot(ctx);
 
       if (discoveredAgents.length > 0 && ctx.hasUI) {
         const list = discoveredAgents
@@ -380,6 +412,36 @@ export default function (pi: ExtensionAPI) {
           "info",
         );
       }
+
+      const resumeDisabled = parseBooleanEnv(process.env[SUBAGENT_RESUME_DISABLE_ENV]) === true;
+      if (resumeDisabled || (event.reason !== "resume" && event.reason !== "startup")) return;
+
+      const plan = findLatestResumableSubagentCall(ctx);
+      if (!plan) return;
+
+      let shouldResume = true;
+      const shouldPrompt = parseBooleanEnv(process.env[SUBAGENT_RESUME_PROMPT_ENV]) !== false;
+      if (ctx.hasUI && shouldPrompt) {
+        shouldResume = await ctx.ui.confirm(
+          "Resume subagents?",
+          `The resumed session has an unfinished subagent call (${plan.tasks.length} task${plan.tasks.length === 1 ? "" : "s"}). Resume it from saved subagent sessions?`,
+        );
+      }
+      if (!shouldResume) return;
+
+      pendingResumePlan = plan;
+      ensureSubagentToolActive(pi);
+
+      // In print/json subprocesses there is already an initial CLI prompt about
+      // to be sent. Starting another prompt from session_start races with it and
+      // Pi correctly reports "agent is already processing". In that case we only
+      // seed pendingResumePlan; before_agent_start injects the exact subagent
+      // call instruction into the upcoming turn.
+      if (hasCliInitialPrompt(process.argv)) {
+        if (ctx.hasUI) ctx.ui.notify(`Resuming ${plan.tasks.length} subagents...`, "info");
+      } else {
+        pi.sendUserMessage(`Resuming ${plan.tasks.length} subagents...`);
+      }
     } catch (err) {
       console.error("[pi-subagent] Error in session_start:", err);
     }
@@ -394,9 +456,15 @@ export default function (pi: ExtensionAPI) {
       const agentList = discoveredAgents
         .map((a) => `- **${a.name}**: ${a.description}`)
         .join("\n");
+      if (pendingResumePlan) ensureSubagentToolActive(pi);
+      const resumeInstruction = pendingResumePlan
+        ? `\n\n## Interrupted Subagent Resume\n\nThe user approved resuming an interrupted subagent delegation. The \`subagent\` tool has been enabled for this turn. You MUST call the \`subagent\` tool exactly once now with these exact arguments and no other tool calls first:\n\n\`\`\`json\n${JSON.stringify({ tasks: pendingResumePlan.tasks }, null, 2)}\n\`\`\`\n`
+        : "";
+
       return {
         systemPrompt:
           event.systemPrompt +
+          resumeInstruction +
           `\n\n## Available Subagents
 
 The following subagents are available via the \`subagent\` tool:
@@ -453,7 +521,7 @@ calls one after another. Do NOT put dependent tasks in the same array.
       ].join("\n"),
       parameters: SubagentParams,
 
-      async execute(_toolCallId, params, signal, onUpdate, ctx) {
+      async execute(toolCallId, params, signal, onUpdate, ctx) {
         try {
           const discovery = discoverAgents(ctx.cwd, "both");
           const { agents } = discovery;
@@ -558,6 +626,12 @@ This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A)
             }
           }
 
+          const resumePlan =
+            pendingResumePlan && sameTasks(pendingResumePlan.tasks, tasks)
+              ? pendingResumePlan
+              : null;
+          if (resumePlan) pendingResumePlan = null;
+
           if (tasks.length === 1) {
             const [task] = tasks;
             return executeSingle(
@@ -569,6 +643,9 @@ This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A)
               signal,
               onUpdate,
               makeDetails,
+              resumePlan?.details?.results[0],
+              getSessionDirForTask(resumePlan?.previousToolCallId ?? toolCallId, 0),
+              !!resumePlan,
             );
           }
 
@@ -579,6 +656,9 @@ This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A)
             signal,
             onUpdate,
             makeDetails,
+            resumePlan?.details?.results,
+            (index) => getSessionDirForTask(resumePlan?.previousToolCallId ?? toolCallId, index),
+            !!resumePlan,
           );
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
@@ -598,6 +678,17 @@ This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A)
     });
   }
 
+  function getSessionDirForTask(toolCallId: string, index: number): string {
+    const root = currentSubagentSessionRoot || pathlessSubagentRootFallback();
+    const dir = buildSubagentSessionDir(root, currentSessionId, toolCallId, index);
+    ensureDir(dir);
+    return dir;
+  }
+
+  function pathlessSubagentRootFallback(): string {
+    return `${process.env.HOME ?? "."}/.pi/agent/sessions-subagents`;
+  }
+
   // -----------------------------------------------------------------------
   // Mode implementations
   // -----------------------------------------------------------------------
@@ -611,7 +702,22 @@ This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A)
     signal: AbortSignal | undefined,
     onUpdate: ((partial: any) => void) | undefined,
     makeDetails: ReturnType<typeof makeDetailsFactory>,
+    previousResult: SingleResult | undefined,
+    sessionDir: string,
+    resumeExistingSession: boolean,
   ) {
+    if (previousResult && isFinishedResult(previousResult)) {
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: getFinalOutput(previousResult.messages) || "(no output)",
+          },
+        ],
+        details: makeDetails("single")([previousResult]),
+      };
+    }
+
     const result = await runAgentSubprocess({
       cwd: defaultCwd,
       agents,
@@ -625,6 +731,9 @@ This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A)
       signal,
       onUpdate,
       makeDetails: makeDetails("single"),
+      sessionDir: previousResult?.sessionDir ?? sessionDir,
+      resumeSession: resumeExistingSession,
+      initialResult: previousResult,
     });
 
     if (isResultError(result)) {
@@ -662,6 +771,9 @@ This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A)
     signal: AbortSignal | undefined,
     onUpdate: ((partial: any) => void) | undefined,
     makeDetails: ReturnType<typeof makeDetailsFactory>,
+    resumeResults: SingleResult[] | undefined,
+    getSessionDir: (index: number) => string,
+    resumeExistingSessions: boolean,
   ) {
     return executeParallelSubprocess(
       tasks,
@@ -674,6 +786,9 @@ This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A)
       signal,
       onUpdate,
       makeDetails("parallel"),
+      resumeResults,
+      (index) => getSessionDir(index),
+      resumeExistingSessions,
     );
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oira666_pi-subagent",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Subagent extension for Pi coding agent. Delegate tasks to specialized agents.",
   "type": "module",
   "main": "index.ts",
@@ -8,6 +8,7 @@
     "index.ts",
     "agents.ts",
     "runner.ts",
+    "resume.ts",
     "shared.ts",
     "render.ts",
     "types.ts",

package/render.ts

@@ -180,21 +180,56 @@ function buildNodesFromNestedResult(nested: NestedSubagentResult): TreeNode[] {
 	return nested.details.results.map((result) => buildResultNode(result));
 }
 
+function subagentCallSignature(call: PendingSubagentCall): string {
+	return JSON.stringify(call.tasks.map((task) => ({ agent: task.agent, task: task.task ?? "" })));
+}
+
+function nestedResultIsHealthy(nested: NestedSubagentResult | undefined): boolean {
+	if (!nested || nested.isError) return false;
+	return nested.details.results.every((result) => !isResultError(result));
+}
+
 function buildNestedChildren(result: SingleResult): TreeNode[] {
+	const parentIsRunning = result.exitCode === -1;
 	const completedByToolCallId = new Map<string, NestedSubagentResult>();
 	for (const nested of getNestedSubagentResults(result.messages)) {
 		completedByToolCallId.set(nested.toolCallId, nested);
 	}
 
+	const calls = extractPendingSubagentCalls(result.messages);
+	const laterResumeBySignature = new Map<string, number>();
+	calls.forEach((call, index) => {
+		const completed = completedByToolCallId.get(call.toolCallId);
+		// A resumed call has the same task signature as the interrupted call but a
+		// newer toolCallId. Prefer that newer running/successful tree over the old
+		// synthetic/aborted result so resumed nested subagents render in-place.
+		if (!completed || nestedResultIsHealthy(completed)) {
+			laterResumeBySignature.set(subagentCallSignature(call), index);
+		}
+	});
+
 	const nodes: TreeNode[] = [];
-	for (const call of extractPendingSubagentCalls(result.messages)) {
+	calls.forEach((call, index) => {
 		const completed = completedByToolCallId.get(call.toolCallId);
+		const newerEquivalent = laterResumeBySignature.get(subagentCallSignature(call));
+		if (
+			newerEquivalent !== undefined &&
+			newerEquivalent > index &&
+			(!completed || completed.isError || !nestedResultIsHealthy(completed))
+		) {
+			return;
+		}
+
 		if (completed && isSubagentDetails(completed.details)) {
 			nodes.push(...buildNodesFromNestedResult(completed));
-			continue;
+			return;
 		}
-		nodes.push(...buildPendingNodes(call));
-	}
+		// Unmatched subagent tool calls are useful while the parent is still
+		// running (they show live pending children). Once the parent finished,
+		// unmatched calls are stale history from an interrupted/resumed session and
+		// must not keep the whole tree in a perpetual "running" state.
+		if (parentIsRunning) nodes.push(...buildPendingNodes(call));
+	});
 	return nodes;
 }
 

package/resume.ts

@@ -0,0 +1,178 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { isResultError, isSubagentDetails, type SingleResult, type SubagentDetails } from "./types.js";
+
+export const SUBAGENT_RESUME_PROMPT_ENV = "PI_SUBAGENT_RESUME_PROMPT";
+export const SUBAGENT_RESUME_DISABLE_ENV = "PI_SUBAGENT_DISABLE_RESUME";
+
+type SessionEntry = ReturnType<ExtensionContext["sessionManager"]["getEntries"]>[number];
+
+export interface ResumableSubagentCall {
+  previousToolCallId: string;
+  tasks: Array<{ agent: string; task: string; cwd?: string }>;
+  details?: SubagentDetails;
+}
+
+export function parseBooleanEnv(raw: unknown): boolean | null {
+  if (typeof raw === "boolean") return raw;
+  if (typeof raw !== "string") return null;
+  const normalized = raw.trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  return null;
+}
+
+export function getDefaultSubagentSessionRoot(ctx: ExtensionContext): string {
+  const mainSessionDir = ctx.sessionManager.getSessionDir?.();
+  if (typeof mainSessionDir === "string" && mainSessionDir.length > 0) {
+    return path.join(path.dirname(mainSessionDir), "sessions-subagents");
+  }
+  return path.join(os.homedir(), ".pi", "agent", "sessions-subagents");
+}
+
+export function buildSubagentSessionDir(
+  root: string,
+  parentSessionId: string,
+  toolCallId: string,
+  index: number,
+): string {
+  const safeParent = parentSessionId.replace(/[^a-zA-Z0-9_.-]+/g, "_");
+  const safeTool = toolCallId.replace(/[^a-zA-Z0-9_.-]+/g, "_");
+  return path.join(root, safeParent, safeTool, String(index));
+}
+
+export function ensureDir(dir: string): void {
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+}
+
+function branchEntries(ctx: ExtensionContext): SessionEntry[] {
+  const leafId = ctx.sessionManager.getLeafId?.();
+  if (leafId) {
+    const branch = ctx.sessionManager.getBranch?.(leafId);
+    if (Array.isArray(branch)) return branch as SessionEntry[];
+  }
+  const entries = ctx.sessionManager.getEntries?.();
+  return Array.isArray(entries) ? entries as SessionEntry[] : [];
+}
+
+function getSubagentToolCalls(message: any): Array<{ id: string; args: any }> {
+  if (!message || message.role !== "assistant" || !Array.isArray(message.content)) return [];
+  const calls: Array<{ id: string; args: any }> = [];
+  for (const part of message.content) {
+    if (part?.type === "toolCall" && part.name === "subagent" && typeof part.id === "string") {
+      calls.push({ id: part.id, args: part.arguments });
+    }
+  }
+  return calls;
+}
+
+function normalizeTasks(args: any): Array<{ agent: string; task: string; cwd?: string }> | null {
+  const rawTasks = args?.tasks;
+  if (!Array.isArray(rawTasks) || rawTasks.length === 0) return null;
+  const tasks: Array<{ agent: string; task: string; cwd?: string }> = [];
+  for (const task of rawTasks) {
+    if (typeof task?.agent !== "string" || typeof task?.task !== "string") return null;
+    tasks.push({
+      agent: task.agent,
+      task: task.task,
+      ...(typeof task.cwd === "string" ? { cwd: task.cwd } : {}),
+    });
+  }
+  return tasks;
+}
+
+function hasUnfinishedResults(details: SubagentDetails | undefined): boolean {
+  if (!details) return true;
+  return details.results.some((result) => result.exitCode === -1 || isResultError(result));
+}
+
+function messageHasNonEmptyText(message: any): boolean {
+  const content = message?.content;
+  if (typeof content === "string") return content.trim().length > 0;
+  if (!Array.isArray(content)) return false;
+  return content.some((part) => part?.type === "text" && typeof part.text === "string" && part.text.trim().length > 0);
+}
+
+function messageHasToolCall(message: any): boolean {
+  return Array.isArray(message?.content) && message.content.some((part: any) => part?.type === "toolCall");
+}
+
+function isIgnorableTrailingAbortMessage(entry: any): boolean {
+  if (entry?.type !== "message") return true;
+  const message = entry.message;
+  if (!message) return true;
+
+  // Pi may append a final aborted/error assistant message after it has already
+  // closed an interrupted tool with a synthetic toolResult. That message is not
+  // user-visible progress after the subagent activity, so it must not prevent
+  // resume detection.
+  if (
+    message.role === "assistant" &&
+    (message.stopReason === "aborted" || message.stopReason === "error") &&
+    !messageHasNonEmptyText(message) &&
+    !messageHasToolCall(message)
+  ) {
+    return true;
+  }
+
+  return false;
+}
+
+function hasOnlyIgnorableTrailingEntries(entries: SessionEntry[], activityOrder: number): boolean {
+  for (let i = activityOrder + 1; i < entries.length; i++) {
+    if (!isIgnorableTrailingAbortMessage(entries[i])) return false;
+  }
+  return true;
+}
+
+export function findLatestResumableSubagentCall(ctx: ExtensionContext): ResumableSubagentCall | null {
+  const entries = branchEntries(ctx);
+  const calls = new Map<string, { tasks: Array<{ agent: string; task: string; cwd?: string }>; order: number }>();
+  const results = new Map<string, { details?: SubagentDetails; isError: boolean; order: number }>();
+
+  entries.forEach((entry: any, order) => {
+    if (entry?.type !== "message") return;
+    const msg = entry.message;
+    for (const call of getSubagentToolCalls(msg)) {
+      const tasks = normalizeTasks(call.args);
+      if (tasks) calls.set(call.id, { tasks, order });
+    }
+    if (msg?.role === "toolResult" && msg.toolName === "subagent" && typeof msg.toolCallId === "string") {
+      results.set(msg.toolCallId, {
+        details: isSubagentDetails(msg.details) ? msg.details : undefined,
+        isError: msg.isError === true,
+        order,
+      });
+    }
+  });
+
+  const candidates: Array<ResumableSubagentCall & { activityOrder: number }> = [];
+  for (const [toolCallId, call] of calls) {
+    const result = results.get(toolCallId);
+    const unfinished = !result || result.isError || hasUnfinishedResults(result.details);
+    if (!unfinished) continue;
+    candidates.push({
+      previousToolCallId: toolCallId,
+      tasks: call.tasks,
+      details: result?.details,
+      activityOrder: result?.order ?? call.order,
+    });
+  }
+
+  const latest = candidates.at(-1);
+  if (!latest || !hasOnlyIgnorableTrailingEntries(entries, latest.activityOrder)) return null;
+  return latest;
+}
+
+export function sameTasks(
+  a: Array<{ agent: string; task: string; cwd?: string }>,
+  b: Array<{ agent: string; task: string; cwd?: string }>,
+): boolean {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
+export function isFinishedResult(result: SingleResult | undefined): boolean {
+  return !!result && result.exitCode === 0 && !isResultError(result);
+}

package/runner.ts

@@ -365,16 +365,20 @@ function buildPiArgs(
   agent: AgentConfig,
   systemPromptPath: string | null,
   task: string,
+  sessionDir: string | undefined,
+  resumeSession: boolean,
 ): string[] {
   const args: string[] = [
     "--mode",
     "json",
     ..._inheritedCliArgs.extensionArgs,
     ..._inheritedCliArgs.alwaysProxy,
-    "-p",
-    "--no-session",
   ];
 
+  if (sessionDir) args.push("--session-dir", sessionDir);
+  if (resumeSession) args.push("--continue");
+  args.push("-p");
+
   // Agent config takes priority; fall back to parent CLI value
   const model = agent.model ?? _inheritedCliArgs.fallbackModel;
   if (model) args.push("--model", model);
@@ -401,7 +405,11 @@ function buildPiArgs(
   }
 
   if (systemPromptPath) args.push("--append-system-prompt", systemPromptPath);
-  args.push(`Task: ${task}`);
+  args.push(
+    resumeSession
+      ? `Continue the previous task from where you left off. Original task: ${task}`
+      : `Task: ${task}`,
+  );
   return args;
 }
 
@@ -434,6 +442,12 @@ export interface RunAgentOptions {
   onUpdate?: OnUpdateCallback;
   /** Factory to wrap results into SubagentDetails. */
   makeDetails: (results: SingleResult[]) => SubagentDetails;
+  /** Dedicated session directory for this subagent process. */
+  sessionDir?: string;
+  /** Continue the most recent session in sessionDir instead of creating a new one. */
+  resumeSession?: boolean;
+  /** Previously captured state for this same subagent, used to render resumed nested trees. */
+  initialResult?: SingleResult;
 }
 
 /**
@@ -455,6 +469,9 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
     signal,
     onUpdate,
     makeDetails,
+    sessionDir,
+    resumeSession = false,
+    initialResult,
   } = opts;
 
   const agent = agents.find((a) => a.name === agentName);
@@ -472,6 +489,7 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
       completedTurns: 0,
       turnInProgress: false,
       liveLog: [],
+      sessionDir: opts.sessionDir,
     };
   }
 
@@ -480,14 +498,16 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
     agentSource: agent.source,
     task,
     exitCode: -1,
-    messages: [],
-    stderr: "",
-    usage: emptyUsage(),
-    toolCalls: {},
-    model: agent.model,
-    completedTurns: 0,
+    messages: initialResult?.messages ? [...initialResult.messages] : [],
+    stderr: initialResult?.stderr ?? "",
+    usage: initialResult?.usage ? { ...initialResult.usage } : emptyUsage(),
+    toolCalls: initialResult?.toolCalls ? { ...initialResult.toolCalls } : {},
+    model: initialResult?.model ?? agent.model,
+    completedTurns: initialResult?.completedTurns ?? 0,
     turnInProgress: false,
-    liveLog: [],
+    liveToolExecutions: initialResult?.liveToolExecutions,
+    liveLog: initialResult?.liveLog ? [...initialResult.liveLog] : [],
+    sessionDir,
   };
 
   const emitUpdate = () => {
@@ -518,6 +538,8 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
       agent,
       promptTmpPath,
       task,
+      sessionDir,
+      resumeSession,
     );
     let wasAborted = false;
 
@@ -736,6 +758,9 @@ export async function executeParallelSubprocess(
   signal: AbortSignal | undefined,
   onUpdate: OnUpdateCallback | undefined,
   makeDetails: (results: SingleResult[]) => SubagentDetails,
+  resumeResults?: SingleResult[],
+  getSessionDir?: (index: number, task: { agent: string; task: string; cwd?: string }) => string | undefined,
+  resumeExistingSessions = false,
 ): Promise<{
   content: Array<{ type: "text"; text: string }>;
   details: SubagentDetails;
@@ -770,7 +795,7 @@ export async function executeParallelSubprocess(
     };
   }
 
-  const allResults: SingleResult[] = tasks.map((t) => ({
+  const allResults: SingleResult[] = tasks.map((t, index) => resumeResults?.[index] ?? ({
     agent: t.agent,
     agentSource: "unknown" as const,
     task: t.task,
@@ -782,6 +807,7 @@ export async function executeParallelSubprocess(
     completedTurns: 0,
     turnInProgress: false,
     liveLog: [],
+    sessionDir: getSessionDir?.(index, t),
   }));
 
   const emitProgress = () => {
@@ -810,6 +836,13 @@ export async function executeParallelSubprocess(
   let results: SingleResult[];
   try {
     results = await mapConcurrent(tasks, maxConcurrency, async (t, index) => {
+      const previousResult = resumeResults?.[index];
+      if (previousResult?.exitCode === 0) {
+        allResults[index] = previousResult;
+        emitProgress();
+        return previousResult;
+      }
+      const sessionDir = previousResult?.sessionDir ?? getSessionDir?.(index, t);
       const result = await runAgentSubprocess({
         cwd: defaultCwd,
         agents,
@@ -821,6 +854,9 @@ export async function executeParallelSubprocess(
         maxDepth,
         preventCycles,
         signal,
+        sessionDir,
+        resumeSession: resumeExistingSessions && !!sessionDir,
+        initialResult: previousResult,
         onUpdate: (partial) => {
           if (partial.details?.results[0]) {
             allResults[index] = partial.details.results[0];

package/types.ts

@@ -45,6 +45,8 @@ export interface SingleResult {
 	model?: string;
 	stopReason?: string;
 	errorMessage?: string;
+	/** Session directory used by this subagent process, when persisted. */
+	sessionDir?: string;
 	/** Number of LLM turns completed so far in this agent run. */
 	completedTurns: number;
 	/** True while an LLM call is currently in flight (between turn_start and turn_end). */