@code-yeongyu/senpi 2026.10.25-4 → 2026.10.26-2

package/dist/core/session-activity.js

@@ -16,6 +16,7 @@
  * `AgentSession.isSessionBusy` instead of testing individual flags, so a source
  * added later cannot be silently missed by one call site.
  */
+import { normalizeWaitItems, wakeSourceItems } from "./lifecycle-wait-items.js";
 /** Live counts of extension-published wake sources, keyed by source name. */
 export class WakeSourceTracker {
     constructor() {
@@ -39,6 +40,7 @@ export class WakeSourceTracker {
             this.counts.set(source, {
                 activeCount,
                 kind: "kind" in data && data.kind === "children" ? "children" : "background",
+                ...normalizeWaitItems(wakeSourceItems(data)),
             });
         else
             this.counts.delete(source);

package/dist/core/session-lifecycle-types.d.ts

@@ -9,13 +9,26 @@ export interface HumanWait {
     readonly childLabel?: string;
     readonly since: string;
 }
+export interface LifecycleWaitItem {
+    readonly id: string;
+    readonly label?: string;
+    readonly startedAt?: string;
+}
+export interface LifecycleWaitSource {
+    readonly source: string;
+    readonly activeCount: number;
+    readonly items?: readonly LifecycleWaitItem[];
+    readonly omittedItems?: number;
+}
 export interface LifecycleWaits {
     readonly children: number;
-    readonly background: readonly {
-        readonly source: string;
-        readonly activeCount: number;
+    /** Named detail can be incomplete even without truncation: custody need not have a named report. */
+    readonly childSources?: readonly LifecycleWaitSource[];
+    readonly childReports?: readonly Pick<ChildLifecycleReport, "taskId" | "childSessionId" | "runEpoch" | "state" | "label" | "since">[];
+    readonly childReportsOmitted?: number;
+    readonly background: readonly (LifecycleWaitSource & {
         readonly retryAtMs?: number;
-    }[];
+    })[];
     readonly human: readonly HumanWait[];
 }
 export interface LifecycleHold {
@@ -83,6 +96,9 @@ export interface ChildLifecycleReport {
     readonly runEpoch: number;
     readonly generation: number;
     readonly state: SessionLifecycleState;
+    readonly label?: string;
+    /** The child's own state-entry time, not the parent's evaluation time. */
+    readonly since?: string;
     readonly waitingOn?: LifecycleWaits;
     readonly terminal?: "completed" | "error" | "lost" | "interrupted" | "cancelled";
 }

package/dist/core/session-lifecycle.js

@@ -1,6 +1,7 @@
 import { effectiveWakes } from "./extensions/builtin/goal/turn-end-liveness.js";
 import { LifecycleChildren } from "./lifecycle-children.js";
 import { LifecycleLedger } from "./lifecycle-ledger.js";
+import { projectWaitItems } from "./lifecycle-wait-items.js";
 import { sameStop, stopDetail } from "./lifecycle-stop.js";
 import { lifecycleState, lifecycleTerminal } from "./session-lifecycle-reducer.js";
 import { SessionWorkObligations } from "./work-obligations.js";
@@ -189,11 +190,34 @@ export class SessionLifecycleController {
     evaluate() {
         const runtime = this.options.readRuntime();
         const active = this.obligations.active;
-        const childRecords = this.children.reports.filter((report) => report.childSessionId !== this.options.sessionId && report.terminal === undefined).length;
+        const childRecords = this.children.reports
+            .filter((report) => report.childSessionId !== this.options.sessionId && report.terminal === undefined)
+            .sort((a, b) => (a.taskId < b.taskId ? -1 : a.taskId > b.taskId ? 1 : 0));
+        const childReports = childRecords
+            .slice(0, 32)
+            .map(({ taskId, childSessionId, runEpoch, state, label, since }) => ({
+            taskId,
+            childSessionId,
+            runEpoch,
+            state,
+            ...(label === undefined ? {} : { label }),
+            ...(since === undefined ? {} : { since }),
+        }));
+        const childSources = active
+            .filter((record) => record.kind === "children")
+            .map((record) => ({
+            source: record.source ?? record.key,
+            activeCount: record.activeCount ?? 1,
+            ...projectWaitItems(record),
+        }));
         const background = active
             .filter((record) => record.kind === "background")
-            .map((record) => ({ source: record.source ?? record.key, activeCount: record.activeCount ?? 1 }));
-        const children = Math.max(childRecords, active
+            .map((record) => ({
+            source: record.source ?? record.key,
+            activeCount: record.activeCount ?? 1,
+            ...projectWaitItems(record),
+        }));
+        const children = Math.max(childRecords.length, active
             .filter((record) => record.kind === "children")
             .reduce((sum, record) => sum + (record.activeCount ?? 1), 0));
         const input = this.liveness;
@@ -297,7 +321,14 @@ export class SessionLifecycleController {
                     runEpoch: this.ownTask.runEpoch,
                 }
                 : undefined;
-        const waits = { children, background, human };
+        const waits = {
+            children,
+            background,
+            human,
+            ...(childSources.length ? { childSources } : {}),
+            ...(childReports.length ? { childReports } : {}),
+            ...(childRecords.length > 32 ? { childReportsOmitted: childRecords.length - 32 } : {}),
+        };
         const lastStop = this.lastStop(input, synthetic.some((wait) => wait.kind === "stalled"));
         const state = lifecycleState({
             role: this.ledger.snapshot.role,

package/dist/core/structured-session-lane.d.ts

@@ -0,0 +1,33 @@
+import type { InternalAgentChannel } from "@earendil-works/pi-agent-core";
+import { type AssistantProgress } from "@earendil-works/pi-ai";
+import type { AgentSessionEvent } from "./agent-session.ts";
+/** One record of a session's internal structured lane: a session event or a block control, in session order. */
+export type AgentSessionStructuredRecord = AgentSessionEvent | AssistantProgress;
+type StructuredListener = (record: AgentSessionStructuredRecord) => void;
+export declare class StructuredLaneUnavailableError extends Error {
+    constructor();
+}
+/**
+ * The AgentSession end of the internal-only agent channel (senpi#4272, R3.C6.2). While a structured listener is
+ * attached, it holds the channel's capture subscription; block controls enter the session's own event queue, so they
+ * keep their position among the ordinary events. Extension listeners, `session.subscribe` and every legacy
+ * destination never see a control.
+ *
+ * The capture subscription is module-wide (`subscribeAssistantCapture`): while it is held, every capture-enabled
+ * provider stream in the process that first pushes afterwards builds capture records, including streams of sessions
+ * with no structured listener, which drop them at their public iterator.
+ */
+export declare class StructuredSessionLane {
+    #private;
+    private readonly listeners;
+    private releaseChannel;
+    constructor(channel: InternalAgentChannel | undefined, enqueue: (deliver: () => void) => void);
+    get active(): boolean;
+    subscribe(listener: StructuredListener): () => void;
+    /** Publishes a session event with the provider capture of its `source` agent event. */
+    emitEvent(event: AgentSessionEvent, source: object): void;
+    dispose(): void;
+    private emit;
+}
+export {};
+//# sourceMappingURL=structured-session-lane.d.ts.map

package/dist/core/structured-session-lane.js

@@ -0,0 +1,62 @@
+import { carryAssistantCapture } from "@earendil-works/pi-ai";
+export class StructuredLaneUnavailableError extends Error {
+    constructor() {
+        super("Structured lane unavailable: Agent was constructed outside the session layer");
+        this.name = "StructuredLaneUnavailableError";
+    }
+}
+/**
+ * The AgentSession end of the internal-only agent channel (senpi#4272, R3.C6.2). While a structured listener is
+ * attached, it holds the channel's capture subscription; block controls enter the session's own event queue, so they
+ * keep their position among the ordinary events. Extension listeners, `session.subscribe` and every legacy
+ * destination never see a control.
+ *
+ * The capture subscription is module-wide (`subscribeAssistantCapture`): while it is held, every capture-enabled
+ * provider stream in the process that first pushes afterwards builds capture records, including streams of sessions
+ * with no structured listener, which drop them at their public iterator.
+ */
+export class StructuredSessionLane {
+    #channel;
+    #enqueue;
+    constructor(channel, enqueue) {
+        this.listeners = new Set();
+        this.#channel = channel;
+        this.#enqueue = enqueue;
+    }
+    get active() {
+        return this.listeners.size > 0;
+    }
+    subscribe(listener) {
+        if (!this.#channel)
+            throw new StructuredLaneUnavailableError();
+        this.listeners.add(listener);
+        this.releaseChannel ??= this.#channel.subscribe((record) => {
+            if ("progress" in record)
+                this.#enqueue(() => this.emit(record.progress));
+        });
+        return () => {
+            this.listeners.delete(listener);
+            if (this.listeners.size === 0)
+                this.dispose();
+        };
+    }
+    /** Publishes a session event with the provider capture of its `source` agent event. */
+    emitEvent(event, source) {
+        const message = (event.type === "message_start" || event.type === "message_end") && event.message.role === "assistant"
+            ? event.message
+            : undefined;
+        // A user-facing description replaced the engine message, so the capture's frozen message must follow it.
+        const described = message && "message" in source && source.message !== message ? message : undefined;
+        this.emit(carryAssistantCapture(source, event, described));
+    }
+    dispose() {
+        this.listeners.clear();
+        this.releaseChannel?.();
+        this.releaseChannel = undefined;
+    }
+    emit(record) {
+        for (const listener of [...this.listeners])
+            listener(record);
+    }
+}
+//# sourceMappingURL=structured-session-lane.js.map

package/dist/core/work-custody-record.d.ts

@@ -1,4 +1,5 @@
 import type { CustomMessage } from "./messages.ts";
+import { type WaitSourceItems } from "./lifecycle-wait-items.ts";
 import type { ObligationKind } from "./session-lifecycle-types.ts";
 export interface CustodyPayload {
     readonly message: Pick<CustomMessage, "customType" | "content" | "display" | "details">;
@@ -7,7 +8,7 @@ export interface CustodyPayload {
     readonly itemIds?: readonly string[];
 }
 /** Mutable only by the registry; every replacement is appended before installation. */
-export interface WorkCustodyRecord {
+export interface WorkCustodyRecord extends WaitSourceItems {
     readonly id: string;
     readonly key: string;
     readonly kind: ObligationKind;

package/dist/core/work-custody-record.js

@@ -1,3 +1,4 @@
+import { normalizeWaitItems } from "./lifecycle-wait-items.js";
 export function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -25,6 +26,7 @@ export function readWorkCustody(value) {
         key: value.key,
         kind: value.kind,
         state: value.state,
+        ...normalizeWaitItems(value.items, value.omittedItems),
         ...(typeof value.source === "string" ? { source: value.source } : {}),
         ...(typeof value.activeCount === "number" ? { activeCount: value.activeCount } : {}),
         ...(typeof value.detail === "string" ? { detail: value.detail } : {}),

package/dist/core/work-obligations.d.ts

@@ -36,7 +36,7 @@ export declare class SessionWorkObligations implements WorkObligations {
     get activeCount(): number;
     get persisted(): boolean;
     open(key: string, kind: ObligationKind, detail?: string): ObligationToken;
-    syncSource(source: string, kind: ObligationKind, activeCount: number): void;
+    syncSource(source: string, kind: ObligationKind, activeCount: number, items?: unknown): void;
     /** After a restart, a restored wake source stays open only if its producer published again. */
     retireRestoredSources(): void;
     /**

package/dist/core/work-obligations.js

@@ -1,3 +1,4 @@
+import { normalizeWaitItems, waitItemSignature } from "./lifecycle-wait-items.js";
 import { custodyIsOpen, readWorkCustody } from "./work-custody-record.js";
 /** Custody keys the engine opens itself (senpi#3986): queued deliveries and published wake sources. */
 export const ENGINE_DELIVERY_KEY_PREFIX = "delivery:";
@@ -59,7 +60,7 @@ export class SessionWorkObligations {
         this.store.changed();
         return this.token(record.id);
     }
-    syncSource(source, kind, activeCount) {
+    syncSource(source, kind, activeCount, items) {
         const key = `${WAKE_SOURCE_KEY_PREFIX}${source}`;
         this.publishedSources.add(key);
         const current = this.active.find((record) => record.key === key);
@@ -68,7 +69,10 @@ export class SessionWorkObligations {
                 this.close(current.id, "passive");
             return;
         }
-        if (current?.activeCount === activeCount && current.kind === kind)
+        const detail = normalizeWaitItems(items);
+        if (current?.activeCount === activeCount &&
+            current.kind === kind &&
+            waitItemSignature(current) === waitItemSignature(detail))
             return;
         this.install({
             ...current,
@@ -77,6 +81,8 @@ export class SessionWorkObligations {
             source,
             kind,
             activeCount,
+            items: detail.items,
+            omittedItems: detail.omittedItems,
             state: current?.state ?? "open",
         });
         this.store.changed();

package/dist/modes/interactive/session-control-commands.js

@@ -13,6 +13,7 @@ import { ENTRIES_TAIL_CAPABILITY, OBSERVE_READS_CAPABILITY, SESSION_STATUS_CAPAB
 import { answerGetEntries } from "../rpc/get-entries-command.js";
 import { answeredUiRequestId, settledQuestionStatus, unansweredQuestionIds } from "../rpc/extension-ui-response.js";
 import { buildRpcSessionState } from "../rpc/rpc-session-state.js";
+import { sessionUiAnswerLedger } from "../rpc/ui-answer-ledger.js";
 import { runTuiRpcCommand, TUI_RPC_COMMANDS } from "./session-control-rpc-commands.js";
 import { failure, success } from "./session-control-server.js";
 import { runSessionControlCommand, SESSION_CONTROL_COMMANDS, } from "./session-control-session-commands.js";
@@ -45,6 +46,8 @@ export async function runControlCommand(context, connection, command) {
                     TUI_OBSERVER_CAPABILITY,
                     OBSERVE_READS_CAPABILITY,
                     ENTRIES_TAIL_CAPABILITY,
+                    "snapshot_cursor",
+                    "ui_answer_ledger",
                 ],
                 mode: "tui",
                 endpoint_kind: "tui",
@@ -89,7 +92,7 @@ export async function runControlCommand(context, connection, command) {
             return success(id, type, { admitted: result.admitted ?? [] });
         }
         case "extension_ui_response":
-            return answerQuestion(context.surface, command);
+            return answerQuestion(context, command);
         default: {
             const rpc = await runTuiRpcCommand(context, connection, command);
             if (rpc !== undefined)
@@ -121,12 +124,25 @@ function sessionRow(session) {
  * settles by the host's rule (`settledQuestionStatus`), so the same frame reaches the model as the same
  * message on either surface.
  */
-function answerQuestion(surface, command) {
+function answerQuestion(context, command) {
+    const { surface, session } = context;
+    const ledger = sessionUiAnswerLedger(session);
+    const answerId = command.answerId;
+    if (answerId !== undefined && (typeof answerId !== "string" || answerId.length < 1 || answerId.length > 256))
+        return failure(command.id, "extension_ui_response", "invalid_answer_id");
     const frameId = command.id;
     const requestId = answeredUiRequestId(command);
+    const receipt = requestId === undefined || answerId === undefined ? undefined : ledger.lookup(requestId, answerId);
+    if (receipt === "replay")
+        return { ...success(frameId, "extension_ui_response"), disposition: receipt };
+    if (receipt === "already_answered")
+        return { ...failure(frameId, "extension_ui_response", "already_answered"), disposition: receipt };
     const request = requestId === undefined ? undefined : surface.pendingQuestion(requestId);
     if (requestId === undefined || request === undefined) {
-        return failure(frameId, "extension_ui_response", "unknown_request");
+        return {
+            ...failure(frameId, "extension_ui_response", answerId === undefined ? "unknown_request" : "unknown_extension_ui_request"),
+            disposition: "unknown",
+        };
     }
     const response = questionResponse(command, request.questions);
     if (response === "question_incomplete")
@@ -134,7 +150,8 @@ function answerQuestion(surface, command) {
     if (response === undefined || !surface.answerQuestion(requestId, response)) {
         return failure(frameId, "extension_ui_response", "invalid_response");
     }
-    return success(frameId, "extension_ui_response");
+    ledger.record(requestId, answerId);
+    return { ...success(frameId, "extension_ui_response"), disposition: "applied" };
 }
 function questionResponse(command, questions) {
     // Another client's cancel (the desktop's Remove) is the user's; the builtin settles it from its own draft.

package/dist/modes/interactive/session-control-rpc-commands.d.ts

@@ -1,7 +1,7 @@
 import type { AgentSession } from "../../core/agent-session.ts";
 import { type ControlAttachments } from "./session-control-attach.ts";
 import { type ControlCommand, type ControlConnection } from "./session-control-server.ts";
-export declare const TUI_RPC_COMMANDS: readonly ["open_session", "subscribe_sessions", "unsubscribe_sessions", "steer", "follow_up", "prompt", "get_effect_status", "set_client_info", "attach_session", "release_attachment", "abort"];
+export declare const TUI_RPC_COMMANDS: readonly ["open_session", "get_snapshot", "subscribe_sessions", "unsubscribe_sessions", "steer", "follow_up", "prompt", "get_effect_status", "set_client_info", "attach_session", "release_attachment", "abort"];
 export interface RpcCommandContext {
     /** This endpoint's instance id: the `expectedHostInstance` an `attach_session` may name. */
     readonly instanceId: string;

package/dist/modes/interactive/session-control-rpc-commands.js

@@ -17,11 +17,13 @@ import { CONNECTION_ROLE_FIXED } from "../rpc/connection-roles.js";
 import { INTERACTIVE_USER_CAPABILITY } from "../rpc/custom-capability.js";
 import { runAbort, runGetEffectStatus } from "../rpc/effect-commands.js";
 import { buildRpcSessionState } from "../rpc/rpc-session-state.js";
+import { getSnapshot } from "../rpc/get-snapshot.js";
 import { answerSubscribeSessions, answerUnsubscribeSessions, refusal } from "../rpc/session-status-commands.js";
 import { keyOf } from "./session-control-attach.js";
 import { failure, success } from "./session-control-server.js";
 export const TUI_RPC_COMMANDS = [
     "open_session",
+    "get_snapshot",
     "subscribe_sessions",
     "unsubscribe_sessions",
     "steer",
@@ -38,6 +40,23 @@ const STOP_REQUIRES_INTERACTIVE_CLIENT = "stop_requires_interactive_client: decl
 /** `null` = answered on the writer already; `undefined` = not a command this file owns. */
 export async function runTuiRpcCommand(context, connection, command) {
     switch (command.type) {
+        case "get_snapshot": {
+            const { attachments, session } = context;
+            if (command.sessionId !== undefined && command.sessionId !== attachments.handle)
+                return {
+                    id: command.id,
+                    type: "response",
+                    command: command.type,
+                    success: false,
+                    error: "unknown_session",
+                };
+            const snapshot = getSnapshot(session, { tail: command.tail, maxBytes: command.maxBytes }, {
+                enqueue: (markerId) => attachments.run(connection, () => attachments.writer.enqueue(attachments.handle, { type: "snapshot_marker", markerId })),
+            });
+            return "error" in snapshot
+                ? { id: command.id, type: "response", command: command.type, success: false, error: snapshot.error }
+                : answered(idOf(command), command.type, snapshot.data);
+        }
         case "open_session":
             return openSession(context, connection, command);
         case "subscribe_sessions":

package/dist/modes/json-event.d.ts

@@ -1,4 +1,4 @@
-import type { Usage } from "@earendil-works/pi-ai";
+import { type AssistantMessage, getAssistantCapture, type TextContent, type ThinkingContent, type ToolCall, type Usage } from "@earendil-works/pi-ai";
 import type { AgentSessionEvent } from "../core/agent-session.ts";
 type WithoutPartial<T> = T extends {
     partial: unknown;
@@ -13,6 +13,7 @@ type ToJsonAssistantMessageEvent<T> = T extends {
 type MessageUpdateEvent = Extract<AgentSessionEvent, {
     type: "message_update";
 }>;
+type AssistantCapture = NonNullable<ReturnType<typeof getAssistantCapture>>;
 type JsonMessageUpdateEvent = {
     type: "message_update";
     usage: Usage;
@@ -23,6 +24,82 @@ type JsonMessageUpdateEvent = {
 export type JsonAgentSessionEvent = Exclude<AgentSessionEvent, {
     type: "message_update";
 }> | JsonMessageUpdateEvent;
+/** The engine-staged block-seed projection (senpi#4272, R3.C6.2); no public destination selects it before S17. */
+export interface BlockSeedOptions {
+    readonly blockSeeds: 1;
+}
+type SeededAssistantEvent = {
+    type: "start";
+    seed: {
+        message: AssistantMessage;
+    };
+} | {
+    type: "text_start";
+    contentIndex: number;
+    seed: {
+        block: TextContent;
+        coveredCodeUnits: number;
+    };
+} | {
+    type: "thinking_start";
+    contentIndex: number;
+    seed: {
+        block: ThinkingContent;
+        coveredCodeUnits: number;
+    };
+} | {
+    type: "toolcall_start";
+    contentIndex: number;
+    id: string;
+    toolName: string;
+    seed: {
+        block: ToolCall;
+        rawArgumentPrefix: string;
+        parsedThrough: number;
+        coveredCodeUnits: number;
+    };
+} | {
+    type: "text_delta" | "thinking_delta";
+    contentIndex: number;
+    delta: string;
+    offset: number;
+} | {
+    type: "toolcall_delta";
+    contentIndex: number;
+    delta: string;
+    offset: number;
+    parsedThrough: number;
+} | {
+    type: "text_end";
+    contentIndex: number;
+    content: string;
+    block: TextContent;
+} | {
+    type: "thinking_end";
+    contentIndex: number;
+    content: string;
+    block: ThinkingContent;
+} | {
+    type: "toolcall_end";
+    contentIndex: number;
+    toolCall: ToolCall;
+} | {
+    type: "done";
+    reason: string;
+    message: AssistantMessage;
+} | {
+    type: "error";
+    reason: string;
+    error: AssistantMessage;
+};
+export type SeededJsonMessageUpdateEvent = Omit<MessageUpdateEvent, "message" | "assistantMessageEvent"> & {
+    usage: Usage;
+    messageMetadata?: AssistantCapture["metadata"];
+    assistantMessageEvent: SeededAssistantEvent;
+};
+export type SeededJsonAgentSessionEvent = Exclude<AgentSessionEvent, {
+    type: "message_update";
+}> | SeededJsonMessageUpdateEvent;
 /**
  * Remove cumulative assistant snapshots from streaming wire events.
  * `message_start` provides the initial message, deltas build it, and
@@ -31,5 +108,6 @@ export type JsonAgentSessionEvent = Exclude<AgentSessionEvent, {
  */
 export declare function toJsonEvent(event: MessageUpdateEvent): JsonMessageUpdateEvent;
 export declare function toJsonEvent(event: AgentSessionEvent): JsonAgentSessionEvent;
+export declare function toJsonEvent(event: AgentSessionEvent, options: BlockSeedOptions): SeededJsonAgentSessionEvent | undefined;
 export {};
 //# sourceMappingURL=json-event.d.ts.map

package/dist/modes/json-event.js

@@ -1,3 +1,4 @@
+import { getAssistantCapture, } from "@earendil-works/pi-ai";
 function toJsonAssistantMessageEvent(event) {
     if (event.type === "toolcall_start") {
         const toolCall = event.partial.content[event.contentIndex];
@@ -13,7 +14,84 @@ function toJsonAssistantMessageEvent(event) {
     const { partial: _partial, ...deltaEvent } = event;
     return deltaEvent;
 }
-export function toJsonEvent(event) {
+/**
+ * Builds a seeded assistant event from the producer-time capture only: an ordinary delta reads its index, its
+ * delta string and the capture, never the shared partial, the block or the parsed arguments.
+ */
+function toSeededAssistantEvent(event, capture) {
+    if (event.type === "start")
+        return capture.message && { type: "start", seed: { message: capture.message } };
+    if (event.type === "done")
+        return { type: "done", reason: event.reason, message: event.message };
+    if (event.type === "error")
+        return { type: "error", reason: event.reason, error: event.error };
+    const contentIndex = capture.contentIndex ?? event.contentIndex;
+    if (event.type === "text_delta" || event.type === "thinking_delta" || event.type === "toolcall_delta") {
+        const { offset, parsedThrough } = capture;
+        if (offset === undefined)
+            return undefined;
+        if (event.type !== "toolcall_delta")
+            return { type: event.type, contentIndex, delta: event.delta, offset };
+        if (parsedThrough === undefined)
+            return undefined;
+        return { type: event.type, contentIndex, delta: event.delta, offset, parsedThrough };
+    }
+    const { block, coveredCodeUnits } = capture;
+    if (event.type === "toolcall_end")
+        return block?.type === "toolCall" ? { type: event.type, contentIndex, toolCall: block } : undefined;
+    if (event.type === "text_end")
+        return block?.type === "text" ? { type: event.type, contentIndex, content: event.content, block } : undefined;
+    if (event.type === "thinking_end")
+        return block?.type === "thinking" ? { type: event.type, contentIndex, content: event.content, block } : undefined;
+    if (coveredCodeUnits === undefined)
+        return undefined;
+    if (event.type === "text_start")
+        return block?.type === "text" ? { type: event.type, contentIndex, seed: { block, coveredCodeUnits } } : undefined;
+    if (event.type === "thinking_start")
+        return block?.type === "thinking"
+            ? { type: event.type, contentIndex, seed: { block, coveredCodeUnits } }
+            : undefined;
+    const { rawArgumentPrefix, parsedThrough } = capture;
+    if (block?.type !== "toolCall" || rawArgumentPrefix === undefined || parsedThrough === undefined)
+        return undefined;
+    return {
+        type: event.type,
+        contentIndex,
+        id: block.id,
+        toolName: block.name,
+        seed: { block, rawArgumentPrefix, parsedThrough, coveredCodeUnits },
+    };
+}
+/**
+ * An assistant record with no capture has no seeded form (`undefined`): its producer captured nothing, so any
+ * seed would be read from the live partial and could already hold later bytes. Identity is never invented.
+ */
+function toSeededJsonEvent(event) {
+    if ((event.type === "message_start" || event.type === "message_end") && event.message.role === "assistant") {
+        const message = getAssistantCapture(event)?.message;
+        if (message)
+            return { ...event, message };
+        // The terminal message is complete when emitted; only an uncaptured start may already hold later bytes.
+        return event.type === "message_end" ? event : undefined;
+    }
+    if (event.type !== "message_update")
+        return event;
+    const capture = getAssistantCapture(event);
+    const assistantMessageEvent = capture && toSeededAssistantEvent(event.assistantMessageEvent, capture);
+    if (!capture || !assistantMessageEvent)
+        return undefined;
+    const { message: _message, assistantMessageEvent: _event, ...outer } = event;
+    const changed = capture.metadata !== undefined && Object.keys(capture.metadata).length > 0;
+    return {
+        ...outer,
+        usage: capture.usage,
+        ...(changed ? { messageMetadata: capture.metadata } : {}),
+        assistantMessageEvent,
+    };
+}
+export function toJsonEvent(event, options) {
+    if (options)
+        return toSeededJsonEvent(event);
     if (event.type !== "message_update") {
         return event;
     }