@jini-ai/chat 0.5.7 → 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/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

@@ -33,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

@@ -32,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.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 } : {}),
     };
 }

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

@@ -33,4 +33,19 @@ export declare function describeToolCallDetail({ input, result }: {
         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

package/dist/core/tool-call-detail.js

@@ -25,6 +25,24 @@ export function describeToolCallDetail({ input, result }, { runStreaming = false
         return { inputText, outputText: null, noteKey: result.isError ? 'Failed without an error message.' : 'Finished with no output.' };
     return { inputText, outputText: show(formatToolOutputForDisplay({ text: result.content })), noteKey: null };
 }
+/** Per-block cap for the text a collapsed row keeps mounted — see {@link describeCollapsedToolCall}. */
+export 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 function describeCollapsedToolCall(required, options = {}) {
+    const detail = describeToolCallDetail(required, { maxChars: COLLAPSED_DETAIL_MAX_CHARS, ...options });
+    return [detail.inputText, detail.outputText ?? detail.noteKey].filter((part) => part !== null).join('\n');
+}
 function missingResultNote({ runStreaming, runSucceeded }) {
     if (runStreaming)
         return 'Waiting for the result or answer…';

package/dist/core/turn-usage.d.ts

@@ -1,11 +1,50 @@
 import type { AgentEvent } from './events.js';
+import type { ChatMessage } from './messages.js';
 type UsageEvent = Extract<AgentEvent, {
     kind: 'usage';
 }>;
-/** Sum per-segment usage for the whole turn, including aborted segments and recovered attempts.
- * Missing fields stay absent; monetary charges are never inferred. O(n) time, O(1) space. */
+/** A turn's reported usage plus the conversation's prefix total. `segments` is present only when the
+ * message holds more than one reply (a mid-run message started a new one): one entry per reply, in
+ * order, each with its own prefix total, so every reply can show its own "Done" line. */
+export type ChatUsageSummary = UsageEvent & {
+    totalCostUsd?: number;
+    segments?: readonly (ChatUsageSummary | undefined)[];
+};
+type SessionCost = {
+    sessionId: string;
+    chargedUsd: number;
+};
+/** The ext event a message sent mid-run arrives as (the daemon's `user_message` run event). The agent
+ * answers it as a new reply inside the same run, so it ends the reply before it. */
+export declare const MID_RUN_USER_MESSAGE_EVENT_NAME = "user_message";
+/** Whether this event is a mid-run user message, i.e. the boundary between two replies of one run. */
+export declare function isReplyBoundary({ event }: {
+    event: AgentEvent;
+}, _optional?: {}): boolean;
+/** Split one assistant message's events into replies at each mid-run user message. A usage event
+ * that lands after a boundary but before the next reply produced anything is the interrupted
+ * reply's own result (the daemon notes it can arrive after the interrupt ack), so it stays with
+ * the reply before. Event order is otherwise preserved. O(n) for n events.
+ * @example replySegments({ events }).length // 1 + number of mid-run user messages */
+export declare function replySegments({ events }: {
+    events: readonly AgentEvent[] | undefined;
+}, _optional?: {}): AgentEvent[][];
+/** Sum reported segment usage for a turn, including aborted segments and recovered attempts.
+ * Optional projection state is updated to reconcile session snapshots across turns.
+ * Missing fields stay absent; money is never inferred. O(n) time for n events.
+ * @example turnUsage({ events: message.events }) */
 export declare function turnUsage({ events }: {
     events: readonly AgentEvent[] | undefined;
-}, _optional?: {}): UsageEvent | undefined;
+}, { sessions, agentId }?: {
+    sessions?: Map<string, SessionCost>;
+    agentId?: string;
+}): UsageEvent | undefined;
+/** Derive per-turn charges and prefix totals from persisted events_json, for live and reloaded
+ * chats alike. A message with mid-run replies also gets per-reply `segments`. O(e + m) for e events
+ * and m messages; no per-row transcript scans or I/O.
+ * @example conversationUsage({ messages: savedMessages }).get('assistant-2') */
+export declare function conversationUsage({ messages }: {
+    messages: readonly ChatMessage[];
+}, _optional?: {}): Map<string, ChatUsageSummary>;
 export {};
 //# sourceMappingURL=turn-usage.d.ts.map

package/dist/core/turn-usage.js

@@ -1,17 +1,114 @@
-/** Sum per-segment usage for the whole turn, including aborted segments and recovered attempts.
- * Missing fields stay absent; monetary charges are never inferred. O(n) time, O(1) space. */
-export function turnUsage({ events }, _optional = {}) {
+/** The ext event a message sent mid-run arrives as (the daemon's `user_message` run event). The agent
+ * answers it as a new reply inside the same run, so it ends the reply before it. */
+export const MID_RUN_USER_MESSAGE_EVENT_NAME = 'user_message';
+/** Whether this event is a mid-run user message, i.e. the boundary between two replies of one run. */
+export function isReplyBoundary({ event }, _optional = {}) {
+    return event.kind === 'ext' && event.name === MID_RUN_USER_MESSAGE_EVENT_NAME;
+}
+/** Split one assistant message's events into replies at each mid-run user message. A usage event
+ * that lands after a boundary but before the next reply produced anything is the interrupted
+ * reply's own result (the daemon notes it can arrive after the interrupt ack), so it stays with
+ * the reply before. Event order is otherwise preserved. O(n) for n events.
+ * @example replySegments({ events }).length // 1 + number of mid-run user messages */
+export function replySegments({ events }, _optional = {}) {
+    const segments = [[]];
+    let started = false;
+    for (const event of events ?? []) {
+        if (isReplyBoundary({ event })) {
+            segments.push([]);
+            started = false;
+            continue;
+        }
+        const target = event.kind === 'usage' && !started && segments.length > 1 ? segments.length - 2 : segments.length - 1;
+        if (event.kind !== 'usage' && event.kind !== 'status' && event.kind !== 'raw')
+            started = true;
+        segments[target].push(event);
+    }
+    return segments;
+}
+/** Resolve one charge against this agent/session's last snapshot. State is local to an
+ * ordered transcript projection; revisiting a session keeps its baseline. A lower snapshot
+ * starts a new counter epoch (some CLIs reset their counter on resume). O(1) map access. */
+function usageCost({ event, agentId, sessions }, _optional = {}) {
+    const sessionId = event.costSessionId;
+    if (!sessionId)
+        return validCost(event.costUsd);
+    const key = JSON.stringify([agentId, sessionId]);
+    const chargedUsd = sessions.get(key)?.chargedUsd ?? 0;
+    const cumulative = validCost(event.cumulativeCostUsd);
+    const cost = cumulative === undefined ? validCost(event.costUsd)
+        : cumulative < chargedUsd ? cumulative : cumulative - chargedUsd;
+    // Interim interrupted-segment charges are already paid; later snapshots subtract them.
+    // After a counter reset the new snapshot, rather than the old epoch's total, is the baseline.
+    sessions.set(key, { sessionId, chargedUsd: cumulative ?? chargedUsd + (cost ?? 0) });
+    return cost;
+}
+/** Missing or malformed costs stay unknown; never infer charges from tokens. */
+function validCost(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+/** Sum reported segment usage for a turn, including aborted segments and recovered attempts.
+ * Optional projection state is updated to reconcile session snapshots across turns.
+ * Missing fields stay absent; money is never inferred. O(n) time for n events.
+ * @example turnUsage({ events: message.events }) */
+export function turnUsage({ events }, { sessions = new Map(), agentId = '' } = {}) {
     let total;
     for (const event of events ?? []) {
         if (event.kind !== 'usage')
             continue;
         total ??= { kind: 'usage' };
-        for (const field of ['inputTokens', 'outputTokens', 'costUsd', 'durationMs']) {
+        for (const field of ['inputTokens', 'outputTokens', 'durationMs']) {
             const value = event[field];
             if (typeof value === 'number' && Number.isFinite(value) && value >= 0)
                 total[field] = (total[field] ?? 0) + value;
         }
+        const cost = usageCost({ event, agentId, sessions });
+        if (cost !== undefined)
+            total.costUsd = (total.costUsd ?? 0) + cost;
     }
     return total;
 }
+/** Add one reply's usage into a message total; fields absent from both stay absent. O(1). */
+function addUsage({ total, usage }, _optional = {}) {
+    if (!usage)
+        return total;
+    const next = { ...(total ?? { kind: 'usage' }) };
+    for (const field of ['inputTokens', 'outputTokens', 'durationMs', 'costUsd']) {
+        const value = usage[field];
+        if (value !== undefined)
+            next[field] = (next[field] ?? 0) + value;
+    }
+    return next;
+}
+/** Derive per-turn charges and prefix totals from persisted events_json, for live and reloaded
+ * chats alike. A message with mid-run replies also gets per-reply `segments`. O(e + m) for e events
+ * and m messages; no per-row transcript scans or I/O.
+ * @example conversationUsage({ messages: savedMessages }).get('assistant-2') */
+export function conversationUsage({ messages }, _optional = {}) {
+    const sessions = new Map();
+    const summaries = new Map();
+    let totalCostUsd;
+    for (const message of messages) {
+        if (message.role !== 'assistant')
+            continue;
+        // Replies run in event order through one session map, so their sum equals the whole-message charge.
+        const segments = [];
+        let usage;
+        for (const events of replySegments({ events: message.events })) {
+            const segment = turnUsage({ events }, { sessions, agentId: message.agentId ?? '' });
+            usage = addUsage({ total: usage, usage: segment });
+            if (segment?.costUsd !== undefined)
+                totalCostUsd = (totalCostUsd ?? 0) + segment.costUsd;
+            segments.push(segment && { ...segment, ...(totalCostUsd === undefined ? {} : { totalCostUsd }) });
+        }
+        if (!usage)
+            continue;
+        summaries.set(message.id, {
+            ...usage,
+            ...(totalCostUsd === undefined ? {} : { totalCostUsd }),
+            ...(segments.length > 1 ? { segments } : {}),
+        });
+    }
+    return summaries;
+}
 //# sourceMappingURL=turn-usage.js.map

package/dist/core/usage-format.d.ts

@@ -0,0 +1,10 @@
+/** Format a known turn charge, and its conversation prefix total only when one is passed; round only
+ * for display. The total is the chat's running total as of that turn, so an earlier turn's line never
+ * changes when later turns run (owner, 2026-10-10: "Done · 16s · $0.39 · total $3.95").
+ * @example formatUsageCost({ costUsd: 0.445, totalCostUsd: 2.5 }) // '$0.45 · total $2.50'
+ * @example formatUsageCost({ costUsd: 0.445 }) // '$0.45' */
+export declare function formatUsageCost({ costUsd, totalCostUsd }: {
+    costUsd: number;
+    totalCostUsd?: number | undefined;
+}, _optional?: {}): string;
+//# sourceMappingURL=usage-format.d.ts.map

package/dist/core/usage-format.js

@@ -0,0 +1,15 @@
+/** Round reported USD upward to cents after clearing arithmetic noise at 1e-8 USD precision.
+ * Keep the minimum cent for any positive reported charge, even below the noise precision. */
+function dollars(usd) {
+    const cents = usd > 0 ? Math.max(1, Math.ceil(Math.round(usd * 1e8) / 1e6)) : 0;
+    return `$${(cents / 100).toFixed(2)}`;
+}
+/** Format a known turn charge, and its conversation prefix total only when one is passed; round only
+ * for display. The total is the chat's running total as of that turn, so an earlier turn's line never
+ * changes when later turns run (owner, 2026-10-10: "Done · 16s · $0.39 · total $3.95").
+ * @example formatUsageCost({ costUsd: 0.445, totalCostUsd: 2.5 }) // '$0.45 · total $2.50'
+ * @example formatUsageCost({ costUsd: 0.445 }) // '$0.45' */
+export function formatUsageCost({ costUsd, totalCostUsd }, _optional = {}) {
+    return totalCostUsd === undefined ? dollars(costUsd) : `${dollars(costUsd)} · total ${dollars(totalCostUsd)}`;
+}
+//# sourceMappingURL=usage-format.js.map