@jini-ai/chat 0.6.10 → 0.6.12

package/CHANGELOG.md

@@ -1,3 +1,20 @@
+## 0.6.12
+
+### Patch Changes
+
+- chat: typing while a choice card waits queues the message instead of cancelling its tool call; answered choice cards keep their question and report option labels, not values; mid-run follow-ups read "Queued" until consumed; one steady thinking clock.
+  - @jini-ai/core@0.6.12
+
+## 0.6.11
+
+### Patch Changes
+
+- Honest turn footers (done / stopped / interrupted), answered question cards keep their question and chosen labels, readable conversation titles and counts; the usage tooltip reads "N output tokens".
+- Mid-run message relay for MCP-bridged engines (Codex, ACP, Antigravity): `registerMessageRelayRoutes` on `@jini-ai/daemon/http`; mid-run messages queue instead of interrupting, and recovery waits on an uncertain probe.
+- Updated dependencies
+- Updated dependencies
+  - @jini-ai/core@0.6.11
+
 ## 0.6.10
 
 ### Patch Changes

package/dist/core/accepted-input.d.ts

@@ -3,6 +3,8 @@ import type { ChatAttachment, ChatMessage } from './messages.js';
 export interface AcceptedChatInput {
     id: string;
     text: string;
+    /** Absent for legacy/ordinary inputs; consumed only after a CLI UUID receipt. */
+    deliveryState?: 'queued' | 'consumed';
     attachments?: ChatAttachment[];
     secretRedaction?: ChatMessage['secretRedaction'];
     /** Wire ids replaced by this receipt remain seen by recall. */

package/dist/core/accepted-input.js

@@ -50,8 +50,16 @@ function expandQuestionAnswers({ events }, _options = {}) {
     }));
     // MOVE: Persisted picks carry values; the original tool input retains their human-readable labels.
     const questions = new Map(events.flatMap(event => event.kind === 'tool_use' ? [[event.id, event.input]] : []));
-    return events.flatMap(event => {
+    const answers = new Map(events.flatMap(event => {
         const answer = questionAnswerEvent({ event, input: event.kind === 'tool_result' ? questions.get(event.toolUseId) : undefined });
+        return answer ? [[answer.data.toolUseId, answer]] : [];
+    }));
+    return events.flatMap(event => {
+        const receipt = acceptedInputEvent({ event });
+        const recorded = receipt?.data.toolUseId ? answers.get(receipt.data.toolUseId) : undefined;
+        if (receipt && recorded)
+            return [{ ...receipt, data: { ...receipt.data, text: recorded.data.text } }];
+        const answer = event.kind === 'tool_result' ? answers.get(event.toolUseId) : undefined;
         return answer && !savedAnswers.has(answer.data.toolUseId) ? [event, answer] : [event];
     });
 }
@@ -81,7 +89,7 @@ function matchOptimisticInput({ input, optimistic, seen }, _options = {}) {
 }
 function mergeAcceptedReceipt({ input, pending }, _options = {}) {
     return { ...input, data: { ...input.data, id: pending.data.id,
-            ...(pending.data.inputs ? { inputs: pending.data.inputs } : {}),
+            ...(pending.data.inputs ? { inputs: pending.data.inputs.map(item => ({ ...item, ...(input.data.deliveryState ? { deliveryState: input.data.deliveryState } : {}) })) } : {}),
             aliases: [...new Set([...(input.data.aliases ?? []), input.data.id, ...(pending.data.aliases ?? [])])] } };
 }
 function acceptedInputIds({ input }, _options = {}) {
@@ -114,13 +122,36 @@ function advanceOptimisticInput({ input, optimistic }, _options = {}) {
     if (candidates && !input.data.toolUseId)
         candidates.index += 1;
 }
+/** Fold state updates into the original bubble, preserving its position, local id and aliases.
+ * O(e + a + i) time/space for events, receipt aliases and expanded input constituents; equal text never establishes identity. */
+function collapseDeliveryReceipts({ events }, _options = {}) {
+    const result = [];
+    const positions = new Map();
+    for (const event of events) {
+        const input = acceptedInputEvent({ event });
+        const position = input ? positions.get(input.data.id) : undefined;
+        if (input && position !== undefined && input.data.deliveryState) {
+            const original = acceptedInputEvent({ event: result[position] });
+            // Replayed queue acceptance cannot undo confirmed consumption.
+            const deliveryState = original.data.deliveryState === 'consumed' ? 'consumed' : input.data.deliveryState;
+            result[position] = { ...original, data: { ...original.data, deliveryState,
+                    ...(original.data.inputs ? { inputs: original.data.inputs.map(input => ({ ...input, deliveryState })) } : {}) } };
+            continue;
+        }
+        if (input)
+            for (const id of acceptedInputIds({ input }))
+                positions.set(id, result.length);
+        result.push(event);
+    }
+    return result;
+}
 /** Projects saved answers and reconciles optimistic bubbles with wire events, occurrence for
  * occurrence. Legacy steering receipts have no client id: only unmatched optimistic input may
  * match by text; two real events with equal text always remain distinct.
  * @complexity O(e + u + a) time, O(e + u) space for e events, u user inputs and total answer-label lookup cost a.
  */
 export function projectAcceptedInputEvents({ events }, _options = {}) {
-    const expanded = expandQuestionAnswers({ events });
+    const expanded = expandQuestionAnswers({ events: collapseDeliveryReceipts({ events }) });
     const optimistic = collectOptimisticInputs({ events: expanded });
     const state = { replacements: new Map(), replaced: new Set(), seen: new Set() };
     for (const event of expanded)

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

@@ -17,7 +17,7 @@ export interface DurableSubscriptionPorts {
         runId: string;
         cursor: string;
         frame: (kind: string, data: string, cursor: string) => void;
-        dropped: () => void;
+        dropped: (reason?: string) => void;
     }, optional: {}) => () => void;
     readonly schedule: (required: {
         work: () => void;
@@ -37,6 +37,8 @@ export declare function followDurableRun({ runId: initialRunId, handlers, signal
     ports: DurableSubscriptionPorts;
     notices: RunNotices;
     bindings: Map<string, DurableRunBinding>;
-}, _optional?: {}): () => void;
+}, { logger }?: {
+    logger?: Pick<Console, "info">;
+}): () => void;
 export {};
 //# sourceMappingURL=durable-run-subscription.d.ts.map

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

@@ -1,18 +1,21 @@
 import { translateRunFrame } from "../run-events/entry.js";
 /** SSE is a view of one attempt. The saved message owns terminal state and can point at a new
  * attempt after recovery; neither a browser 404 nor a closed stream may fail the logical run. */
-export function followDurableRun({ runId: initialRunId, handlers, signal, binding, ports, notices, bindings }, _optional = {}) {
+export function followDurableRun({ runId: initialRunId, handlers, signal, binding, ports, notices, bindings }, { logger = console } = {}) {
+    let streamEpoch = 0;
     let runId = initialRunId;
     let cursor = "";
     let stopped = false;
     let reading = false;
     let recoveryPending = true;
     let dropped = false;
+    let reconnectDelayMs = 0;
     let stopStream;
     let stopTimer;
     let messageId = binding?.messageId;
     function stop() {
         stopped = true;
+        streamEpoch += 1;
         stopStream?.();
         stopTimer?.();
         signal?.removeEventListener("abort", stop);
@@ -25,15 +28,42 @@ export function followDurableRun({ runId: initialRunId, handlers, signal, bindin
         handlers.onDone(message.events ?? []);
     }
     function open() {
+        const epoch = ++streamEpoch;
         dropped = false;
         stopStream?.();
-        stopStream = ports.stream({ runId, cursor, frame, dropped: () => { dropped = true; recoveryPending = true; void read().catch(() => undefined); } }, {});
+        stopStream = ports.stream({ runId, cursor,
+            frame: (...args) => { if (epoch === streamEpoch)
+                frame(...args); },
+            dropped: reason => { if (epoch === streamEpoch)
+                disconnected(reason); },
+        }, {});
+    }
+    /** One timer owns reconnects, including faults during a checkpoint read. No cursor reset. */
+    function disconnected(reason = "stream-error") {
+        if (stopped || dropped)
+            return;
+        dropped = true;
+        streamEpoch += 1;
+        recoveryPending = true;
+        reconnectDelayMs = Math.min(30_000, Math.max(1_000, reconnectDelayMs * 2));
+        // Metadata only: neither frame contents nor saved user messages belong in transport logs.
+        logger.info("[durable-subscription] " + JSON.stringify({ runId, reason, cursor, retryDelayMs: reconnectDelayMs }));
+        stopStream?.();
+        if (!reading)
+            scheduleRead();
+    }
+    function scheduleRead() {
+        stopTimer?.();
+        stopTimer = ports.schedule({ work: () => void read().catch(() => undefined), delayMs: dropped ? reconnectDelayMs : 1_000 }, {});
     }
     function frame(kind, data, nextCursor) {
         if (stopped)
             return;
-        if (nextCursor)
+        if (nextCursor) {
+            if (nextCursor !== cursor)
+                reconnectDelayMs = 0;
             cursor = nextCursor;
+        }
         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) {
@@ -70,10 +100,8 @@ export function followDurableRun({ runId: initialRunId, handlers, signal, bindin
         finally {
             reading = false;
             if (!stopped) {
-                if (recoveryPending)
-                    void read().catch(() => undefined);
-                else
-                    stopTimer = ports.schedule({ work: () => void read().catch(() => undefined), delayMs: 1_000 }, {});
+                // Always schedule: an error arriving during read must not create a tight recovery loop.
+                scheduleRead();
             }
         }
     }
@@ -87,6 +115,7 @@ export function followDurableRun({ runId: initialRunId, handlers, signal, bindin
         if (message.runId && message.runId !== runId) {
             runId = message.runId;
             cursor = "";
+            reconnectDelayMs = 0;
             if (binding)
                 bindings.set(runId, binding);
             dropped = true;

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

@@ -10,18 +10,12 @@
  * better title asks its agent for one later and calls `rename(id, title, 'generated')`; the
  * store refuses to overwrite a `manual` title, so a user's own rename always wins.
  *
- * Ported from Open Design's `summarizeProjectNameFromPrompt` (`apps/web/src/utils/projectName.ts`),
- * which this generalizes from project names to conversation titles. Its behaviour is preserved
- * deliberately — including the CJK path, which is not decoration: the filler and punctuation
- * rules for Chinese prompts differ enough from the Latin ones that a shared code path produced
- * visibly worse titles in both.
- *
- * Two intentional divergences from the original, both fixing output the original gets wrong; each
- * is documented at its own declaration below:
- *   1. `LEADING_LATIN_FILLER` requires the separator inside the article group. The original's form
- *      let a bare `a` eat the first letter of the next word ("update app.tsx" → "Pp Tsx").
- *   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").
+ * Ported from Open Design's `summarizeProjectNameFromPrompt` (`apps/web/src/utils/projectName.ts`).
+ * The Latin path has since diverged: it keeps the prompt's words, names and dotted domains (the
+ * original's stop-word removal and title casing turned "port example.com to jini" into "Port
+ * Example Com Jini"), and `LEADING_LATIN_FILLER` fixes the original's article bug, documented at
+ * its declaration. The CJK path keeps the original's filler and punctuation rules, which is not
+ * decoration: they differ enough from the Latin ones that a shared path produced worse titles in both.
  */
 /** 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.
@@ -45,10 +39,8 @@ export declare function stripConversationTitleMarkdown({ text }: {
  */
 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.
+}, _optional?: Record<string, never>): string;
+/** A known heuristic title is already display-ready: derivation keeps the prompt's own wording.
  * 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.

package/dist/core/persistence/title.js

@@ -10,26 +10,19 @@
  * better title asks its agent for one later and calls `rename(id, title, 'generated')`; the
  * store refuses to overwrite a `manual` title, so a user's own rename always wins.
  *
- * Ported from Open Design's `summarizeProjectNameFromPrompt` (`apps/web/src/utils/projectName.ts`),
- * which this generalizes from project names to conversation titles. Its behaviour is preserved
- * deliberately — including the CJK path, which is not decoration: the filler and punctuation
- * rules for Chinese prompts differ enough from the Latin ones that a shared code path produced
- * visibly worse titles in both.
- *
- * Two intentional divergences from the original, both fixing output the original gets wrong; each
- * is documented at its own declaration below:
- *   1. `LEADING_LATIN_FILLER` requires the separator inside the article group. The original's form
- *      let a bare `a` eat the first letter of the next word ("update app.tsx" → "Pp Tsx").
- *   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").
+ * Ported from Open Design's `summarizeProjectNameFromPrompt` (`apps/web/src/utils/projectName.ts`).
+ * The Latin path has since diverged: it keeps the prompt's words, names and dotted domains (the
+ * original's stop-word removal and title casing turned "port example.com to jini" into "Port
+ * Example Com Jini"), and `LEADING_LATIN_FILLER` fixes the original's article bug, documented at
+ * its declaration. The CJK path keeps the original's filler and punctuation rules, which is not
+ * decoration: they differ enough from the Latin ones that a shared path produced worse titles in both.
  */
-const MAX_LATIN_WORDS = 6;
 const MAX_CJK_LENGTH = 18;
 /**
  * Hard character ceiling, because a word cap is not a length cap.
  *
- * Six "words" says nothing about their size: a pasted base64 blob or minified bundle is a single
- * enormous token, so it survived the word cap intact and became the title verbatim. That title is
+ * A word boundary says nothing about token size: a pasted base64 blob or minified bundle is a single
+ * enormous token, so it must not survive intact and become the title verbatim. That title is
  * then stored, listed, and re-rendered on every conversation-list read — megabytes of it. Applied to
  * the finished title so both the Latin and CJK paths are covered.
  */
@@ -51,33 +44,9 @@ const LEADING_CJK_FILLER = [
     /^(先)?(实现|做|做一下|创建|生成|设计|开发|新增|添加|优化|修复|改|更改|调整)(一下|一个|一版|下)?/,
     /^(一个|一份|这个|那个)/,
 ];
-const LATIN_STOP_WORDS = new Set([
-    'a', 'an', 'and', 'for', 'in', 'of', 'on', 'please', 'the', 'to', 'with', 'my',
-]);
-/**
- * Function words that are fine *inside* a title but never acceptable as its last word.
- *
- * These cannot go in `LATIN_STOP_WORDS`, because removing them everywhere mangles real titles —
- * "how many posts do I have" would lose the "how many" that makes it a question, and a prompt like
- * "make it work" would reduce to "Work". The problem is specifically the word-cap boundary: a
- * question-shaped prompt reliably spends its six words before reaching the noun, so the title got
- * cut mid-clause. Observed live: "how many published posts do I have?" produced
- * "How Many Published Posts Do I" — a dangling auxiliary plus a stranded pronoun, which in a narrow
- * dock also wrapped to leave a lone "I" on its own line.
- *
- * Trimming only the tail is what makes this safe: it can never shorten a title that already ended
- * on a content word, so no existing good title changes.
- */
-const LATIN_NEVER_TRAILING = new Set([
-    'do', 'does', 'did', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
-    'have', 'has', 'had', 'can', 'could', 'should', 'would', 'will', 'shall', 'may', 'might', 'must',
-    'i', 'me', 'you', 'we', 'us', 'it', 'they', 'them', 'he', 'she',
-    'that', 'this', 'these', 'those', 'but', 'or', 'if', 'then', 'than', 'as', 'at', 'by',
-    'from', 'into', 'about', 'so', 'just', 'also', 'too', 'up', 'out',
-]);
 /**
  * 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.
+ * `@handle`/`#tag` tokens. Each of these is high-entropy and low-meaning in a short summary.
  * Inline code keeps its label with delimiters removed, so a filename can still name the task.
  */
 function cleanPrompt(prompt) {
@@ -114,7 +83,8 @@ export function stripConversationTitleMarkdown({ text }, _options = {}) {
         .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.
+ * prefix: pasted blobs must never become megabyte-sized stored/listed titles. The old six-word cap
+ * stranded auxiliaries and pronouns mid-clause; the character ceiling leaves short questions whole.
  * @complexity O(n) time/space, bounded by the title ceiling after the initial length check.
  */
 function truncateTitle(title) {
@@ -126,24 +96,11 @@ function truncateTitle(title) {
     const lastSpace = prefix.lastIndexOf(' ');
     return (lastSpace > 0 ? prefix.slice(0, lastSpace) : prefix).trimEnd();
 }
-/** Callers pass only non-empty words (`trimLatinTitle` filters blanks before mapping). */
-function toTitleCase(word) {
-    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
-}
-function trimLatinTitle(input, { casing }) {
-    const words = input
-        .replace(LEADING_LATIN_FILLER, '')
-        .replace(/[^\p{L}\p{N}\s-]/gu, ' ')
-        .split(/\s+/)
-        .filter(Boolean)
-        .filter((word) => !LATIN_STOP_WORDS.has(word.toLowerCase()))
-        .slice(0, MAX_LATIN_WORDS);
-    // Applied after the cap, because the cap is what strands these words in the first place.
-    while (words.length > 0 && LATIN_NEVER_TRAILING.has(words[words.length - 1].toLowerCase())) {
-        words.pop();
-    }
-    const title = casing === 'title' ? words.map(toTitleCase).join(' ') : words.join(' ');
-    return title ? title.charAt(0).toUpperCase() + title.slice(1) : title;
+function trimLatinTitle(input) {
+    const words = input.replace(LEADING_LATIN_FILLER, '').match(/[\p{L}\p{N}]+(?:[._-][\p{L}\p{N}]+)*/gu) ?? [];
+    const title = words.join(' ');
+    // Domain and filename tokens retain their original case, even at the start of a sentence.
+    return words[0]?.includes('.') ? title : title.charAt(0).toUpperCase() + title.slice(1);
 }
 function trimCjkTitle(input) {
     let title = input.trim();
@@ -161,7 +118,7 @@ function trimCjkTitle(input) {
  *
  * @complexity O(n) in prompt length; no allocation beyond the intermediate strings.
  */
-export function deriveConversationTitle({ prompt }, { casing = 'title' } = {}) {
+export function deriveConversationTitle({ prompt }, _optional = {}) {
     const cleaned = cleanPrompt(prompt);
     if (!cleaned)
         return '';
@@ -169,12 +126,12 @@ export function deriveConversationTitle({ prompt }, { casing = 'title' } = {}) {
     const firstClause = cleaned.split(/[\n\r。！？!?]/)[0].trim();
     if (!firstClause)
         return '';
-    const title = CJK_PATTERN.test(firstClause) ? trimCjkTitle(firstClause) : trimLatinTitle(firstClause, { casing });
+    const title = CJK_PATTERN.test(firstClause) ? trimCjkTitle(firstClause) : trimLatinTitle(firstClause);
     // 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 truncateTitle(title);
 }
-/** Sentence-case only a known heuristic title using the original prompt's proper names/acronyms.
+/** A known heuristic title is already display-ready: derivation keeps the prompt's own wording.
  * 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.
@@ -183,7 +140,7 @@ export function conversationTitleForDisplay({ title, titleSource, firstPrompt },
     if (!title)
         return title;
     if (titleSource === 'generated' && firstPrompt && title === deriveConversationTitle({ prompt: firstPrompt })) {
-        return deriveConversationTitle({ prompt: firstPrompt }, { casing: 'sentence' });
+        return title;
     }
     return truncateTitle(stripConversationTitleMarkdown({ text: title })) || null;
 }

package/dist/core/question-answer.js

@@ -15,11 +15,11 @@ function selectedAnswerText({ result, input }, _options = {}) {
     const question = record(input);
     const labels = [];
     if (typeof result.choice === 'string')
-        labels.push(optionLabel(question.singleSelect, result.choice));
+        labels.push(optionLabel(question.singleSelect ?? question, result.choice));
     if (Array.isArray(result.selections)) {
         for (const selection of result.selections) {
             if (typeof selection === 'string')
-                labels.push(optionLabel(question.multiSelect, selection));
+                labels.push(optionLabel(question.multiSelect ?? question, selection));
         }
     }
     if (labels.length > 0)

package/dist/core/run-activity.js

@@ -19,6 +19,7 @@
  */
 import { a2uiSurfaceIdOf, displayOnlySurfaceIdOf } from '@jini-ai/agentic/a2ui';
 import { isDelegatedWrapperToolName } from './tool-events.js';
+import { MID_RUN_USER_MESSAGE_EVENT_NAME } from './turn-usage.js';
 /** Tool names whose only job is finding the right tool (MCP tool search / schema lookup). */
 const DISCOVERY_TOOL_NAMES = new Set([
     'ToolSearch',
@@ -88,6 +89,9 @@ function scanStatus({ scan, event, index }, _optional = {}) {
     }
 }
 function scanEvent(scan, event, index) {
+    // Queue acceptance/consumption is user input, not new agent activity. Neither restarts its clock.
+    if (event.kind === 'ext' && event.name === MID_RUN_USER_MESSAGE_EVENT_NAME)
+        return;
     if (isVisible(event)) {
         scan.lastVisible = { index, kind: event.kind };
         scan.visibleCount += 1;

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

@@ -53,7 +53,7 @@ export declare function asString({ value }: {
  * `mcp-ui`/`a2ui` cases (each a one-line unwrap, zero branching — see their own comments below) for
  * a cost that actually came from here.
  */
-/** Keep only numeric usage fields; omit absent fields without changing JSON output. */
+/** Keep numeric usage and the model's stop reason; omit absent or malformed fields. */
 export declare function parseUsageEvent({ payload }: {
     payload: RunAgentPayload;
 }, _options?: Record<string, never>): AgentEvent;

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

@@ -25,7 +25,7 @@ export function asString({ value }, _options = {}) {
  * `mcp-ui`/`a2ui` cases (each a one-line unwrap, zero branching — see their own comments below) for
  * a cost that actually came from here.
  */
-/** Keep only numeric usage fields; omit absent fields without changing JSON output. */
+/** Keep numeric usage and the model's stop reason; omit absent or malformed fields. */
 export function parseUsageEvent({ payload }, _options = {}) {
     const usage = (payload.usage ?? {});
     return {
@@ -36,6 +36,7 @@ export function parseUsageEvent({ payload }, _options = {}) {
         ...(typeof payload.cumulativeCostUsd === "number" ? { cumulativeCostUsd: payload.cumulativeCostUsd } : {}),
         ...(typeof payload.costSessionId === "string" ? { costSessionId: payload.costSessionId } : {}),
         ...(typeof payload.durationMs === "number" ? { durationMs: payload.durationMs } : {}),
+        ...(typeof payload.stopReason === "string" ? { stopReason: payload.stopReason } : {}),
     };
 }
 /**

package/dist/core/turn-usage.js

@@ -5,6 +5,18 @@ export const MID_RUN_USER_MESSAGE_EVENT_NAME = 'user_message';
 export function isReplyBoundary({ event }, _optional = {}) {
     return event.kind === 'ext' && event.name === MID_RUN_USER_MESSAGE_EVENT_NAME;
 }
+/** Queued/consumed receipts update one input, so usage must split that reply only once. */
+function newReplyBoundary({ event, seen }, _options = {}) {
+    if (!isReplyBoundary({ event }))
+        return false;
+    const id = event.data;
+    if (typeof id?.id !== 'string')
+        return true;
+    if (seen.has(id.id))
+        return false;
+    seen.add(id.id);
+    return true;
+}
 /** 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
@@ -13,8 +25,9 @@ export function isReplyBoundary({ event }, _optional = {}) {
 export function replySegments({ events }, _optional = {}) {
     const segments = [[]];
     let started = false;
+    const seen = new Set();
     for (const event of events ?? []) {
-        if (isReplyBoundary({ event })) {
+        if (newReplyBoundary({ event, seen })) {
             segments.push([]);
             started = false;
             continue;
@@ -27,7 +40,7 @@ export function replySegments({ events }, _optional = {}) {
 }
 /** Usage, status and raw lines are bookkeeping; anything else means the reply has produced output. */
 function producesReplyOutput({ event }, _optional = {}) {
-    return event.kind !== 'usage' && event.kind !== 'status' && event.kind !== 'raw';
+    return !['usage', 'status', 'raw'].includes(event.kind) && !isReplyBoundary({ event });
 }
 /** 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
@@ -61,6 +74,8 @@ export function turnUsage({ events }, { sessions = new Map(), agentId = '' } = {
             continue;
         total ??= { kind: 'usage' };
         addReportedCounts({ total, event });
+        if (event.stopReason !== undefined)
+            total.stopReason = event.stopReason;
         const cost = usageCost({ event, agentId, sessions });
         if (cost !== undefined)
             total.costUsd = (total.costUsd ?? 0) + cost;
@@ -80,6 +95,8 @@ function addUsage({ total, usage }, _optional = {}) {
     if (!usage)
         return total;
     const next = { ...(total ?? { kind: 'usage' }) };
+    if (usage.stopReason !== undefined)
+        next.stopReason = usage.stopReason;
     for (const field of ['inputTokens', 'outputTokens', 'durationMs', 'costUsd']) {
         const value = usage[field];
         if (value !== undefined)

package/dist/react/components/Markdown.js

@@ -428,9 +428,9 @@ function renderInline(text) {
         else if (mdLink)
             nodes.push(renderMarkdownLink(mdLink, key++));
         else if (bold)
-            nodes.push(_jsx("strong", { children: bold.slice(2, -2) }, key++));
+            nodes.push(_jsx("strong", { children: renderInline(bold.slice(2, -2)) }, key++));
         else if (italic)
-            nodes.push(_jsx("em", { children: italic.slice(1, -1) }, key++));
+            nodes.push(_jsx("em", { children: renderInline(italic.slice(1, -1)) }, key++));
         else if (link)
             nodes.push(_jsx("a", { href: link, ...NEW_TAB, children: link }, key++));
         // `whole` is `match[0]` — a successful `RegExpExecArray` always has a

package/dist/react/components/McpUiSurfaceCard.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 /**
  * @module components/McpUiSurfaceCard
  *
@@ -120,8 +120,10 @@ function PendingSurfaceMirror({ uri, plan, t }) {
 }
 /** A closed card: the question's title, when the call gave one, and why it is closed. */
 function ClosedSurface({ call, label }) {
-    const title = call?.input?.title;
-    return (_jsx("div", { className: "mcpui-surface-card mcpui-surface-card-closed", role: "status", children: typeof title === 'string' && title.trim() !== '' ? `${title}: ${label}` : label }));
+    const input = call?.input;
+    const title = [input?.title, input?.question, input?.prompt]
+        .find(value => typeof value === 'string' && value.trim() !== '');
+    return (_jsx("div", { className: "mcpui-surface-card mcpui-surface-card-closed", role: "status", children: typeof title === 'string' ? `${title}: ${label}` : label }));
 }
 /** The live card's answer lifecycle: its deadline and delivery notification, using their existing owners. */
 function surfaceInteraction({ resource, answered, onToolCall, onAnswered, onAnswerText, call }, _options = {}) {
@@ -144,16 +146,17 @@ export function McpUiSurfaceCard({ events, sandboxProxyUrl, onToolCall, onOpenLi
     const closed = single === undefined
         ? undefined
         : closedSurfaceLabel({ t, call, runStreaming, documentsForUri: events.length, expired: expiry?.expired === true });
-    const answer = answerText ?? questionAnswerFromResult({ result: call?.result, input: call?.input });
+    const answer = questionAnswerFromResult({ result: call?.result, input: call?.input }) ?? answerText;
     return _jsx(SurfaceCardContent, { resources: resources, single: single, answerRecorded: answerRecorded, answer: answer, closed: closed, call: call, t: t, sandboxProxyUrl: sandboxProxyUrl, toolCall: toolCall, onOpenLink: onOpenLink, maxHeight: maxHeight, expiry: expiry });
 }
 /** Rendering priority stays receipt, answer, closure, then the live documents. */
 function SurfaceCardContent({ resources, single, answerRecorded, answer, closed, call, t, sandboxProxyUrl, toolCall, onOpenLink, maxHeight, expiry }) {
-    // MOVE: The accepted-input receipt owns its bubble; rendering the closed card too duplicates typed answers.
+    // MOVE: The accepted-input receipt owns its bubble; the closed card retains the question's context.
     if (single !== undefined && answerRecorded)
-        return null;
+        return _jsx(ClosedSurface, { call: call, label: answer ?? closed ?? t('Answered') });
     if (single !== undefined && answer !== undefined) {
-        return _jsx(MidRunUserMessage, { events: [{ text: answer === 'Declined' ? t('Declined') : answer }] });
+        const label = answer === 'Declined' ? t('Declined') : answer;
+        return _jsxs(_Fragment, { children: [_jsx(ClosedSurface, { call: call, label: label }), _jsx(MidRunUserMessage, { events: [{ text: label }] })] });
     }
     if (closed !== undefined)
         return _jsx(ClosedSurface, { call: call, label: closed });

package/dist/react/components/MessageList.hooks.js

@@ -6,11 +6,15 @@
  */
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { conversationUsage } from '../../core/turn-usage.js';
+import { projectAcceptedInputEvents } from '../../core/accepted-input.js';
 import { nextStickToBottom, startsNewTurn } from './MessageList.rules.js';
 const prefersReducedMotion = () => typeof window !== 'undefined' && (window.matchMedia?.('(prefers-reduced-motion: reduce)').matches ?? false);
 /** Recompute costs once per immutable transcript snapshot, including saved history on reload. */
 export function useConversationUsage({ messages }, _optional = {}) {
-    return useMemo(() => conversationUsage({ messages }), [messages]);
+    // Usage and rendering must see the same answer boundaries, including receipts rebuilt on reload.
+    return useMemo(() => conversationUsage({ messages: messages.map(message => message.events === undefined ? message : {
+            ...message, events: projectAcceptedInputEvents({ events: message.events }),
+        }) }), [messages]);
 }
 export function useMessageListAutoScroll({ messages, scrollIntent }, { onScrolled, reducedMotion = prefersReducedMotion } = {}) {
     const containerRef = useRef(null);