@jini-ai/chat 0.6.6 → 0.6.10

package/dist/core/run-events/entry.js

@@ -3,9 +3,10 @@
  * compaction and paragraph boundaries so live and persisted turns agree. Notice strings, custom
  * event names and excluded run-ID prefixes are explicit host inputs, never product wire defaults.
  * Authenticated routing, ownership, boot repair and storage transactions remain host responsibilities. */
-import { decodeSseFrames, parseSseRecord } from "@jini-ai/agent-runtime/providers/sse-decode";
+import { decodeSseFrames, parseSseRecord } from "@jini-ai/core/primitives";
 import { assistantContentFromEvents } from "../assistant-content.js";
 import { mergeAdjacentTextEvents } from "../compact-events.js";
+import { dedupeToolUsesById } from "../tool-events.js";
 function wireString(v) {
     return typeof v === "string" ? v : v == null ? "" : JSON.stringify(v);
 }
@@ -63,38 +64,13 @@ export function parseUsageEvent({ payload }, _options = {}) {
  * cannot fall through to `default` — see below). A lookup table would have to carry those as a
  * parallel structure, one step removed from the code they explain. Left as a `switch`, documented
  * here rather than only in this session's report.
+ *
+ * Superseded (2026-10-20, code-health wave 1; bar is ≤10/≤10): the flat switch is now TWO switches —
+ * the chat-core event types here, and the UI-envelope / dropped / `ext` types in
+ * {@link translateEnvelopePayload} below — so each scope stays under the cyclomatic bar while BOTH
+ * keep what the paragraph above argued for: every case is still a `case` with its own comment
+ * attached, not an entry in a parallel lookup table.
  */
-// Typed media (currently just images) the daemon attached alongside the flattened `content`
-// string — see `@jini-ai/protocol`'s `events.ts` doc on why the wire field is `unknown`
-// rather than a checked type here: the real shape is validated where `ToolCard` renders it.
-// Forwarded verbatim rather than re-validated a second time in this reducer — an
-// `Array.isArray` guard rather than a deep shape check, since a malformed entry inside it
-// is a rendering concern (`ToolCard`'s own `ToolResultMedia` already ignores anything that
-// isn't a recognized block), not a transport one.
-// An MCP content block the daemon withheld from the tool result because it is for the HUMAN,
-// not the model (`@jini-ai/daemon`'s `delegated-tool-bridge.ts` → `tool-result-surfaces.ts`).
-// Explicit rather than left to `default` below because the shapes do not line up: the default
-// passes the WHOLE wire payload as `data`, but `@jini-ai/chat`'s `McpUiSurfaceCard` runs
-// `parseUIResource` over each event's `data` and that requires the bare `EmbeddedResource`
-// (`{type:'resource', resource:{uri,mimeType,text}}`). Handing it the envelope instead fails
-// the `type !== 'resource'` check and renders an empty frame — a silent no-op, which is the
-// worst possible failure for a confirmation dialog. Unwrapping here is what makes the two ends
-// meet. `name` must stay `"mcp-ui"` to match `MCP_UI_EXT_EVENT_NAME`.
-// A2UI's own agent->renderer envelope (`@jini-ai/core`'s `SurfaceEmission` with
-// `channel: "a2ui"`, injected by `@jini-ai/daemon`'s `delegated-tool-bridge.ts` as
-// `{type: "a2ui", message: <AgentToRendererMessage>}`). Unwrapped to the bare `.message` here,
-// not left to the `default` branch below, for the same reason `mcp-ui` above is explicit:
-// `@jini-ai/chat/react`'s `A2uiSurfaceCard` (registered against `'a2ui'` in
-// `AssistantDock.tsx`) runs `extractSurfaceId`/`interpreter.applyAgentMessage` over each event's
-// `data` directly, and both require a bare, spec-shaped envelope — not the `{type, message}`
-// wire wrapper. Mirrors Jini's own reference host's identical `case "a2ui"` in
-// `examples/reference-web/src/daemon-transport.ts`.
-// thinking_start/stage_start/stage_end/surface_request/surface_response: no dedicated
-// chat-core variant. Routed through the `ext` escape hatch rather than dropped, so a future
-// renderer can opt in without a transport change.
-// Streamed tool input (with `--include-partial-messages`): the finished `tool_use` carries the
-// same input whole, and nothing renders the fragments. Kept, they became one no-op `ext` event
-// per chunk in the saved row.
 /** Reduce one daemon payload; preserve UI envelopes and drop duplicate input fragments. */
 export function translateRunAgentPayload({ payload }, _options = {}) {
     switch (payload.type) {
@@ -107,25 +83,66 @@ export function translateRunAgentPayload({ payload }, _options = {}) {
         case "tool_use":
             return { kind: "tool_use", id: wireString(payload.id), name: wireString(payload.name), input: payload.input };
         case "tool_result":
-            return {
-                kind: "tool_result",
-                toolUseId: wireString(payload.toolUseId),
-                content: wireString(payload.content),
-                isError: Boolean(payload.isError),
-                ...(Array.isArray(payload.media) ? { media: payload.media } : {}),
-            };
+            return toolResultEvent(payload);
         case "usage":
             return parseUsageEvent({ payload });
         case "raw":
             return { kind: "raw", line: wireString(payload.line) };
+        default:
+            return translateEnvelopePayload(payload);
+    }
+}
+function toolResultEvent(payload) {
+    return {
+        kind: "tool_result",
+        toolUseId: wireString(payload.toolUseId),
+        content: wireString(payload.content),
+        isError: Boolean(payload.isError),
+        // Typed media (currently just images) the daemon attached alongside the flattened `content`
+        // string — see `@jini-ai/protocol`'s `events.ts` doc on why the wire field is `unknown`
+        // rather than a checked type here: the real shape is validated where `ToolCard` renders it.
+        // Forwarded verbatim rather than re-validated a second time in this reducer — an
+        // `Array.isArray` guard rather than a deep shape check, since a malformed entry inside it
+        // is a rendering concern (`ToolCard`'s own `ToolResultMedia` already ignores anything that
+        // isn't a recognized block), not a transport one.
+        ...(Array.isArray(payload.media) ? { media: payload.media } : {}),
+    };
+}
+/** The payload types with no chat-core event of their own: UI envelopes, dropped types, and `ext`. */
+function translateEnvelopePayload(payload) {
+    switch (payload.type) {
+        // An MCP content block the daemon withheld from the tool result because it is for the HUMAN,
+        // not the model (`@jini-ai/daemon`'s `delegated-tool-bridge.ts` → `tool-result-surfaces.ts`).
+        // Explicit rather than left to `default` below because the shapes do not line up: the default
+        // passes the WHOLE wire payload as `data`, but `@jini-ai/chat`'s `McpUiSurfaceCard` runs
+        // `parseUIResource` over each event's `data` and that requires the bare `EmbeddedResource`
+        // (`{type:'resource', resource:{uri,mimeType,text}}`). Handing it the envelope instead fails
+        // the `type !== 'resource'` check and renders an empty frame — a silent no-op, which is the
+        // worst possible failure for a confirmation dialog. Unwrapping here is what makes the two ends
+        // meet. `name` must stay `"mcp-ui"` to match `MCP_UI_EXT_EVENT_NAME`.
         case "mcp-ui":
             return { kind: "ext", name: "mcp-ui", data: payload.resource };
+        // A2UI's own agent->renderer envelope (`@jini-ai/core`'s `SurfaceEmission` with
+        // `channel: "a2ui"`, injected by `@jini-ai/daemon`'s `delegated-tool-bridge.ts` as
+        // `{type: "a2ui", message: <AgentToRendererMessage>}`). Unwrapped to the bare `.message` here,
+        // not left to the `default` branch below, for the same reason `mcp-ui` above is explicit:
+        // `@jini-ai/chat/react`'s `A2uiSurfaceCard` (registered against `'a2ui'` in
+        // `AssistantDock.tsx`) runs `extractSurfaceId`/`interpreter.applyAgentMessage` over each event's
+        // `data` directly, and both require a bare, spec-shaped envelope — not the `{type, message}`
+        // wire wrapper. Mirrors Jini's own reference host's identical `case "a2ui"` in
+        // `examples/reference-web/src/daemon-transport.ts`.
         case "a2ui":
             return { kind: "ext", name: "a2ui", data: payload.message };
         case "thinking_start":
             return null;
+        // Streamed tool input (with `--include-partial-messages`): the finished `tool_use` carries the
+        // same input whole, and nothing renders the fragments. Kept, they became one no-op `ext` event
+        // per chunk in the saved row.
         case "tool_input_delta":
             return null;
+        // thinking_start/stage_start/stage_end/surface_request/surface_response: no dedicated
+        // chat-core variant. Routed through the `ext` escape hatch rather than dropped, so a future
+        // renderer can opt in without a transport change.
         default:
             return { kind: "ext", name: payload.type, data: payload };
     }
@@ -175,18 +192,9 @@ function neverStarted(outcome) {
 }
 /** Read non-successful daemon classification without throwing on malformed frames. */
 export function readTerminalOutcome({ raw }, _options = {}) {
-    if (!raw)
+    const payload = parseWirePayload(raw);
+    if (!payload)
         return null;
-    let payload;
-    try {
-        const frame = JSON.parse(raw);
-        if (!isRecord(frame) || !isRecord(frame.payload))
-            return null;
-        payload = frame.payload;
-    }
-    catch {
-        return null;
-    }
     const status = payload.status;
     if (status !== "failed" && status !== "canceled")
         return null;
@@ -375,9 +383,12 @@ export function runContentFromEvents({ events }, _options = {}) {
  * onto the screen; saved, it only repeats the event wrapper per token. Used by every saver (the server
  * finalizer and the chat PUT route the browser saves through), so both write the same shape.
  */
-/** Compact adjacent text/thinking deltas for durable storage. */
+/** Compact adjacent text/thinking deltas and keep the first occurrence of each tool-call ID.
+ * Replayed tool calls must not become duplicate history rows. Other events retain their order.
+ * @complexity O(n + total text length) time and O(n) space for n events.
+ */
 export function runEventsForSave({ events }, _options = {}) {
-    return mergeAdjacentTextEvents({ events });
+    return mergeAdjacentTextEvents({ events: dedupeToolUsesById({ events: [...events] }) });
 }
 function parseWire(raw) {
     if (!raw)
@@ -390,12 +401,18 @@ function parseWire(raw) {
         return null;
     }
 }
+/** A wire frame's `payload` when it is a plain object; `null` for an absent, malformed or bare body. */
+function parseWirePayload(raw) {
+    const payload = parseWire(raw)?.payload;
+    return isRecord(payload) ? payload : null;
+}
 function parseJsonLine(line) {
     if (!line.startsWith("{"))
         return null;
     try {
-        const value = JSON.parse(line);
-        return typeof value === "object" && value !== null ? value : null;
+        // A line starting with `{` either parses to a plain object or throws; it cannot parse to an
+        // array, a scalar or `null`, so no shape check is needed after the parse.
+        return JSON.parse(line);
     }
     catch {
         return null;
@@ -451,32 +468,41 @@ function chunkEvent(raw, channel, carry) {
         return [];
     const chunk = wireString(frame.payload?.chunk);
     const open = carry ? (carry.openEchoChannels ??= new Set()) : undefined;
+    const { kept, statuses, droppedAny } = splitChunk({ chunk, channel }, { open });
+    const line = droppedAny ? kept : chunk;
+    return line.length > 0 ? [{ kind: "raw", line }, ...statuses] : statuses;
+}
+/** A chunk's non-echo text and heartbeat statuses, and whether any echo piece was dropped. */
+function splitChunk({ chunk, channel }, { open } = {}) {
     const statuses = [];
     let kept = "";
     let droppedAny = false;
-    let first = true;
-    for (const piece of chunk.split(/(?<=\n)/)) {
-        // Only a chunk's first piece can continue the previous chunk's line; splitting on "\n" starts
-        // every later piece on a fresh line. Channels are tracked apart: stderr can interleave mid-line.
-        const echo = (first && open?.has(channel) === true) || ECHO_LINE.test(piece.trimStart());
-        first = false;
-        if (echo && !piece.endsWith("\n"))
-            open?.add(channel);
-        else
-            open?.delete(channel);
-        if (echo) {
+    chunk.split(/(?<=\n)/).forEach((piece, index) => {
+        if (isEchoPiece({ piece, channel, first: index === 0 }, { open })) {
             droppedAny = true;
-            continue;
+            return;
         }
-        const line = parseJsonLine(piece.trim());
-        const status = line ? heartbeatStatus(line) : null;
+        const status = pieceStatus(piece);
         if (status)
             statuses.push(status);
         kept += piece;
-    }
-    if (!droppedAny)
-        kept = chunk;
-    return kept.length > 0 ? [{ kind: "raw", line: kept }, ...statuses] : statuses;
+    });
+    return { kept, statuses, droppedAny };
+}
+/** Whether a piece belongs to an echo line, updating which channels are mid-way through one. */
+function isEchoPiece({ piece, channel, first }, { open } = {}) {
+    // Only a chunk's first piece can continue the previous chunk's line; splitting on "\n" starts
+    // every later piece on a fresh line. Channels are tracked apart: stderr can interleave mid-line.
+    const echo = (first && open?.has(channel) === true) || ECHO_LINE.test(piece.trimStart());
+    if (echo && !piece.endsWith("\n"))
+        open?.add(channel);
+    else
+        open?.delete(channel);
+    return echo;
+}
+function pieceStatus(piece) {
+    const line = parseJsonLine(piece.trim());
+    return line ? heartbeatStatus(line) : null;
 }
 // Order matters and matches the browser's `end` listener: the `max_tool_turns` notice first, then
 // the failed/canceled notice, then the failure itself.
@@ -504,33 +530,37 @@ function endOutcome(raw, notices) {
  *
  * @complexity O(size of the frame).
  */
-// The agent CLI's own output. `stderr` is where a dying CLI says WHY it is dying.
-// Shown AND saved as a status line, not only reported: the error is live-only state, so without
-// the event the saved turn (and a reload) showed a bare "failed" with the reason lost. This is
-// where the daemon's plain pre-spawn reason ("The assistant could not start: ...") and the
-// host's start refusals reach the user.
 /** Fold one named daemon frame into events, a failure and an optional terminal status. */
 export function translateRunFrame({ kind, raw, notices }, { carry } = {}) {
     switch (kind) {
-        case "agent": {
-            const frame = parseWire(raw);
-            const translated = frame && isRecord(frame.payload) && typeof frame.payload.type === "string" ? translateRunAgentPayload({ payload: frame.payload }) : null;
-            return { events: translated ? [translated] : [] };
-        }
+        case "agent":
+            return { events: agentFrameEvents(raw) };
+        // The agent CLI's own output. `stderr` is where a dying CLI says WHY it is dying.
         case "stdout":
         case "stderr":
             return { events: chunkEvent(raw, kind, carry) };
-        case "error": {
-            const frame = parseWire(raw);
-            const message = wireString(frame?.payload?.message) || "agent run failed";
-            return { events: [{ kind: "status", label: message }], error: new Error(message) };
-        }
+        case "error":
+            return errorFrameOutcome(raw);
         case "end":
             return endOutcome(raw, notices);
         default:
             return { events: [] };
     }
 }
+function agentFrameEvents(raw) {
+    const payload = parseWirePayload(raw);
+    const translated = typeof payload?.type === "string" ? translateRunAgentPayload({ payload: payload }) : null;
+    return translated ? [translated] : [];
+}
+// Shown AND saved as a status line, not only reported: the error is live-only state, so without
+// the event the saved turn (and a reload) showed a bare "failed" with the reason lost. This is
+// where the daemon's plain pre-spawn reason ("The assistant could not start: ...") and the
+// host's start refusals reach the user.
+function errorFrameOutcome(raw) {
+    const frame = parseWire(raw);
+    const message = wireString(frame?.payload?.message) || "agent run failed";
+    return { events: [{ kind: "status", label: message }], error: new Error(message) };
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/dist/core/todos.d.ts

@@ -7,7 +7,7 @@
  * no framework.
  */
 import type { AgentEvent } from './events.js';
-import type { ChatRunStatus } from './messages.js';
+import { type ChatRunStatus } from './messages.js';
 export type TodoStatus = 'pending' | 'in_progress' | 'completed' | 'stopped';
 export interface TodoItem {
     content: string;

package/dist/core/todos.js

@@ -1,3 +1,4 @@
+import { isTerminalRunStatus } from './messages.js';
 const TODO_WRITE_TOOL_NAMES = new Set([
     'TodoWrite',
     'todowrite',
@@ -28,39 +29,43 @@ function normalizeTodoStatus(status) {
  * @complexity O(n) in the number of raw plan entries.
  */
 export function parseTodoWriteInput({ input }) {
+    const list = todoListOf({ input });
+    return list ? list.items.map((todo) => parseTodoItem({ todo })).filter((todo) => todo !== null) : [];
+}
+/** The plan array a tool input carries (`todos` wins over `plan`), with the key it sits under. */
+function todoListOf({ input }, _optional = {}) {
     if (!input || typeof input !== 'object')
-        return [];
+        return null;
     const obj = input;
-    const rawItems = Array.isArray(obj.todos) ? obj.todos : Array.isArray(obj.plan) ? obj.plan : [];
-    return rawItems
-        .map((todo) => {
-        if (!todo || typeof todo !== 'object')
-            return null;
-        const record = todo;
-        const content = typeof record.content === 'string'
-            ? record.content
-            : typeof record.step === 'string'
-                ? record.step
-                : typeof record.description === 'string'
-                    ? record.description
-                    : typeof record.label === 'string'
-                        ? record.label
-                        : typeof record.text === 'string'
-                            ? record.text
-                            : '';
-        if (!content)
-            return null;
-        return {
-            content,
-            status: normalizeTodoStatus(record.status),
-            activeForm: typeof record.activeForm === 'string'
-                ? record.activeForm
-                : typeof record.active_form === 'string'
-                    ? record.active_form
-                    : undefined,
-        };
-    })
-        .filter((todo) => todo !== null);
+    if (Array.isArray(obj.todos))
+        return { key: 'todos', items: obj.todos };
+    if (Array.isArray(obj.plan))
+        return { key: 'plan', items: obj.plan };
+    return null;
+}
+/** The first of `keys` whose value is a string (even an empty one), else undefined. */
+function firstStringField({ record, keys }, _optional = {}) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === 'string')
+            return value;
+    }
+    return undefined;
+}
+const TODO_BODY_KEYS = ['content', 'step', 'description', 'label', 'text'];
+const TODO_ACTIVE_FORM_KEYS = ['activeForm', 'active_form'];
+function parseTodoItem({ todo }, _optional = {}) {
+    if (!todo || typeof todo !== 'object')
+        return null;
+    const record = todo;
+    const content = firstStringField({ record, keys: TODO_BODY_KEYS });
+    if (!content)
+        return null;
+    return {
+        content,
+        status: normalizeTodoStatus(record.status),
+        activeForm: firstStringField({ record, keys: TODO_ACTIVE_FORM_KEYS }),
+    };
 }
 /**
  * Find the most recent plan-tool `tool_use` in a single turn's events and
@@ -68,15 +73,22 @@ export function parseTodoWriteInput({ input }) {
  * @complexity O(n), scanning from the end.
  */
 export function latestTodosFromEvents({ events }) {
-    if (!events)
-        return [];
-    for (let i = events.length - 1; i >= 0; i -= 1) {
-        const event = events[i];
-        if (event?.kind !== 'tool_use' || !isTodoWriteToolName({ name: event.name }))
-            continue;
-        return parseTodoWriteInput({ input: event.input });
+    const event = latestTodoWriteEvent({ events });
+    return event ? parseTodoWriteInput({ input: event.input }) : [];
+}
+/** The newest plan-tool `tool_use` in one turn's events, scanning from the end. */
+function latestTodoWriteEvent({ events }, _optional = {}) {
+    return events?.findLast((event) => event.kind === 'tool_use' && isTodoWriteToolName({ name: event.name }));
+}
+/** The newest message holding a plan-tool call, with that call; messages are scanned newest first. */
+function latestTodoWriteInMessages({ messages }, _optional = {}) {
+    for (let mi = (messages?.length ?? 0) - 1; mi >= 0; mi -= 1) {
+        const message = messages[mi];
+        const event = latestTodoWriteEvent({ events: message.events });
+        if (event)
+            return { message, event };
     }
-    return [];
+    return null;
 }
 /** The subset of {@link latestTodosFromEvents} not yet marked `completed`. */
 export function unfinishedTodosFromEvents({ events }) {
@@ -95,42 +107,20 @@ export function unfinishedTodosFromEvents({ events }) {
  *   update) is far cheaper.
  */
 export function latestTodoWriteInputFromMessages({ messages }) {
-    if (!messages || messages.length === 0)
-        return null;
-    for (let mi = messages.length - 1; mi >= 0; mi -= 1) {
-        const events = messages[mi]?.events;
-        if (!events || events.length === 0)
-            continue;
-        for (let ei = events.length - 1; ei >= 0; ei -= 1) {
-            const event = events[ei];
-            if (event?.kind !== 'tool_use')
-                continue;
-            if (!isTodoWriteToolName({ name: event.name }))
-                continue;
-            return event.input;
-        }
-    }
-    return null;
+    return latestTodoWriteInMessages({ messages })?.event.input ?? null;
 }
 /** Convenience alias for {@link latestTodoWriteInputFromMessages} matching the `latestTodoWriteInput()` name in the target API. */
 export const latestTodoWriteInput = latestTodoWriteInputFromMessages;
 function hasTerminalRunEnded(runStatus, endedAt) {
-    return (runStatus === 'succeeded' ||
-        runStatus === 'failed' ||
-        runStatus === 'canceled' ||
-        (runStatus === undefined && endedAt !== undefined));
+    return isTerminalRunStatus({ status: runStatus }) || (runStatus === undefined && endedAt !== undefined);
 }
 function stoppedTodoWriteInput(input) {
-    if (!input || typeof input !== 'object')
+    const list = todoListOf({ input });
+    if (!list)
         return input;
-    const obj = input;
-    const key = Array.isArray(obj.todos) ? 'todos' : Array.isArray(obj.plan) ? 'plan' : null;
-    if (!key)
-        return input;
-    const items = obj[key];
     return {
         ...input,
-        [key]: items.map((todo) => {
+        [list.key]: list.items.map((todo) => {
             if (!todo || typeof todo !== 'object')
                 return todo;
             const record = todo;
@@ -151,25 +141,10 @@ function stoppedTodoWriteInput(input) {
  *   remap of the winning turn's items when the run has ended.
  */
 export function latestTodoWriteInputForPinnedCard({ messages }) {
-    if (!messages || messages.length === 0)
+    const found = latestTodoWriteInMessages({ messages });
+    if (!found)
         return null;
-    for (let mi = messages.length - 1; mi >= 0; mi -= 1) {
-        const message = messages[mi];
-        const events = message?.events;
-        if (!events || events.length === 0)
-            continue;
-        for (let ei = events.length - 1; ei >= 0; ei -= 1) {
-            const event = events[ei];
-            if (event?.kind !== 'tool_use')
-                continue;
-            if (!isTodoWriteToolName({ name: event.name }))
-                continue;
-            if (!hasTerminalRunEnded(message.runStatus, message.endedAt)) {
-                return event.input;
-            }
-            return stoppedTodoWriteInput(event.input);
-        }
-    }
-    return null;
+    const { message, event } = found;
+    return hasTerminalRunEnded(message.runStatus, message.endedAt) ? stoppedTodoWriteInput(event.input) : event.input;
 }
 //# sourceMappingURL=todos.js.map

package/dist/core/tool-events.js

@@ -20,16 +20,16 @@ export function dedupeToolUsesById({ events }) {
     let deduped = null;
     for (let i = 0; i < events.length; i += 1) {
         const event = events[i];
-        if (event.kind === 'tool_use') {
-            if (seen.has(event.id)) {
-                if (!deduped)
-                    deduped = events.slice(0, i);
-                continue;
-            }
+        if (event.kind !== 'tool_use') {
+            deduped?.push(event);
+        }
+        else if (seen.has(event.id)) {
+            deduped ??= events.slice(0, i);
+        }
+        else {
             seen.add(event.id);
+            deduped?.push(event);
         }
-        if (deduped)
-            deduped.push(event);
     }
     return deduped ?? events;
 }
@@ -46,8 +46,8 @@ const DELEGATED_WRAPPER_PATTERN = /^(?:mcp__.+__)?execute_(?:readonly_)?delegate
 export function isDelegatedWrapperToolName({ name }) {
     return DELEGATED_WRAPPER_PATTERN.test(name);
 }
-function wrapperToolId(event) {
-    if (event.kind !== 'tool_use' || !isDelegatedWrapperToolName({ name: event.name }))
+function wrapperToolId({ event }) {
+    if (!isDelegatedWrapperToolName({ name: event.name }))
         return undefined;
     const input = event.input;
     const toolId = typeof input === 'object' && input !== null ? input.toolId : undefined;
@@ -79,9 +79,11 @@ export function foldDelegatedWrapperCalls({ events }) {
     const claimed = new Set();
     const folded = new Set();
     events.forEach((event, i) => {
-        const toolId = wrapperToolId(event);
+        if (event.kind !== 'tool_use')
+            return;
+        const toolId = wrapperToolId({ event });
         // A replayed wrapper (same id) must not claim a second canonical row.
-        if (toolId === undefined || event.kind !== 'tool_use' || folded.has(event.id))
+        if (toolId === undefined || folded.has(event.id))
             return;
         const match = events.findIndex((other, j) => j > i && !claimed.has(j) && other.kind === 'tool_use' && other.name === toolId);
         if (match === -1)

package/dist/core/transcript.js

@@ -45,18 +45,7 @@ function escapeTranscriptRoleDelimiters(content) {
  * @complexity O(n) across all messages' events.
  */
 function buildPriorRunContextWarning(history, largeToolResultChars, highInputTokenWarningThreshold) {
-    let highestInputTokens = 0;
-    let largeToolResults = 0;
-    for (const message of history) {
-        for (const event of message.events ?? []) {
-            if (event.kind === 'usage' && typeof event.inputTokens === 'number') {
-                highestInputTokens = Math.max(highestInputTokens, event.inputTokens);
-            }
-            if (event.kind === 'tool_result' && event.content.length > largeToolResultChars) {
-                largeToolResults += 1;
-            }
-        }
-    }
+    const { highestInputTokens, largeToolResults } = scanPriorRunTelemetry({ history, largeToolResultChars });
     const notes = [];
     if (highestInputTokens >= highInputTokenWarningThreshold) {
         notes.push(`a previous run reported ${highestInputTokens} input tokens`);
@@ -68,6 +57,20 @@ function buildPriorRunContextWarning(history, largeToolResultChars, highInputTok
         return null;
     return ['## context warning', `Detected ${notes.join(', ')}.`, 'Keep this turn compact: summarize prior tool output, read large references from temp files, and quote only task-relevant lines.'].join('\n');
 }
+/** The highest reported input-token count and the number of oversized tool results across all events. */
+function scanPriorRunTelemetry({ history, largeToolResultChars }, _optional = {}) {
+    let highestInputTokens = 0;
+    let largeToolResults = 0;
+    for (const event of history.flatMap((message) => message.events ?? [])) {
+        if (event.kind === 'usage' && typeof event.inputTokens === 'number') {
+            highestInputTokens = Math.max(highestInputTokens, event.inputTokens);
+        }
+        if (event.kind === 'tool_result' && event.content.length > largeToolResultChars) {
+            largeToolResults += 1;
+        }
+    }
+    return { highestInputTokens, largeToolResults };
+}
 function scopeHistoryToAgent(history, targetAgentId, isSameAgentFamily) {
     if (!targetAgentId)
         return history;
@@ -79,6 +82,43 @@ function scopeHistoryToAgent(history, targetAgentId, isSameAgentFamily) {
     }
     return history;
 }
+/** Scan tag boundaries once, including malformed openers, without retrying an unterminated tag. */
+function questionFormTags({ content }) {
+    const matcher = /<(question-form|ask-question)\b|<\/(question-form|ask-question)>/g;
+    const tags = [];
+    let match;
+    while ((match = matcher.exec(content))) {
+        const closing = match[2] !== undefined;
+        const end = closing ? matcher.lastIndex : content.indexOf('>', matcher.lastIndex) + 1;
+        if (!end)
+            break;
+        tags.push({ name: (match[1] ?? match[2]), start: match.index, end, closing });
+        matcher.lastIndex = end;
+    }
+    return tags;
+}
+/** Find matched form ranges in reverse source order without retrying unmatched openers.
+ * Keep the first following close of the same name, matching the former non-greedy replacement.
+ * Matching by name (formerly a `\1` backreference) means a `<question-form>…</ask-question>`
+ * mismatch is never spliced.
+ * @complexity O(n) time and space in content length; each tag and source character is scanned once.
+ */
+function questionFormRanges({ content }) {
+    const tags = questionFormTags({ content });
+    const nextClose = new Map();
+    const ranges = [];
+    for (let i = tags.length - 1; i >= 0; i--) {
+        const tag = tags[i];
+        if (tag.closing)
+            nextClose.set(tag.name, tag.end);
+        else {
+            const end = nextClose.get(tag.name);
+            if (end !== undefined)
+                ranges.push({ start: tag.start, end });
+        }
+    }
+    return ranges;
+}
 /**
  * Strip transcript-echo hazards from a prior assistant turn before it goes
  * back to the agent as history: an already-answered `<question-form>` /
@@ -99,10 +139,16 @@ function scopeHistoryToAgent(history, targetAgentId, isSameAgentFamily) {
  *   passes) plus {@link summarizeArtifactsForTranscript}'s cost.
  */
 export function sanitizePriorAssistantTurn({ content }, { persistedArtifactFiles = [] } = {}) {
-    let sanitized = content.replace(
-    // `\1` backreference keeps the open/close tag names matched so this never
-    // splices across a `<question-form>…</ask-question>` mismatch.
-    /<(question-form|ask-question)\b[^>]*>[\s\S]*?<\/\1>/g, '[question-form was emitted here on a prior turn; the user already answered, see their reply below.]');
+    const chunks = [];
+    let copiedTo = 0;
+    for (const range of questionFormRanges({ content }).reverse()) {
+        if (range.start < copiedTo)
+            continue;
+        chunks.push(content.slice(copiedTo, range.start), '[question-form was emitted here on a prior turn; the user already answered, see their reply below.]');
+        copiedTo = range.end;
+    }
+    chunks.push(content.slice(copiedTo));
+    let sanitized = chunks.join('');
     // Strip ```json (or plain ```) fenced blocks whose body matches the form
     // schema shape — `"questions": [` is the strongest tell. A generic JSON
     // snippet without that key is left intact.