@gotgenes/pi-subagents 6.1.0 → 6.3.0

package/src/agent-manager.ts

@@ -8,13 +8,14 @@
 
 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 type { AgentRunner } from "./agent-runner.js";
 import { debugLog } from "./debug.js";
+import { buildParentSnapshot } from "./parent-snapshot.js";
+import { subscribeRecordObserver } from "./record-observer.js";
 import type { RunConfig } from "./runtime.js";
-import type { AgentInvocation, IsolationMode, SubagentType, ThinkingLevel } from "./types.js";
-import { addUsage } from "./usage.js";
+import type { AgentInvocation, IsolationMode, ParentSnapshot, ShellExec, SubagentType, ThinkingLevel } from "./types.js";
 import type { WorktreeManager } from "./worktree.js";
 
 export type OnAgentComplete = (record: AgentRecord) => void;
@@ -28,6 +29,7 @@ const DEFAULT_MAX_CONCURRENT = 4;
 export interface AgentManagerOptions {
   runner: AgentRunner;
   worktrees: WorktreeManager;
+  exec: ShellExec;
   maxConcurrent?: number;
   getRunConfig?: () => RunConfig;
   onStart?: OnAgentStart;
@@ -36,8 +38,7 @@ export interface AgentManagerOptions {
 }
 
 interface SpawnArgs {
-  pi: ExtensionAPI;
-  ctx: ExtensionContext;
+  snapshot: ParentSnapshot;
   type: SubagentType;
   prompt: string;
   options: SpawnOptions;
@@ -63,18 +64,8 @@ export interface SpawnOptions {
   invocation?: AgentInvocation;
   /** Parent abort signal — when aborted, the subagent is also stopped. */
   signal?: AbortSignal;
-  /** Called on tool start/end with activity info (for streaming progress to UI). */
-  onToolActivity?: (activity: ToolActivity) => void;
-  /** Called on streaming text deltas from the assistant response. */
-  onTextDelta?: (delta: string, fullText: string) => void;
-  /** Called when the agent session is created (for accessing session stats). */
+  /** Called when the agent session is created — the one remaining callback. */
   onSessionCreated?: (session: AgentSession) => void;
-  /** Called at the end of each agentic turn with the cumulative count. */
-  onTurnEnd?: (turnCount: number) => void;
-  /** Called once per assistant message_end with that message's usage delta. */
-  onAssistantUsage?: (usage: { input: number; output: number; cacheWrite: number }) => void;
-  /** Called when the session successfully compacts. */
-  onCompaction?: (info: CompactionInfo) => void;
   /** Path to the parent session's JSONL file (for deriving the subagent session directory). */
   parentSessionFile?: string;
   /** Session ID of the parent agent (stored in the child session's parentSession header). */
@@ -89,6 +80,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;
 
@@ -100,6 +92,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;
@@ -126,7 +119,6 @@ export class AgentManager {
    * If the concurrency limit is reached, the agent is queued.
    */
   spawn(
-    pi: ExtensionAPI,
     ctx: ExtensionContext,
     type: SubagentType,
     prompt: string,
@@ -145,7 +137,8 @@ export class AgentManager {
     });
     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
@@ -165,7 +158,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.
@@ -195,35 +188,21 @@ export class AgentManager {
     }
     const detach = () => { detachParentSignal?.(); detachParentSignal = undefined; };
 
+    let unsubRecordObserver: (() => void) | 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,
       parentSessionId: options.parentSessionId,
       signal: record.abortController!.signal,
-      onToolActivity: (activity) => {
-        if (activity.type === "end") record.toolUses++;
-        options.onToolActivity?.(activity);
-      },
-      onTurnEnd: options.onTurnEnd,
-      onTextDelta: options.onTextDelta,
-      onAssistantUsage: (usage) => {
-        addUsage(record.lifetimeUsage, usage);
-        options.onAssistantUsage?.(usage);
-      },
-      onCompaction: (info) => {
-        record.compactionCount++;
-        this.onCompact?.(record, info);
-        options.onCompaction?.(info);
-      },
       onSessionCreated: (session) => {
         record.session = session;
         // Capture the session file path early so it's available for display
@@ -237,10 +216,15 @@ export class AgentManager {
           }
           record.pendingSteers = undefined;
         }
+        // Subscribe record observer for stats accumulation
+        unsubRecordObserver = subscribeRecordObserver(session, record, {
+          onCompact: (r, info) => this.onCompact?.(r, info),
+        });
         options.onSessionCreated?.(session);
       },
     })
       .then(({ responseText, session, aborted, steered, sessionFile }) => {
+        unsubRecordObserver?.();
         detach();
 
         // Clean up worktree before transition so the final result includes branch text
@@ -271,6 +255,7 @@ export class AgentManager {
       .catch((err) => {
         record.markError(err);
 
+        unsubRecordObserver?.();
         detach();
 
         // Best-effort worktree cleanup on error
@@ -314,13 +299,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;
@@ -339,23 +323,19 @@ export class AgentManager {
 
     record.resetForResume(Date.now());
 
+    const unsubResume = subscribeRecordObserver(record.session, record, {
+      onCompact: (r, info) => this.onCompact?.(r, info),
+    });
+
     try {
       const responseText = await this.runner.resume(record.session, prompt, {
-        onToolActivity: (activity) => {
-          if (activity.type === "end") record.toolUses++;
-        },
-        onAssistantUsage: (usage) => {
-          addUsage(record.lifetimeUsage, usage);
-        },
-        onCompaction: (info) => {
-          record.compactionCount++;
-          this.onCompact?.(record, info);
-        },
         signal,
       });
       record.markCompleted(responseText);
     } catch (err) {
       record.markError(err);
+    } finally {
+      unsubResume();
     }
 
     return record;

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"];
@@ -66,20 +64,13 @@ export function normalizeMaxTurns(n: number | undefined): number | undefined {
 }
 
 
-/** Info about a tool event in the subagent. */
-export interface ToolActivity {
-  type: "start" | "end";
-  toolName: string;
-}
-
 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;
@@ -87,31 +78,8 @@ export interface RunOptions {
   parentSessionFile?: string;
   /** Session ID of the parent agent (stored in the child session's parentSession header). */
   parentSessionId?: string;
-  /** Called on tool start/end with activity info. */
-  onToolActivity?: (activity: ToolActivity) => void;
-  /** Called on streaming text deltas from the assistant response. */
-  onTextDelta?: (delta: string, fullText: string) => void;
+  /** Called once after session creation — session delivery mechanism. */
   onSessionCreated?: (session: AgentSession) => void;
-  /** Called at the end of each agentic turn with the cumulative count. */
-  onTurnEnd?: (turnCount: number) => void;
-  /**
-   * Called once per assistant message_end with that message's usage delta.
-   * Lets callers maintain a lifetime accumulator that survives compaction
-   * (which replaces session.state.messages and resets stats-derived sums).
-   */
-  onAssistantUsage?: (usage: {
-    input: number;
-    output: number;
-    cacheWrite: number;
-  }) => void;
-  /**
-   * Called when the session successfully compacts. `tokensBefore` is upstream's
-   * pre-compaction context size estimate. Aborted compactions don't fire.
-   */
-  onCompaction?: (info: {
-    reason: "manual" | "threshold" | "overflow";
-    tokensBefore: number;
-  }) => void;
   /**
    * Default max turns from runtime config. Falls back to the module-scope
    * `defaultMaxTurns` during the lift-and-shift migration; superseded by
@@ -138,9 +106,6 @@ export interface RunResult {
 
 /** Options for resuming an existing agent session. */
 export interface ResumeOptions {
-  onToolActivity?: (activity: ToolActivity) => void;
-  onAssistantUsage?: (usage: { input: number; output: number; cacheWrite: number }) => void;
-  onCompaction?: (info: { reason: "manual" | "threshold" | "overflow"; tokensBefore: number }) => void;
   signal?: AbortSignal;
 }
 
@@ -149,7 +114,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 +164,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 +224,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,
@@ -287,14 +252,7 @@ export async function runAgent(
   // (e.g. loading credentials, setting up state). Placed after tool filtering
   // so extension-provided skills/prompts from extendResourcesFromExtensions()
   // respect the active tool set. All ExtensionBindings fields are optional.
-  await session.bindExtensions({
-    onError: (err) => {
-      options.onToolActivity?.({
-        type: "end",
-        toolName: `extension-error:${err.extensionPath}`,
-      });
-    },
-  });
+  await session.bindExtensions({});
 
   // Patch 2 (RepOne #443): re-filter active tools after bindExtensions.
   // Extension-registered tools (added during bindExtensions) are not in the
@@ -322,11 +280,9 @@ export async function runAgent(
   let softLimitReached = false;
   let aborted = false;
 
-  let currentMessageText = "";
   const unsubTurns = session.subscribe((event: AgentSessionEvent) => {
     if (event.type === "turn_end") {
       turnCount++;
-      options.onTurnEnd?.(turnCount);
       if (maxTurns != null) {
         if (!softLimitReached && turnCount >= maxTurns) {
           softLimitReached = true;
@@ -339,52 +295,15 @@ export async function runAgent(
         }
       }
     }
-    if (event.type === "message_start") {
-      currentMessageText = "";
-    }
-    if (
-      event.type === "message_update" &&
-      event.assistantMessageEvent.type === "text_delta"
-    ) {
-      currentMessageText += event.assistantMessageEvent.delta;
-      options.onTextDelta?.(
-        event.assistantMessageEvent.delta,
-        currentMessageText,
-      );
-    }
-    if (event.type === "tool_execution_start") {
-      options.onToolActivity?.({ type: "start", toolName: event.toolName });
-    }
-    if (event.type === "tool_execution_end") {
-      options.onToolActivity?.({ type: "end", toolName: event.toolName });
-    }
-    if (event.type === "message_end" && event.message.role === "assistant") {
-      const u = (event.message as any).usage;
-      if (u)
-        options.onAssistantUsage?.({
-          input: u.input ?? 0,
-          output: u.output ?? 0,
-          cacheWrite: u.cacheWrite ?? 0,
-        });
-    }
-    if (event.type === "compaction_end" && !event.aborted && event.result) {
-      options.onCompaction?.({
-        reason: event.reason,
-        tokensBefore: event.result.tokensBefore,
-      });
-    }
   });
 
   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 {
@@ -417,46 +336,10 @@ export async function resumeAgent(
   const collector = collectResponseText(session);
   const cleanupAbort = forwardAbortSignal(session, options.signal);
 
-  const unsubEvents =
-    options.onToolActivity || options.onAssistantUsage || options.onCompaction
-      ? session.subscribe((event: AgentSessionEvent) => {
-          if (event.type === "tool_execution_start")
-            options.onToolActivity?.({
-              type: "start",
-              toolName: event.toolName,
-            });
-          if (event.type === "tool_execution_end")
-            options.onToolActivity?.({ type: "end", toolName: event.toolName });
-          if (
-            event.type === "message_end" &&
-            event.message.role === "assistant"
-          ) {
-            const u = (event.message as any).usage;
-            if (u)
-              options.onAssistantUsage?.({
-                input: u.input ?? 0,
-                output: u.output ?? 0,
-                cacheWrite: u.cacheWrite ?? 0,
-              });
-          }
-          if (
-            event.type === "compaction_end" &&
-            !event.aborted &&
-            event.result
-          ) {
-            options.onCompaction?.({
-              reason: event.reason,
-              tokensBefore: event.result.tokensBefore,
-            });
-          }
-        })
-      : () => {};
-
   try {
     await session.prompt(prompt);
   } finally {
     collector.unsubscribe();
-    unsubEvents();
     cleanupAbort();
   }
 

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/record-observer.ts

@@ -0,0 +1,60 @@
+/**
+ * record-observer.ts — Subscribes to session events and updates AgentRecord stats.
+ *
+ * Replaces the scattered callback-wrapping logic in AgentManager's startAgent()
+ * and resume() with a single direct subscription.
+ */
+
+import type { CompactionInfo } from "./agent-manager.js";
+import type { AgentRecord } from "./agent-record.js";
+import { addUsage } from "./usage.js";
+
+/** Narrow session interface — only the subscribe method needed by the observer. */
+interface SubscribableSession {
+  subscribe(fn: (event: any) => void): () => void;
+}
+
+export interface RecordObserverOptions {
+  onCompact?: (record: AgentRecord, info: CompactionInfo) => void;
+}
+
+/**
+ * Subscribe to session events and accumulate stats on the agent record.
+ *
+ * Handles:
+ * - `tool_execution_end` → `record.toolUses++`
+ * - `message_end` (assistant, with usage) → `addUsage(record.lifetimeUsage, …)`
+ * - `compaction_end` (not aborted) → `record.compactionCount++`, call `onCompact`
+ *
+ * @returns An unsubscribe function.
+ */
+export function subscribeRecordObserver(
+  session: SubscribableSession,
+  record: AgentRecord,
+  options?: RecordObserverOptions,
+): () => void {
+  return session.subscribe((event: any) => {
+    if (event.type === "tool_execution_end") {
+      record.toolUses++;
+    }
+
+    if (event.type === "message_end" && event.message?.role === "assistant") {
+      const u = event.message.usage;
+      if (u) {
+        addUsage(record.lifetimeUsage, {
+          input: u.input ?? 0,
+          output: u.output ?? 0,
+          cacheWrite: u.cacheWrite ?? 0,
+        });
+      }
+    }
+
+    if (event.type === "compaction_end" && !event.aborted && event.result) {
+      record.compactionCount++;
+      options?.onCompact?.(record, {
+        reason: event.reason,
+        tokensBefore: event.result.tokensBefore,
+      });
+    }
+  });
+}

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,