@bytetrue/byspace 0.17.0 → 0.18.0

package/node_modules/@bytetrue/client/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytetrue/client",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "BySpace client SDK package",
   "files": [
     "dist",
@@ -39,8 +39,8 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@bytetrue/protocol": "0.17.0",
-    "@bytetrue/relay": "0.17.0"
+    "@bytetrue/protocol": "0.18.0",
+    "@bytetrue/relay": "0.18.0"
   },
   "devDependencies": {
     "@types/node": "^20.9.0",

package/node_modules/@bytetrue/highlight/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytetrue/highlight",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "files": [
     "dist",
     "!dist/**/*.map",

package/node_modules/@bytetrue/protocol/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytetrue/protocol",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "BySpace shared protocol schemas and wire types",
   "files": [
     "dist",

package/node_modules/@bytetrue/relay/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytetrue/relay",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "BySpace relay for bridging daemon and client connections",
   "files": [
     "dist",

package/node_modules/@bytetrue/server/dist/server/server/agent/agent-manager.d.ts

@@ -11,6 +11,7 @@ import { type ForegroundTurnWaiter } from "./agent-run-state.js";
 import { type RewindMode } from "./rewind/rewind.js";
 import type { BySpaceToolCatalogFactory } from "./tools/types.js";
 import { type ProviderSubagentDescriptor, type ProviderSubagentStoreEvent } from "./provider-subagents/store.js";
+import { type SubagentObservation } from "./provider-subagents/observation.js";
 export declare class AgentManagerShuttingDownError extends Error {
     constructor();
 }
@@ -244,6 +245,9 @@ export declare class AgentManager {
     private readonly agents;
     private readonly timelineStore;
     private readonly providerSubagents;
+    private readonly piSubagentReportTokens;
+    private piSubagentReportBaseUrl;
+    private readonly piSubagentTailers;
     private readonly agentsAwaitingInitialSnapshotPersist;
     private readonly sessionEventTails;
     private readonly steerEventBarriers;
@@ -287,6 +291,32 @@ export declare class AgentManager {
     setAgentAttentionCallback(callback: AgentAttentionCallback): void;
     setAgentArchivedCallback(callback: AgentArchivedCallback): void;
     setMcpBaseUrl(url: string | null): void;
+    setPiSubagentReportBaseUrl(url: string | null): void;
+    /**
+     * Resolve the agent a pi-subagent report token was minted for. Tokens are random
+     * per pi launch, so the token alone identifies the agent — the reporter extension
+     * never needs to know its own BySpace agent id.
+     */
+    resolvePiSubagentReportAgentId(token: string): string | null;
+    /**
+     * Apply a provider-subagent store event with the terminal latch: a running upsert for an
+     * already-terminal subagent is dropped. HTTP reports and transcript replays have no ordering
+     * guarantee, so a stale running snapshot must not reopen a finished subagent. New launches
+     * get fresh ids and are unaffected.
+     */
+    private applyProviderSubagentEvent;
+    /**
+     * Apply a provider-subagent observation reported from outside the agent stream (the pi
+     * subagent extension POSTs progress snapshots over loopback) and dispatch the resulting
+     * store event.
+     */
+    applyExternalProviderSubagentObservation(agentId: string, provider: AgentProvider, observation: SubagentObservation): boolean;
+    /**
+     * Apply a pi-subagent progress report POSTed by the pi-subagent extension over loopback:
+     * verify the per-launch token, fold each record into a provider-subagent observation, and
+     * feed session references to the jsonl tailers that stream child-session timelines.
+     */
+    applyPiSubagentReport(token: string, records: readonly unknown[]): "ok" | "unauthorized";
     prepareForShutdown(): void;
     setBySpaceToolsEnabled(enabled: boolean): void;
     setBySpaceToolCatalogFactory(factory: BySpaceToolCatalogFactory | null): void;

package/node_modules/@bytetrue/server/dist/server/server/agent/agent-manager.js

@@ -1,4 +1,4 @@
-import { randomUUID } from "node:crypto";
+import { randomBytes, randomUUID } from "node:crypto";
 import { basename, resolve } from "node:path";
 import { stat } from "node:fs/promises";
 import { AGENT_LIFECYCLE_STATUSES, } from "@bytetrue/protocol/agent-lifecycle";
@@ -17,6 +17,9 @@ import { stripInternalBySpaceMcpServer, withRuntimeBySpaceMcpServer, } from "./r
 import { resolveCreateAgentTitles } from "./create-agent-title.js";
 import { isBySpaceToolPolicyEnabled } from "./byspace-tool-policy.js";
 import { ProviderSubagentStore, } from "./provider-subagents/store.js";
+import { foldSubagentObservations, } from "./provider-subagents/observation.js";
+import { observePiSubagentRecord } from "./providers/pi/agent-subagents.js";
+import { PI_SUBAGENT_TERMINAL_STATUSES, parsePiSubagentTailerSnapshot, PiSubagentSessionTailers, } from "./providers/pi/subagent-session-tailer.js";
 import { withTimeout } from "../../utils/promise-timeout.js";
 const RELOAD_SESSION_CLOSE_TIMEOUT_MS = 3000;
 const INTERRUPT_SESSION_TIMEOUT_MS = 2000;
@@ -263,6 +266,13 @@ export class AgentManager {
         this.agents = new Map();
         this.timelineStore = new InMemoryAgentTimelineStore();
         this.providerSubagents = new ProviderSubagentStore();
+        this.piSubagentReportTokens = new Map();
+        this.piSubagentReportBaseUrl = null;
+        this.piSubagentTailers = new PiSubagentSessionTailers({
+            emit: (agentId, observation) => {
+                this.applyExternalProviderSubagentObservation(agentId, "pi", observation);
+            },
+        });
         this.agentsAwaitingInitialSnapshotPersist = new Set();
         this.sessionEventTails = new Map();
         this.steerEventBarriers = new Map();
@@ -353,8 +363,87 @@ export class AgentManager {
     setMcpBaseUrl(url) {
         this.mcpBaseUrl = url;
     }
+    setPiSubagentReportBaseUrl(url) {
+        this.piSubagentReportBaseUrl = url;
+        if (!url) {
+            this.piSubagentReportTokens.clear();
+        }
+    }
+    /**
+     * Resolve the agent a pi-subagent report token was minted for. Tokens are random
+     * per pi launch, so the token alone identifies the agent — the reporter extension
+     * never needs to know its own BySpace agent id.
+     */
+    resolvePiSubagentReportAgentId(token) {
+        if (!token)
+            return null;
+        for (const [agentId, minted] of this.piSubagentReportTokens) {
+            if (minted === token && this.agents.has(agentId))
+                return agentId;
+        }
+        return null;
+    }
+    /**
+     * Apply a provider-subagent store event with the terminal latch: a running upsert for an
+     * already-terminal subagent is dropped. HTTP reports and transcript replays have no ordering
+     * guarantee, so a stale running snapshot must not reopen a finished subagent. New launches
+     * get fresh ids and are unaffected.
+     */
+    applyProviderSubagentEvent(agentId, provider, event) {
+        if (event.type === "upsert" && event.status === "running") {
+            const current = this.providerSubagents.get(agentId, event.id)?.status;
+            if (current && PI_SUBAGENT_TERMINAL_STATUSES.includes(current)) {
+                return null;
+            }
+        }
+        return this.providerSubagents.apply(agentId, provider, event);
+    }
+    /**
+     * Apply a provider-subagent observation reported from outside the agent stream (the pi
+     * subagent extension POSTs progress snapshots over loopback) and dispatch the resulting
+     * store event.
+     */
+    applyExternalProviderSubagentObservation(agentId, provider, observation) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            return false;
+        }
+        const [event] = foldSubagentObservations([observation]);
+        if (!event) {
+            return false;
+        }
+        const update = this.applyProviderSubagentEvent(agentId, provider, event);
+        if (!update) {
+            return false;
+        }
+        this.dispatch({ type: "provider_subagent", event: update });
+        return true;
+    }
+    /**
+     * Apply a pi-subagent progress report POSTed by the pi-subagent extension over loopback:
+     * verify the per-launch token, fold each record into a provider-subagent observation, and
+     * feed session references to the jsonl tailers that stream child-session timelines.
+     */
+    applyPiSubagentReport(token, records) {
+        const agentId = this.resolvePiSubagentReportAgentId(token);
+        if (!agentId) {
+            return "unauthorized";
+        }
+        for (const record of records) {
+            const observation = observePiSubagentRecord(record);
+            if (observation) {
+                this.applyExternalProviderSubagentObservation(agentId, "pi", observation);
+            }
+            const snapshot = parsePiSubagentTailerSnapshot(record);
+            if (snapshot) {
+                this.piSubagentTailers.update(agentId, snapshot);
+            }
+        }
+        return "ok";
+    }
     prepareForShutdown() {
         this.acceptingAgentRegistrations = false;
+        this.piSubagentTailers.dispose();
     }
     setBySpaceToolsEnabled(enabled) {
         this.byspaceToolsEnabled = enabled;
@@ -778,8 +867,10 @@ export class AgentManager {
                 publishWhenReady: true,
             });
             for (const event of imported.providerSubagentEvents ?? []) {
-                const update = this.providerSubagents.apply(agent.id, event.provider, event.event);
-                this.dispatch({ type: "provider_subagent", event: update });
+                const update = this.applyProviderSubagentEvent(agent.id, event.provider, event.event);
+                if (update) {
+                    this.dispatch({ type: "provider_subagent", event: update });
+                }
             }
             return agent;
         }
@@ -2511,6 +2602,10 @@ export class AgentManager {
         this.agentStreamCoalescer.flushAndDiscard(agent.id);
         this.agents.delete(agent.id);
         this.previousStatuses.delete(agent.id);
+        // Child-session tailers and report tokens are live-process state: on close (and reload,
+        // whose new process re-reports) they have no owner and would poll until daemon shutdown.
+        this.piSubagentReportTokens.delete(agent.id);
+        this.piSubagentTailers.removeAgent(agent.id);
         if (agent.unsubscribeSession) {
             agent.unsubscribeSession();
             agent.unsubscribeSession = null;
@@ -2541,6 +2636,8 @@ export class AgentManager {
     discardRetainedAgentState(agentId) {
         this.timelineStore.delete(agentId);
         this.byspaceToolPolicies.delete(agentId);
+        this.piSubagentReportTokens.delete(agentId);
+        this.piSubagentTailers.removeAgent(agentId);
         for (const event of this.providerSubagents.deleteParent(agentId)) {
             this.dispatch({ type: "provider_subagent", event });
         }
@@ -2627,8 +2724,10 @@ export class AgentManager {
     }
     async dispatchSessionEvent(agent, event) {
         if (event.type === "provider_subagent") {
-            const update = this.providerSubagents.apply(agent.id, event.provider, event.event);
-            this.dispatch({ type: "provider_subagent", event: update });
+            const update = this.applyProviderSubagentEvent(agent.id, event.provider, event.event);
+            if (update) {
+                this.dispatch({ type: "provider_subagent", event: update });
+            }
             return;
         }
         const turnId = getAgentStreamEventTurnId(event);
@@ -2766,8 +2865,8 @@ export class AgentManager {
             }
         }
         for (const event of providerSubagentEvents) {
-            const update = this.providerSubagents.apply(agent.id, event.provider, event.event);
-            if (broadcast) {
+            const update = this.applyProviderSubagentEvent(agent.id, event.provider, event.event);
+            if (update && broadcast) {
                 this.dispatch({ type: "provider_subagent", event: update });
             }
         }
@@ -2793,7 +2892,9 @@ export class AgentManager {
             for await (const rawEvent of agent.session.streamHistory()) {
                 const event = limitAgentStreamEventContent(rawEvent);
                 if (event.type === "provider_subagent") {
-                    const update = this.providerSubagents.apply(agent.id, event.provider, event.event);
+                    const update = this.applyProviderSubagentEvent(agent.id, event.provider, event.event);
+                    if (!update)
+                        continue;
                     const managerEvent = { type: "provider_subagent", event: update };
                     if (deferredBroadcast) {
                         providerSubagentEvents.push(managerEvent);
@@ -3625,6 +3726,15 @@ export class AgentManager {
                 BYSPACE_AGENT_CWD: cwd,
             },
         };
+        if (client.provider === "pi" && this.piSubagentReportBaseUrl) {
+            const reportToken = randomBytes(32).toString("base64url");
+            this.piSubagentReportTokens.set(agentId, reportToken);
+            context.env = {
+                ...context.env,
+                BYSPACE_SUBAGENT_REPORT_URL: `${this.piSubagentReportBaseUrl}/api/subagent-report`,
+                BYSPACE_SUBAGENT_REPORT_TOKEN: reportToken,
+            };
+        }
         if (this.byspaceToolsEnabled &&
             isBySpaceToolPolicyEnabled(byspaceToolPolicy) &&
             client.capabilities.supportsNativeBySpaceTools &&

package/node_modules/@bytetrue/server/dist/server/server/agent/mcp-shared.d.ts

@@ -164,7 +164,7 @@ export declare function toScheduleSummary(schedule: z.infer<typeof StoredSchedul
             mcpServers?: Record<string, unknown> | undefined;
         };
     };
-    status: "completed" | "active" | "paused";
+    status: "completed" | "paused" | "active";
     createdAt: string;
     updatedAt: string;
     nextRunAt: string | null;

package/node_modules/@bytetrue/server/dist/server/server/agent/{providers/claude/subagents → provider-subagents}/observation.d.ts

@@ -1,5 +1,5 @@
-import type { AgentTimelineItem } from "../../../agent-sdk-types.js";
-import type { ProviderSubagentInputEvent, ProviderSubagentStatus } from "../../../provider-subagents/store.js";
+import type { AgentTimelineItem } from "../agent-sdk-types.js";
+import type { ProviderSubagentInputEvent, ProviderSubagentStatus } from "./store.js";
 /**
  * A single fact a provider observed about one subagent.
  *

package/node_modules/@bytetrue/server/dist/server/server/agent/providers/claude/agent.js

@@ -12,7 +12,7 @@ import { ClaudeSidechainTracker } from "./sidechain-tracker.js";
 import { ClaudeTaskState } from "./task-state.js";
 import { ClaudeTaskProtocolSource, } from "./subagents/live-source.js";
 import { observeReplaySubagents, parseClaudeSubagentMeta, } from "./subagents/replay-source.js";
-import { foldSubagentObservations } from "./subagents/observation.js";
+import { foldSubagentObservations, } from "../../provider-subagents/observation.js";
 import { observeReplayWorkflows, parseClaudeWorkflowRun, } from "./subagents/workflow-replay-source.js";
 import { readClaudeWorkflowResultFile } from "./subagents/workflow-output.js";
 import { buildClaudeFeatures, claudeModelSupportsFastMode } from "./feature-definitions.js";

package/node_modules/@bytetrue/server/dist/server/server/agent/providers/claude/subagents/live-source.d.ts

@@ -1,6 +1,6 @@
 import type { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
 import type { AgentMetadata } from "../../../agent-sdk-types.js";
-import type { SubagentObservation } from "./observation.js";
+import type { SubagentObservation } from "../../../provider-subagents/observation.js";
 /**
  * The subset of a hook input this source reads. Every hook shares these base fields: `agent_id`
  * is set when the hook fires from inside a subagent, and `effort.level` is the ACTIVE level for

package/node_modules/@bytetrue/server/dist/server/server/agent/providers/claude/subagents/replay-source.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import type { AgentTimelineItem } from "../../../agent-sdk-types.js";
-import type { SubagentObservation } from "./observation.js";
+import type { SubagentObservation } from "../../../provider-subagents/observation.js";
 /**
  * Rebuilds subagent observations from a persisted session, producing the same vocabulary the
  * live task-protocol source produces. Identical observations in means identical descriptor

package/node_modules/@bytetrue/server/dist/server/server/agent/providers/claude/subagents/workflow-replay-source.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import type { AgentTimelineItem } from "../../../agent-sdk-types.js";
-import type { SubagentObservation } from "./observation.js";
+import type { SubagentObservation } from "../../../provider-subagents/observation.js";
 import type { ClaudeReplayEntry } from "./replay-source.js";
 declare const ClaudeWorkflowRunSchema: z.ZodObject<{
     runId: z.ZodString;

package/node_modules/@bytetrue/server/dist/server/server/agent/providers/omp/rpc-types.d.ts

@@ -1,12 +1,12 @@
 import { z } from "zod";
 export declare const OmpThinkingLevelSchema: z.ZodEnum<{
     off: "off";
-    high: "high";
+    minimal: "minimal";
     low: "low";
     medium: "medium";
+    high: "high";
     xhigh: "xhigh";
     max: "max";
-    minimal: "minimal";
 }>;
 export declare const OmpImageContentSchema: z.ZodObject<{
     type: z.ZodLiteral<"image">;
@@ -144,12 +144,12 @@ export declare const OmpSessionStateSchema: z.ZodObject<{
     }, z.core.$loose>>>;
     thinkingLevel: z.ZodOptional<z.ZodEnum<{
         off: "off";
-        high: "high";
+        minimal: "minimal";
         low: "low";
         medium: "medium";
+        high: "high";
         xhigh: "xhigh";
         max: "max";
-        minimal: "minimal";
     }>>;
     isStreaming: z.ZodBoolean;
     isCompacting: z.ZodBoolean;
@@ -1868,12 +1868,12 @@ export declare const OmpRpcCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"set_thinking_level">;
     level: z.ZodEnum<{
         off: "off";
-        high: "high";
+        minimal: "minimal";
         low: "low";
         medium: "medium";
+        high: "high";
         xhigh: "xhigh";
         max: "max";
-        minimal: "minimal";
     }>;
     id: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{

package/node_modules/@bytetrue/server/dist/server/server/agent/providers/pi/agent-subagents.d.ts

@@ -0,0 +1,45 @@
+import type { SubagentObservation } from "../../provider-subagents/observation.js";
+import type { ProviderSubagentStatus } from "../../provider-subagents/store.js";
+import type { PiAgentMessage } from "./rpc-types.js";
+export declare function isPiSubagentToolName(toolName: string): boolean;
+/**
+ * The descriptor has no paused state and paused is not terminal, so it reads as running.
+ * Unknown statuses map to undefined: the caller's upsert then preserves the stored status.
+ */
+export declare function mapPiSubagentStatus(status: unknown): ProviderSubagentStatus | undefined;
+interface PiSubagentRecordDetails {
+    id: string;
+    status?: string;
+    description?: string;
+    agent?: string;
+}
+/**
+ * The subset of `toMessageDetails` this source reads. Every field is optional except the
+ * id: the extension adds fields across releases and older runtimes omit newer ones, so a
+ * wrong-typed field reads as absent rather than failing the record.
+ */
+export declare function parsePiSubagentRecordDetails(details: unknown): PiSubagentRecordDetails | null;
+/** Launch observation from the `subagent` tool result plus its call arguments. */
+export declare function observePiSubagentLaunch(input: {
+    toolCallId: string;
+    args: unknown;
+    details: unknown;
+}): SubagentObservation | null;
+/** Status observation from a full task record (status/stop tool result or exit message). */
+export declare function observePiSubagentRecord(details: unknown): SubagentObservation | null;
+/**
+ * Exit custom messages carry one record, or an array when several children finished before
+ * the extension could deliver the notification (its exit-batch path).
+ */
+export declare function observePiSubagentExit(details: unknown): SubagentObservation[];
+/**
+ * Rebuilds subagent observations from a persisted session, producing the same vocabulary the
+ * live source produces. Identical observations in means identical descriptor state out.
+ *
+ * The transcript carries all three origins: assistant toolCall blocks with their toolResult
+ * messages (launch and record results), and `subagent-exit` custom messages. Tool calls
+ * precede their results in an assistant turn, so a single pass with a pending map pairs them.
+ */
+export declare function replayPiSubagentObservations(messages: readonly PiAgentMessage[]): SubagentObservation[];
+export {};
+//# sourceMappingURL=agent-subagents.d.ts.map

package/node_modules/@bytetrue/server/dist/server/server/agent/providers/pi/agent-subagents.js

@@ -0,0 +1,159 @@
+/**
+ * Pi announces background subagents through the @bytetrue/pi-subagent extension. Three wire
+ * origins carry the facts, and all three reduce to the shared observation vocabulary:
+ *
+ * - the `subagent` tool result (launch): details `{ id, status: "running" }`, the task
+ *   description lives on the tool call arguments;
+ * - `subagent_status` / `subagent_stop` tool results and `subagent-exit` custom
+ *   messages: details are the extension's full task record (`toMessageDetails`).
+ *
+ * The extension strips live objects before details cross the wire, so every field here is
+ * clone-safe JSON. Both the live event stream and the persisted session replay read through
+ * these functions, so a fact is derived once for both paths.
+ */
+/** Tool the extension registers to launch a background child. */
+const PI_SUBAGENT_LAUNCH_TOOL = "subagent";
+/** Tools whose results carry the full task record. */
+const PI_SUBAGENT_RECORD_TOOLS = new Set(["subagent_status", "subagent_stop"]);
+/** Custom message type the extension sends when a child finishes. */
+const PI_SUBAGENT_EXIT_CUSTOM_TYPE = "subagent-exit";
+export function isPiSubagentToolName(toolName) {
+    return toolName === PI_SUBAGENT_LAUNCH_TOOL || PI_SUBAGENT_RECORD_TOOLS.has(toolName);
+}
+/**
+ * The descriptor has no paused state and paused is not terminal, so it reads as running.
+ * Unknown statuses map to undefined: the caller's upsert then preserves the stored status.
+ */
+export function mapPiSubagentStatus(status) {
+    switch (status) {
+        case "running":
+        case "pending":
+        case "paused":
+            return "running";
+        case "succeeded":
+            return "completed";
+        case "failed":
+            return "failed";
+        case "cancelled":
+            return "canceled";
+        default:
+            return undefined;
+    }
+}
+/**
+ * The subset of `toMessageDetails` this source reads. Every field is optional except the
+ * id: the extension adds fields across releases and older runtimes omit newer ones, so a
+ * wrong-typed field reads as absent rather than failing the record.
+ */
+export function parsePiSubagentRecordDetails(details) {
+    if (typeof details !== "object" || details === null || Array.isArray(details)) {
+        return null;
+    }
+    const record = details;
+    if (typeof record.id !== "string" || record.id.length === 0) {
+        return null;
+    }
+    return {
+        id: record.id,
+        ...(typeof record.status === "string" ? { status: record.status } : {}),
+        ...(typeof record.description === "string" ? { description: record.description } : {}),
+        ...(typeof record.agent === "string" && record.agent.length > 0 ? { agent: record.agent } : {}),
+    };
+}
+function readStringArg(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+/** Launch observation from the `subagent` tool result plus its call arguments. */
+export function observePiSubagentLaunch(input) {
+    const record = parsePiSubagentRecordDetails(input.details);
+    if (!record) {
+        return null;
+    }
+    const args = typeof input.args === "object" && input.args !== null
+        ? input.args
+        : {};
+    const agent = readStringArg(args.agent);
+    const task = readStringArg(args.task) ?? record.description;
+    return {
+        kind: "declared",
+        id: record.id,
+        toolCallId: input.toolCallId,
+        ...(agent ? { title: agent } : {}),
+        ...(task ? { description: task } : {}),
+    };
+}
+/** Status observation from a full task record (status/stop tool result or exit message). */
+export function observePiSubagentRecord(details) {
+    const record = parsePiSubagentRecordDetails(details);
+    if (!record) {
+        return null;
+    }
+    const status = mapPiSubagentStatus(record.status);
+    if (!status) {
+        return null;
+    }
+    return { kind: "status", id: record.id, status };
+}
+/**
+ * Exit custom messages carry one record, or an array when several children finished before
+ * the extension could deliver the notification (its exit-batch path).
+ */
+export function observePiSubagentExit(details) {
+    if (Array.isArray(details)) {
+        return details
+            .map((entry) => observePiSubagentRecord(entry))
+            .filter((observation) => observation !== null);
+    }
+    const observation = observePiSubagentRecord(details);
+    return observation ? [observation] : [];
+}
+/**
+ * Rebuilds subagent observations from a persisted session, producing the same vocabulary the
+ * live source produces. Identical observations in means identical descriptor state out.
+ *
+ * The transcript carries all three origins: assistant toolCall blocks with their toolResult
+ * messages (launch and record results), and `subagent-exit` custom messages. Tool calls
+ * precede their results in an assistant turn, so a single pass with a pending map pairs them.
+ */
+export function replayPiSubagentObservations(messages) {
+    const observations = [];
+    const pendingLaunches = new Map();
+    for (const message of messages) {
+        if (message.role === "assistant") {
+            for (const content of message.content) {
+                if (content.type === "toolCall" && isPiSubagentToolName(content.name)) {
+                    pendingLaunches.set(content.id, { name: content.name, args: content.arguments });
+                }
+            }
+            continue;
+        }
+        if (message.role === "toolResult") {
+            const launch = pendingLaunches.get(message.toolCallId);
+            pendingLaunches.delete(message.toolCallId);
+            if (!launch) {
+                continue;
+            }
+            if (launch.name === PI_SUBAGENT_LAUNCH_TOOL) {
+                const observation = observePiSubagentLaunch({
+                    toolCallId: message.toolCallId,
+                    args: launch.args,
+                    details: message.details,
+                });
+                if (observation) {
+                    observations.push(observation);
+                }
+                continue;
+            }
+            const observation = observePiSubagentRecord(message.details);
+            if (observation) {
+                observations.push(observation);
+            }
+            continue;
+        }
+        if (message.role === "custom" && message.customType === PI_SUBAGENT_EXIT_CUSTOM_TYPE) {
+            observations.push(...observePiSubagentExit(message.details));
+        }
+    }
+    return observations;
+}
+//# sourceMappingURL=agent-subagents.js.map

package/node_modules/@bytetrue/server/dist/server/server/agent/providers/pi/agent.d.ts

@@ -128,6 +128,8 @@ export declare class PiRpcAgentSession implements AgentSession {
     private handleSessionEvent;
     private handleTurnBoundaryEvent;
     private handleToolExecutionEnd;
+    /** Background subagents announce themselves through tool result details, not the stream. */
+    private emitPiSubagentToolObservations;
     private emitCompactionTimeline;
     private handleMessageUpdate;
     private handleMessageStart;
@@ -171,8 +173,6 @@ export declare class PiRpcAgentClient implements AgentClient {
      */
     private resolveLaunchModel;
     private fetchAvailableProviders;
-    private prepareMcpConfig;
-    private detectMcpAdapter;
     private resolvePiLaunch;
 }
 export {};