oira666_pi-subagent 0.1.15 → 0.2.1

package/README.md

@@ -1,6 +1,6 @@
 # Pi Subagent
 
-Delegate tasks to specialized subagents with configurable context modes (`spawn` / `fork`).
+Delegate tasks to specialized subagents.
 
 ## Install
 
@@ -39,21 +39,17 @@ Processes are spawned via the operating system and communicate through JSON-line
 Each subagent runs as an **in-process `AgentSession`** created via the pi SDK — no new process is spawned.
 
 - No spawn overhead — sessions start in milliseconds
-- No temp files for system prompts or fork snapshots
+- No temp files for system prompts
 - Concurrency through the Node.js event loop (fine for I/O-bound LLM work)
 - All sessions share the same memory and event loop
 
-### Context modes
-
-**`spawn` (default)** — Child receives only the task string. Best for isolated work, lower cost.  
-**`fork`** — Child receives a snapshot of the current session context + task. Best for follow-up work.
-
-The main agent receives only the **final text output** from subagents (no tool calls, no reasoning).
+Each subagent receives only the task string. The main agent in turn receives
+only the **final text output** from subagents (no tool calls, no reasoning).
 
 ## Tool Call Shape
 
 ```json
-{ "tasks": [{ "agent": "code-writer", "task": "Implement the API" }], "mode": "spawn" }
+{ "tasks": [{ "agent": "code-writer", "task": "Implement the API" }] }
 ```
 
 Multiple tasks run in parallel:
@@ -63,8 +59,7 @@ Multiple tasks run in parallel:
   "tasks": [
     { "agent": "code-writer", "task": "Draft the implementation" },
     { "agent": "code-reviwer", "task": "Review the plan" }
-  ],
-  "mode": "fork"
+  ]
 }
 ```
 
@@ -136,7 +131,6 @@ PI_SUBAGENTS_MODE=subprocess pi
 | Session isolation | Full OS-level | Shared memory/event loop |
 | Startup overhead | ~200–500 ms per agent | ~10–50 ms per agent |
 | Parallelism | True OS parallelism | Event-loop concurrency |
-| Fork mode context | Temp JSONL file | Temp JSONL file (same format) |
 | Depth tracking | Env vars in child process | Closure parameters |
 | `pi` binary required | Yes | No |
 | Crash isolation | Yes — subprocess crash is contained | No — exception bubbles up |
@@ -236,7 +230,7 @@ tool_result_end
 interface SubagentDetails {
   // Execution metadata
   mode: "single" | "parallel";          // one task vs multiple parallel tasks
-  delegationMode: "spawn" | "fork";     // context mode used
+  delegationMode: "spawn";              // always "spawn" (kept for backward-compatible serialization)
   projectAgentsDir: string | null;      // path to .pi/agents/ dir if used
 
   // Individual agent results (one per task)

package/agents/code-architect.md

@@ -1,8 +1,6 @@
 ---
 name: code-architect
 description: Technical design agent for shaping implementations, APIs, module boundaries, and tradeoffs before coding. Use this agent for plans and architecture decisions.
-thinking: high
-tools: read,bash,grep,find,ls
 ---
 
 You are a senior software architect focused on practical design.

package/agents/code-reviwer.md

@@ -1,8 +1,6 @@
 ---
 name: code-reviwer
 description: Code review specialist for finding bugs, regressions, edge cases, and maintainability issues. Use this agent to review code, plans, or patches.
-thinking: high
-tools: read,bash,grep,find,ls
 ---
 
 You are a skeptical, detail-oriented code reviewer.

package/agents/code-writer.md

@@ -1,8 +1,6 @@
 ---
 name: code-writer
 description: Focused implementation agent for writing and refactoring code with small, reliable diffs. Use this agent when you want code changes made directly.
-thinking: medium
-tools: read,bash,edit,write
 ---
 
 You are a pragmatic software engineer focused on implementation.

package/index.ts

@@ -13,10 +13,6 @@
  * The tool always accepts a `tasks` array:
  *   - One task: treated as a single-agent delegation.
  *   - Multiple tasks: treated as a parallel delegation.
- *
- * And two context modes:
- *   - spawn (default): child gets only the task prompt.
- *   - fork: child gets a forked snapshot of current session context + task prompt.
  */
 
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
@@ -25,7 +21,12 @@ import { type AgentConfig, discoverAgents } from "./agents.js";
 import { renderCall, renderResult } from "./render.js";
 import { runAgentSubprocess, executeParallelSubprocess } from "./runner.js";
 import { runAgentSameProcess, executeParallelSameProcess } from "./runner-sdk.js";
-import { parseNonNegativeInt, subagentContext } from "./shared.js";
+import {
+  DEFAULT_MAX_PARALLEL_TASKS,
+  SUBAGENT_MAX_PARALLEL_TASKS_ENV,
+  parseNonNegativeInt,
+  subagentContext,
+} from "./shared.js";
 
 import {
   type DelegationMode,
@@ -33,7 +34,6 @@ import {
   type SubagentDetails,
   DEFAULT_DELEGATION_MODE,
   buildSubagentDetails,
-  emptyUsage,
   getFinalOutput,
   isResultError,
 } from "./types.js";
@@ -65,7 +65,7 @@ const TaskItem = Type.Object({
   }),
   task: Type.String({
     description:
-      "Task description for this delegated run. In spawn mode include all required context; in fork mode the subagent also sees your current session context.",
+      "Task description for this delegated run. Include all required context; the subagent receives only this prompt.",
   }),
   cwd: Type.Optional(
     Type.String({ description: "Working directory for this agent's process" }),
@@ -78,13 +78,6 @@ const SubagentParams = Type.Object({
     description:
       "Array of {agent, task} objects. One task behaves like a single-agent delegation; multiple tasks run concurrently.",
   }),
-  mode: Type.Optional(
-    Type.String({
-      description:
-        "Context mode for delegated runs. 'spawn' (default) sends only the task prompt (best for isolated, reproducible runs with lower token/cost and less context leakage). 'fork' adds a snapshot of current session context plus task prompt (best for follow-up work, but usually higher token/cost and may include sensitive context).",
-      default: DEFAULT_DELEGATION_MODE,
-    }),
-  ),
 });
 
 // ---------------------------------------------------------------------------
@@ -99,34 +92,6 @@ interface DelegationDepthConfig {
   preventCycles: boolean;
 }
 
-interface SessionSnapshotSource {
-  getHeader: () => unknown;
-  getBranch: () => unknown[];
-}
-
-function parseDelegationMode(raw: unknown): DelegationMode | null {
-  if (raw === undefined) return DEFAULT_DELEGATION_MODE;
-  if (typeof raw !== "string") return null;
-  const normalized = raw.trim().toLowerCase();
-  if (normalized === "spawn" || normalized === "fork") {
-    return normalized;
-  }
-  return null;
-}
-
-function buildForkSessionSnapshotJsonl(
-  sessionManager: SessionSnapshotSource,
-): string | null {
-  const header = sessionManager.getHeader();
-  if (!header || typeof header !== "object") return null;
-
-  const branchEntries = sessionManager.getBranch();
-  const lines = [JSON.stringify(header)];
-  for (const entry of branchEntries) lines.push(JSON.stringify(entry));
-  return `${lines.join("\n")}\n`;
-}
-
-
 function parseBoolean(raw: unknown): boolean | null {
   if (typeof raw === "boolean") return raw;
   if (typeof raw !== "string") return null;
@@ -449,6 +414,9 @@ export default function (pi: ExtensionAPI) {
   const { currentDepth, maxDepth, canDelegate, ancestorAgentStack, preventCycles } =
     depthConfig;
   const subagentMode = getSubagentMode();
+  const maxParallelTasks =
+    parseNonNegativeInt(process.env[SUBAGENT_MAX_PARALLEL_TASKS_ENV]) ??
+    DEFAULT_MAX_PARALLEL_TASKS;
 
   let discoveredAgents: AgentConfig[] = [];
   const approvedProjectAgentDirsForSession = new Set<string>();
@@ -496,30 +464,25 @@ ${agentList}
 
 Each subagent runs in an **isolated process**.
 
-Context behavior is controlled by optional 'mode':
-- 'spawn' (default): child receives only the provided task prompt. Best for isolated, reproducible tasks with lower token/cost and less context leakage.
-- 'fork': child receives a forked snapshot of current session context plus the task prompt. Best for follow-up tasks that rely on prior context; usually higher token/cost and may include sensitive context.
+Pass a \`tasks\` array. **Every task in the same call runs in parallel.**
+- 1 task  -> single delegation
+- N tasks -> all N run concurrently in one call
 
-The tool always accepts a \`tasks\` array:
-- one item = single-agent delegation
-- multiple items = parallel delegation
+For **sequential** work (task B needs task A's output), make separate tool
+calls one after another. Do NOT put dependent tasks in the same array.
 
-**Single-task delegation**:
+**Single (1 agent)**:
 \`\`\`json
-{ "tasks": [{ "agent": "agent-name", "task": "Detailed task..." }], "mode": "spawn" }
+{ "tasks": [{ "agent": "agent-name", "task": "Detailed task..." }] }
 \`\`\`
 
-**Multi-task delegation**:
+**Parallel (N agents at once)**:
 \`\`\`json
-{ "tasks": [{ "agent": "agent-name", "task": "..." }, { "agent": "other-agent", "task": "..." }], "mode": "fork" }
+{ "tasks": [{ "agent": "agent-a", "task": "..." }, { "agent": "agent-b", "task": "..." }] }
 \`\`\`
 
-### Runtime delegation guards
-
 - Max depth: current depth ${currentDepth}, max depth ${maxDepth}
-- Cycle prevention: ${preventCycles ? "enabled" : "disabled"}
-- Current delegation stack: ${ancestorAgentStack.length > 0 ? ancestorAgentStack.join(" -> ") : "(root)"}
-- Execution mode: ${subagentMode === "sdk" ? "in-process SDK" : "subprocess"}
+- Max subagents per tool call: ${maxParallelTasks}
 `,
       };
     } catch (err) {
@@ -537,18 +500,15 @@ The tool always accepts a \`tasks\` array:
           subagentMode === "sdk" ? "in-process SDK sessions" : "isolated pi processes"
         }.`,
         "",
-        "The tool always accepts a `tasks` array:",
-        "  - one task: single-agent delegation",
-        "  - multiple tasks: parallel delegation",
+        "Pass a `tasks` array. Every task in the same call runs IN PARALLEL.",
+        "  - 1 task  -> single delegation",
+        "  - N tasks -> all N run concurrently in one call",
         "",
-        "Optional context mode switch:",
-        "  mode: \"spawn\" (default) -> child gets only your task prompt.",
-        "                             Best for isolated/reproducible work; lower token/cost and less context leakage.",
-        "  mode: \"fork\"            -> child gets current session context + your task prompt.",
-        "                             Best for follow-up work that depends on prior context; higher token/cost and may include sensitive context.",
+        "For sequential work (task B depends on task A's output), make separate",
+        "tool calls one after another. Do NOT put dependent tasks in the same array.",
         "",
-        'Example single:   { tasks: [{ agent: "writer", task: "Rewrite README.md" }], mode: "spawn" }',
-        'Example parallel: { tasks: [{ agent: "writer", task: "..." }, { agent: "tester", task: "..." }], mode: "fork" }',
+        'Single:   { tasks: [{ agent: "writer", task: "Rewrite README.md" }] }',
+        'Parallel: { tasks: [{ agent: "writer", task: "..." }, { agent: "tester", task: "..." }] }',
       ].join("\n"),
       parameters: SubagentParams,
 
@@ -557,48 +517,11 @@ The tool always accepts a \`tasks\` array:
           const discovery = discoverAgents(ctx.cwd, "both");
           const { agents } = discovery;
 
-          const delegationMode = parseDelegationMode(params.mode);
-          if (!delegationMode) {
-            const fallbackDetails = makeDetailsFactory(
-              discovery.projectAgentsDir,
-              DEFAULT_DELEGATION_MODE,
-            );
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Invalid mode \"${String(params.mode)}\". Expected \"spawn\" or \"fork\".\nAvailable agents: ${formatAgentNames(agents)}`,
-                },
-              ],
-              details: fallbackDetails("single")([]),
-              isError: true,
-            };
-          }
-
           const makeDetails = makeDetailsFactory(
             discovery.projectAgentsDir,
-            delegationMode,
+            DEFAULT_DELEGATION_MODE,
           );
 
-          let forkSessionSnapshotJsonl: string | undefined;
-          if (delegationMode === "fork") {
-            forkSessionSnapshotJsonl = buildForkSessionSnapshotJsonl(
-              ctx.sessionManager,
-            );
-            if (!forkSessionSnapshotJsonl) {
-              return {
-                content: [
-                  {
-                    type: "text",
-                    text: "Cannot use mode=\"fork\": failed to snapshot current session context.",
-                  },
-                ],
-                details: makeDetails("single")([]),
-                isError: true,
-              };
-            }
-          }
-
           const tasks = params.tasks ?? [];
           if (tasks.length === 0) {
             return {
@@ -700,8 +623,6 @@ This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A)
               task.agent,
               task.task,
               task.cwd,
-              delegationMode,
-              forkSessionSnapshotJsonl,
               agents,
               ctx.cwd,
               signal,
@@ -714,8 +635,6 @@ This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A)
 
           return await executeParallel(
             tasks,
-            delegationMode,
-            forkSessionSnapshotJsonl,
             agents,
             ctx.cwd,
             signal,
@@ -750,8 +669,6 @@ This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A)
     agentName: string,
     task: string,
     cwd: string | undefined,
-    delegationMode: DelegationMode,
-    forkSessionSnapshotJsonl: string | undefined,
     agents: AgentConfig[],
     defaultCwd: string,
     signal: AbortSignal | undefined,
@@ -768,8 +685,6 @@ This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A)
             agentName,
             task,
             taskCwd: cwd,
-            delegationMode,
-            forkSessionSnapshotJsonl,
             parentDepth: currentDepth,
             parentAgentStack: ancestorAgentStack,
             maxDepth,
@@ -786,8 +701,6 @@ This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A)
             agentName,
             task,
             taskCwd: cwd,
-            delegationMode,
-            forkSessionSnapshotJsonl,
             parentDepth: currentDepth,
             parentAgentStack: ancestorAgentStack,
             maxDepth,
@@ -827,8 +740,6 @@ This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A)
 
   async function executeParallel(
     tasks: Array<{ agent: string; task: string; cwd?: string }>,
-    delegationMode: DelegationMode,
-    forkSessionSnapshotJsonl: string | undefined,
     agents: AgentConfig[],
     defaultCwd: string,
     signal: AbortSignal | undefined,
@@ -840,8 +751,6 @@ This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A)
     if (subagentMode === "sdk") {
       return executeParallelSameProcess(
         tasks,
-        delegationMode,
-        forkSessionSnapshotJsonl,
         agents,
         defaultCwd,
         currentDepth,
@@ -857,8 +766,6 @@ This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A)
     }
     return executeParallelSubprocess(
       tasks,
-      delegationMode,
-      forkSessionSnapshotJsonl,
       agents,
       defaultCwd,
       currentDepth,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oira666_pi-subagent",
-  "version": "0.1.15",
+  "version": "0.2.1",
   "description": "Subagent extension for Pi coding agent. Delegate tasks to specialized agents.",
   "type": "module",
   "main": "index.ts",

package/render.ts

@@ -5,13 +5,11 @@
 import * as os from "node:os";
 import { Container, Spacer, Text } from "@mariozechner/pi-tui";
 import {
-	type DelegationMode,
 	type LiveLogEntry,
 	type NestedSubagentResult,
 	type SingleResult,
 	type SubagentDetails,
 	type UsageStats,
-	DEFAULT_DELEGATION_MODE,
 	aggregateUsage,
 	getDisplayItems,
 	getFinalOutput,
@@ -35,6 +33,7 @@ interface TreeNode {
 	children: TreeNode[];
 }
 
+
 interface TreeCounts {
 	total: number;
 	running: number;
@@ -45,7 +44,6 @@ interface TreeCounts {
 
 interface PendingSubagentCall {
 	toolCallId: string;
-	mode: DelegationMode;
 	tasks: Array<{ agent: string; task?: string }>;
 }
 
@@ -83,10 +81,6 @@ function truncate(text: string, maxLen: number): string {
 	return text.length > maxLen ? `${text.slice(0, maxLen)}...` : text;
 }
 
-function normalizeDelegationMode(raw: unknown): DelegationMode {
-	return raw === "fork" ? "fork" : DEFAULT_DELEGATION_MODE;
-}
-
 function splitOutputLines(text: string): string[] {
 	const lines = text.replace(/\r\n?/g, "\n").split("\n");
 	if (lines.length > 1 && lines[lines.length - 1] === "") lines.pop();
@@ -166,7 +160,6 @@ function extractPendingSubagentCalls(messages: SingleResult["messages"]): Pendin
 						: typeof part.id === "string"
 							? part.id
 							: `${messageIndex}:${partIndex}`,
-				mode: normalizeDelegationMode((args as any).mode),
 				tasks,
 			});
 		}
@@ -178,14 +171,13 @@ function buildPendingNodes(call: PendingSubagentCall): TreeNode[] {
 	return call.tasks.map((task) => ({
 		label: task.agent,
 		status: "running",
-		meta: call.mode === "fork" ? "fork" : "spawn",
 		task: task.task,
 		children: [],
 	}));
 }
 
 function buildNodesFromNestedResult(nested: NestedSubagentResult): TreeNode[] {
-	return nested.details.results.map((result) => buildResultNode(result, nested.details.delegationMode));
+	return nested.details.results.map((result) => buildResultNode(result));
 }
 
 function buildNestedChildren(result: SingleResult): TreeNode[] {
@@ -292,10 +284,10 @@ function buildLeafPreview(result: SingleResult): string[] | undefined {
 	return unique.length > 0 ? unique.slice(-OUTPUT_PREVIEW_LINE_COUNT) : undefined;
 }
 
-function buildResultNode(result: SingleResult, delegationMode: DelegationMode): TreeNode {
+function buildResultNode(result: SingleResult): TreeNode {
 	const status = statusFromResult(result);
 	const usage = formatUsage(result.usage, result.model);
-	const metaParts: string[] = [result.agentSource, delegationMode];
+	const metaParts: string[] = [result.agentSource];
 	if (usage) metaParts.push(usage);
 	if (status === "error") {
 		const errorText = result.errorMessage || result.stderr || result.stopReason;
@@ -316,7 +308,7 @@ function buildResultNode(result: SingleResult, delegationMode: DelegationMode):
 }
 
 function buildTopLevelNodes(details: SubagentDetails): TreeNode[] {
-	return details.results.map((result) => buildResultNode(result, details.delegationMode));
+	return details.results.map((result) => buildResultNode(result));
 }
 
 function renderTreeLines(
@@ -374,10 +366,9 @@ function topLevelSummary(details: SubagentDetails, counts: TreeCounts): string {
 // ---------------------------------------------------------------------------
 
 export function renderCall(args: Record<string, any>, theme: { fg: ThemeFg; bold: (s: string) => string }): Text {
-	const delegationMode = normalizeDelegationMode(args.mode);
 	const tasks = Array.isArray(args.tasks) ? args.tasks : [];
 	const count = tasks.length;
-	let text = `${theme.fg("toolTitle", theme.bold("subagent "))}${theme.fg("muted", `[${delegationMode}]`)} ${theme.fg("accent", `${count} task${count === 1 ? "" : "s"}`)}`;
+	let text = `${theme.fg("toolTitle", theme.bold("subagent "))}${theme.fg("accent", `${count} task${count === 1 ? "" : "s"}`)}`;
 	for (const task of tasks.slice(0, 6)) {
 		const agent = typeof task?.agent === "string" ? task.agent : "...";
 		const preview = typeof task?.task === "string" ? ` ${truncate(task.task, 56)}` : "";
@@ -414,7 +405,7 @@ export function renderResult(
 	const container = new Container();
 	container.addChild(
 		new Text(
-			`${icon} ${theme.fg("toolTitle", theme.bold("subagent tree "))}${theme.fg("muted", `[${details.delegationMode}]`)} ${theme.fg("dim", topLevelSummary(details, counts))}`,
+			`${icon} ${theme.fg("toolTitle", theme.bold("subagent tree "))}${theme.fg("dim", topLevelSummary(details, counts))}`,
 			0,
 			0,
 		),

package/runner-sdk.ts

@@ -8,8 +8,6 @@
  * read at the root level exactly as before — they're just propagated to nested
  * sessions via closure parameters rather than via subprocess env inheritance.
  *
- * Fork mode still writes a JSONL snapshot to a temp file; the child session
- * opens it with SessionManager.open() instead of receiving it via --session.
  */
 
 import {
@@ -26,12 +24,8 @@ import {
 	createLsTool,
 	type ToolDefinition,
 } from "@mariozechner/pi-coding-agent";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
 import type { AgentConfig } from "./agents.js";
 import {
-	type DelegationMode,
 	type LiveLogEntry,
 	type SingleResult,
 	type SubagentDetails,
@@ -60,26 +54,6 @@ import {
 // ---------------------------------------------------------------------------
 
 
-function writeForkSessionToTempFile(
-	agentName: string,
-	sessionJsonl: string,
-): { dir: string; filePath: string } {
-	const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagent-"));
-	const safeName = agentName.replace(/[^\w.-]+/g, "_");
-	const filePath = path.join(tmpDir, `fork-${safeName}.jsonl`);
-	fs.writeFileSync(filePath, sessionJsonl, { encoding: "utf-8", mode: 0o600 });
-	return { dir: tmpDir, filePath };
-}
-
-function cleanupTempDir(dir: string | null): void {
-	if (!dir) return;
-	try {
-		fs.rmSync(dir, { recursive: true, force: true });
-	} catch {
-		/* ignore */
-	}
-}
-
 /**
  * Build the tool list for a child agent.
  * When the agent config restricts tools, only those are included.
@@ -127,9 +101,6 @@ export interface RunAgentSameProcessOptions {
 	agentName: string;
 	task: string;
 	taskCwd?: string;
-	delegationMode: DelegationMode;
-	/** JSONL session snapshot for fork mode — same format as subprocess runner */
-	forkSessionSnapshotJsonl?: string;
 	parentDepth: number;
 	parentAgentStack: string[];
 	maxDepth: number;
@@ -163,8 +134,6 @@ export async function runAgentSameProcess(
 		agentName,
 		task,
 		taskCwd,
-		delegationMode,
-		forkSessionSnapshotJsonl,
 		parentDepth,
 		parentAgentStack,
 		maxDepth,
@@ -194,28 +163,6 @@ export async function runAgentSameProcess(
 		};
 	}
 
-	if (
-		delegationMode === "fork" &&
-		(!forkSessionSnapshotJsonl || !forkSessionSnapshotJsonl.trim())
-	) {
-		return {
-			agent: agentName,
-			agentSource: agent.source,
-			task,
-			exitCode: 1,
-			messages: [],
-			stderr: "Cannot run in fork mode: missing parent session snapshot context.",
-			usage: emptyUsage(),
-			toolCalls: {},
-			model: agent.model,
-			stopReason: "error",
-			errorMessage: "Cannot run in fork mode: missing parent session snapshot context.",
-			completedTurns: 0,
-			turnInProgress: false,
-			liveLog: [],
-		};
-	}
-
 	const childDepth = Math.max(0, Math.floor(parentDepth)) + 1;
 	const childStack = [...parentAgentStack, agentName];
 	const effectiveCwd = taskCwd ?? cwd;
@@ -243,16 +190,6 @@ export async function runAgentSameProcess(
 
 	emitUpdate();
 
-	// Fork mode: write JSONL to a temp file; opened via SessionManager.open()
-	// (same serialisation format as the subprocess runner — backward-compatible)
-	let forkTmpDir: string | null = null;
-	let forkTmpPath: string | null = null;
-	if (delegationMode === "fork" && forkSessionSnapshotJsonl) {
-		const tmp = writeForkSessionToTempFile(agentName, forkSessionSnapshotJsonl);
-		forkTmpDir = tmp.dir;
-		forkTmpPath = tmp.filePath;
-	}
-
 	const childCtx: SubagentSessionContext = {
 		depth: childDepth,
 		maxDepth,
@@ -284,9 +221,7 @@ export async function runAgentSameProcess(
 		// Thinking level from agent config (same string values as --thinking flag)
 		const thinkingLevel = agent.thinking as any | undefined;
 
-		const sessionManager = forkTmpPath
-			? SessionManager.open(forkTmpPath)
-			: SessionManager.inMemory();
+		const sessionManager = SessionManager.inMemory();
 
 		const { session } = await subagentContext.run(childCtx, () =>
 			createAgentSession({
@@ -407,8 +342,6 @@ export async function runAgentSameProcess(
 		result.errorMessage = result.errorMessage ?? msg;
 		if (!result.stderr.trim()) result.stderr = msg;
 		return result;
-	} finally {
-		cleanupTempDir(forkTmpDir);
 	}
 }
 
@@ -418,8 +351,6 @@ export async function runAgentSameProcess(
 
 export async function executeParallelSameProcess(
 	tasks: Array<{ agent: string; task: string; cwd?: string }>,
-	delegationMode: DelegationMode,
-	forkSessionSnapshotJsonl: string | undefined,
 	agents: AgentConfig[],
 	defaultCwd: string,
 	depth: number,
@@ -509,8 +440,6 @@ export async function executeParallelSameProcess(
 				agentName: t.agent,
 				task: t.task,
 				taskCwd: t.cwd,
-				delegationMode,
-				forkSessionSnapshotJsonl,
 				parentDepth: depth,
 				parentAgentStack: stack,
 				maxDepth,

package/runner.ts

@@ -12,12 +12,10 @@ import type { AgentToolResult } from "@mariozechner/pi-agent-core";
 import type { Message } from "@mariozechner/pi-ai";
 import type { AgentConfig } from "./agents.js";
 import {
-  type DelegationMode,
   type LiveLogEntry,
   type SingleResult,
   type SubagentDetails,
   MAX_LIVE_LOG_ENTRIES,
-  buildSubagentDetails,
   emptyUsage,
   extractToolCalls,
   getFinalOutput,
@@ -74,17 +72,6 @@ function writePromptToTempFile(
   return { dir: tmpDir, filePath };
 }
 
-function writeForkSessionToTempFile(
-  agentName: string,
-  sessionJsonl: string,
-): { dir: string; filePath: string } {
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagent-"));
-  const safeName = agentName.replace(/[^\w.-]+/g, "_");
-  const filePath = path.join(tmpDir, `fork-${safeName}.jsonl`);
-  fs.writeFileSync(filePath, sessionJsonl, { encoding: "utf-8", mode: 0o600 });
-  return { dir: tmpDir, filePath };
-}
-
 function cleanupTempDir(dir: string | null): void {
   if (!dir) return;
   try {
@@ -363,8 +350,6 @@ function buildPiArgs(
   agent: AgentConfig,
   systemPromptPath: string | null,
   task: string,
-  delegationMode: DelegationMode,
-  forkSessionPath: string | null,
 ): string[] {
   const args: string[] = [
     "--mode",
@@ -372,14 +357,9 @@ function buildPiArgs(
     ..._inheritedCliArgs.extensionArgs,
     ..._inheritedCliArgs.alwaysProxy,
     "-p",
+    "--no-session",
   ];
 
-  if (delegationMode === "spawn") {
-    args.push("--no-session");
-  } else if (forkSessionPath) {
-    args.push("--session", forkSessionPath);
-  }
-
   // Agent config takes priority; fall back to parent CLI value
   const model = agent.model ?? _inheritedCliArgs.fallbackModel;
   if (model) args.push("--model", model);
@@ -425,10 +405,6 @@ export interface RunAgentOptions {
   task: string;
   /** Optional override working directory. */
   taskCwd?: string;
-  /** Context mode: spawn (fresh) or fork (session snapshot + task). */
-  delegationMode: DelegationMode;
-  /** Serialized parent session snapshot used when delegationMode is "fork". */
-  forkSessionSnapshotJsonl?: string;
   /** Current delegation depth of the caller process. */
   parentDepth: number;
   /** Delegation stack from the caller process (ancestor agent names). */
@@ -457,8 +433,6 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
     agentName,
     task,
     taskCwd,
-    delegationMode,
-    forkSessionSnapshotJsonl,
     parentDepth,
     parentAgentStack,
     maxDepth,
@@ -486,30 +460,6 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
     };
   }
 
-  if (
-    delegationMode === "fork" &&
-    (!forkSessionSnapshotJsonl || !forkSessionSnapshotJsonl.trim())
-  ) {
-    return {
-      agent: agentName,
-      agentSource: agent.source,
-      task,
-      exitCode: 1,
-      messages: [],
-      stderr:
-        "Cannot run in fork mode: missing parent session snapshot context.",
-      usage: emptyUsage(),
-      toolCalls: {},
-      model: agent.model,
-      stopReason: "error",
-      errorMessage:
-        "Cannot run in fork mode: missing parent session snapshot context.",
-      completedTurns: 0,
-      turnInProgress: false,
-      liveLog: [],
-    };
-  }
-
   const result: SingleResult = {
     agent: agentName,
     agentSource: agent.source,
@@ -548,22 +498,11 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
     promptTmpPath = tmp.filePath;
   }
 
-  // Write forked session snapshot if needed
-  let forkSessionTmpDir: string | null = null;
-  let forkSessionTmpPath: string | null = null;
-  if (delegationMode === "fork" && forkSessionSnapshotJsonl) {
-    const tmp = writeForkSessionToTempFile(agent.name, forkSessionSnapshotJsonl);
-    forkSessionTmpDir = tmp.dir;
-    forkSessionTmpPath = tmp.filePath;
-  }
-
   try {
     const piArgs = buildPiArgs(
       agent,
       promptTmpPath,
       task,
-      delegationMode,
-      forkSessionTmpPath,
     );
     let wasAborted = false;
 
@@ -761,7 +700,6 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
     return result;
   } finally {
     cleanupTempDir(promptTmpDir);
-    cleanupTempDir(forkSessionTmpDir);
   }
 }
 
@@ -774,8 +712,6 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
 
 export async function executeParallelSubprocess(
   tasks: Array<{ agent: string; task: string; cwd?: string }>,
-  delegationMode: DelegationMode,
-  forkSessionSnapshotJsonl: string | undefined,
   agents: AgentConfig[],
   defaultCwd: string,
   parentDepth: number,
@@ -865,8 +801,6 @@ export async function executeParallelSubprocess(
         agentName: t.agent,
         task: t.task,
         taskCwd: t.cwd,
-        delegationMode,
-        forkSessionSnapshotJsonl,
         parentDepth,
         parentAgentStack,
         maxDepth,

package/shared.ts

@@ -31,7 +31,7 @@ export const subagentContext = new AsyncLocalStorage<SubagentSessionContext>();
 // Parallel execution limits
 // ---------------------------------------------------------------------------
 
-export const DEFAULT_MAX_PARALLEL_TASKS = 16;
+export const DEFAULT_MAX_PARALLEL_TASKS = 30;
 export const DEFAULT_MAX_CONCURRENCY = 8;
 export const PARALLEL_HEARTBEAT_MS = 1000;
 export const SUBAGENT_MAX_PARALLEL_TASKS_ENV = "PI_SUBAGENT_MAX_PARALLEL_TASKS";

package/types.ts

@@ -5,7 +5,7 @@
 import type { Message } from "@mariozechner/pi-ai";
 
 /** Context mode for delegated runs. */
-export type DelegationMode = "spawn" | "fork";
+export type DelegationMode = "spawn";
 
 /** Default context mode for delegated runs. */
 export const DEFAULT_DELEGATION_MODE: DelegationMode = "spawn";
@@ -224,7 +224,7 @@ export function isSubagentDetails(value: unknown): value is SubagentDetails {
 	if (!value || typeof value !== "object") return false;
 	const maybe = value as Partial<SubagentDetails>;
 	return (maybe.mode === "single" || maybe.mode === "parallel") &&
-		(maybe.delegationMode === "spawn" || maybe.delegationMode === "fork") &&
+		maybe.delegationMode === "spawn" &&
 		Array.isArray(maybe.results);
 }