oira666_pi-subagent 0.2.0 → 0.2.2

package/README.md

@@ -22,26 +22,13 @@ pi remove npm:oira666_pi-subagent
 
 ## How It Works
 
-The extension supports two execution modes, selectable via `PI_SUBAGENTS_MODE`.
-
-### Execution mode: `subprocess` (default)
-
 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.
 
 - Full OS-level isolation — a crashed subagent cannot affect the parent
 - True parallel execution across all CPU cores
-- Each subprocess boots a fresh Node.js runtime (adds ~200–500 ms per subagent)
-- Requires the `pi` binary on `PATH`
-
-### Execution mode: `sdk`
-
-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
-- Concurrency through the Node.js event loop (fine for I/O-bound LLM work)
-- All sessions share the same memory and event loop
+- Each subprocess boots a fresh Node.js runtime
+- Uses the same Pi CLI entrypoint as the parent process when available
 
 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).
@@ -110,31 +97,6 @@ Available tools: `read`, `bash`, `edit`, `write`.
 
 The Markdown body becomes the agent's system prompt (appended to Pi's default, not replacing it).
 
-## Execution Mode
-
-| Env Var               | Default      | Values               | Description                            |
-| --------------------- | ------------ | -------------------- | -------------------------------------- |
-| `PI_SUBAGENTS_MODE`   | `subprocess` | `subprocess` / `sdk` | How subagent sessions are created      |
-
-```bash
-# Run subagents as in-process SDK sessions (faster startup, no spawn overhead)
-PI_SUBAGENTS_MODE=sdk pi
-
-# Run subagents as isolated subprocess pi instances (default, full isolation)
-PI_SUBAGENTS_MODE=subprocess pi
-```
-
-### Comparison
-
-| | `subprocess` | `sdk` |
-|---|---|---|
-| 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 |
-| 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 |
-
 ## Delegation Guards
 
 Depth and cycle guards prevent runaway recursive delegation.
@@ -165,11 +127,7 @@ pi --no-subagent-prevent-cycles   # allow cycles (not recommended)
 
 ## CLI Argument Proxying
 
-> **Note:** CLI argument proxying only applies to `subprocess` mode. In `sdk` mode, subagents
-> inherit provider and model configuration directly from the calling session's model registry
-> and API keys from environment variables, so no forwarding is needed.
-
-In `subprocess` mode, all flags passed to the parent `pi` process are forwarded to subagent child
+Flags passed to the parent `pi` process are forwarded to subagent child
 processes, so they inherit the same provider, API key, model, and other runtime settings. Flags the
 extension manages itself are blocked from being forwarded.
 
@@ -466,7 +424,7 @@ for await (const line of jsonLines) {
 
 Note: if you also track the main agent's own usage from `message_end` events, make sure **not** to
 double-count the subagent costs there — the main agent's own token usage (from its own `message_end`
-events) does not include subagent work (whether subprocess or SDK-mode).
+events) does not include subagent work.
 
 ---
 

package/index.ts

@@ -1,14 +1,7 @@
 /**
  * Pi Subagent Extension
  *
- * Delegates tasks to specialized subagents running as in-process AgentSessions
- * (via the pi SDK) rather than spawning separate `pi` processes.
- *
- * Environment variables (PI_SUBAGENT_DEPTH, PI_SUBAGENT_MAX_DEPTH,
- * PI_SUBAGENT_STACK, PI_SUBAGENT_PREVENT_CYCLES, PI_SUBAGENT_MAX_PARALLEL_TASKS,
- * PI_SUBAGENT_MAX_CONCURRENCY, PI_SUBAGENT_CONFIRM_PROJECT_AGENTS) are read
- * here at root startup exactly as before.  Depth/stack propagate to nested
- * sessions via closure in runner-sdk.ts instead of via subprocess env vars.
+ * Delegates tasks to specialized subagents running as isolated `pi` processes.
  *
  * The tool always accepts a `tasks` array:
  *   - One task: treated as a single-agent delegation.
@@ -20,8 +13,11 @@ 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 { runAgentSameProcess, executeParallelSameProcess } from "./runner-sdk.js";
-import { parseNonNegativeInt, subagentContext } from "./shared.js";
+import {
+  DEFAULT_MAX_PARALLEL_TASKS,
+  SUBAGENT_MAX_PARALLEL_TASKS_ENV,
+  parseNonNegativeInt,
+} from "./shared.js";
 
 import {
   type DelegationMode,
@@ -45,7 +41,6 @@ const SUBAGENT_MAX_DEPTH_ENV = "PI_SUBAGENT_MAX_DEPTH";
 const SUBAGENT_STACK_ENV = "PI_SUBAGENT_STACK";
 const SUBAGENT_PREVENT_CYCLES_ENV = "PI_SUBAGENT_PREVENT_CYCLES";
 const SUBAGENT_CONFIRM_PROJECT_AGENTS_ENV = "PI_SUBAGENT_CONFIRM_PROJECT_AGENTS";
-const SUBAGENTS_MODE_ENV = "PI_SUBAGENTS_MODE";
 
 type ProjectAgentConfirmationSetting = "ask" | "never" | "session";
 type ProjectAgentApproval = "once" | "session" | "no";
@@ -186,20 +181,6 @@ function getPreventCyclesFlagFromArgv(
 }
 
 function resolveDelegationDepthConfig(pi: ExtensionAPI): DelegationDepthConfig {
-  // When loaded inside an in-process child session (SDK mode), the correct
-  // depth/stack/limits are provided via AsyncLocalStorage rather than
-  // process.env (which still holds the root process values).
-  const inProcessCtx = subagentContext.getStore();
-  if (inProcessCtx) {
-    return {
-      currentDepth: inProcessCtx.depth,
-      maxDepth: inProcessCtx.maxDepth,
-      canDelegate: inProcessCtx.depth < inProcessCtx.maxDepth,
-      ancestorAgentStack: inProcessCtx.stack,
-      preventCycles: inProcessCtx.preventCycles,
-    };
-  }
-
   const depthRaw = process.env[SUBAGENT_DEPTH_ENV];
   const parsedDepth = parseNonNegativeInt(depthRaw);
   if (depthRaw !== undefined && parsedDepth === null) {
@@ -358,38 +339,6 @@ function getProjectAgentSessionKey(projectAgentsDir: string | null): string {
   return projectAgentsDir ?? "(unknown-project-agents-dir)";
 }
 
-// ---------------------------------------------------------------------------
-// Subagent mode helpers (exported for testing and external consumers)
-// ---------------------------------------------------------------------------
-
-/** The two supported subagent execution modes. */
-export type SubagentMode = "subprocess" | "sdk";
-
-/** Default subagent execution mode. */
-export const DEFAULT_SUBAGENTS_MODE: SubagentMode = "subprocess";
-
-/**
- * Parse a raw value into a SubagentMode.
- * Returns null for invalid/unrecognized values, the default mode for undefined.
- */
-export function parseSubagentMode(raw: unknown): SubagentMode | null {
-  if (raw === undefined) return DEFAULT_SUBAGENTS_MODE;
-  if (typeof raw !== "string") return null;
-  const normalized = raw.trim().toLowerCase();
-  if (normalized === "subprocess") return "subprocess";
-  if (normalized === "sdk") return "sdk";
-  return null;
-}
-
-/**
- * Read the subagent mode from PI_SUBAGENTS_MODE env var.
- * Falls back to DEFAULT_SUBAGENTS_MODE if the env var is absent or invalid.
- */
-export function getSubagentMode(): SubagentMode {
-  const parsed = parseSubagentMode(process.env["PI_SUBAGENTS_MODE"]);
-  return parsed ?? DEFAULT_SUBAGENTS_MODE;
-}
-
 // ---------------------------------------------------------------------------
 // Extension entry point
 // ---------------------------------------------------------------------------
@@ -408,7 +357,9 @@ export default function (pi: ExtensionAPI) {
   const depthConfig = resolveDelegationDepthConfig(pi);
   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>();
@@ -456,26 +407,25 @@ ${agentList}
 
 Each subagent runs in an **isolated process**.
 
-The tool always accepts a \`tasks\` array:
-- one item = single-agent delegation
-- multiple items = 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
 
-**Single-task 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 (1 agent)**:
 \`\`\`json
 { "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": "..." }] }
+{ "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) {
@@ -489,16 +439,17 @@ The tool always accepts a \`tasks\` array:
       name: "subagent",
       label: "Subagent",
       description: [
-        `Delegate work to specialized subagents running as ${
-          subagentMode === "sdk" ? "in-process SDK sessions" : "isolated pi processes"
-        }.`,
+        "Delegate work to specialized subagents running as 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",
         "",
-        'Example single:   { tasks: [{ agent: "writer", task: "Rewrite README.md" }] }',
-        'Example parallel: { tasks: [{ agent: "writer", task: "..." }, { agent: "tester", task: "..." }] }',
+        "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.",
+        "",
+        'Single:   { tasks: [{ agent: "writer", task: "Rewrite README.md" }] }',
+        'Parallel: { tasks: [{ agent: "writer", task: "..." }, { agent: "tester", task: "..." }] }',
       ].join("\n"),
       parameters: SubagentParams,
 
@@ -618,8 +569,6 @@ This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A)
               signal,
               onUpdate,
               makeDetails,
-              ctx.modelRegistry,
-              ctx.model,
             );
           }
 
@@ -630,8 +579,6 @@ This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A)
             signal,
             onUpdate,
             makeDetails,
-            ctx.modelRegistry,
-            ctx.model,
           );
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
@@ -664,41 +611,21 @@ 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>,
-    modelRegistry: any,
-    parentModel: any,
   ) {
-    const result =
-      subagentMode === "sdk"
-        ? await runAgentSameProcess({
-            cwd: defaultCwd,
-            agents,
-            agentName,
-            task,
-            taskCwd: cwd,
-            parentDepth: currentDepth,
-            parentAgentStack: ancestorAgentStack,
-            maxDepth,
-            preventCycles,
-            modelRegistry,
-            parentModel,
-            signal,
-            onUpdate,
-            makeDetails: makeDetails("single"),
-          })
-        : await runAgentSubprocess({
-            cwd: defaultCwd,
-            agents,
-            agentName,
-            task,
-            taskCwd: cwd,
-            parentDepth: currentDepth,
-            parentAgentStack: ancestorAgentStack,
-            maxDepth,
-            preventCycles,
-            signal,
-            onUpdate,
-            makeDetails: makeDetails("single"),
-          });
+    const result = await runAgentSubprocess({
+      cwd: defaultCwd,
+      agents,
+      agentName,
+      task,
+      taskCwd: cwd,
+      parentDepth: currentDepth,
+      parentAgentStack: ancestorAgentStack,
+      maxDepth,
+      preventCycles,
+      signal,
+      onUpdate,
+      makeDetails: makeDetails("single"),
+    });
 
     if (isResultError(result)) {
       const errorMsg =
@@ -735,25 +662,7 @@ 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>,
-    modelRegistry: any,
-    parentModel: any,
   ) {
-    if (subagentMode === "sdk") {
-      return executeParallelSameProcess(
-        tasks,
-        agents,
-        defaultCwd,
-        currentDepth,
-        maxDepth,
-        ancestorAgentStack,
-        preventCycles,
-        modelRegistry,
-        parentModel,
-        signal,
-        onUpdate,
-        makeDetails("parallel"),
-      );
-    }
     return executeParallelSubprocess(
       tasks,
       agents,

package/package.json

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

package/runner.ts

@@ -81,6 +81,21 @@ function cleanupTempDir(dir: string | null): void {
   }
 }
 
+function getCurrentPiCliScript(): string | null {
+  const script = process.argv[1];
+  if (!script) return null;
+
+  // When this extension is loaded by pi, process.argv[1] is the pi CLI JS
+  // entrypoint. Reusing it with process.execPath avoids relying on PATH while
+  // still running the exact same pi installation as the parent process.
+  const normalized = script.replace(/\\/g, "/");
+  if (!normalized.includes("/pi-coding-agent/") || !normalized.endsWith("/dist/cli.js")) {
+    return null;
+  }
+
+  return script;
+}
+
 function resolveExtensionArg(value: string): string {
   if (!value) return value;
   if (value.startsWith("npm:") || value.startsWith("git:")) return value;
@@ -514,8 +529,9 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
       // but shell:true splits arguments on whitespace — breaking task strings.
       // Fix: reuse the running node binary + the pi CLI script path directly,
       // so the child is spawned without a shell and args are passed safely.
-      const spawnCmd = process.platform === "win32" ? process.execPath : "pi";
-      const spawnArgs = process.platform === "win32" ? [process.argv[1], ...piArgs] : piArgs;
+      const currentPiCli = getCurrentPiCliScript();
+      const spawnCmd = currentPiCli ? process.execPath : "pi";
+      const spawnArgs = currentPiCli ? [currentPiCli, ...piArgs] : piArgs;
       const proc = spawn(spawnCmd, spawnArgs, {
         cwd: taskCwd ?? cwd,
         shell: false,
@@ -705,8 +721,7 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
 
 
 // ---------------------------------------------------------------------------
-// Parallel execution (subprocess flavour)
-// Symmetric to executeParallelSameProcess in runner-sdk.ts but uses runAgentSubprocess().
+// Parallel execution (subprocess runner).
 // ---------------------------------------------------------------------------
 
 

package/shared.ts

@@ -1,37 +1,14 @@
 /**
- * Shared constants and utilities used by both runner.ts and runner-sdk.ts.
+ * Shared constants and utilities used by the subprocess runner.
  *
- * Single source of truth for parallel-execution defaults and the small helpers
- * that both runners need. Change a value here and it propagates everywhere.
+ * Single source of truth for parallel-execution defaults and helpers.
  */
 
-import { AsyncLocalStorage } from "node:async_hooks";
-
-// ---------------------------------------------------------------------------
-// In-process child session context
-// ---------------------------------------------------------------------------
-
-/**
- * Depth and delegation config for an in-process child AgentSession.
- *
- * Stored via AsyncLocalStorage so each nested session sees its own correct
- * values without mutating process.env. index.ts reads this first; if absent
- * it falls back to env vars (subprocess mode).
- */
-export interface SubagentSessionContext {
-	depth: number;
-	maxDepth: number;
-	stack: string[];
-	preventCycles: boolean;
-}
-
-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/runner-sdk.ts

@@ -1,481 +0,0 @@
-/**
- * In-process subagent runner using the pi SDK.
- *
- * Creates an isolated AgentSession per subagent call instead of spawning a
- * separate `pi` process.  All environment variables (PI_SUBAGENT_DEPTH,
- * PI_SUBAGENT_MAX_DEPTH, PI_SUBAGENT_STACK, PI_SUBAGENT_PREVENT_CYCLES,
- * PI_SUBAGENT_MAX_PARALLEL_TASKS, PI_SUBAGENT_MAX_CONCURRENCY, …) are still
- * read at the root level exactly as before — they're just propagated to nested
- * sessions via closure parameters rather than via subprocess env inheritance.
- *
- */
-
-import {
-	createAgentSession,
-	DefaultResourceLoader,
-	SessionManager,
-	createCodingTools,
-	createReadTool,
-	createBashTool,
-	createEditTool,
-	createWriteTool,
-	createGrepTool,
-	createFindTool,
-	createLsTool,
-	type ToolDefinition,
-} from "@mariozechner/pi-coding-agent";
-import type { AgentConfig } from "./agents.js";
-import {
-	type LiveLogEntry,
-	type SingleResult,
-	type SubagentDetails,
-	MAX_LIVE_LOG_ENTRIES,
-	emptyUsage,
-	extractToolCalls,
-	getFinalOutput,
-	getNestedSubagentErrorSummary,
-	isResultError,
-} from "./types.js";
-import { renderCall, renderResult } from "./render.js";
-import {
-	DEFAULT_MAX_PARALLEL_TASKS,
-	DEFAULT_MAX_CONCURRENCY,
-	PARALLEL_HEARTBEAT_MS,
-	SUBAGENT_MAX_PARALLEL_TASKS_ENV,
-	SUBAGENT_MAX_CONCURRENCY_ENV,
-	parseNonNegativeInt,
-	mapConcurrent,
-	subagentContext,
-	type SubagentSessionContext,
-} from "./shared.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-
-/**
- * Build the tool list for a child agent.
- * When the agent config restricts tools, only those are included.
- * Otherwise the full default coding tools are used.
- */
-function buildAgentTools(agent: AgentConfig, cwd: string) {
-	if (!agent.tools || agent.tools.length === 0) {
-		return createCodingTools(cwd);
-	}
-	const factories: Record<string, () => unknown> = {
-		read: () => createReadTool(cwd),
-		bash: () => createBashTool(cwd),
-		edit: () => createEditTool(cwd),
-		write: () => createWriteTool(cwd),
-		grep: () => createGrepTool(cwd),
-		find: () => createFindTool(cwd),
-		ls: () => createLsTool(cwd),
-	};
-	const tools = agent.tools
-		.map((name) => factories[name.toLowerCase()]?.())
-		.filter(Boolean) as ReturnType<typeof createCodingTools>;
-	return tools.length > 0 ? tools : createCodingTools(cwd);
-}
-
-/**
- * Search available models by id.
- * Falls back to undefined when the model name can't be resolved.
- */
-function resolveModelByName(modelName: string, modelRegistry: any): any {
-	try {
-		const available: any[] = modelRegistry.getAvailable();
-		return available.find((m) => m.id === modelName) ?? undefined;
-	} catch {
-		return undefined;
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Public API: RunAgentSameProcessOptions / runAgentSameProcess
-// ---------------------------------------------------------------------------
-
-export interface RunAgentSameProcessOptions {
-	cwd: string;
-	agents: AgentConfig[];
-	agentName: string;
-	task: string;
-	taskCwd?: string;
-	parentDepth: number;
-	parentAgentStack: string[];
-	maxDepth: number;
-	preventCycles: boolean;
-	/** Pass ctx.modelRegistry from the calling tool's ExtensionContext */
-	modelRegistry: any;
-	/** Pass ctx.model from the calling tool's ExtensionContext */
-	parentModel: any;
-	signal?: AbortSignal;
-	onUpdate?: (partial: any) => void;
-	makeDetails: (results: SingleResult[]) => SubagentDetails;
-}
-
-/**
- * Run a single subagent in-process using createAgentSession().
- *
- * Replaces runner.ts::runAgentSubprocess — no subprocess is spawned.
- *
- * Environment variables (PI_SUBAGENT_DEPTH, PI_SUBAGENT_MAX_DEPTH,
- * PI_SUBAGENT_STACK, PI_SUBAGENT_PREVENT_CYCLES, …) are read at the root
- * level in index.ts exactly as before.  Here depth/stack propagate via
- * the opts parameters and are captured in closure by child extension
- * factories, so nested levels always see the correct values.
- */
-export async function runAgentSameProcess(
-	opts: RunAgentSameProcessOptions,
-): Promise<SingleResult> {
-	const {
-		cwd,
-		agents,
-		agentName,
-		task,
-		taskCwd,
-		parentDepth,
-		parentAgentStack,
-		maxDepth,
-		preventCycles,
-		modelRegistry,
-		parentModel,
-		signal,
-		onUpdate,
-		makeDetails,
-	} = opts;
-
-	const agent = agents.find((a) => a.name === agentName);
-	if (!agent) {
-		const available = agents.map((a) => `"${a.name}"`).join(", ") || "none";
-		return {
-			agent: agentName,
-			agentSource: "unknown",
-			task,
-			exitCode: 1,
-			messages: [],
-			stderr: `Unknown agent: "${agentName}". Available agents: ${available}.`,
-			usage: emptyUsage(),
-			toolCalls: {},
-			completedTurns: 0,
-			turnInProgress: false,
-			liveLog: [],
-		};
-	}
-
-	const childDepth = Math.max(0, Math.floor(parentDepth)) + 1;
-	const childStack = [...parentAgentStack, agentName];
-	const effectiveCwd = taskCwd ?? cwd;
-
-	const result: SingleResult = {
-		agent: agentName,
-		agentSource: agent.source,
-		task,
-		exitCode: -1,
-		messages: [],
-		stderr: "",
-		usage: emptyUsage(),
-		toolCalls: {},
-		model: agent.model,
-		completedTurns: 0,
-		turnInProgress: false,
-		liveLog: [],
-	};
-
-	const emitUpdate = () =>
-		onUpdate?.({
-			content: [{ type: "text", text: getFinalOutput(result.messages) || "(running...)" }],
-			details: makeDetails([result]),
-		});
-
-	emitUpdate();
-
-	const childCtx: SubagentSessionContext = {
-		depth: childDepth,
-		maxDepth,
-		stack: childStack,
-		preventCycles,
-	};
-
-	try {
-		// Run the child session inside an AsyncLocalStorage context so that all
-		// extensions loaded within it — including the subagent extension itself —
-		// see the correct depth/stack/limits for this nesting level rather than
-		// the stale root values that live in process.env.
-		const loader = await subagentContext.run(childCtx, async () => {
-			const l = new DefaultResourceLoader({
-				cwd: effectiveCwd,
-				// Append agent system prompt on top of the base pi prompt —
-				// matches the --append-system-prompt behaviour of the subprocess runner
-				...(agent.systemPrompt.trim() ? { appendSystemPrompt: agent.systemPrompt } : {}),
-			});
-			await l.reload();
-			return l;
-		});
-
-		// Resolve model: agent config overrides parent fallback
-		const model = agent.model
-			? (resolveModelByName(agent.model, modelRegistry) ?? parentModel)
-			: parentModel;
-
-		// Thinking level from agent config (same string values as --thinking flag)
-		const thinkingLevel = agent.thinking as any | undefined;
-
-		const sessionManager = SessionManager.inMemory();
-
-		const { session } = await subagentContext.run(childCtx, () =>
-			createAgentSession({
-				cwd: effectiveCwd,
-				sessionManager,
-				resourceLoader: loader,
-				tools: buildAgentTools(agent, effectiveCwd),
-				modelRegistry,
-				...(model ? { model } : {}),
-				...(thinkingLevel ? { thinkingLevel } : {}),
-			})
-		);
-
-		// Forward abort signal to the child session
-		const onAbort = () => session.abort();
-		signal?.addEventListener("abort", onAbort, { once: true });
-
-		const pushLiveLog = (entry: LiveLogEntry) => {
-			result.liveLog.push(entry);
-			if (result.liveLog.length > MAX_LIVE_LOG_ENTRIES) result.liveLog.shift();
-		};
-
-		const unsub = session.subscribe((event: any) => {
-			if (event.type === "message_end" && event.message) {
-				result.messages.push(event.message);
-				if (event.message.role === "assistant") {
-					const u = event.message.usage;
-					if (u) {
-						result.usage.input += u.input ?? 0;
-						result.usage.output += u.output ?? 0;
-						result.usage.cacheRead += u.cacheRead ?? 0;
-						result.usage.cacheWrite += u.cacheWrite ?? 0;
-						result.usage.cost += u.cost?.total ?? 0;
-						result.usage.contextTokens = u.totalTokens ?? 0;
-						result.usage.turns++;
-					}
-					if (event.message.stopReason) result.stopReason = event.message.stopReason;
-					if (event.message.errorMessage)
-						result.errorMessage = event.message.errorMessage;
-					if (!result.model && event.message.model) result.model = event.message.model;
-				}
-				emitUpdate();
-
-			} else if (event.type === "turn_start") {
-				result.turnInProgress = true;
-				pushLiveLog({ kind: "turn_start" });
-				emitUpdate();
-
-			} else if (event.type === "turn_end") {
-				result.completedTurns++;
-				result.turnInProgress = false;
-				const u = (event.message as any)?.usage;
-				pushLiveLog({
-					kind: "turn_end",
-					turn: result.completedTurns,
-					inputTokens: u?.input ?? 0,
-					outputTokens: u?.output ?? 0,
-				});
-				emitUpdate();
-
-			} else if (event.type === "tool_execution_start") {
-				result.liveToolExecutions ??= {};
-				result.liveToolExecutions[event.toolCallId] = {
-					toolName: event.toolName,
-					args: event.args,
-				};
-				pushLiveLog({ kind: "tool_start", toolName: event.toolName, args: event.args });
-				emitUpdate();
-
-			} else if (event.type === "tool_execution_end") {
-				if (result.liveToolExecutions) {
-					delete result.liveToolExecutions[event.toolCallId];
-				}
-				pushLiveLog({ kind: "tool_end", toolName: event.toolName });
-				emitUpdate();
-			}
-		});
-
-		try {
-			await session.prompt(`Task: ${task}`);
-			result.exitCode = 0;
-			result.toolCalls = extractToolCalls(result.messages);
-
-			if (result.exitCode === 0) {
-				const nestedError = getNestedSubagentErrorSummary(result.messages);
-				if (nestedError) {
-					result.exitCode = 1;
-					result.stopReason = "error";
-					result.errorMessage = nestedError;
-					if (!result.stderr.trim()) result.stderr = nestedError;
-				}
-			}
-		} catch (err: any) {
-			if (signal?.aborted) {
-				result.exitCode = 130;
-				result.stopReason = "aborted";
-				result.errorMessage = "Subagent was aborted.";
-				if (!result.stderr.trim()) result.stderr = "Subagent was aborted.";
-			} else {
-				result.exitCode = 1;
-				result.stopReason = "error";
-				result.errorMessage = err?.message ?? String(err);
-				result.stderr = result.errorMessage ?? "";
-			}
-		} finally {
-			signal?.removeEventListener("abort", onAbort);
-			unsub();
-			session.dispose();
-		}
-
-		return result;
-	} catch (err: any) {
-		// Outer safety net: catches anything thrown by loader.reload(),
-		// createAgentSession(), or other setup code outside the inner try/catch.
-		const msg = err instanceof Error ? err.message : String(err);
-		result.exitCode = result.exitCode === -1 ? 1 : result.exitCode;
-		result.stopReason = result.stopReason ?? "error";
-		result.errorMessage = result.errorMessage ?? msg;
-		if (!result.stderr.trim()) result.stderr = msg;
-		return result;
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Parallel execution (shared by root index.ts and child extension factories)
-// ---------------------------------------------------------------------------
-
-export async function executeParallelSameProcess(
-	tasks: Array<{ agent: string; task: string; cwd?: string }>,
-	agents: AgentConfig[],
-	defaultCwd: string,
-	depth: number,
-	maxDepth: number,
-	stack: string[],
-	preventCycles: boolean,
-	modelRegistry: any,
-	parentModel: any,
-	signal: AbortSignal | undefined,
-	onUpdate: ((partial: any) => void) | undefined,
-	makeDetails: (results: SingleResult[]) => SubagentDetails,
-) {
-	// Limits still read from env vars — same as before
-	const maxParallelTasksRaw = process.env[SUBAGENT_MAX_PARALLEL_TASKS_ENV];
-	const maxParallelTasksParsed = parseNonNegativeInt(maxParallelTasksRaw);
-	if (maxParallelTasksRaw !== undefined && maxParallelTasksParsed === null) {
-		console.warn(
-			`[pi-subagent] Ignoring invalid ${SUBAGENT_MAX_PARALLEL_TASKS_ENV}="${maxParallelTasksRaw}". Expected a non-negative integer.`,
-		);
-	}
-	const maxParallelTasks = maxParallelTasksParsed ?? DEFAULT_MAX_PARALLEL_TASKS;
-
-	const maxConcurrencyRaw = process.env[SUBAGENT_MAX_CONCURRENCY_ENV];
-	const maxConcurrencyParsed = parseNonNegativeInt(maxConcurrencyRaw);
-	if (maxConcurrencyRaw !== undefined && maxConcurrencyParsed === null) {
-		console.warn(
-			`[pi-subagent] Ignoring invalid ${SUBAGENT_MAX_CONCURRENCY_ENV}="${maxConcurrencyRaw}". Expected a non-negative integer.`,
-		);
-	}
-	const maxConcurrency = maxConcurrencyParsed ?? DEFAULT_MAX_CONCURRENCY;
-
-	if (tasks.length > maxParallelTasks) {
-		return {
-			content: [
-				{
-					type: "text" as const,
-					text: `Too many parallel tasks (${tasks.length}). Max is ${maxParallelTasks}.`,
-				},
-			],
-			details: makeDetails([]),
-		};
-	}
-
-	const allResults: SingleResult[] = tasks.map((t) => ({
-		agent: t.agent,
-		agentSource: "unknown" as const,
-		task: t.task,
-		exitCode: -1,
-		messages: [],
-		stderr: "",
-		usage: emptyUsage(),
-		toolCalls: {},
-		completedTurns: 0,
-		turnInProgress: false,
-		liveLog: [],
-	}));
-
-	const emitProgress = () => {
-		if (!onUpdate) return;
-		const running = allResults.filter((r) => r.exitCode === -1).length;
-		const done = allResults.filter((r) => r.exitCode !== -1).length;
-		onUpdate({
-			content: [
-				{
-					type: "text",
-					text: `Parallel: ${done}/${allResults.length} done, ${running} running...`,
-				},
-			],
-			details: makeDetails([...allResults]),
-		});
-	};
-
-	let heartbeat: NodeJS.Timeout | undefined;
-	if (onUpdate) {
-		emitProgress();
-		heartbeat = setInterval(() => {
-			if (allResults.some((r) => r.exitCode === -1)) emitProgress();
-		}, PARALLEL_HEARTBEAT_MS);
-	}
-
-	let results: SingleResult[];
-	try {
-		results = await mapConcurrent(tasks, maxConcurrency, async (t, index) => {
-			const result = await runAgentSameProcess({
-				cwd: defaultCwd,
-				agents,
-				agentName: t.agent,
-				task: t.task,
-				taskCwd: t.cwd,
-				parentDepth: depth,
-				parentAgentStack: stack,
-				maxDepth,
-				preventCycles,
-				modelRegistry,
-				parentModel,
-				signal,
-				onUpdate: (partial: any) => {
-					if (partial.details?.results[0]) {
-						allResults[index] = partial.details.results[0];
-						emitProgress();
-					}
-				},
-				makeDetails,
-			});
-			allResults[index] = result;
-			emitProgress();
-			return result;
-		});
-	} finally {
-		if (heartbeat) clearInterval(heartbeat);
-	}
-
-	const successCount = results.filter((r) => r.exitCode === 0).length;
-	const summaries = results.map((r) => {
-		const output = getFinalOutput(r.messages);
-		return `[${r.agent}] ${r.exitCode === 0 ? "completed" : "failed"}: ${output || "(no output)"}`;
-	});
-
-	return {
-		content: [
-			{
-				type: "text" as const,
-				text: `Parallel: ${successCount}/${results.length} succeeded\n\n${summaries.join("\n\n")}`,
-			},
-		],
-		details: makeDetails(results),
-	};
-}