@hheei/pi-subagents 0.2.4 → 0.3.0

package/dist/manager.js

@@ -1,12 +1,29 @@
+import { readFile } from "node:fs/promises";
 import { errorMessage, isRecord } from "@hheei/pi-ext-core";
+import { isOperationError } from "./domain.js";
 import { stripHindsightContent } from "./launch-spec.js";
 import { BridgeError, isChildInputPayload, isChildLifecyclePayload, isContactReportPayload, } from "./protocol.js";
 import { findSessionFile, planSessionPlacement } from "./session-bootstrap.js";
-import { readSessionJsonlEntries } from "./session-fork.js";
+async function readSessionJsonlEntries(filePath) {
+    const content = await readFile(filePath, "utf8");
+    const entries = [];
+    for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed.length > 0) {
+            try {
+                entries.push(JSON.parse(trimmed));
+            }
+            catch {
+                // Ignore corrupted line
+            }
+        }
+    }
+    return entries;
+}
 import { createStateProjector } from "./state.js";
 /**
  * How long an idle child keeps its runtime. A background child holds a whole Pi process and its
- * session lock, so an idle one is reclaimed after this window and a later `send_agent` starts it
+ * session lock, so an idle one is reclaimed after this window and a later `agent_send` starts it
  * again from the same session.
  */
 export const SUBAGENT_IDLE_TIMEOUT_MS = 15_000;
@@ -29,9 +46,19 @@ function failure(operation, reason, childId, state, sideEffects = [], safeToRetr
         safeToRetry,
     };
 }
-function publicChild(record, live) {
+function acknowledgedPath(response) {
+    if (!isRecord(response) ||
+        response.accepted !== true ||
+        typeof response.path !== "string" ||
+        response.path === "") {
+        throw new BridgeError("invalid_state", "Child did not confirm its session path");
+    }
+    return response.path;
+}
+function publicChild(record, live, path = record.sessionPath) {
     return {
         id: record.subagentId,
+        ...(path === undefined ? {} : { path }),
         agent: record.launchConfig.agent.name,
         ...(record.launchConfig.agent.displayName === undefined
             ? {}
@@ -40,12 +67,12 @@ function publicChild(record, live) {
         presentation: record.presentation,
         cwd: record.cwd,
         sessionId: record.sessionId,
+        ...(record.initialTask === undefined ? {} : { task: record.initialTask }),
         ...(record.latestSummary === undefined ? {} : { summary: record.latestSummary }),
         ...(record.activeTool === undefined ? {} : { activeTool: record.activeTool }),
         ...(record.usage === undefined ? {} : { usage: record.usage }),
         ...(record.interrupted === undefined ? {} : { interrupted: record.interrupted }),
         freshness: live ? "live" : "last_known",
-        interactive: record.launchConfig.interactive,
         model: record.launchConfig.model,
         thinking: record.launchConfig.thinking,
         createdAt: record.createdAt,
@@ -131,12 +158,15 @@ export class SubagentManager {
     /** Bumped by every inbound bridge signal, so a reclaim in flight can tell the child moved. */
     #activity = new Map();
     #projectors = new Map();
+    /** Display paths do not imply that a session has been flushed to disk. */
+    #paths = new Map();
     /** Known child work in flight, separate from failures recorded before Pi finally settles. */
     #working = new Set();
     /** A settled event from an older run cannot clear a newer synchronous start signal. */
     #workVersions = new Map();
     #settledPanelCloseTimers = new Map();
-    #autoReportTimers = new Map();
+    #pendingAutoReports = new Map();
+    #autoReportBatchTimer;
     #lastDeliveredTurn = new Map();
     #stopping = new Set();
     #listeners = new Set();
@@ -168,7 +198,7 @@ export class SubagentManager {
             this.#childEventListeners.delete(listener);
         };
     }
-    /** Presentation-only: widget and similar projections re-read list() after this. */
+    /** Presentation-only: status and similar projections re-read list() after this. */
     onChange(listener) {
         this.#listeners.add(listener);
         return () => {
@@ -176,6 +206,11 @@ export class SubagentManager {
         };
     }
     dispose() {
+        if (this.#autoReportBatchTimer !== undefined) {
+            clearTimeout(this.#autoReportBatchTimer);
+            this.#autoReportBatchTimer = undefined;
+        }
+        this.#pendingAutoReports.clear();
         for (const timer of this.#settledPanelCloseTimers.values()) {
             clearTimeout(timer);
         }
@@ -190,12 +225,18 @@ export class SubagentManager {
      */
     closeLocalConnections() {
         this.dispose();
+        if (this.#autoReportBatchTimer !== undefined) {
+            clearTimeout(this.#autoReportBatchTimer);
+            this.#autoReportBatchTimer = undefined;
+        }
+        this.#pendingAutoReports.clear();
         this.#processes.clear();
         this.#attachments.clear();
         this.#leftSessions.clear();
         this.#unresolvedRuntimes.clear();
         this.#activity.clear();
         this.#projectors.clear();
+        this.#paths.clear();
         this.#working.clear();
         this.#workVersions.clear();
         this.#notify();
@@ -299,13 +340,15 @@ export class SubagentManager {
             // A panel the host confirms is gone stops holding this child — the handle it left behind is
             // also what a retried stop would act on, so it is released here before refusing.
             await this.#releasePanel(id).catch(() => undefined);
-            if ((await this.#deps.registry.get(id))?.intent === "stopped") {
-                return STOPPED_SEND_REASON;
-            }
         }
         if (this.#runtimeStarted(id)) {
             return "This child's previous runtime is not confirmed gone (its process or panel may still be running); stop the child to end it, then spawn a new one for this work";
         }
+        if (this.#attachments.has(id)) {
+            if ((await this.#deps.registry.get(id))?.intent === "stopped") {
+                return STOPPED_SEND_REASON;
+            }
+        }
         if (this.#unresolvedRuntimes.has(id)) {
             return "This child's panel runtime is disconnected and its exit cannot be confirmed; no replacement was started. Close any remaining panel, stop the child, then spawn a new child for this work";
         }
@@ -397,21 +440,29 @@ export class SubagentManager {
      * only ever closed on a judgement, never on a guess.
      */
     #scheduleAutoReport(id, record) {
-        this.#clearAutoReport(id);
-        const timer = setTimeout(() => {
-            this.#autoReportTimers.delete(id);
-            void this.#performAutoReport(id, record).catch((error) => {
-                diagnose(`failed to report child ${id}: ${errorMessage(error)}`);
-            });
-        }, 5_000);
-        timer.unref?.();
-        this.#autoReportTimers.set(id, timer);
+        this.#pendingAutoReports.set(id, record);
+        if (this.#autoReportBatchTimer !== undefined) {
+            clearTimeout(this.#autoReportBatchTimer);
+        }
+        // Batch reports: if all children settled, flush in 500ms; otherwise wait up to 10000ms for others
+        const delayMs = this.#working.size > 0 ? 10_000 : 500;
+        this.#autoReportBatchTimer = setTimeout(async () => {
+            this.#autoReportBatchTimer = undefined;
+            const batch = [...this.#pendingAutoReports.entries()];
+            this.#pendingAutoReports.clear();
+            for (const [childId, childRecord] of batch) {
+                await this.#performAutoReport(childId, childRecord).catch((error) => {
+                    diagnose(`failed to report child ${childId}: ${errorMessage(error)}`);
+                });
+            }
+        }, delayMs);
+        this.#autoReportBatchTimer.unref?.();
     }
     #clearAutoReport(id) {
-        const timer = this.#autoReportTimers.get(id);
-        if (timer !== undefined) {
-            clearTimeout(timer);
-            this.#autoReportTimers.delete(id);
+        this.#pendingAutoReports.delete(id);
+        if (this.#pendingAutoReports.size === 0 && this.#autoReportBatchTimer !== undefined) {
+            clearTimeout(this.#autoReportBatchTimer);
+            this.#autoReportBatchTimer = undefined;
         }
     }
     #scheduleSettledPanelClose(id) {
@@ -534,10 +585,14 @@ export class SubagentManager {
                 (this.#activity.get(id) ?? 0) !== activity ||
                 (this.#workVersions.get(id) ?? 0) !== workVersion)
                 return;
-            const hasError = record.state === "error" ||
-                (record.interrupted !== undefined && record.interrupted.trim() !== "");
-            const isBlocked = hasError;
-            if (!isBlocked && (text === undefined || text.trim() === "")) {
+            const isError = current.state === "error" || record.state === "error";
+            const isBlocked = !isError &&
+                (current.state === "blocked" ||
+                    record.state === "blocked" ||
+                    (current.interrupted !== undefined && current.interrupted.trim() !== "") ||
+                    (record.interrupted !== undefined && record.interrupted.trim() !== ""));
+            const failed = isError || isBlocked;
+            if (!failed && (text === undefined || text.trim() === "")) {
                 const projector = this.#projectors.get(id);
                 if (projector !== undefined) {
                     projector.syncState("done");
@@ -559,12 +614,16 @@ export class SubagentManager {
                 return;
             }
             let message;
-            if (isBlocked) {
-                if (record.interrupted !== undefined && record.interrupted.trim() !== "") {
+            const interruptedText = current.interrupted?.trim() || record.interrupted?.trim();
+            if (isError) {
+                message = interruptedText || "Subagent failed without error details.";
+            }
+            else if (isBlocked) {
+                if (interruptedText !== undefined && interruptedText !== "") {
                     message =
                         text !== undefined && text.trim() !== ""
-                            ? `${record.interrupted}\n\n${text}`
-                            : record.interrupted;
+                            ? `${interruptedText}\n\n${text}`
+                            : interruptedText;
                 }
                 else if (text !== undefined && text.trim() !== "") {
                     message = text;
@@ -576,13 +635,16 @@ export class SubagentManager {
             else {
                 message = text ?? "";
             }
-            if (this.#lastDeliveredTurn.get(id) === message)
+            const lastDelivered = this.#lastDeliveredTurn.get(id);
+            if (lastDelivered !== undefined &&
+                lastDelivered.workVersion === workVersion &&
+                lastDelivered.message === message) {
                 return;
-            this.#lastDeliveredTurn.set(id, message);
-            const reason = isBlocked ? "blocked" : "success";
-            const taskStatus = isBlocked ? "failed" : "completed";
+            }
+            const reason = isError ? "error" : isBlocked ? "blocked" : "success";
+            const taskStatus = failed ? "failed" : "completed";
             const projector = this.#projectors.get(id);
-            const updatedRecord = !isBlocked
+            const updatedRecord = !failed
                 ? await this.#update(id, (current) => {
                     const { interrupted: _interrupted, ...clean } = current;
                     return {
@@ -592,16 +654,13 @@ export class SubagentManager {
                 })
                 : await this.#update(id, (current) => ({
                     ...current,
-                    state: "blocked",
+                    state: isError ? "error" : "blocked",
                     interrupted: current.interrupted ?? message,
                 }));
             if (projector !== undefined) {
-                projector.syncState(isBlocked ? "blocked" : "done");
+                projector.syncState(isError ? "error" : isBlocked ? "blocked" : "done");
             }
             this.#scheduleSettledPanelClose(id);
-            if (this.#deps.channel !== undefined) {
-                await this.contactParent(id, reason, message, updatedRecord);
-            }
             if (this.#taskRegistry !== undefined) {
                 this.#taskRegistry.settle(id, {
                     status: taskStatus,
@@ -609,6 +668,16 @@ export class SubagentManager {
                     truncated: false,
                 });
             }
+            let deliveryOk = true;
+            if (this.#deps.channel !== undefined) {
+                const contactResult = await this.contactParent(id, reason, message, updatedRecord);
+                if (isOperationError(contactResult)) {
+                    deliveryOk = false;
+                }
+            }
+            if (deliveryOk) {
+                this.#lastDeliveredTurn.set(id, { workVersion, message });
+            }
         });
     }
     /** Reads a child's session entries; exposed for Task completion inspection. */
@@ -745,11 +814,37 @@ export class SubagentManager {
      */
     async #settleUnrecovered(record) {
         this.#working.delete(record.subagentId);
+        this.#projectors.delete(record.subagentId);
         const retired = record.runtime;
-        if (retired === undefined)
-            return;
         if (record.presentation === "panel") {
-            this.#unresolvedRuntimes.add(record.subagentId);
+            if (retired !== undefined) {
+                this.#unresolvedRuntimes.add(record.subagentId);
+            }
+            await this.#update(record.subagentId, (current) => {
+                if (current.intent === "stopped")
+                    return current;
+                if (current.state !== "running")
+                    return current;
+                return {
+                    ...current,
+                    state: "blocked",
+                    interrupted: "The child panel runtime did not reconnect; its process exit is not confirmed",
+                };
+            });
+            return;
+        }
+        if (retired === undefined) {
+            await this.#update(record.subagentId, (current) => {
+                if (current.intent === "stopped")
+                    return current;
+                if (current.state !== "running")
+                    return current;
+                return {
+                    ...current,
+                    state: "done",
+                    interrupted: "The child runtime ended with the parent process; a later send starts it again from the same session",
+                };
+            });
             return;
         }
         await this.#update(record.subagentId, (current) => {
@@ -779,6 +874,9 @@ export class SubagentManager {
             throw new BridgeError("invalid_state", `Child ${id} did not confirm its current work state`);
         }
         const idle = state.idle && !state.pendingMessages;
+        if (typeof state.path === "string" && state.path !== "") {
+            this.#paths.set(id, state.path);
+        }
         if ((this.#workVersions.get(id) ?? 0) === workVersion) {
             if (idle)
                 this.#working.delete(id);
@@ -803,8 +901,9 @@ export class SubagentManager {
                 ? current
                 : (({ unacknowledgedInput: _input, ...rest }) => rest)(current);
             const hasError = snapshot.state === "error";
+            const { interrupted: _interrupted, ...withoutInterrupted } = base;
             return {
-                ...base,
+                ...withoutInterrupted,
                 state: hasError ? "error" : idle ? "done" : "running",
                 ...(snapshot.summary === undefined ? {} : { latestSummary: snapshot.summary }),
                 usage: snapshot.usage,
@@ -866,8 +965,10 @@ export class SubagentManager {
             this.#working.add(childId);
             this.#notify();
             await withDeadline(this.#start(record), this.#deps.deadlineMs ?? 60_000);
+            let path;
             try {
-                await this.#request(record.subagentId, "prompt", { message: cleanTask });
+                path = acknowledgedPath(await this.#request(record.subagentId, "prompt", { message: cleanTask }));
+                this.#paths.set(record.subagentId, path);
             }
             catch (error) {
                 let failureState = "error";
@@ -908,6 +1009,9 @@ export class SubagentManager {
                                 output: `Subagent ${record.subagentId} (${input.agent}) is running`,
                                 truncated: false,
                             }),
+                            consume: () => {
+                                this.#deps.channel?.dismiss?.(record.subagentId);
+                            },
                         }),
                     });
                 }
@@ -916,7 +1020,8 @@ export class SubagentManager {
                 }
             }
             return {
-                child: publicChild((await this.#deps.registry.get(record.subagentId)) ?? record, true),
+                child: publicChild((await this.#deps.registry.get(record.subagentId)) ?? record, true, path),
+                path,
                 ...(placement.note === undefined ? {} : { note: placement.note }),
             };
         }
@@ -956,10 +1061,11 @@ export class SubagentManager {
             const record = await this.#deps.registry.get(id);
             if (record === undefined)
                 return failure("send", "Unknown child", id);
-            if (record.intent === "stopped" || record.state === "error") {
+            if (record.intent === "stopped") {
                 const doubt = await this.#runtimeDoubt(id);
-                return failure("send", doubt ??
-                    `Subagent ${id} is in error state and cannot continue (${record.interrupted ?? "fatal error"}). You can reference its context via spawn_agent with forkFrom: "${id}".`, id, record.state, [], false);
+                if (doubt !== undefined) {
+                    return failure("send", doubt, id, record.state, ["runtime metadata retained"], false);
+                }
             }
             let isResumed = false;
             // Deliverability is the bridge connection, minus a process that left the delegated session:
@@ -984,6 +1090,7 @@ export class SubagentManager {
                 const resumedRecord = await this.#update(id, (current) => ({
                     ...current,
                     state: "running",
+                    intent: "active",
                     persistence,
                     ...(sessionPath === undefined ? {} : { sessionPath }),
                     launchConfig: sessionPath === undefined
@@ -996,6 +1103,31 @@ export class SubagentManager {
                 try {
                     await withDeadline(this.#start(resumedRecord), this.#deps.deadlineMs ?? 60_000);
                     isResumed = true;
+                    if (this.#taskRegistry !== undefined) {
+                        try {
+                            this.#taskRegistry.create({
+                                id: resumedRecord.subagentId,
+                                type: "agent",
+                                purpose: `${resumedRecord.launchConfig.agent}: resumed task`,
+                                inlineResult: true,
+                                begin: () => ({
+                                    stop: () => {
+                                        void this.stop(resumedRecord.subagentId);
+                                    },
+                                    describe: () => ({
+                                        output: `Subagent ${resumedRecord.subagentId} (${resumedRecord.launchConfig.agent}) is running`,
+                                        truncated: false,
+                                    }),
+                                    consume: () => {
+                                        this.#deps.channel?.dismiss?.(resumedRecord.subagentId);
+                                    },
+                                }),
+                            });
+                        }
+                        catch (regError) {
+                            diagnose(`failed to renew background task for subagent ${resumedRecord.subagentId}: ${errorMessage(regError)}`);
+                        }
+                    }
                 }
                 catch (error) {
                     const reason = errorMessage(error);
@@ -1042,23 +1174,38 @@ export class SubagentManager {
                 return {
                     ...clean,
                     state: "running",
+                    intent: "active",
                     unacknowledgedInput: message,
                 };
             });
             try {
-                await this.#request(id, operation, { message });
+                const path = acknowledgedPath(await this.#request(id, operation, { message }));
+                this.#paths.set(id, path);
             }
             catch (error) {
                 return failure("send", errorMessage(error), id, pending.state, ["input persisted as unacknowledged before dispatch"], false);
             }
-            return publicChild((await this.#deps.registry.get(id)) ?? record, true);
+            return publicChild((await this.#deps.registry.get(id)) ?? pending, true, this.#paths.get(id));
         });
     }
     async get(id) {
         const record = await this.#deps.registry.get(id);
-        return record === undefined
-            ? failure("get", "Unknown child", id)
-            : publicChild(record, this.#isLive(id));
+        if (record === undefined)
+            return failure("get", "Unknown child", id);
+        const live = this.#isLive(id);
+        const projector = this.#projectors.get(id);
+        if (projector !== undefined) {
+            const snap = projector.snapshot();
+            const mergedRecord = {
+                ...record,
+                ...(snap.activeTool !== undefined ? { activeTool: snap.activeTool } : {}),
+                ...(snap.summary !== undefined ? { latestSummary: snap.summary } : {}),
+                ...(snap.interrupted !== undefined ? { interrupted: snap.interrupted } : {}),
+                usage: snap.usage ?? record.usage,
+            };
+            return publicChild(mergedRecord, live, this.#paths.get(id));
+        }
+        return publicChild(record, live, this.#paths.get(id));
     }
     async list() {
         const records = await this.#deps.registry.list();
@@ -1092,7 +1239,6 @@ export class SubagentManager {
                 stopped = await this.#update(id, (current) => ({
                     ...current,
                     intent: "stopped",
-                    state: "error",
                 }));
             }
             catch (error) {
@@ -1122,6 +1268,7 @@ export class SubagentManager {
                     // bridge-only stop.
                     const cleanup = await attachment.cleanup();
                     if (!(await this.#panelGone(attachment))) {
+                        await this.#update(id, (current) => ({ ...current, state: "error" })).catch(() => undefined);
                         return failure("stop", `The child's ${attachment.identity.host} panel is not confirmed gone (${cleanup.stderr || "its state could not be observed"}): the child process may still be running`, id, "error", ["stopped intent persisted", "runtime metadata retained"], true);
                     }
                     this.#attachments.delete(id);
@@ -1148,7 +1295,10 @@ export class SubagentManager {
                 if (current !== undefined) {
                     stopped = await this.#deps.registry.update(id, current.revision, (value) => {
                         const { runtime: _runtime, ...withoutRuntime } = value;
-                        return withoutRuntime;
+                        return {
+                            ...withoutRuntime,
+                            state: "done",
+                        };
                     });
                 }
                 if (this.#taskRegistry !== undefined) {
@@ -1212,7 +1362,6 @@ export class SubagentManager {
                 }
                 await this.#update(id, (current) => ({
                     ...current,
-                    intent: "stopped",
                     state: "error",
                     interrupted: message,
                 }));
@@ -1410,7 +1559,7 @@ export class SubagentManager {
             return;
         projector.applyEvent(event);
         let confirmedInput;
-        if (value.type === "agent_end") {
+        if (value.type === "turn_end" || value.type === "agent_end") {
             // A finished turn is exactly when the session file has the message, so this is where
             // unacknowledged input becomes part of the child's conversation.
             const entries = await this.#entries(id);

package/dist/registry.js

@@ -57,11 +57,10 @@ const LAUNCH_CONFIG_FIELDS = {
     skills: true,
     prompt: true,
     bridgeExtensionPath: true,
-    interactive: true,
     title: true,
     task: true,
-    referencedSessionPath: true,
     codemodeOnly: true,
+    mcp: true,
 };
 const AGENT_FIELDS = {
     name: true,
@@ -221,6 +220,23 @@ function parseRuntime(value, path) {
     const endpoint = expectString(raw.endpoint, "runtime.endpoint", path);
     return Object.freeze({ runtimeIdentity, endpoint });
 }
+function parseMcpSelection(value, path) {
+    if (value === undefined)
+        return Object.freeze({ enabled: true });
+    const raw = expectObject(value, "launchConfig.mcp", path);
+    const enabled = expectOptionalBoolean(raw.enabled, "launchConfig.mcp.enabled", path, true);
+    const servers = raw.servers === undefined
+        ? undefined
+        : Object.freeze(expectStringArray(raw.servers, "launchConfig.mcp.servers", path));
+    const excluded = raw.excluded === undefined
+        ? undefined
+        : Object.freeze(expectStringArray(raw.excluded, "launchConfig.mcp.excluded", path));
+    return Object.freeze({
+        enabled,
+        ...(servers === undefined ? {} : { servers }),
+        ...(excluded === undefined ? {} : { excluded }),
+    });
+}
 function parseLaunchConfig(value, path) {
     const raw = expectObject(value, "launchConfig", path);
     expectKeys(raw, LAUNCH_CONFIG_FIELDS, "launchConfig", path);
@@ -228,7 +244,6 @@ function parseLaunchConfig(value, path) {
     if (!isSessionId(sessionId))
         throw invalid(path, "launchConfig.sessionId is not a valid session id");
     const sessionPath = expectOptionalString(raw.sessionPath, "launchConfig.sessionPath", path);
-    const referencedSessionPath = expectOptionalString(raw.referencedSessionPath, "launchConfig.referencedSessionPath", path);
     const extensions = parseSelection(raw.extensions, path, "extensions");
     const bridgeExtensionPath = expectString(raw.bridgeExtensionPath, "launchConfig.bridgeExtensionPath", path);
     if (!extensions.paths.includes(bridgeExtensionPath)) {
@@ -245,7 +260,6 @@ function parseLaunchConfig(value, path) {
         sessionId,
         sessionDir: expectString(raw.sessionDir, "launchConfig.sessionDir", path),
         ...(sessionPath === undefined ? {} : { sessionPath }),
-        ...(referencedSessionPath === undefined ? {} : { referencedSessionPath }),
         agent: parseAgent(raw.agent, path),
         model: parseModel(raw.model, path),
         thinking: parseThinking(raw.thinking, path),
@@ -253,9 +267,9 @@ function parseLaunchConfig(value, path) {
         excludeTools: Object.freeze(expectStringArray(raw.excludeTools, "launchConfig.excludeTools", path)),
         extensions,
         skills: parseSelection(raw.skills, path, "skills"),
+        mcp: parseMcpSelection(raw.mcp, path),
         prompt: expectString(raw.prompt, "launchConfig.prompt", path),
         bridgeExtensionPath,
-        interactive: expectOptionalBoolean(raw.interactive, "launchConfig.interactive", path, false),
         ...(expectOptionalBoolean(raw.codemodeOnly, "launchConfig.codemodeOnly", path, false)
             ? { codemodeOnly: true }
             : {}),

package/dist/rpc-events.d.ts

@@ -2,5 +2,5 @@
  * The Pi events a child forwards to its parent. Everything else — streaming token noise,
  * undocumented internals — is dropped, so the parent's projection only sees turn-level facts.
  */
-export declare const FORWARDED_PI_EVENT_TYPES: readonly ["agent_start", "agent_end", "turn_start", "turn_end", "tool_execution_start", "tool_execution_update", "tool_execution_end", "auto_retry", "auto_retry_start", "auto_retry_end", "message_update", "agent_settled"];
+export declare const FORWARDED_PI_EVENT_TYPES: readonly ["agent_start", "agent_end", "turn_start", "turn_end", "tool_execution_start", "tool_execution_end", "auto_retry", "auto_retry_start", "auto_retry_end", "message_update", "agent_settled"];
 export declare function shouldForwardPiEvent(event: unknown): boolean;

package/dist/rpc-events.js

@@ -9,7 +9,6 @@ export const FORWARDED_PI_EVENT_TYPES = [
     "turn_start",
     "turn_end",
     "tool_execution_start",
-    "tool_execution_update",
     "tool_execution_end",
     "auto_retry",
     "auto_retry_start",

package/dist/session-bootstrap.d.ts

@@ -1,6 +1,8 @@
 import type { ModelRegistryLike, ParentAgentDefaults, SkillCatalogEntry } from "./agent-resolver.js";
 import type { EffectiveLaunchConfig, PersistenceState, PiInvocation, Presentation, SpawnSubagentInput, SubagentRecord } from "./domain.js";
 import type { SubagentRegistry } from "./registry.js";
+/** Reads all JSON entries from a session file on disk. */
+export declare function readSessionJsonlEntries(sessionPath: string): Promise<unknown[]>;
 export interface SessionPlacement {
     readonly sessionId: string;
     readonly sessionDir: string;
@@ -62,7 +64,6 @@ export interface ResolveSubagentLaunchOptions {
     readonly existingSubagentIds?: readonly string[];
     readonly enforceEnabled?: boolean;
     readonly sessionPath?: string;
-    readonly referencedSessionPath?: string;
 }
 /**
  * One resolution chain for a spawn: agent definition + explicit parent defaults