@jini-ai/chat 0.5.6 → 0.5.8

package/dist/core/ag-ui/entry.js

@@ -15,6 +15,8 @@ function reduceUsagePayload(payload) {
         ...(typeof usage.input_tokens === "number" ? { inputTokens: usage.input_tokens } : {}),
         ...(typeof usage.output_tokens === "number" ? { outputTokens: usage.output_tokens } : {}),
         ...(typeof payload.costUsd === "number" ? { costUsd: payload.costUsd } : {}),
+        ...(typeof payload.cumulativeCostUsd === "number" ? { cumulativeCostUsd: payload.cumulativeCostUsd } : {}),
+        ...(typeof payload.costSessionId === "string" ? { costSessionId: payload.costSessionId } : {}),
         ...(typeof payload.durationMs === "number" ? { durationMs: payload.durationMs } : {}),
     };
 }

package/dist/core/assistant-client/durable-run-subscription.d.ts

@@ -6,10 +6,13 @@ export interface DurableRunBinding {
     readonly conversationId: string;
 }
 export interface DurableSubscriptionPorts {
+    /** Absent recover intent preserves legacy recovery; false requests only the saved checkpoint. */
     readonly read: (required: {
         runId: string;
         messageId?: string;
-    }, optional: {}) => Promise<ChatMessage | null | "gone">;
+    }, optional: {
+        recover?: boolean;
+    }) => Promise<ChatMessage | null | "gone">;
     readonly stream: (required: {
         runId: string;
         cursor: string;

package/dist/core/assistant-client/durable-run-subscription.js

@@ -6,6 +6,7 @@ export function followDurableRun({ runId: initialRunId, handlers, signal, bindin
     let cursor = "";
     let stopped = false;
     let reading = false;
+    let recoveryPending = true;
     let dropped = false;
     let stopStream;
     let stopTimer;
@@ -26,7 +27,7 @@ export function followDurableRun({ runId: initialRunId, handlers, signal, bindin
     function open() {
         dropped = false;
         stopStream?.();
-        stopStream = ports.stream({ runId, cursor, frame, dropped: () => { dropped = true; void read().catch(() => undefined); } }, {});
+        stopStream = ports.stream({ runId, cursor, frame, dropped: () => { dropped = true; recoveryPending = true; void read().catch(() => undefined); } }, {});
     }
     function frame(kind, data, nextCursor) {
         if (stopped)
@@ -36,6 +37,7 @@ export function followDurableRun({ runId: initialRunId, handlers, signal, bindin
         const outcome = translateRunFrame({ kind, raw: data, notices }, {});
         // An attempt's error/end may be followed by a continuation. Only the row can finalize it.
         if (outcome.terminal || outcome.error) {
+            recoveryPending = true;
             void read().catch(() => undefined);
             return;
         }
@@ -52,8 +54,11 @@ export function followDurableRun({ runId: initialRunId, handlers, signal, bindin
         reading = true;
         stopTimer?.();
         stopTimer = undefined;
+        const recover = recoveryPending;
+        // Consume only when a read starts: faults during its await latch one follow-up recovery.
+        recoveryPending = false;
         try {
-            const message = await ports.read({ runId, ...(messageId ? { messageId } : {}) }, {});
+            const message = await ports.read({ runId, ...(messageId ? { messageId } : {}) }, { recover });
             if (stopped || !message)
                 return;
             if (message === "gone") {
@@ -64,8 +69,12 @@ export function followDurableRun({ runId: initialRunId, handlers, signal, bindin
         }
         finally {
             reading = false;
-            if (!stopped)
-                stopTimer = ports.schedule({ work: () => void read().catch(() => undefined), delayMs: 1_000 }, {});
+            if (!stopped) {
+                if (recoveryPending)
+                    void read().catch(() => undefined);
+                else
+                    stopTimer = ports.schedule({ work: () => void read().catch(() => undefined), delayMs: 1_000 }, {});
+            }
         }
     }
     function applySavedMessage(message) {

package/dist/core/durable-projection.d.ts

@@ -24,5 +24,7 @@ export declare function terminalMessageNotice({ message }: {
  * visible text can justify a Continued divider; the recovery marker still records the attempt. */
 export declare function recoveredRunEvents({ saved }: {
     saved: readonly AgentEvent[];
-}, _optional?: {}): AgentEvent[];
+}, { notice }?: {
+    notice?: 'visible' | 'silent';
+}): AgentEvent[];
 //# sourceMappingURL=durable-projection.d.ts.map

package/dist/core/durable-projection.js

@@ -1,4 +1,4 @@
-function identity(event) {
+function identity(event, usageOccurrences) {
     const wire = event;
     if (wire.eventId !== undefined)
         return `event:${wire.eventId}`;
@@ -8,7 +8,15 @@ function identity(event) {
         return `use:${event.id}`;
     if (event.kind === 'tool_result')
         return `result:${event.toolUseId}`;
-    return JSON.stringify(event);
+    const snapshot = JSON.stringify(event);
+    if (event.kind === 'usage') {
+        // Two segments can have identical counters. Match occurrence-for-occurrence during replay,
+        // rather than treating equal charges as the same event and silently dropping one segment.
+        const occurrence = (usageOccurrences.get(snapshot) ?? 0) + 1;
+        usageOccurrences.set(snapshot, occurrence);
+        return `usage:${snapshot}:${occurrence}`;
+    }
+    return snapshot;
 }
 function textOf(events) {
     return events.filter((event) => event.kind === 'text').map((event) => event.text).join('');
@@ -18,7 +26,9 @@ function textOf(events) {
 export function mergeRunEvents({ saved, incoming }, _optional = {}) {
     const previous = saved ?? [];
     const result = [...previous];
-    const keys = new Set(previous.map(identity));
+    const savedUsage = new Map();
+    const incomingUsage = new Map();
+    const keys = new Set(previous.map(event => identity(event, savedUsage)));
     const before = textOf(previous);
     const after = textOf(incoming);
     let skip = after.startsWith(before) ? before.length : after.length;
@@ -29,9 +39,12 @@ export function mergeRunEvents({ saved, incoming }, _optional = {}) {
             if (text)
                 result.push({ ...event, text });
         }
-        else if (!keys.has(identity(event))) {
-            keys.add(identity(event));
-            result.push(event);
+        else {
+            const key = identity(event, incomingUsage);
+            if (!keys.has(key)) {
+                keys.add(key);
+                result.push(event);
+            }
         }
     }
     return result;
@@ -44,6 +57,9 @@ export function continuingRunNotice({ events, active }, _optional = {}) {
     const marker = list.findLastIndex((event) => event.kind === 'status' && event.code === 'run_recovering');
     if (marker < 0)
         return null;
+    const markerEvent = list[marker];
+    if (markerEvent?.kind === 'status' && markerEvent.label === '')
+        return null;
     const progressed = list.slice(marker + 1).some((event) => event.kind === 'text' || event.kind === 'tool_use' || event.kind === 'tool_result');
     return progressed ? null : 'Continuing…';
 }
@@ -63,7 +79,24 @@ export function terminalMessageNotice({ message }, _optional = {}) {
 }
 /** The first answer has no earlier segment to divide, even if startup was retried. Only saved
  * visible text can justify a Continued divider; the recovery marker still records the attempt. */
-export function recoveredRunEvents({ saved }, _optional = {}) {
+export function recoveredRunEvents({ saved }, { notice = 'visible' } = {}) {
+    if (notice === 'silent') {
+        // A missing rollout is an expected reconstruction fallback, not a failed user turn. Keep an
+        // invisible attempt marker for fencing/diagnostic offsets, and preserve all unrelated work.
+        const attemptStart = saved.findLastIndex(event => event.kind === 'status' && event.code === 'run_recovering') + 1;
+        const diagnostic = saved.findIndex((event, index) => index >= attemptStart && ((event.kind === 'status' && /no rollout found for thread id/.test(`${event.label}\n${event.detail ?? ''}`)) ||
+            (event.kind === 'raw' && /no rollout found for thread id/.test(event.line))));
+        const events = saved.filter((event, index) => {
+            if (diagnostic < 0 || index < attemptStart)
+                return true;
+            if (event.kind === 'raw')
+                return !/no rollout found for thread id/.test(event.line);
+            if (event.kind === 'status')
+                return event.label !== 'Run failed — the agent process exited without answering' && !/no rollout found for thread id/.test(`${event.label}\n${event.detail ?? ''}`);
+            return true;
+        });
+        return [...events, { kind: 'status', code: 'run_recovering', label: '' }];
+    }
     const hasAnswer = saved.some(event => event.kind === 'text' && event.text.trim().length > 0);
     return [...saved, ...(hasAnswer ? [{ kind: 'text', text: '\n\n---\n\nContinued\n\n' }] : []),
         { kind: 'status', code: 'run_recovering', label: 'Continuing…' }];

package/dist/core/events.d.ts

@@ -65,6 +65,9 @@ export type AgentEvent = {
     inputTokens?: number;
     outputTokens?: number;
     costUsd?: number;
+    /** CLI session snapshot, persisted in events_json; reconciled across turns before display. */
+    cumulativeCostUsd?: number;
+    costSessionId?: string;
     durationMs?: number;
     stopReason?: string;
 } | {

package/dist/core/history-tool-metadata.d.ts

@@ -0,0 +1,23 @@
+/** Discovery and read approval for the generic history tools, shared with host projections. */
+export declare const assistantHistoryToolMetadata: {
+    readonly assistant_chats_list: {
+        readonly search: {
+            readonly keywords: "previous earlier interrupted chat conversation history search resume continue what we were doing";
+            readonly queries: readonly ["I had to start a new chat. Can you find what we were doing?", "Find my previous conversation."];
+        };
+        readonly approval: {
+            readonly class: "read";
+            readonly confirmation: "direct";
+        };
+    };
+    readonly assistant_chat_read: {
+        readonly search: {
+            readonly keywords: "read previous chat transcript history tail messages resume interrupted continue conversation";
+        };
+        readonly approval: {
+            readonly class: "read";
+            readonly confirmation: "direct";
+        };
+    };
+};
+//# sourceMappingURL=history-tool-metadata.d.ts.map

package/dist/core/history-tool-metadata.js

@@ -0,0 +1,13 @@
+/** Discovery and read approval for the generic history tools, shared with host projections. */
+export const assistantHistoryToolMetadata = {
+    assistant_chats_list: {
+        search: { keywords: 'previous earlier interrupted chat conversation history search resume continue what we were doing',
+            queries: ['I had to start a new chat. Can you find what we were doing?', 'Find my previous conversation.'] },
+        approval: { class: 'read', confirmation: 'direct' },
+    },
+    assistant_chat_read: {
+        search: { keywords: 'read previous chat transcript history tail messages resume interrupted continue conversation' },
+        approval: { class: 'read', confirmation: 'direct' },
+    },
+};
+//# sourceMappingURL=history-tool-metadata.js.map

package/dist/core/index.d.ts

@@ -8,6 +8,7 @@ export * from './messages.js';
 export * from './partial-json.js';
 export * from './tool-events.js';
 export * from './tool-output.js';
+export * from './tool-call-detail.js';
 export * from './transport.js';
 export * from './tools.js';
 export * from './todos.js';
@@ -32,4 +33,7 @@ export { recoveredRunEvents } from './durable-projection.js';
 export { composerHistoryKeyAction, createComposerHistoryState, mergeComposerHistory, normalizeComposerHistory, transitionComposerHistory, } from './composer-history.js';
 export type { ComposerHistoryKeyInput, ComposerHistoryState, ComposerHistoryStoragePort } from './composer-history.js';
 export * from './user-text-redaction.js';
+export * from './history-tool-metadata.js';
+export { turnUsage, conversationUsage, replySegments, isReplyBoundary, MID_RUN_USER_MESSAGE_EVENT_NAME, type ChatUsageSummary } from './turn-usage.js';
+export { formatUsageCost } from './usage-format.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.js

@@ -8,6 +8,7 @@ export * from './messages.js';
 export * from './partial-json.js';
 export * from './tool-events.js';
 export * from './tool-output.js';
+export * from './tool-call-detail.js';
 export * from './transport.js';
 export * from './tools.js';
 export * from './todos.js';
@@ -31,4 +32,7 @@ export * from './persistence/index.js';
 export { recoveredRunEvents } from './durable-projection.js';
 export { composerHistoryKeyAction, createComposerHistoryState, mergeComposerHistory, normalizeComposerHistory, transitionComposerHistory, } from './composer-history.js';
 export * from './user-text-redaction.js';
+export * from './history-tool-metadata.js';
+export { turnUsage, conversationUsage, replySegments, isReplyBoundary, MID_RUN_USER_MESSAGE_EVENT_NAME } from './turn-usage.js';
+export { formatUsageCost } from './usage-format.js';
 //# sourceMappingURL=index.js.map

package/dist/core/persistence/title.d.ts

@@ -23,6 +23,18 @@
  *   2. `LATIN_NEVER_TRAILING` trims function words off the end. The original's word cap lands
  *      mid-clause on question-shaped prompts and strands them ("...Posts Do I").
  */
+/** Remove presentation markup from title text while preserving link labels and inline code.
+ * Shared by prompt derivation, stored-title display and product naming adapters; no DOM or I/O.
+ * Fenced programs and reference definitions are not titles. Only paired emphasis is stripped:
+ * glob stars and identifier underscores are meaningful text. Older saved titles may already have
+ * been cut through a markdown span; cut links keep their partial label, unpaired emphasis stays.
+ * @param input.text - A prompt or a previously saved title.
+ * @returns Plain text with whitespace collapsed; identifiers keep their internal underscores.
+ * @complexity O(n²) worst-case regex time for unmatched spans; O(n) space in title/prompt length.
+ */
+export declare function stripConversationTitleMarkdown({ text }: {
+    text: string;
+}, _options?: {}): string;
 /**
  * Returns a short display title for a conversation, or `''` when the prompt yields nothing
  * usable (a bare URL, a lone code fence, pure punctuation). Callers should treat `''` as "leave
@@ -33,5 +45,17 @@
  */
 export declare function deriveConversationTitle({ prompt }: {
     prompt: string;
+}, { casing }?: {
+    casing?: 'title' | 'sentence';
 }): string;
+/** Sentence-case only a known heuristic title using the original prompt's proper names/acronyms.
+ * Manual names, model-authored names and unloaded transcripts keep their saved wording, with
+ * presentation markup removed and the display ceiling applied; no writes.
+ * @complexity O(n) time/space in the first prompt's length, using the existing bounded heuristic.
+ */
+export declare function conversationTitleForDisplay({ title, titleSource, firstPrompt }: {
+    title: string | null;
+    titleSource: 'fallback' | 'generated' | 'manual';
+    firstPrompt?: string | undefined;
+}, _options?: {}): string | null;
 //# sourceMappingURL=title.d.ts.map

package/dist/core/persistence/title.js

@@ -76,23 +76,60 @@ const LATIN_NEVER_TRAILING = new Set([
     'from', 'into', 'about', 'so', 'just', 'also', 'too', 'up', 'out',
 ]);
 /**
- * Strips the parts of a prompt that are never a good title: fenced and inline code, URLs, and
+ * Strips the parts of a prompt that are never a good title: fenced code, URLs, and
  * `@handle`/`#tag` tokens. Each of these is high-entropy and low-meaning in a six-word summary.
+ * Inline code keeps its label with delimiters removed, so a filename can still name the task.
  */
 function cleanPrompt(prompt) {
-    return prompt
-        .replace(/```[\s\S]*?```/g, ' ')
-        .replace(/`[^`]*`/g, ' ')
+    return stripConversationTitleMarkdown({ text: prompt })
         .replace(/https?:\/\/\S+/g, ' ')
         .replace(/[@#][\w.-]+/g, ' ')
         .replace(/[“”"']/g, '')
         .replace(/\s+/g, ' ')
         .trim();
 }
+/** Remove presentation markup from title text while preserving link labels and inline code.
+ * Shared by prompt derivation, stored-title display and product naming adapters; no DOM or I/O.
+ * Fenced programs and reference definitions are not titles. Only paired emphasis is stripped:
+ * glob stars and identifier underscores are meaningful text. Older saved titles may already have
+ * been cut through a markdown span; cut links keep their partial label, unpaired emphasis stays.
+ * @param input.text - A prompt or a previously saved title.
+ * @returns Plain text with whitespace collapsed; identifiers keep their internal underscores.
+ * @complexity O(n²) worst-case regex time for unmatched spans; O(n) space in title/prompt length.
+ */
+export function stripConversationTitleMarkdown({ text }, _options = {}) {
+    return text
+        .replace(/```[\s\S]*?(?:```|$)/g, ' ')
+        .replace(/^\s{0,3}\[[^\]\n]+\]:[^\n]*(?:\n|$)/gm, ' ')
+        .replace(/!?\[([^\[\]\n]+)\]\((?:[^()[\]\n]|\([^()[\]\n]*\))*(?:\)|$)/g, '$1')
+        .replace(/\[([^\[\]\n]+)\]\[[^\[\]\n]*(?:\]|$)/g, '$1')
+        .replace(/^\s{0,3}#{1,6}\s+|[ \t]+#+[ \t]*$/gm, '')
+        .replace(/(?<![\w\\*])(\*\*|\*)(?=[^\s*])([^*\n]*?[^\s*\\])\1(?![\w*])/g, '$2')
+        .replace(/(?<![\w\\_])(__|_)(?=[^\s_])([^\n]*?[^\s\\])\1(?![\w_])/g, '$2')
+        .replace(/`|~~/g, '')
+        .replace(/!?\[([^\]\n]*)(?=\n|$)/g, '$1')
+        // Unescape after markup removal so an escaped literal marker cannot become emphasis.
+        .replace(/\\([\\`*_[\]~])/g, '$1')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+/** Keep complete words at the display ceiling. A single oversized token still gets a bounded
+ * prefix: pasted blobs must never become megabyte-sized stored/listed titles.
+ * @complexity O(n) time/space, bounded by the title ceiling after the initial length check.
+ */
+function truncateTitle(title) {
+    if (title.length <= MAX_TITLE_CHARS)
+        return title;
+    const prefix = title.slice(0, MAX_TITLE_CHARS);
+    if (/\s/.test(title.charAt(MAX_TITLE_CHARS)))
+        return prefix.trimEnd();
+    const lastSpace = prefix.lastIndexOf(' ');
+    return (lastSpace > 0 ? prefix.slice(0, lastSpace) : prefix).trimEnd();
+}
 function toTitleCase(word) {
     return word ? word.charAt(0).toUpperCase() + word.slice(1).toLowerCase() : word;
 }
-function trimLatinTitle(input) {
+function trimLatinTitle(input, { casing }) {
     const words = input
         .replace(LEADING_LATIN_FILLER, '')
         .replace(/[^\p{L}\p{N}\s-]/gu, ' ')
@@ -104,7 +141,8 @@ function trimLatinTitle(input) {
     while (words.length > 0 && LATIN_NEVER_TRAILING.has(words[words.length - 1].toLowerCase())) {
         words.pop();
     }
-    return words.map(toTitleCase).join(' ');
+    const title = casing === 'title' ? words.map(toTitleCase).join(' ') : words.join(' ');
+    return title ? title.charAt(0).toUpperCase() + title.slice(1) : title;
 }
 function trimCjkTitle(input) {
     let title = input.trim();
@@ -122,16 +160,29 @@ function trimCjkTitle(input) {
  *
  * @complexity O(n) in prompt length; no allocation beyond the intermediate strings.
  */
-export function deriveConversationTitle({ prompt }) {
+export function deriveConversationTitle({ prompt }, { casing = 'title' } = {}) {
     const cleaned = cleanPrompt(prompt);
     if (!cleaned)
         return '';
     const firstClause = cleaned.split(/[\n\r。！？!?]/)[0]?.trim() ?? cleaned;
     if (!firstClause)
         return '';
-    const title = CJK_PATTERN.test(firstClause) ? trimCjkTitle(firstClause) : trimLatinTitle(firstClause);
+    const title = CJK_PATTERN.test(firstClause) ? trimCjkTitle(firstClause) : trimLatinTitle(firstClause, { casing });
     // Truncated without an ellipsis: this is a working title, not prose, and a `…` would end up stored
     // and shown as if the author wrote it.
-    return title.length > MAX_TITLE_CHARS ? title.slice(0, MAX_TITLE_CHARS).trimEnd() : title;
+    return truncateTitle(title);
+}
+/** Sentence-case only a known heuristic title using the original prompt's proper names/acronyms.
+ * Manual names, model-authored names and unloaded transcripts keep their saved wording, with
+ * presentation markup removed and the display ceiling applied; no writes.
+ * @complexity O(n) time/space in the first prompt's length, using the existing bounded heuristic.
+ */
+export function conversationTitleForDisplay({ title, titleSource, firstPrompt }, _options = {}) {
+    if (!title)
+        return title;
+    if (titleSource === 'generated' && firstPrompt && title === deriveConversationTitle({ prompt: firstPrompt })) {
+        return deriveConversationTitle({ prompt: firstPrompt }, { casing: 'sentence' });
+    }
+    return truncateTitle(stripConversationTitleMarkdown({ text: title })) || null;
 }
 //# sourceMappingURL=title.js.map

package/dist/core/run-activity.d.ts

@@ -34,6 +34,19 @@ export declare function humanizeToolName({ name }: {
 }, { input }?: {
     input?: (unknown) | undefined;
 }): string;
+/** Whether the person already answered a card, before its tool call returned. */
+export type IsAnsweredCard = (card: {
+    name: string;
+    data: unknown;
+}) => boolean;
+export interface RunActivityOptions {
+    /**
+     * A card the person answered no longer waits on them, even though its tool call stays open while
+     * the confirmed work runs (a publish can take minutes). Without this the line kept saying
+     * "Waiting for your answer above" under a card that already read "Done." (owner, 2026-10-11).
+     */
+    isAnsweredCard?: IsAnsweredCard | undefined;
+}
 /**
  * The latest signal in a running turn's events.
  *
@@ -46,7 +59,7 @@ export declare function humanizeToolName({ name }: {
  */
 export declare function deriveRunActivity({ events }: {
     events: readonly AgentEvent[] | undefined;
-}): RunActivityState;
+}, { isAnsweredCard }?: RunActivityOptions): RunActivityState;
 /**
  * Whether the run is waiting on the person: a card (form, confirm, sign-in) arrived while its tool
  * call is still open. Hosts use it to hide "still working" notices, which read as a hung run while
@@ -56,7 +69,7 @@ export declare function deriveRunActivity({ events }: {
  */
 export declare function isAwaitingAnswer({ events }: {
     events: readonly AgentEvent[] | undefined;
-}): boolean;
+}, options?: RunActivityOptions): boolean;
 /** `4` → `"4 s"`, `80` → `"1 m 20 s"`, `120` → `"2 m 0 s"`. */
 export declare function formatActivityClock({ totalSeconds }: {
     totalSeconds: number;

package/dist/core/run-activity.js

@@ -67,6 +67,8 @@ function isVisible(event) {
 function isAnswerCard(scan, name, data) {
     if (!CARD_EXT_NAMES.has(name))
         return false;
+    if (scan.isAnsweredCard?.({ name, data }) === true)
+        return false;
     if (name !== A2UI_EXT_NAME)
         return true;
     const displayOnlyId = displayOnlySurfaceIdOf({ message: data });
@@ -109,8 +111,8 @@ function scanEvent(scan, event, index) {
  *
  * @complexity O(n) in events, O(open tool calls) extra space.
  */
-export function deriveRunActivity({ events }) {
-    const scan = { open: [], lastVisible: null, lastCardIndex: -1, retry: null, progress: null, visibleCount: 0, displayOnlySurfaces: new Set() };
+export function deriveRunActivity({ events }, { isAnsweredCard } = {}) {
+    const scan = { open: [], lastVisible: null, lastCardIndex: -1, retry: null, progress: null, visibleCount: 0, displayOnlySurfaces: new Set(), isAnsweredCard };
     (events ?? []).forEach((event, index) => scanEvent(scan, event, index));
     const visibleCount = scan.visibleCount;
     const lastVisibleIndex = scan.lastVisible?.index ?? -1;
@@ -161,8 +163,8 @@ export function deriveRunActivity({ events }) {
  *
  * @complexity O(n) in events.
  */
-export function isAwaitingAnswer({ events }) {
-    return deriveRunActivity({ events }).activity.kind === 'awaiting-answer';
+export function isAwaitingAnswer({ events }, options = {}) {
+    return deriveRunActivity({ events }, options).activity.kind === 'awaiting-answer';
 }
 /** `4` → `"4 s"`, `80` → `"1 m 20 s"`, `120` → `"2 m 0 s"`. */
 export function formatActivityClock({ totalSeconds }) {

package/dist/core/run-events/entry.d.ts

@@ -293,6 +293,15 @@ export interface RunFrameOutcome {
     readonly error?: Error;
     readonly terminal?: Extract<ChatRunStatus, "succeeded" | "failed" | "canceled">;
 }
+/**
+ * Per-connection memory for {@link translateRunFrame}: which channels are mid-way through an echo
+ * line. Only a line's first chunk carries the {@link ECHO_LINE} prefix, so without it the rest of a
+ * split `user` echo stays as `raw` — tool-result prose that durable recovery then reads as executor
+ * diagnostics. Pass one fresh `{}` per daemon connection (each connection replays from event 0).
+ */
+export interface RunFrameCarry {
+    openEchoChannels?: Set<string>;
+}
 /**
  * Translates one named daemon SSE frame (`event:` name plus raw `data:` text) into its effect on the
  * turn. The browser's `subscribeToRun` dispatches the result to `RunHandlers`; the server finalizer
@@ -309,5 +318,7 @@ export declare function translateRunFrame({ kind, raw, notices }: {
     kind: string;
     raw: string | undefined;
     notices: RunNotices;
-}, _options?: Record<string, never>): RunFrameOutcome;
+}, { carry }?: {
+    carry?: RunFrameCarry;
+}): RunFrameOutcome;
 //# sourceMappingURL=entry.d.ts.map

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

@@ -32,6 +32,8 @@ export function parseUsageEvent({ payload }, _options = {}) {
         ...(typeof usage.input_tokens === "number" ? { inputTokens: usage.input_tokens } : {}),
         ...(typeof usage.output_tokens === "number" ? { outputTokens: usage.output_tokens } : {}),
         ...(typeof payload.costUsd === "number" ? { costUsd: payload.costUsd } : {}),
+        ...(typeof payload.cumulativeCostUsd === "number" ? { cumulativeCostUsd: payload.cumulativeCostUsd } : {}),
+        ...(typeof payload.costSessionId === "string" ? { costSessionId: payload.costSessionId } : {}),
         ...(typeof payload.durationMs === "number" ? { durationMs: payload.durationMs } : {}),
     };
 }
@@ -439,19 +441,30 @@ function heartbeatStatus(line) {
 const ECHO_LINE = /^\{"type":"(?:stream_event|assistant|user)"/;
 /**
  * One CLI stdout/stderr chunk → events. Every JSON line that is a heartbeat also yields a typed
- * `status` event; echo lines ({@link ECHO_LINE}) are dropped; everything else stays in ONE `raw`
- * event, verbatim. A chunk with no JSON lines at all (a plain-format CLI) is one `raw` event, as before.
+ * `status` event; echo lines ({@link ECHO_LINE}) are dropped — with a `carry`, including the later
+ * chunks of a split one; everything else stays in ONE `raw` event, verbatim. A chunk with no JSON
+ * lines at all (a plain-format CLI) is one `raw` event, as before.
  */
-function chunkEvent(raw) {
+function chunkEvent(raw, channel, carry) {
     const frame = parseWire(raw);
     if (!frame)
         return [];
     const chunk = wireString(frame.payload?.chunk);
+    const open = carry ? (carry.openEchoChannels ??= new Set()) : undefined;
     const statuses = [];
     let kept = "";
     let droppedAny = false;
+    let first = true;
     for (const piece of chunk.split(/(?<=\n)/)) {
-        if (ECHO_LINE.test(piece.trimStart())) {
+        // 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) {
             droppedAny = true;
             continue;
         }
@@ -497,7 +510,7 @@ function endOutcome(raw, notices) {
 // 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 }, _options = {}) {
+export function translateRunFrame({ kind, raw, notices }, { carry } = {}) {
     switch (kind) {
         case "agent": {
             const frame = parseWire(raw);
@@ -506,7 +519,7 @@ export function translateRunFrame({ kind, raw, notices }, _options = {}) {
         }
         case "stdout":
         case "stderr":
-            return { events: chunkEvent(raw) };
+            return { events: chunkEvent(raw, kind, carry) };
         case "error": {
             const frame = parseWire(raw);
             const message = wireString(frame?.payload?.message) || "agent run failed";

package/dist/core/tool-call-detail.d.ts

@@ -0,0 +1,51 @@
+import { type RedactUserText } from './user-text-redaction.js';
+/** The note keys a row shows instead of (or beside) a result. English text doubles as the i18n key, as everywhere else in this package. */
+export type ToolCallDetailNote = 'Waiting for the result or answer…' | 'No result was recorded for this call.' | 'The run ended before this call returned a result.' | 'Finished with no output.' | 'Failed without an error message.';
+export interface ToolCallDetail {
+    /** The call's input, pretty-printed and redacted; `null` when there is none or it cannot be serialized. */
+    readonly inputText: string | null;
+    /** The result's text, re-indented when JSON and redacted; `null` when there is no result text. */
+    readonly outputText: string | null;
+    /** Why there is no output, when there is none; `null` when the output says it all. */
+    readonly noteKey: ToolCallDetailNote | null;
+}
+export interface ToolCallDetailOptions {
+    readonly runStreaming?: boolean;
+    readonly runSucceeded?: boolean;
+    /** Per-block display cap; a longer input or output is cut with an ellipsis. Defaults to 10 000. */
+    readonly maxChars?: number;
+    /** Defaults to the chat text policy, so a tool call never shows a key the rest of the chat would hide. */
+    readonly redact?: RedactUserText;
+}
+/**
+ * Builds the readable detail for one tool call.
+ *
+ * @param required.input - The `tool_use` event's input, any shape.
+ * @param required.result - The paired `tool_result`, when one arrived.
+ * @param options - Run state that explains a missing result, the display cap, and the redactor.
+ * @returns Display-ready input and output text plus a note when the output is absent.
+ * @complexity O(n) in the serialized input plus result length.
+ */
+export declare function describeToolCallDetail({ input, result }: {
+    readonly input: unknown;
+    readonly result?: {
+        readonly content: string;
+        readonly isError?: boolean;
+    } | undefined;
+}, { runStreaming, runSucceeded, maxChars, redact }?: ToolCallDetailOptions): ToolCallDetail;
+/** Per-block cap for the text a collapsed row keeps mounted — see {@link describeCollapsedToolCall}. */
+export declare const COLLAPSED_DETAIL_MAX_CHARS = 400;
+/**
+ * The short, single-node text a collapsed row keeps in the DOM in place of its full detail. A long
+ * chat mounts hundreds of collapsed rows (713 in a 38-message chat, 3.45 MB of hidden text at the
+ * full 10 000-char cap), so the full panel is mounted only while open; this keeps the gist —
+ * input, then output or the note explaining its absence — readable through the row's
+ * `textContent` for a `page.*` DOM reader that never clicks.
+ *
+ * @param required - Same as {@link describeToolCallDetail}.
+ * @param options - Same as {@link describeToolCallDetail}; `maxChars` defaults to {@link COLLAPSED_DETAIL_MAX_CHARS}.
+ * @returns Input (when it has a JSON form) and output or note, joined by a newline — never empty, since a missing output always carries a note.
+ * @complexity O(n) in the serialized input plus result length (redaction runs before the cap).
+ */
+export declare function describeCollapsedToolCall(required: Parameters<typeof describeToolCallDetail>[0], options?: ToolCallDetailOptions): string;
+//# sourceMappingURL=tool-call-detail.d.ts.map