@hheei/pi-subagents 0.2.4 → 0.4.0

package/dist/child-control.js

@@ -1,7 +1,8 @@
 import { errorMessage, isRecord } from "@hheei/pi-ext-core";
-import { ChildBridgeClient } from "./bridge-client.js";
-import { BridgeError } from "./protocol.js";
+import { attachChildMailbox } from "./mailbox.js";
+import { BridgeError, CHILD_INPUT_EVENT } from "./protocol.js";
 import { FORWARDED_PI_EVENT_TYPES, shouldForwardPiEvent } from "./rpc-events.js";
+import { assistantUpdatePhase, transcriptFacts } from "./state.js";
 const CHILD_INPUT_SOURCES = ["interactive", "extension", "rpc"];
 /** The source of a Pi input event, when it is one the parent is allowed to hear about. */
 export function childInputSource(event) {
@@ -22,47 +23,150 @@ export function promptMessage(payload) {
  * Answers a parent request with this child's Pi state. Idleness is the child's own answer: the
  * parent never infers it from how long ago it last heard something.
  */
-export function childState(ctx) {
-    const sessionPath = ctx.sessionManager.getSessionFile();
+export function childState(ctx, isCompacting = false) {
+    const path = ctx.sessionManager.getSessionFile();
     return {
         idle: ctx.isIdle(),
         pendingMessages: ctx.hasPendingMessages(),
+        ...(isCompacting ? { compacting: true } : {}),
         sessionId: ctx.sessionManager.getSessionId(),
-        ...(sessionPath ? { sessionPath } : {}),
+        ...(path ? { path } : {}),
     };
 }
 /**
- * Truncates bulky data (like huge file reads, grep blocks, or base64 images) in advisory events
- * before they are serialized and pushed over the bridge. The parent projector only requires
- * turn-level signals, not multi-megabyte payloads.
+ * The dedup key for a streaming update: its phase plus the tool it names. Two deltas with the same
+ * key are the same telemetry, so only the first is forwarded while the parent is listening.
+ */
+function assistantPhaseKey(event) {
+    const phase = assistantUpdatePhase(event.assistantMessageEvent, event.message);
+    if (phase === undefined)
+        return undefined;
+    return phase.toolName === undefined ? phase.kind : `${phase.kind}:${phase.toolName}`;
+}
+/** Text kept from a message part: enough for the parent's summary, never the whole payload. */
+const BRIDGE_MESSAGE_TEXT_LIMIT = 200;
+/** Text kept from a tool result part: the parent shows tool activity, not tool output. */
+const BRIDGE_TOOL_TEXT_LIMIT = 1000;
+/** Content parts kept per message, so a frame stays bounded no matter how long the stream runs. */
+const BRIDGE_MAX_CONTENT_PARTS = 32;
+/**
+ * Reduces one content part to what the parent's projector reads. Text is truncated, image data is
+ * replaced by a marker, and a tool call keeps its name but not its arguments: the parent projects
+ * turn-level activity, so it never needs the payload that produced it.
+ */
+function compactContentPart(part, textLimit) {
+    if (!isRecord(part))
+        return part;
+    if (part.type === "text" && typeof part.text === "string") {
+        return part.text.length > textLimit
+            ? { ...part, text: `${part.text.slice(0, textLimit)}\n... [truncated for bridge event]` }
+            : part;
+    }
+    if (part.type === "image") {
+        return {
+            type: "image",
+            mimeType: part.mimeType,
+            data: "[image omitted for bridge event]",
+        };
+    }
+    if (part.type === "toolCall") {
+        return {
+            type: "toolCall",
+            ...(typeof part.id === "string" ? { id: part.id } : {}),
+            ...(typeof part.name === "string" ? { name: part.name } : {}),
+        };
+    }
+    return typeof part.type === "string" ? { type: part.type } : {};
+}
+function compactContent(content, textLimit) {
+    if (!Array.isArray(content))
+        return undefined;
+    return content
+        .slice(0, BRIDGE_MAX_CONTENT_PARTS)
+        .map((part) => compactContentPart(part, textLimit));
+}
+/** Keeps only the turn-level message fields the projector reads, dropping the rest. */
+function compactMessage(message, textLimit) {
+    const value = isRecord(message) ? message : undefined;
+    if (value === undefined)
+        return undefined;
+    const content = compactContent(value.content, textLimit);
+    return {
+        ...(typeof value.role === "string" ? { role: value.role } : {}),
+        ...(typeof value.stopReason === "string" ? { stopReason: value.stopReason } : {}),
+        ...(typeof value.errorMessage === "string" ? { errorMessage: value.errorMessage } : {}),
+        ...(content === undefined ? {} : { content }),
+    };
+}
+/**
+ * Compacts an advisory event to the telemetry the parent projects before it is serialized and
+ * pushed over the bridge. A streaming update carries the whole partial message — text, tool
+ * arguments, the accumulating `partial` — which is what the parent neither reads nor needs; only
+ * the phase metadata (type, content index) and the tool name survive, so a frame stays far below
+ * the protocol limit under any payload size.
  */
 export function sanitizeEventForBridge(event) {
     if (!isRecord(event))
         return event;
+    if (event.type === "message_update") {
+        const update = isRecord(event.assistantMessageEvent) ? event.assistantMessageEvent : undefined;
+        const message = compactMessage(event.message, BRIDGE_MESSAGE_TEXT_LIMIT);
+        return {
+            type: "message_update",
+            ...(message === undefined ? {} : { message }),
+            ...(update === undefined
+                ? {}
+                : {
+                    assistantMessageEvent: {
+                        ...(typeof update.type === "string" ? { type: update.type } : {}),
+                        ...(typeof update.contentIndex === "number"
+                            ? { contentIndex: update.contentIndex }
+                            : {}),
+                    },
+                }),
+        };
+    }
+    if (event.type === "tool_execution_start") {
+        return {
+            type: "tool_execution_start",
+            ...(typeof event.toolName === "string" ? { toolName: event.toolName } : {}),
+            ...(typeof event.toolCallId === "string" ? { toolCallId: event.toolCallId } : {}),
+        };
+    }
     if (event.type === "tool_execution_end" && isRecord(event.result)) {
-        const result = event.result;
-        if (Array.isArray(result.content)) {
-            const sanitizedContent = result.content.map((part) => {
-                if (isRecord(part) &&
-                    part.type === "text" &&
-                    typeof part.text === "string" &&
-                    part.text.length > 2000) {
-                    return {
-                        ...part,
-                        text: `${part.text.slice(0, 1000)}\n... [truncated for bridge event]`,
-                    };
-                }
-                if (isRecord(part) && part.type === "image") {
-                    return {
-                        type: "image",
-                        mimeType: part.mimeType,
-                        data: "[image omitted for bridge event]",
-                    };
-                }
-                return part;
-            });
-            return { ...event, result: { ...result, content: sanitizedContent } };
-        }
+        const content = compactContent(event.result.content, BRIDGE_TOOL_TEXT_LIMIT);
+        return {
+            ...event,
+            result: {
+                ...(content === undefined ? {} : { content }),
+                ...(typeof event.result.isError === "boolean" ? { isError: event.result.isError } : {}),
+            },
+        };
+    }
+    if (event.type === "turn_end") {
+        const message = compactMessage(event.message, BRIDGE_MESSAGE_TEXT_LIMIT);
+        return {
+            type: "turn_end",
+            ...(typeof event.turnIndex === "number" ? { turnIndex: event.turnIndex } : {}),
+            ...(message === undefined ? {} : { message }),
+        };
+    }
+    if (event.type === "agent_end" || event.type === "agent_settled") {
+        const messages = Array.isArray(event.messages) ? event.messages : undefined;
+        const last = messages?.[messages.length - 1];
+        const message = compactMessage(last ?? event.message, BRIDGE_MESSAGE_TEXT_LIMIT);
+        return {
+            type: event.type,
+            ...(event.type === "agent_settled" ? { aborted: event.aborted } : {}),
+            ...(message === undefined ? {} : { message, messages: [message] }),
+        };
+    }
+    if (event.type === "compaction_start" || event.type === "compaction_end") {
+        return {
+            type: event.type,
+            ...(typeof event.reason === "string" ? { reason: event.reason } : {}),
+            ...(typeof event.aborted === "boolean" ? { aborted: event.aborted } : {}),
+        };
     }
     return event;
 }
@@ -73,6 +177,21 @@ export function sanitizeEventForBridge(event) {
 export function registerChildControl(pi, options) {
     const isActive = options.isActive ?? (() => true);
     let ctx;
+    let isCompacting = false;
+    const pendingCompactionDeliveries = [];
+    const flushCompactionQueue = () => {
+        if (pendingCompactionDeliveries.length === 0)
+            return;
+        const queued = pendingCompactionDeliveries.splice(0);
+        for (const item of queued) {
+            if (item.deliverAs !== undefined) {
+                pi.sendUserMessage(item.message, { deliverAs: item.deliverAs });
+            }
+            else {
+                pi.sendUserMessage(item.message);
+            }
+        }
+    };
     const requireContext = () => {
         if (ctx === undefined) {
             throw new BridgeError("session_not_ready", "This child has no active Pi session yet");
@@ -83,12 +202,40 @@ export function registerChildControl(pi, options) {
         const message = promptMessage(payload);
         // A message needs a session to land in: while the process is between sessions the parent
         // hears that instead of a silent drop.
-        requireContext();
+        const path = requireContext().sessionManager.getSessionFile();
+        if (path === undefined) {
+            throw new BridgeError("session_not_ready", "This child has no session file path");
+        }
+        if (isCompacting) {
+            pendingCompactionDeliveries.push({ message, deliverAs });
+            return { accepted: true, path, queuedForCompaction: true };
+        }
         if (deliverAs !== undefined)
             pi.sendUserMessage(message, { deliverAs });
         else
             pi.sendUserMessage(message);
-        return { accepted: true };
+        return { accepted: true, path };
+    };
+    const currentEntries = () => {
+        const sm = requireContext().sessionManager;
+        const branch = typeof sm.getBranch === "function" ? sm.getBranch() : undefined;
+        return Array.isArray(branch) && branch.length > 0 ? branch : sm.getEntries();
+    };
+    let cachedFacts;
+    const sessionFacts = (expected) => {
+        const sm = requireContext().sessionManager;
+        const leaf = typeof sm.getLeafId === "function" ? sm.getLeafId() : undefined;
+        // Append-only: a new message, compaction, or branch moves the leaf. The same leaf is the
+        // same transcript, so turn_end and agent_end do not each copy and walk it.
+        if (typeof leaf === "string" && leaf.length > 0) {
+            const key = `${leaf}:${expected ?? ""}`;
+            if (cachedFacts?.key === key)
+                return cachedFacts.facts;
+            const facts = transcriptFacts(currentEntries(), expected);
+            cachedFacts = { key, facts };
+            return facts;
+        }
+        return transcriptFacts(currentEntries(), expected);
     };
     const handleRequest = async (request) => {
         if (!isActive()) {
@@ -104,9 +251,14 @@ export function registerChildControl(pi, options) {
             case "follow_up":
                 return deliverPrompt(request.payload, "followUp");
             case "get_state":
-                return childState(requireContext());
-            case "get_entries":
-                return { entries: requireContext().sessionManager.getEntries() };
+                return childState(requireContext(), isCompacting);
+            case "get_entries": {
+                return { entries: currentEntries() };
+            }
+            case "session_facts": {
+                const expected = isRecord(request.payload) ? request.payload.expectedInput : undefined;
+                return sessionFacts(typeof expected === "string" ? expected : undefined);
+            }
             case "abort":
                 requireContext().abort();
                 return { accepted: true };
@@ -117,36 +269,88 @@ export function registerChildControl(pi, options) {
                 throw new BridgeError("unsupported_operation", `This child does not implement ${request.operation}`);
         }
     };
-    const client = new ChildBridgeClient({
-        endpoint: options.endpoint,
-        identity: options.identity,
+    const dispose = [];
+    let currentPhase;
+    /** The compact event carrying the current phase, resent when the parent reconnects. */
+    const phaseResetEvents = [
+        "agent_start",
+        "agent_end",
+        "turn_start",
+        "turn_end",
+        "agent_settled",
+        "tool_execution_start",
+        "tool_execution_end",
+        "compaction_start",
+        "compaction_end",
+    ];
+    const client = attachChildMailbox({
+        filePath: options.endpoint,
+        parentSessionId: options.identity.parentSessionId,
+        subagentId: options.identity.subagentId,
         handleRequest,
         ...(options.diagnose === undefined ? {} : { diagnose: options.diagnose }),
     });
-    const dispose = [];
     // `pi.on` is declared as literal-name overloads, so a loop over the forwarded event types cannot
     // be typed through them; every name in FORWARDED_PI_EVENT_TYPES is a real Pi event.
     const onPiEvent = pi.on;
     for (const type of FORWARDED_PI_EVENT_TYPES) {
         dispose.push(onPiEvent(type, (event) => {
-            if (!isActive())
+            if (!isActive() || !client.connected)
                 return;
-            if (shouldForwardPiEvent(event))
-                client.sendEvent(sanitizeEventForBridge(event));
+            if (!shouldForwardPiEvent(event))
+                return;
+            const compact = sanitizeEventForBridge(event);
+            if (isRecord(event)) {
+                if (typeof event.type === "string" && phaseResetEvents.includes(event.type)) {
+                    currentPhase = undefined;
+                }
+                else if (event.type === "message_update") {
+                    const phase = assistantPhaseKey(event);
+                    if (phase !== undefined) {
+                        // While the parent is listening, repetitive deltas in the same phase are dropped to
+                        // prevent socket floods. A disconnected parent suppresses nothing: the phase is
+                        // resent from `onConnect` instead, so a dropped delta cannot hide it.
+                        if (phase === currentPhase && client.connected)
+                            return;
+                        currentPhase = phase;
+                    }
+                }
+            }
+            client.sendEvent(compact);
         }));
     }
     dispose.push(pi.on("input", (event) => {
-        if (!isActive())
+        if (!isActive() || !client.connected)
             return;
         const source = childInputSource(event);
-        if (source !== undefined)
-            client.sendChildInput(source);
+        if (source !== undefined) {
+            client.sendEvent({
+                type: CHILD_INPUT_EVENT,
+                parentSessionId: options.identity.parentSessionId,
+                childId: options.identity.subagentId,
+                runtimeIdentity: options.identity.runtimeIdentity,
+                source,
+            });
+        }
     }));
     dispose.push(pi.on("session_start", (_event, context) => {
         ctx = context;
     }));
+    dispose.push(onPiEvent("compaction_start", () => {
+        isCompacting = true;
+    }));
+    dispose.push(onPiEvent("compaction_end", () => {
+        isCompacting = false;
+        queueMicrotask(() => {
+            if (!isCompacting) {
+                flushCompactionQueue();
+            }
+        });
+    }));
     dispose.push(pi.on("session_shutdown", () => {
         ctx = undefined;
+        isCompacting = false;
+        pendingCompactionDeliveries.length = 0;
     }));
     let started = false;
     return {
@@ -158,7 +362,7 @@ export function registerChildControl(pi, options) {
             started = true;
             client.start();
         },
-        report: (operation, payload, signal) => client.sendReport(operation, payload, signal),
+        report: (operation, payload, signal) => client.report(operation, payload, signal),
         sendEvent: (event) => client.sendEvent(event),
         dispose: () => {
             for (const off of dispose) {

package/dist/child-process.d.ts

@@ -19,3 +19,5 @@ export interface ChildRuntime {
  * supervisor process, so nothing else can end a background child after its parent is gone.
  */
 export declare function spawnChildRuntime(options: ChildProcessOptions): ChildRuntime;
+/** The process-scoped stdin leash for a background child that survived an extension reload. */
+export declare function attachRetainedChild(pid: number): ChildRuntime | undefined;

package/dist/child-process.js

@@ -18,6 +18,7 @@ function hasExited(child) {
  * would send it an EOF and end a child that only its parent's exit is supposed to end.
  */
 const retained = new Set();
+const retainedRuntimes = new Map();
 /**
  * Starts a detached-from-the-terminal child Pi. The caller keeps the handle: this package has no
  * supervisor process, so nothing else can end a background child after its parent is gone.
@@ -43,22 +44,14 @@ export function spawnChildRuntime(options) {
             resolve(code);
         });
     });
-    if (child.pid === undefined) {
+    const pid = child.pid;
+    if (pid === undefined) {
         child.kill("SIGKILL");
         throw new Error(`Child process ${options.command} did not start`);
     }
     retained.add(child);
-    // stdout is the child's Pi protocol stream and stderr its diagnostics; neither is a control
-    // channel, so they are drained to keep the pipes from filling and reported only as diagnostics.
-    child.stdout.on("data", () => { });
-    child.stderr.on("data", (chunk) => {
-        const text = chunk.toString("utf8").trim();
-        if (text !== "")
-            diagnose(text);
-    });
-    child.stdin.on("error", () => { });
-    return {
-        pid: child.pid,
+    const runtime = {
+        pid,
         get alive() {
             return !hasExited(child);
         },
@@ -76,6 +69,25 @@ export function spawnChildRuntime(options) {
             }
         },
     };
+    retainedRuntimes.set(pid, runtime);
+    void exited.then(() => {
+        retainedRuntimes.delete(pid);
+    });
+    // stdout is the child's Pi protocol stream and stderr its diagnostics; neither is a control
+    // channel, so they are drained to keep the pipes from filling and reported only as diagnostics.
+    child.stdout.on("data", () => { });
+    child.stderr.on("data", (chunk) => {
+        const text = chunk.toString("utf8").trim();
+        if (text !== "")
+            diagnose(text);
+    });
+    child.stdin.on("error", () => { });
+    return runtime;
+}
+/** The process-scoped stdin leash for a background child that survived an extension reload. */
+export function attachRetainedChild(pid) {
+    const runtime = retainedRuntimes.get(pid);
+    return runtime?.alive === true ? runtime : undefined;
 }
 /** True when `work` settled within the window; the child process outlives this wait either way. */
 function settled(work, timeoutMs) {

package/dist/commands.d.ts

@@ -1,6 +1,3 @@
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { type PublicSubagent } from "./domain.js";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { SubagentManager } from "./manager.js";
-export declare function formatStatusLine(children: readonly PublicSubagent[]): string | undefined;
 export declare function registerParentCommands(pi: ExtensionAPI, manager: SubagentManager): void;
-export declare function bindParentStatus(_pi: ExtensionAPI, context: ExtensionContext, manager: SubagentManager, signal?: AbortSignal): () => void;

package/dist/commands.js

@@ -1,23 +1,8 @@
 import { splitSubcommand, subcommandCompletions } from "@hheei/pi-ext-core";
 import { toVisualSubagentState, VISUAL_SUBAGENT_GLYPH } from "./domain.js";
-const STATUS_KEY = "pi-subagents";
 /** Verbs of the dispatcher below; the completer and the no-argument picker share them. */
 const SUBAGENT_SUBCOMMANDS = ["list", "inspect", "send", "stop"];
 const SUBAGENT_COMMAND_USAGE = "Usage: /subagents list|inspect|send|stop [id]";
-export function formatStatusLine(children) {
-    const visible = children.filter((child) => child.state !== "done" && child.state !== "error");
-    if (visible.length === 0)
-        return undefined;
-    return visible
-        .map((child) => {
-        const visual = toVisualSubagentState(child.state, child.interrupted);
-        const glyph = VISUAL_SUBAGENT_GLYPH[visual];
-        const name = child.displayName ?? child.agent;
-        const mode = child.presentation === "panel" ? `${visual} panel` : visual;
-        return `${glyph} ${name} ${mode}`;
-    })
-        .join(" · ");
-}
 function notifyResult(ctx, result, ok) {
     if ("reason" in result && typeof result.reason === "string") {
         ctx.ui.notify(result.reason, "error");
@@ -61,7 +46,7 @@ export function registerParentCommands(pi, manager) {
         getArgumentCompletions: subcommandCompletions(SUBAGENT_SUBCOMMANDS),
         handler: async (args, ctx) => {
             if (ctx.mode !== "tui") {
-                ctx.ui.notify("Use spawn_agent / send_agent / get_agent / stop_agent in this mode");
+                ctx.ui.notify("Use agent_spawn / agent_send / agent_get / agent_stop in this mode");
                 return;
             }
             const { verb, rest: target } = splitSubcommand(args);
@@ -109,39 +94,3 @@ export function registerParentCommands(pi, manager) {
         },
     });
 }
-export function bindParentStatus(_pi, context, manager, signal) {
-    let disposed = false;
-    const refresh = () => {
-        if (disposed || signal?.aborted)
-            return;
-        void manager
-            .list()
-            .then((children) => {
-            if (disposed || signal?.aborted)
-                return;
-            try {
-                context.ui.setStatus(STATUS_KEY, formatStatusLine(children));
-            }
-            catch {
-                // Context may be stale after session replacement or reload.
-            }
-        })
-            .catch(() => { });
-    };
-    const unsubscribe = manager.onChange(refresh);
-    refresh();
-    return () => {
-        if (disposed)
-            return;
-        disposed = true;
-        unsubscribe();
-        if (signal?.aborted)
-            return;
-        try {
-            context.ui.setStatus(STATUS_KEY, undefined);
-        }
-        catch {
-            // Context may be stale after session replacement or reload.
-        }
-    };
-}

package/dist/domain.d.ts

@@ -67,6 +67,11 @@ export interface Selection {
 /** Extensions and skills are selected the same way; the aliases keep the two roles named. */
 export type ExtensionSelection = Selection;
 export type SkillSelection = Selection;
+export interface McpSelection {
+    readonly enabled: boolean;
+    readonly servers?: readonly string[];
+    readonly excluded?: readonly string[];
+}
 export interface EffectiveLaunchConfig {
     /** Logical child id; the same value the child bridge reports back. */
     readonly subagentId: string;
@@ -77,8 +82,6 @@ export interface EffectiveLaunchConfig {
     readonly sessionDir: string;
     /** Known only once the session has been flushed to disk. */
     readonly sessionPath?: string;
-    /** Optional path to a prior session JSONL file referenced for on-demand context inspection. */
-    readonly referencedSessionPath?: string;
     readonly agent: ResolvedAgentIdentity;
     readonly model: ResolvedModel;
     readonly thinking: ResolvedThinking;
@@ -86,10 +89,9 @@ export interface EffectiveLaunchConfig {
     readonly excludeTools: readonly string[];
     readonly extensions: ExtensionSelection;
     readonly skills: SkillSelection;
+    readonly mcp: McpSelection;
     readonly prompt: string;
     readonly bridgeExtensionPath: string;
-    /** Frozen at spawn. Interactive children do not auto-wake the parent except via contact_parent. */
-    readonly interactive: boolean;
     /** Whether the subagent operates in codemode-only mode. */
     readonly codemodeOnly?: boolean;
     /**
@@ -106,7 +108,7 @@ export interface ResolvedAgentPolicy {
     readonly excludeTools: readonly string[];
     readonly extensions: ExtensionSelection;
     readonly skills: SkillSelection;
-    readonly interactive: boolean;
+    readonly mcp: McpSelection;
     readonly codemodeOnly?: boolean;
     readonly enabled?: boolean;
 }
@@ -114,9 +116,24 @@ export interface ResolvedAgentPolicy {
  * The runtime attachment a child was last launched with. It is evidence, never a liveness proof:
  * whether that process is still serving this child is answered by the bridge connection.
  */
+export type PanelHost = "herdr" | "cmux";
+/**
+ * The surface that owns a child runtime. A panel id is a host tab or surface. A process id is a
+ * background child. Neither one is liveness by itself: the host list or a pid check says whether
+ * it is still there.
+ */
+export type RuntimeAttachment = {
+    readonly kind: "panel";
+    readonly host: PanelHost;
+    readonly id: string;
+} | {
+    readonly kind: "process";
+    readonly pid: number;
+};
 export interface RuntimeMetadata {
     readonly runtimeIdentity: string;
     readonly endpoint: string;
+    readonly attachment?: RuntimeAttachment;
 }
 export interface UsageSummary {
     readonly inputTokens: number;
@@ -150,18 +167,20 @@ export interface SubagentRecord {
 }
 export interface PublicSubagent {
     readonly id: string;
+    /** Pi-assigned session file path; the first write may still be pending. */
+    readonly path?: string;
     readonly agent: string;
     readonly displayName?: string;
     readonly state: SubagentState;
     readonly presentation: Presentation;
     readonly cwd: string;
     readonly sessionId: string;
+    readonly task?: string;
     readonly summary?: string;
     readonly activeTool?: string;
     readonly usage?: UsageSummary;
     readonly interrupted?: string;
     readonly freshness: "live" | "last_known";
-    readonly interactive: boolean;
     readonly model: ResolvedModel;
     readonly thinking: ResolvedThinking;
     readonly createdAt: string;
@@ -183,21 +202,17 @@ export interface SpawnSubagentInput {
      * Where to run this child. `auto` (the default) means a panel whenever this parent has a
      * presentation host, and the background otherwise; the Task tool pins `background` because a
      * Task is settled by its parent and never handed to a human. This is not a model-facing
-     * parameter: `spawn_agent` always spawns with `auto`.
+     * parameter: `agent_spawn` always spawns with `auto`.
      */
     readonly presentation?: Presentation | "auto";
     /** Optional child session title; the child branch prefixes it with the subagent marker. */
     readonly title?: string;
-    /**
-     * Optional session or agent to fork context from (e.g. 'parent', or a subagent id like 'agent-1').
-     * Thinking blocks are stripped and context is compacted if pi-ext-memory is active.
-     */
-    readonly forkFrom?: string;
 }
 /** True when a manager call returned a structured failure instead of a value. */
 export declare function isOperationError(value: unknown): value is OperationError;
 /** Child bridge tool name; agent tool policy must never remove it. */
 export declare const CONTACT_PARENT_TOOL_NAME: "contact_parent";
+export declare const DEFAULT_PI_TOOLS: readonly ["read", "bash", "edit", "write"];
 /** Environment contract between a parent launch and the child branch of this extension. */
 export declare const BRIDGE_ENVIRONMENT_KEYS: {
     readonly parentSessionId: "PI_SUBAGENTS_PARENT_SESSION_ID";

package/dist/domain.js

@@ -10,12 +10,12 @@ export function normalizeSubagentState(value) {
         case "idle":
             return "running";
         case "done":
+        case "stopped":
             return "done";
         case "blocked":
             return "blocked";
         case "error":
         case "failed":
-        case "stopped":
             return "error";
         default:
             return undefined;
@@ -53,6 +53,7 @@ export function isOperationError(value) {
 }
 /** Child bridge tool name; agent tool policy must never remove it. */
 export const CONTACT_PARENT_TOOL_NAME = "contact_parent";
+export const DEFAULT_PI_TOOLS = ["read", "bash", "edit", "write"];
 /** Environment contract between a parent launch and the child branch of this extension. */
 export const BRIDGE_ENVIRONMENT_KEYS = {
     parentSessionId: "PI_SUBAGENTS_PARENT_SESSION_ID",