@tintinweb/pi-subagents 0.4.10 → 0.4.11

package/CHANGELOG.md

@@ -5,6 +5,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.11] - 2026-03-18
+
+### Fixed
+- **Stale dist in published package** — added `prepublishOnly` hook to build fresh `dist/` on every `npm publish`.
+
 ## [0.4.10] - 2026-03-18
 
 ### Changed

package/dist/agent-manager.d.ts

@@ -5,12 +5,12 @@
  * Excess agents are queued and auto-started as running agents complete.
  * Foreground agents bypass the queue (they block the parent anyway).
  */
-import type { ExtensionContext, ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import type { Model } from "@mariozechner/pi-ai";
-import type { AgentSession } from "@mariozechner/pi-coding-agent";
+import type { AgentSession, ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { type ToolActivity } from "./agent-runner.js";
-import type { SubagentType, AgentRecord, ThinkingLevel } from "./types.js";
+import type { AgentRecord, IsolationMode, SubagentType, ThinkingLevel } from "./types.js";
 export type OnAgentComplete = (record: AgentRecord) => void;
+export type OnAgentStart = (record: AgentRecord) => void;
 interface SpawnOptions {
     description: string;
     model?: Model<any>;
@@ -19,23 +19,28 @@ interface SpawnOptions {
     inheritContext?: boolean;
     thinkingLevel?: ThinkingLevel;
     isBackground?: boolean;
+    /** Isolation mode — "worktree" creates a temp git worktree for the agent. */
+    isolation?: IsolationMode;
     /** 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). */
     onSessionCreated?: (session: AgentSession) => void;
+    /** Called at the end of each agentic turn with the cumulative count. */
+    onTurnEnd?: (turnCount: number) => void;
 }
 export declare class AgentManager {
     private agents;
     private cleanupInterval;
     private onComplete?;
+    private onStart?;
     private maxConcurrent;
     /** Queue of background agents waiting to start. */
     private queue;
     /** Number of currently running background agents. */
     private runningBackground;
-    constructor(onComplete?: OnAgentComplete, maxConcurrent?: number);
+    constructor(onComplete?: OnAgentComplete, maxConcurrent?: number, onStart?: OnAgentStart);
     /** Update the max concurrent background agents limit. */
     setMaxConcurrent(n: number): void;
     getMaxConcurrent(): number;
@@ -60,9 +65,18 @@ export declare class AgentManager {
     getRecord(id: string): AgentRecord | undefined;
     listAgents(): AgentRecord[];
     abort(id: string): boolean;
+    /** Dispose a record's session and remove it from the map. */
+    private removeRecord;
     private cleanup;
+    /**
+     * Remove all completed/stopped/errored records immediately.
+     * Called on session start/switch so tasks from a prior session don't persist.
+     */
+    clearCompleted(): void;
     /** Whether any agents are still running or queued. */
     hasRunning(): boolean;
+    /** Abort all running and queued agents immediately. */
+    abortAll(): number;
     /** Wait for all running and queued agents to complete (including queued ones). */
     waitForAll(): Promise<void>;
     dispose(): void;

package/dist/agent-manager.js

@@ -6,20 +6,23 @@
  * Foreground agents bypass the queue (they block the parent anyway).
  */
 import { randomUUID } from "node:crypto";
-import { runAgent, resumeAgent } from "./agent-runner.js";
+import { resumeAgent, runAgent } from "./agent-runner.js";
+import { cleanupWorktree, createWorktree, pruneWorktrees, } from "./worktree.js";
 /** Default max concurrent background agents. */
 const DEFAULT_MAX_CONCURRENT = 4;
 export class AgentManager {
     agents = new Map();
     cleanupInterval;
     onComplete;
+    onStart;
     maxConcurrent;
     /** Queue of background agents waiting to start. */
     queue = [];
     /** Number of currently running background agents. */
     runningBackground = 0;
-    constructor(onComplete, maxConcurrent = DEFAULT_MAX_CONCURRENT) {
+    constructor(onComplete, maxConcurrent = DEFAULT_MAX_CONCURRENT, onStart) {
         this.onComplete = onComplete;
+        this.onStart = onStart;
         this.maxConcurrent = maxConcurrent;
         // Cleanup completed agents after 10 minutes (but keep sessions for resume)
         this.cleanupInterval = setInterval(() => this.cleanup(), 60_000);
@@ -65,22 +68,47 @@ export class AgentManager {
         record.startedAt = Date.now();
         if (options.isBackground)
             this.runningBackground++;
-        const promise = runAgent(ctx, type, prompt, {
+        this.onStart?.(record);
+        // Worktree isolation: create a temporary git worktree if requested
+        let worktreeCwd;
+        let worktreeWarning = "";
+        if (options.isolation === "worktree") {
+            const wt = createWorktree(ctx.cwd, id);
+            if (wt) {
+                record.worktree = wt;
+                worktreeCwd = wt.path;
+            }
+            else {
+                worktreeWarning = "\n\n[WARNING: Worktree isolation was requested but failed (not a git repo, or no commits yet). Running in the main working directory instead.]";
+            }
+        }
+        // Prepend worktree warning to prompt if isolation failed
+        const effectivePrompt = worktreeWarning ? worktreeWarning + "\n\n" + prompt : prompt;
+        const promise = runAgent(ctx, type, effectivePrompt, {
             pi,
             model: options.model,
             maxTurns: options.maxTurns,
             isolated: options.isolated,
             inheritContext: options.inheritContext,
             thinkingLevel: options.thinkingLevel,
+            cwd: worktreeCwd,
             signal: record.abortController.signal,
             onToolActivity: (activity) => {
                 if (activity.type === "end")
                     record.toolUses++;
                 options.onToolActivity?.(activity);
             },
+            onTurnEnd: options.onTurnEnd,
             onTextDelta: options.onTextDelta,
             onSessionCreated: (session) => {
                 record.session = session;
+                // Flush any steers that arrived before the session was ready
+                if (record.pendingSteers?.length) {
+                    for (const msg of record.pendingSteers) {
+                        session.steer(msg).catch(() => { });
+                    }
+                    record.pendingSteers = undefined;
+                }
                 options.onSessionCreated?.(session);
             },
         })
@@ -92,6 +120,23 @@ export class AgentManager {
             record.result = responseText;
             record.session = session;
             record.completedAt ??= Date.now();
+            // Final flush of streaming output file
+            if (record.outputCleanup) {
+                try {
+                    record.outputCleanup();
+                }
+                catch { /* ignore */ }
+                record.outputCleanup = undefined;
+            }
+            // Clean up worktree if used
+            if (record.worktree) {
+                const wtResult = cleanupWorktree(ctx.cwd, 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}\``;
+                }
+            }
             if (options.isBackground) {
                 this.runningBackground--;
                 this.onComplete?.(record);
@@ -106,6 +151,22 @@ export class AgentManager {
             }
             record.error = err instanceof Error ? err.message : String(err);
             record.completedAt ??= Date.now();
+            // Final flush of streaming output file on error
+            if (record.outputCleanup) {
+                try {
+                    record.outputCleanup();
+                }
+                catch { /* ignore */ }
+                record.outputCleanup = undefined;
+            }
+            // Best-effort worktree cleanup on error
+            if (record.worktree) {
+                try {
+                    const wtResult = cleanupWorktree(ctx.cwd, record.worktree, options.description);
+                    record.worktreeResult = wtResult;
+                }
+                catch { /* ignore cleanup errors */ }
+            }
             if (options.isBackground) {
                 this.runningBackground--;
                 this.onComplete?.(record);
@@ -190,6 +251,12 @@ export class AgentManager {
         record.completedAt = Date.now();
         return true;
     }
+    /** Dispose a record's session and remove it from the map. */
+    removeRecord(id, record) {
+        record.session?.dispose?.();
+        record.session = undefined;
+        this.agents.delete(id);
+    }
     cleanup() {
         const cutoff = Date.now() - 10 * 60_000;
         for (const [id, record] of this.agents) {
@@ -197,18 +264,48 @@ export class AgentManager {
                 continue;
             if ((record.completedAt ?? 0) >= cutoff)
                 continue;
-            // Dispose and clear session so memory can be reclaimed
-            if (record.session) {
-                record.session.dispose();
-                record.session = undefined;
-            }
-            this.agents.delete(id);
+            this.removeRecord(id, record);
+        }
+    }
+    /**
+     * Remove all completed/stopped/errored records immediately.
+     * Called on session start/switch so tasks from a prior session don't persist.
+     */
+    clearCompleted() {
+        for (const [id, record] of this.agents) {
+            if (record.status === "running" || record.status === "queued")
+                continue;
+            this.removeRecord(id, record);
         }
     }
     /** Whether any agents are still running or queued. */
     hasRunning() {
         return [...this.agents.values()].some(r => r.status === "running" || r.status === "queued");
     }
+    /** Abort all running and queued agents immediately. */
+    abortAll() {
+        let count = 0;
+        // Clear queued agents first
+        for (const queued of this.queue) {
+            const record = this.agents.get(queued.id);
+            if (record) {
+                record.status = "stopped";
+                record.completedAt = Date.now();
+                count++;
+            }
+        }
+        this.queue = [];
+        // Abort running agents
+        for (const record of this.agents.values()) {
+            if (record.status === "running") {
+                record.abortController?.abort();
+                record.status = "stopped";
+                record.completedAt = Date.now();
+                count++;
+            }
+        }
+        return count;
+    }
     /** Wait for all running and queued agents to complete (including queued ones). */
     async waitForAll() {
         // Loop because drainQueue respects the concurrency limit — as running
@@ -232,5 +329,10 @@ export class AgentManager {
             record.session?.dispose();
         }
         this.agents.clear();
+        // Prune any orphaned git worktrees (crash recovery)
+        try {
+            pruneWorktrees(process.cwd());
+        }
+        catch { /* ignore */ }
     }
 }

package/dist/agent-runner.d.ts

@@ -1,14 +1,14 @@
 /**
  * agent-runner.ts — Core execution engine: creates sessions, runs agents, collects results.
  */
-import { type AgentSession, type ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
 import type { Model } from "@mariozechner/pi-ai";
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { type AgentSession, type ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import type { SubagentType, ThinkingLevel } from "./types.js";
-/** Get the default max turns value. */
-export declare function getDefaultMaxTurns(): number;
-/** Set the default max turns value (minimum 1). */
-export declare function setDefaultMaxTurns(n: number): void;
+/** Get the default max turns value. undefined = unlimited. */
+export declare function getDefaultMaxTurns(): number | undefined;
+/** Set the default max turns value. undefined = unlimited, otherwise minimum 1. */
+export declare function setDefaultMaxTurns(n: number | undefined): void;
 /** Get the grace turns value. */
 export declare function getGraceTurns(): number;
 /** Set the grace turns value (minimum 1). */
@@ -27,11 +27,15 @@ export interface RunOptions {
     isolated?: boolean;
     inheritContext?: boolean;
     thinkingLevel?: ThinkingLevel;
+    /** Override working directory (e.g. for worktree isolation). */
+    cwd?: 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;
     onSessionCreated?: (session: AgentSession) => void;
+    /** Called at the end of each agentic turn with the cumulative count. */
+    onTurnEnd?: (turnCount: number) => void;
 }
 export interface RunResult {
     responseText: string;

package/dist/agent-runner.js

@@ -2,18 +2,20 @@
  * agent-runner.ts — Core execution engine: creates sessions, runs agents, collects results.
  */
 import { createAgentSession, DefaultResourceLoader, SessionManager, SettingsManager, } from "@mariozechner/pi-coding-agent";
-import { getToolsForType, getConfig, getAgentConfig } from "./agent-types.js";
-import { buildAgentPrompt } from "./prompts.js";
+import { getAgentConfig, getConfig, getMemoryTools, getReadOnlyMemoryTools, getToolsForType } from "./agent-types.js";
 import { buildParentContext, extractText } from "./context.js";
 import { detectEnv } from "./env.js";
+import { buildMemoryBlock, buildReadOnlyMemoryBlock } from "./memory.js";
+import { buildAgentPrompt } from "./prompts.js";
+import { preloadSkills } from "./skill-loader.js";
 /** Names of tools registered by this extension that subagents must NOT inherit. */
 const EXCLUDED_TOOL_NAMES = ["Agent", "get_subagent_result", "steer_subagent"];
-/** Default max turns to prevent subagents from looping indefinitely. */
-let defaultMaxTurns = 50;
-/** Get the default max turns value. */
+/** Default max turns. undefined = unlimited (no turn limit). */
+let defaultMaxTurns;
+/** Get the default max turns value. undefined = unlimited. */
 export function getDefaultMaxTurns() { return defaultMaxTurns; }
-/** Set the default max turns value (minimum 1). */
-export function setDefaultMaxTurns(n) { defaultMaxTurns = Math.max(1, n); }
+/** Set the default max turns value. undefined = unlimited, otherwise minimum 1. */
+export function setDefaultMaxTurns(n) { defaultMaxTurns = n != null ? Math.max(1, n) : undefined; }
 /** Additional turns allowed after the soft limit steer message. */
 let graceTurns = 5;
 /** Get the grace turns value. */
@@ -73,13 +75,52 @@ function forwardAbortSignal(session, signal) {
 export async function runAgent(ctx, type, prompt, options) {
     const config = getConfig(type);
     const agentConfig = getAgentConfig(type);
-    const env = await detectEnv(options.pi, ctx.cwd);
+    // Resolve working directory: worktree override > parent cwd
+    const effectiveCwd = options.cwd ?? ctx.cwd;
+    const env = await detectEnv(options.pi, effectiveCwd);
     // Get parent system prompt for append-mode agents
     const parentSystemPrompt = ctx.getSystemPrompt();
+    // Build prompt extras (memory, skill preloading)
+    const extras = {};
+    // Resolve extensions/skills: isolated overrides to false
+    const extensions = options.isolated ? false : config.extensions;
+    const skills = options.isolated ? false : config.skills;
+    // Skill preloading: when skills is string[], preload their content into prompt
+    if (Array.isArray(skills)) {
+        const loaded = preloadSkills(skills, effectiveCwd);
+        if (loaded.length > 0) {
+            extras.skillBlocks = loaded;
+        }
+    }
+    let tools = getToolsForType(type, effectiveCwd);
+    // Persistent memory: detect write capability and branch accordingly.
+    // Account for disallowedTools — a tool in the base set but on the denylist is not truly available.
+    if (agentConfig?.memory) {
+        const existingNames = new Set(tools.map(t => t.name));
+        const denied = agentConfig.disallowedTools ? new Set(agentConfig.disallowedTools) : undefined;
+        const effectivelyHas = (name) => existingNames.has(name) && !denied?.has(name);
+        const hasWriteTools = effectivelyHas("write") || effectivelyHas("edit");
+        if (hasWriteTools) {
+            // Read-write memory: add any missing memory tools (read/write/edit)
+            const memTools = getMemoryTools(effectiveCwd, existingNames);
+            if (memTools.length > 0)
+                tools = [...tools, ...memTools];
+            extras.memoryBlock = buildMemoryBlock(agentConfig.name, agentConfig.memory, effectiveCwd);
+        }
+        else {
+            // Read-only memory: only add read tool, use read-only prompt
+            if (!existingNames.has("read")) {
+                const readTools = getReadOnlyMemoryTools(effectiveCwd, existingNames);
+                if (readTools.length > 0)
+                    tools = [...tools, ...readTools];
+            }
+            extras.memoryBlock = buildReadOnlyMemoryBlock(agentConfig.name, agentConfig.memory, effectiveCwd);
+        }
+    }
     // Build system prompt from agent config
     let systemPrompt;
     if (agentConfig) {
-        systemPrompt = buildAgentPrompt(agentConfig, ctx.cwd, env, parentSystemPrompt);
+        systemPrompt = buildAgentPrompt(agentConfig, effectiveCwd, env, parentSystemPrompt, extras);
     }
     else {
         // Unknown type fallback: general-purpose (defensive — unreachable in practice
@@ -94,17 +135,16 @@ export async function runAgent(ctx, type, prompt, options) {
             inheritContext: false,
             runInBackground: false,
             isolated: false,
-        }, ctx.cwd, env, parentSystemPrompt);
+        }, effectiveCwd, env, parentSystemPrompt, extras);
     }
-    const tools = getToolsForType(type, ctx.cwd);
-    // Resolve extensions/skills: isolated overrides to false
-    const extensions = options.isolated ? false : config.extensions;
-    const skills = options.isolated ? false : config.skills;
+    // When skills is string[], we've already preloaded them into the prompt.
+    // Still pass noSkills: true since we don't need the skill loader to load them again.
+    const noSkills = skills === false || Array.isArray(skills);
     // Load extensions/skills: true or string[] → load; false → don't
     const loader = new DefaultResourceLoader({
-        cwd: ctx.cwd,
+        cwd: effectiveCwd,
         noExtensions: extensions === false,
-        noSkills: skills === false,
+        noSkills,
         noPromptTemplates: true,
         noThemes: true,
         systemPromptOverride: () => systemPrompt,
@@ -115,8 +155,8 @@ export async function runAgent(ctx, type, prompt, options) {
     // Resolve thinking level: explicit option > agent config > undefined (inherit)
     const thinkingLevel = options.thinkingLevel ?? agentConfig?.thinking;
     const sessionOpts = {
-        cwd: ctx.cwd,
-        sessionManager: SessionManager.inMemory(ctx.cwd),
+        cwd: effectiveCwd,
+        sessionManager: SessionManager.inMemory(effectiveCwd),
         settingsManager: SettingsManager.create(),
         modelRegistry: ctx.modelRegistry,
         model,
@@ -128,13 +168,19 @@ export async function runAgent(ctx, type, prompt, options) {
     }
     // createAgentSession's type signature may not include thinkingLevel yet
     const { session } = await createAgentSession(sessionOpts);
+    // Build disallowed tools set from agent config
+    const disallowedSet = agentConfig?.disallowedTools
+        ? new Set(agentConfig.disallowedTools)
+        : undefined;
     // Filter active tools: remove our own tools to prevent nesting,
-    // and apply extension allowlist if specified
+    // apply extension allowlist if specified, and apply disallowedTools denylist
     if (extensions !== false) {
         const builtinToolNames = new Set(tools.map(t => t.name));
         const activeTools = session.getActiveToolNames().filter((t) => {
             if (EXCLUDED_TOOL_NAMES.includes(t))
                 return false;
+            if (disallowedSet?.has(t))
+                return false;
             if (builtinToolNames.has(t))
                 return true;
             if (Array.isArray(extensions)) {
@@ -144,6 +190,11 @@ export async function runAgent(ctx, type, prompt, options) {
         });
         session.setActiveToolsByName(activeTools);
     }
+    else if (disallowedSet) {
+        // Even with extensions disabled, apply denylist to built-in tools
+        const activeTools = session.getActiveToolNames().filter(t => !disallowedSet.has(t));
+        session.setActiveToolsByName(activeTools);
+    }
     options.onSessionCreated?.(session);
     // Track turns for graceful max_turns enforcement
     let turnCount = 0;
@@ -154,13 +205,16 @@ export async function runAgent(ctx, type, prompt, options) {
     const unsubTurns = session.subscribe((event) => {
         if (event.type === "turn_end") {
             turnCount++;
-            if (!softLimitReached && turnCount >= maxTurns) {
-                softLimitReached = true;
-                session.steer("You have reached your turn limit. Wrap up immediately — provide your final answer now.");
-            }
-            else if (softLimitReached && turnCount >= maxTurns + graceTurns) {
-                aborted = true;
-                session.abort();
+            options.onTurnEnd?.(turnCount);
+            if (maxTurns != null) {
+                if (!softLimitReached && turnCount >= maxTurns) {
+                    softLimitReached = true;
+                    session.steer("You have reached your turn limit. Wrap up immediately — provide your final answer now.");
+                }
+                else if (softLimitReached && turnCount >= maxTurns + graceTurns) {
+                    aborted = true;
+                    session.abort();
+                }
             }
         }
         if (event.type === "message_start") {

package/dist/agent-types.d.ts

@@ -28,6 +28,16 @@ export declare function getDefaultAgentNames(): string[];
 export declare function getUserAgentNames(): string[];
 /** Check if a type is valid and enabled (case-insensitive). */
 export declare function isValidType(type: string): boolean;
+/**
+ * Get the tools needed for memory management (read, write, edit).
+ * Only returns tools that are NOT already in the provided set.
+ */
+export declare function getMemoryTools(cwd: string, existingToolNames: Set<string>): AgentTool<any>[];
+/**
+ * Get only the read tool for read-only memory access.
+ * Only returns tools that are NOT already in the provided set.
+ */
+export declare function getReadOnlyMemoryTools(cwd: string, existingToolNames: Set<string>): AgentTool<any>[];
 /** Get built-in tools for a type (case-insensitive). */
 export declare function getToolsForType(type: string, cwd: string): AgentTool<any>[];
 /** Get config for a type (case-insensitive, returns a SubagentTypeConfig-compatible object). Falls back to general-purpose. */

package/dist/agent-types.js

@@ -4,7 +4,7 @@
  * Merges embedded default agents with user-defined agents from .pi/agents/*.md.
  * User agents override defaults with the same name. Disabled agents are kept but excluded from spawning.
  */
-import { createReadTool, createBashTool, createEditTool, createWriteTool, createGrepTool, createFindTool, createLsTool, } from "@mariozechner/pi-coding-agent";
+import { createBashTool, createEditTool, createFindTool, createGrepTool, createLsTool, createReadTool, createWriteTool, } from "@mariozechner/pi-coding-agent";
 import { DEFAULT_AGENTS } from "./default-agents.js";
 const TOOL_FACTORIES = {
     read: (cwd) => createReadTool(cwd),
@@ -84,6 +84,28 @@ export function isValidType(type) {
         return false;
     return agents.get(key)?.enabled !== false;
 }
+/** Tool names required for memory management. */
+const MEMORY_TOOL_NAMES = ["read", "write", "edit"];
+/**
+ * Get the tools needed for memory management (read, write, edit).
+ * Only returns tools that are NOT already in the provided set.
+ */
+export function getMemoryTools(cwd, existingToolNames) {
+    return MEMORY_TOOL_NAMES
+        .filter(n => !existingToolNames.has(n) && n in TOOL_FACTORIES)
+        .map(n => TOOL_FACTORIES[n](cwd));
+}
+/** Tool names needed for read-only memory access. */
+const READONLY_MEMORY_TOOL_NAMES = ["read"];
+/**
+ * Get only the read tool for read-only memory access.
+ * Only returns tools that are NOT already in the provided set.
+ */
+export function getReadOnlyMemoryTools(cwd, existingToolNames) {
+    return READONLY_MEMORY_TOOL_NAMES
+        .filter(n => !existingToolNames.has(n) && n in TOOL_FACTORIES)
+        .map(n => TOOL_FACTORIES[n](cwd));
+}
 /** Get built-in tools for a type (case-insensitive). */
 export function getToolsForType(type, cwd) {
     const key = resolveKey(type);

package/dist/cross-extension-rpc.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Cross-extension RPC handlers for the subagents extension.
+ *
+ * Exposes ping and spawn RPCs over the pi.events event bus,
+ * using per-request scoped reply channels.
+ */
+/** Minimal event bus interface needed by the RPC handlers. */
+export interface EventBus {
+    on(event: string, handler: (data: unknown) => void): () => void;
+    emit(event: string, data: unknown): void;
+}
+/** Minimal AgentManager interface needed by the spawn RPC. */
+export interface SpawnCapable {
+    spawn(pi: unknown, ctx: unknown, type: string, prompt: string, options: any): string;
+}
+export interface RpcDeps {
+    events: EventBus;
+    pi: unknown;
+    getCtx: () => unknown | undefined;
+    manager: SpawnCapable;
+}
+export interface RpcHandle {
+    unsubPing: () => void;
+    unsubSpawn: () => void;
+}
+/**
+ * Register ping and spawn RPC handlers on the event bus.
+ * Returns unsub functions for cleanup.
+ */
+export declare function registerRpcHandlers(deps: RpcDeps): RpcHandle;

package/dist/cross-extension-rpc.js

@@ -0,0 +1,33 @@
+/**
+ * Cross-extension RPC handlers for the subagents extension.
+ *
+ * Exposes ping and spawn RPCs over the pi.events event bus,
+ * using per-request scoped reply channels.
+ */
+/**
+ * Register ping and spawn RPC handlers on the event bus.
+ * Returns unsub functions for cleanup.
+ */
+export function registerRpcHandlers(deps) {
+    const { events, pi, getCtx, manager } = deps;
+    const unsubPing = events.on("subagents:rpc:ping", (raw) => {
+        const { requestId } = raw;
+        events.emit(`subagents:rpc:ping:reply:${requestId}`, {});
+    });
+    const unsubSpawn = events.on("subagents:rpc:spawn", async (raw) => {
+        const { requestId, type, prompt, options } = raw;
+        const ctx = getCtx();
+        if (!ctx) {
+            events.emit(`subagents:rpc:spawn:reply:${requestId}`, { error: "No active session" });
+            return;
+        }
+        try {
+            const id = manager.spawn(pi, ctx, type, prompt, options ?? {});
+            events.emit(`subagents:rpc:spawn:reply:${requestId}`, { id });
+        }
+        catch (err) {
+            events.emit(`subagents:rpc:spawn:reply:${requestId}`, { error: err.message });
+        }
+    });
+    return { unsubPing, unsubSpawn };
+}