@gotgenes/pi-subagents 6.0.1 → 6.2.0

package/src/agent-manager.ts

@@ -8,11 +8,13 @@
 
 import { randomUUID } from "node:crypto";
 import type { Model } from "@earendil-works/pi-ai";
-import type { AgentSession, ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { AgentSession, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { AgentRecord } from "./agent-record.js";
 import type { AgentRunner, ToolActivity } from "./agent-runner.js";
 import { debugLog } from "./debug.js";
+import { buildParentSnapshot } from "./parent-snapshot.js";
 import type { RunConfig } from "./runtime.js";
-import type { AgentInvocation, AgentRecord, IsolationMode, SubagentType, ThinkingLevel } from "./types.js";
+import type { AgentInvocation, IsolationMode, ParentSnapshot, ShellExec, SubagentType, ThinkingLevel } from "./types.js";
 import { addUsage } from "./usage.js";
 import type { WorktreeManager } from "./worktree.js";
 
@@ -27,6 +29,7 @@ const DEFAULT_MAX_CONCURRENT = 4;
 export interface AgentManagerOptions {
   runner: AgentRunner;
   worktrees: WorktreeManager;
+  exec: ShellExec;
   maxConcurrent?: number;
   getRunConfig?: () => RunConfig;
   onStart?: OnAgentStart;
@@ -35,8 +38,7 @@ export interface AgentManagerOptions {
 }
 
 interface SpawnArgs {
-  pi: ExtensionAPI;
-  ctx: ExtensionContext;
+  snapshot: ParentSnapshot;
   type: SubagentType;
   prompt: string;
   options: SpawnOptions;
@@ -88,6 +90,7 @@ export class AgentManager {
   private onCompact?: OnAgentCompact;
   private readonly runner: AgentRunner;
   private readonly worktrees: WorktreeManager;
+  private readonly exec: ShellExec;
   private maxConcurrent: number;
   private getRunConfig?: () => RunConfig;
 
@@ -99,6 +102,7 @@ export class AgentManager {
   constructor(options: AgentManagerOptions) {
     this.runner = options.runner;
     this.worktrees = options.worktrees;
+    this.exec = options.exec;
     this.onComplete = options.onComplete;
     this.onStart = options.onStart;
     this.onCompact = options.onCompact;
@@ -125,7 +129,6 @@ export class AgentManager {
    * If the concurrency limit is reached, the agent is queued.
    */
   spawn(
-    pi: ExtensionAPI,
     ctx: ExtensionContext,
     type: SubagentType,
     prompt: string,
@@ -133,21 +136,19 @@ export class AgentManager {
   ): string {
     const id = randomUUID().slice(0, 17);
     const abortController = new AbortController();
-    const record: AgentRecord = {
+    const record = new AgentRecord({
       id,
       type,
       description: options.description,
       status: options.isBackground ? "queued" : "running",
-      toolUses: 0,
       startedAt: Date.now(),
       abortController,
-      lifetimeUsage: { input: 0, output: 0, cacheWrite: 0 },
-      compactionCount: 0,
       invocation: options.invocation,
-    };
+    });
     this.agents.set(id, record);
 
-    const args: SpawnArgs = { pi, ctx, type, prompt, options };
+    const snapshot = buildParentSnapshot(ctx, options.inheritContext);
+    const args: SpawnArgs = { snapshot, type, prompt, options };
 
     if (options.isBackground && !options.bypassQueue && this.runningBackground >= this.maxConcurrent) {
       // Queue it — will be started when a running agent completes
@@ -167,7 +168,7 @@ export class AgentManager {
   }
 
   /** Actually start an agent (called immediately or from queue drain). */
-  private startAgent(id: string, record: AgentRecord, { pi, ctx, type, prompt, options }: SpawnArgs) {
+  private startAgent(id: string, record: AgentRecord, { snapshot, type, prompt, options }: SpawnArgs) {
     // Worktree isolation: try to create a temporary git worktree. Strict —
     // fail loud if not possible (no silent fallback to main tree). Done
     // BEFORE state mutation so a throw doesn't leave the record half-running.
@@ -184,8 +185,7 @@ export class AgentManager {
       worktreeCwd = wt.path;
     }
 
-    record.status = "running";
-    record.startedAt = Date.now();
+    record.markRunning(Date.now());
     if (options.isBackground) this.runningBackground++;
     this.onStart?.(record);
 
@@ -199,14 +199,13 @@ export class AgentManager {
     const detach = () => { detachParentSignal?.(); detachParentSignal = undefined; };
 
     const runConfig = this.getRunConfig?.();
-    const promise = this.runner.run(ctx, type, prompt, {
-      pi,
+    const promise = this.runner.run(snapshot, type, prompt, {
+      exec: this.exec,
       model: options.model,
       maxTurns: options.maxTurns,
       defaultMaxTurns: runConfig?.defaultMaxTurns,
       graceTurns: runConfig?.graceTurns,
       isolated: options.isolated,
-      inheritContext: options.inheritContext,
       thinkingLevel: options.thinkingLevel,
       cwd: worktreeCwd,
       parentSessionFile: options.parentSessionFile,
@@ -244,27 +243,26 @@ export class AgentManager {
       },
     })
       .then(({ responseText, session, aborted, steered, sessionFile }) => {
-        // Don't overwrite status if externally stopped via abort()
-        if (record.status !== "stopped") {
-          record.status = aborted ? "aborted" : steered ? "steered" : "completed";
-        }
-        record.result = responseText;
-        record.session = session;
-        record.completedAt ??= Date.now();
-        if (sessionFile) record.outputFile = sessionFile;
-
         detach();
 
-        // Clean up worktree if used
+        // Clean up worktree before transition so the final result includes branch text
+        let finalResult = responseText;
         if (record.worktree) {
           const wtResult = this.worktrees.cleanup(record.worktree, options.description);
           record.worktreeResult = wtResult;
           if (wtResult.hasChanges && wtResult.branch) {
-            record.result = (record.result ?? "") +
-              `\n\n---\nChanges saved to branch \`${wtResult.branch}\`. Merge with: \`git merge ${wtResult.branch}\``;
+            finalResult += `\n\n---\nChanges saved to branch \`${wtResult.branch}\`. Merge with: \`git merge ${wtResult.branch}\``;
           }
         }
 
+        // Transition — guards against overwriting externally-stopped status
+        if (aborted) record.markAborted(finalResult);
+        else if (steered) record.markSteered(finalResult);
+        else record.markCompleted(finalResult);
+
+        record.session = session;
+        if (sessionFile) record.outputFile = sessionFile;
+
         if (options.isBackground) {
           this.runningBackground--;
           try { this.onComplete?.(record); } catch (err) { debugLog("onComplete callback", err); }
@@ -273,17 +271,10 @@ export class AgentManager {
         return responseText;
       })
       .catch((err) => {
-        // Don't overwrite status if externally stopped via abort()
-        if (record.status !== "stopped") {
-          record.status = "error";
-        }
-        record.error = err instanceof Error ? err.message : String(err);
-        record.completedAt ??= Date.now();
+        record.markError(err);
 
         detach();
 
-
-
         // Best-effort worktree cleanup on error
         if (record.worktree) {
           try {
@@ -314,9 +305,7 @@ export class AgentManager {
       } catch (err) {
         // Late failure (e.g. strict worktree-isolation) — surface on the record
         // so the user/agent can see it via /agents, then keep draining.
-        record.status = "error";
-        record.error = err instanceof Error ? err.message : String(err);
-        record.completedAt = Date.now();
+        record.markError(err);
         this.onComplete?.(record);
       }
     }
@@ -327,13 +316,12 @@ export class AgentManager {
    * Foreground agents bypass the concurrency queue.
    */
   async spawnAndWait(
-    pi: ExtensionAPI,
     ctx: ExtensionContext,
     type: SubagentType,
     prompt: string,
     options: Omit<SpawnOptions, "isBackground">,
   ): Promise<AgentRecord> {
-    const id = this.spawn(pi, ctx, type, prompt, { ...options, isBackground: false });
+    const id = this.spawn(ctx, type, prompt, { ...options, isBackground: false });
     const record = this.agents.get(id)!;
     await record.promise;
     return record;
@@ -350,11 +338,7 @@ export class AgentManager {
     const record = this.agents.get(id);
     if (!record?.session) return undefined;
 
-    record.status = "running";
-    record.startedAt = Date.now();
-    record.completedAt = undefined;
-    record.result = undefined;
-    record.error = undefined;
+    record.resetForResume(Date.now());
 
     try {
       const responseText = await this.runner.resume(record.session, prompt, {
@@ -370,13 +354,9 @@ export class AgentManager {
         },
         signal,
       });
-      record.status = "completed";
-      record.result = responseText;
-      record.completedAt = Date.now();
+      record.markCompleted(responseText);
     } catch (err) {
-      record.status = "error";
-      record.error = err instanceof Error ? err.message : String(err);
-      record.completedAt = Date.now();
+      record.markError(err);
     }
 
     return record;
@@ -399,15 +379,13 @@ export class AgentManager {
     // Remove from queue if queued
     if (record.status === "queued") {
       this.queue = this.queue.filter(q => q.id !== id);
-      record.status = "stopped";
-      record.completedAt = Date.now();
+      record.markStopped();
       return true;
     }
 
     if (record.status !== "running") return false;
     record.abortController?.abort();
-    record.status = "stopped";
-    record.completedAt = Date.now();
+    record.markStopped();
     return true;
   }
 
@@ -452,8 +430,7 @@ export class AgentManager {
     for (const queued of this.queue) {
       const record = this.agents.get(queued.id);
       if (record) {
-        record.status = "stopped";
-        record.completedAt = Date.now();
+        record.markStopped();
         count++;
       }
     }
@@ -462,8 +439,7 @@ export class AgentManager {
     for (const record of this.agents.values()) {
       if (record.status === "running") {
         record.abortController?.abort();
-        record.status = "stopped";
-        record.completedAt = Date.now();
+        record.markStopped();
         count++;
       }
     }

package/src/agent-record.ts

@@ -0,0 +1,179 @@
+/**
+ * agent-record.ts — AgentRecord class with encapsulated status-transition logic.
+ *
+ * Status transitions (status, result, error, startedAt, completedAt) are owned
+ * by the class and exposed via transition methods. External code reads these
+ * fields through public properties but cannot write them directly.
+ *
+ * Non-transition state (session, toolUses, lifetimeUsage, etc.) remains public.
+ */
+
+import type { AgentSession } from "@earendil-works/pi-coding-agent";
+import type { AgentInvocation, SubagentType } from "./types.js";
+import type { LifetimeUsage } from "./usage.js";
+
+export type AgentRecordStatus =
+	| "queued"
+	| "running"
+	| "completed"
+	| "steered"
+	| "aborted"
+	| "stopped"
+	| "error";
+
+export interface AgentRecordInit {
+	id: string;
+	type: SubagentType;
+	description: string;
+	status?: AgentRecordStatus;
+	startedAt?: number;
+	completedAt?: number;
+	result?: string;
+	error?: string;
+	toolUses?: number;
+	lifetimeUsage?: LifetimeUsage;
+	compactionCount?: number;
+	abortController?: AbortController;
+	invocation?: AgentInvocation;
+	session?: AgentSession;
+	promise?: Promise<string>;
+	resultConsumed?: boolean;
+	pendingSteers?: string[];
+	worktree?: { path: string; branch: string };
+	worktreeResult?: { hasChanges: boolean; branch?: string };
+	toolCallId?: string;
+	outputFile?: string;
+}
+
+export class AgentRecord {
+	// Identity — set once at construction
+	readonly id: string;
+	readonly type: SubagentType;
+	readonly description: string;
+	readonly invocation?: AgentInvocation;
+
+	// Transition state — encapsulated behind getters, mutated only via transition methods
+	private _status: AgentRecordStatus;
+	get status(): AgentRecordStatus { return this._status; }
+
+	private _result?: string;
+	get result(): string | undefined { return this._result; }
+
+	private _error?: string;
+	get error(): string | undefined { return this._error; }
+
+	private _startedAt: number;
+	get startedAt(): number { return this._startedAt; }
+
+	private _completedAt?: number;
+	get completedAt(): number | undefined { return this._completedAt; }
+
+	// Non-transition mutable state
+	toolUses: number;
+	lifetimeUsage: LifetimeUsage;
+	compactionCount: number;
+	session?: AgentSession;
+	abortController?: AbortController;
+	promise?: Promise<string>;
+	resultConsumed?: boolean;
+	pendingSteers?: string[];
+	worktree?: { path: string; branch: string };
+	worktreeResult?: { hasChanges: boolean; branch?: string };
+	toolCallId?: string;
+	outputFile?: string;
+
+	constructor(init: AgentRecordInit) {
+		this.id = init.id;
+		this.type = init.type;
+		this.description = init.description;
+		this.invocation = init.invocation;
+
+		this._status = init.status ?? "queued";
+		this._result = init.result;
+		this._error = init.error;
+		this._startedAt = init.startedAt ?? Date.now();
+		this._completedAt = init.completedAt;
+
+		this.toolUses = init.toolUses ?? 0;
+		this.lifetimeUsage = init.lifetimeUsage ?? { input: 0, output: 0, cacheWrite: 0 };
+		this.compactionCount = init.compactionCount ?? 0;
+		this.abortController = init.abortController;
+		this.session = init.session;
+		this.promise = init.promise;
+		this.resultConsumed = init.resultConsumed;
+		this.pendingSteers = init.pendingSteers;
+		this.worktree = init.worktree;
+		this.worktreeResult = init.worktreeResult;
+		this.toolCallId = init.toolCallId;
+		this.outputFile = init.outputFile;
+	}
+
+	/** Transition to running state. Sets status and startedAt. */
+	markRunning(startedAt: number): void {
+		this._status = "running";
+		this._startedAt = startedAt;
+	}
+
+	/**
+	 * Transition to completed state.
+	 * Always sets result and completedAt (??=). Only changes status if not stopped.
+	 */
+	markCompleted(result: string, completedAt?: number): void {
+		this._result = result;
+		this._completedAt ??= completedAt ?? Date.now();
+		if (this._status !== "stopped") {
+			this._status = "completed";
+		}
+	}
+
+	/**
+	 * Transition to aborted state.
+	 * Always sets result and completedAt (??=). Only changes status if not stopped.
+	 */
+	markAborted(result: string, completedAt?: number): void {
+		this._result = result;
+		this._completedAt ??= completedAt ?? Date.now();
+		if (this._status !== "stopped") {
+			this._status = "aborted";
+		}
+	}
+
+	/**
+	 * Transition to steered state.
+	 * Always sets result and completedAt (??=). Only changes status if not stopped.
+	 */
+	markSteered(result: string, completedAt?: number): void {
+		this._result = result;
+		this._completedAt ??= completedAt ?? Date.now();
+		if (this._status !== "stopped") {
+			this._status = "steered";
+		}
+	}
+
+	/**
+	 * Transition to error state.
+	 * Always sets error (formatted) and completedAt (??=). Only changes status if not stopped.
+	 */
+	markError(error: unknown, completedAt?: number): void {
+		this._error = error instanceof Error ? error.message : String(error);
+		this._completedAt ??= completedAt ?? Date.now();
+		if (this._status !== "stopped") {
+			this._status = "error";
+		}
+	}
+
+	/** Transition to stopped state. Always valid — no guard. */
+	markStopped(completedAt?: number): void {
+		this._status = "stopped";
+		this._completedAt = completedAt ?? Date.now();
+	}
+
+	/** Reset for resume: running status, new startedAt, clear completedAt/result/error. */
+	resetForResume(startedAt: number): void {
+		this._status = "running";
+		this._startedAt = startedAt;
+		this._completedAt = undefined;
+		this._result = undefined;
+		this._error = undefined;
+	}
+}

package/src/agent-runner.ts

@@ -3,22 +3,20 @@
  */
 
 import type { Model } from "@earendil-works/pi-ai";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
   type AgentSession,
   type AgentSessionEvent,
   createAgentSession,
   DefaultResourceLoader,
-  type ExtensionAPI,
   getAgentDir,
   SessionManager,
   SettingsManager,
 } from "@earendil-works/pi-coding-agent";
-import { buildParentContext, extractText } from "./context.js";
+import { extractText } from "./context.js";
 import { detectEnv } from "./env.js";
 import { assembleSessionConfig } from "./session-config.js";
 import { deriveSubagentSessionDir } from "./session-dir.js";
-import type { SubagentType, ThinkingLevel } from "./types.js";
+import type { ParentSnapshot, ShellExec, SubagentType, ThinkingLevel } from "./types.js";
 
 /** Names of tools registered by this extension that subagents must NOT inherit. */
 const EXCLUDED_TOOL_NAMES = ["Agent", "get_subagent_result", "steer_subagent"];
@@ -73,13 +71,12 @@ export interface ToolActivity {
 }
 
 export interface RunOptions {
-  /** ExtensionAPI instance — used for pi.exec() instead of execSync. */
-  pi: ExtensionAPI;
+  /** Shell-exec callback for detectEnv — injected from pi.exec(). */
+  exec: ShellExec;
   model?: Model<any>;
   maxTurns?: number;
   signal?: AbortSignal;
   isolated?: boolean;
-  inheritContext?: boolean;
   thinkingLevel?: ThinkingLevel;
   /** Override working directory (e.g. for worktree isolation). */
   cwd?: string;
@@ -149,7 +146,7 @@ export interface ResumeOptions {
  * SDK session orchestration in runAgent/resumeAgent.
  */
 export interface AgentRunner {
-  run(ctx: ExtensionContext, type: SubagentType, prompt: string, options: RunOptions): Promise<RunResult>;
+  run(snapshot: ParentSnapshot, type: SubagentType, prompt: string, options: RunOptions): Promise<RunResult>;
   resume(session: AgentSession, prompt: string, options?: ResumeOptions): Promise<string>;
 }
 
@@ -199,23 +196,23 @@ function forwardAbortSignal(
 }
 
 export async function runAgent(
-  ctx: ExtensionContext,
+  snapshot: ParentSnapshot,
   type: SubagentType,
   prompt: string,
   options: RunOptions,
 ): Promise<RunResult> {
   // Resolve working directory upfront — needed for detectEnv before assembly.
-  const effectiveCwd = options.cwd ?? ctx.cwd;
-  const env = await detectEnv(options.pi, effectiveCwd);
+  const effectiveCwd = options.cwd ?? snapshot.cwd;
+  const env = await detectEnv(options.exec, effectiveCwd);
 
   // Assemble session configuration (synchronous, no SDK objects).
   const cfg = assembleSessionConfig(
     type,
     {
-      cwd: ctx.cwd,
-      parentSystemPrompt: ctx.getSystemPrompt(),
-      parentModel: ctx.model,
-      modelRegistry: ctx.modelRegistry,
+      cwd: snapshot.cwd,
+      parentSystemPrompt: snapshot.systemPrompt,
+      parentModel: snapshot.model,
+      modelRegistry: snapshot.modelRegistry,
     },
     {
       cwd: options.cwd,
@@ -259,7 +256,7 @@ export async function runAgent(
     agentDir,
     sessionManager,
     settingsManager: SettingsManager.create(cfg.effectiveCwd, agentDir),
-    modelRegistry: ctx.modelRegistry,
+    modelRegistry: snapshot.modelRegistry as any,
     model: cfg.model as Model<any> | undefined,
     tools: cfg.toolNames,
     resourceLoader: loader,
@@ -378,13 +375,10 @@ export async function runAgent(
   const collector = collectResponseText(session);
   const cleanupAbort = forwardAbortSignal(session, options.signal);
 
-  // Build the effective prompt: optionally prepend parent context
+  // Prepend parent context if it was captured at spawn time
   let effectivePrompt = prompt;
-  if (options.inheritContext) {
-    const parentContext = buildParentContext(ctx);
-    if (parentContext) {
-      effectivePrompt = parentContext + prompt;
-    }
+  if (snapshot.parentContext) {
+    effectivePrompt = snapshot.parentContext + prompt;
   }
 
   try {

package/src/env.ts

@@ -2,16 +2,15 @@
  * env.ts — Detect environment info (git, platform) for subagent system prompts.
  */
 
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { debugLog } from "./debug.js";
-import type { EnvInfo } from "./types.js";
+import type { EnvInfo, ShellExec } from "./types.js";
 
-export async function detectEnv(pi: ExtensionAPI, cwd: string): Promise<EnvInfo> {
+export async function detectEnv(exec: ShellExec, cwd: string): Promise<EnvInfo> {
   let isGitRepo = false;
   let branch = "";
 
   try {
-    const result = await pi.exec("git", ["rev-parse", "--is-inside-work-tree"], { cwd, timeout: 5000 });
+    const result = await exec("git", ["rev-parse", "--is-inside-work-tree"], { cwd, timeout: 5000 });
     isGitRepo = result.code === 0 && result.stdout.trim() === "true";
   } catch (err) {
     debugLog("git rev-parse", err);
@@ -19,7 +18,7 @@ export async function detectEnv(pi: ExtensionAPI, cwd: string): Promise<EnvInfo>
 
   if (isGitRepo) {
     try {
-      const result = await pi.exec("git", ["branch", "--show-current"], { cwd, timeout: 5000 });
+      const result = await exec("git", ["branch", "--show-current"], { cwd, timeout: 5000 });
       branch = result.code === 0 ? result.stdout.trim() : "unknown";
     } catch (err) {
       debugLog("git branch", err);

package/src/index.ts

@@ -66,6 +66,7 @@ export default function (pi: ExtensionAPI) {
   const manager = new AgentManager({
     runner: { run: runAgent, resume: resumeAgent },
     worktrees: new GitWorktreeManager(process.cwd()),
+    exec: (cmd, args, opts) => pi.exec(cmd, args, opts),
     onComplete: (record) => {
       // Emit lifecycle event based on terminal status
       const isError = record.status === "error" || record.status === "stopped" || record.status === "aborted";
@@ -185,8 +186,8 @@ export default function (pi: ExtensionAPI) {
 
   pi.registerTool(defineTool(createAgentTool({
     manager: {
-      spawn: (ctx, type, prompt, opts) => manager.spawn(pi, ctx, type, prompt, opts),
-      spawnAndWait: (ctx, type, prompt, opts) => manager.spawnAndWait(pi, ctx, type, prompt, opts),
+      spawn: (ctx, type, prompt, opts) => manager.spawn(ctx, type, prompt, opts),
+      spawnAndWait: (ctx, type, prompt, opts) => manager.spawnAndWait(ctx, type, prompt, opts),
       resume: (id, prompt, signal) => manager.resume(id, prompt, signal),
       getRecord: (id) => manager.getRecord(id),
       getMaxConcurrent: () => manager.getMaxConcurrent(),
@@ -229,7 +230,7 @@ export default function (pi: ExtensionAPI) {
     manager: {
       listAgents: () => manager.listAgents(),
       getRecord: (id) => manager.getRecord(id),
-      spawnAndWait: (piArg, ctx, type, prompt, opts) => manager.spawnAndWait(piArg ?? pi, ctx, type, prompt, opts),
+      spawnAndWait: (ctx, type, prompt, opts) => manager.spawnAndWait(ctx, type, prompt, opts),
       getMaxConcurrent: () => manager.getMaxConcurrent(),
       setMaxConcurrent: (n) => manager.setMaxConcurrent(n),
     },

package/src/parent-snapshot.ts

@@ -0,0 +1,27 @@
+/**
+ * parent-snapshot.ts — Capture parent session state as a plain data snapshot.
+ */
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { buildParentContext } from "./context.js";
+import type { ParentSnapshot } from "./types.js";
+
+/**
+ * Build an immutable snapshot of the parent session state.
+ *
+ * Called once at spawn time so queued agents capture state as it existed
+ * when the user requested the agent, not when a queue slot opens.
+ */
+export function buildParentSnapshot(
+  ctx: ExtensionContext,
+  inheritContext?: boolean,
+): ParentSnapshot {
+  const parentContext = inheritContext ? buildParentContext(ctx) : undefined;
+  return {
+    cwd: ctx.cwd,
+    systemPrompt: ctx.getSystemPrompt(),
+    model: ctx.model,
+    modelRegistry: ctx.modelRegistry,
+    parentContext: parentContext || undefined,
+  };
+}

package/src/service-adapter.ts

@@ -11,7 +11,7 @@ import type { AgentRecord } from "./types.js";
 
 /** Narrow interface for the AgentManager — avoids coupling to the concrete class. */
 export interface AgentManagerLike {
-  spawn(pi: unknown, ctx: unknown, type: string, prompt: string, options: unknown): string;
+  spawn(ctx: unknown, type: string, prompt: string, options: unknown): string;
   getRecord(id: string): AgentRecord | undefined;
   listAgents(): AgentRecord[];
   abort(id: string): boolean;
@@ -54,7 +54,7 @@ export function createSubagentsService(deps: AdapterDeps): SubagentsService {
       const description = options?.description ?? prompt.slice(0, 80);
       const isBackground = !(options?.foreground ?? false);
 
-      return manager.spawn(session.pi, session.ctx, type, prompt, {
+      return manager.spawn(session.ctx, type, prompt, {
         description,
         model,
         maxTurns: options?.maxTurns,