@jini-ai/chat 0.6.10 → 0.6.11

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 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-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);

package/dist/react/components/MessageRow.js

@@ -2,7 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { projectAcceptedInputEvents } from '../../core/accepted-input.js';
 import { MidRunUserMessage, MID_RUN_USER_MESSAGE_EXT_EVENT_NAME } from './MidRunUserMessage.js';
 import { terminalMessageNotice, continuingRunNotice } from '../../core/durable-projection.js';
-import { usageLayout, usageLineMeetsActions, useMessageUsage, useUsageSummary } from './MessageRow.usage.js';
+import { usageEndLabel, usageLayout, usageLineMeetsActions, useMessageUsage, useUsageSummary } from './MessageRow.usage.js';
 /**
  * @module MessageRow
  *
@@ -111,12 +111,13 @@ function isRunInProgress(runStatus) {
 /** One "Done · 6m 29s · $0.41 · total $2.50" line from reported usage, never estimated (the total is
  * left off when `showTotal` is false). Partial usage stays partial; output tokens are available to
  * assistive technology and in the tooltip. */
-function UsageSummary({ usage, showTotal }) {
+function UsageSummary({ usage, showTotal, message, awaitingAnswer }) {
     const t = useT();
-    const { text, title, ariaLabel } = useUsageSummary({ usage }, { showTotal });
+    const label = usageEndLabel({ usage, ...(message === undefined ? {} : { message }), ...(awaitingAnswer === undefined ? {} : { awaitingAnswer }) });
+    const { text, title, ariaLabel } = useUsageSummary({ usage }, { showTotal, label });
     if (!text)
         return null;
-    return (_jsxs("div", { className: "jini-message-usage", title: title, role: "note", "aria-label": ariaLabel, children: [_jsx("span", { className: "jini-message-usage-dot", "aria-hidden": true, children: "\u25CF" }), t('Done'), " \u00B7 ", text] }));
+    return (_jsxs("div", { className: "jini-message-usage", title: title, role: "note", "aria-label": ariaLabel, children: [label === 'Done' ? _jsx("span", { className: "jini-message-usage-dot", "aria-hidden": true, children: "\u25CF" }) : null, t(label), " \u00B7 ", text] }));
 }
 function messageBlocks({ message, rows, registry, content = message.content }, { toolCallDisplay = 'show', includeThinking = false } = {}) {
     const blocks = interleaveMessageBlocks({ events: message.events, content, rows }, { slotOf: (ev) => registry.slot({ name: ev.name, data: ev.data }), includeThinking });
@@ -150,7 +151,7 @@ function messageAwaitingAnswer({ runStreaming, runInProgress, events }, { isAnsw
 }
 function AssistantMessageFooter({ message, usageEvent, showUsageTotal, terminalNotice, pending, runInProgress, runStreaming, visibleContent, isAnsweredCard }, _optional = {}) {
     const t = useT();
-    return _jsxs(_Fragment, { children: [usageEvent ? _jsx(UsageSummary, { usage: usageEvent, showTotal: showUsageTotal }) : null, terminalNotice ? _jsx("div", { className: "jini-message-error", role: "status", children: t(terminalNotice) }) : null, !pending && !runInProgress ? (_jsx("div", { className: "jini-message-actions jini-message-actions--assistant", children: _jsx(CopyMessageButton, { text: visibleContent, label: t('Copy message') }) })) : null, runInProgress ? _jsx(RunActivityLine, { events: message.events, active: pending || (runStreaming === true && runInProgress), isAnsweredCard: isAnsweredCard }) : null] });
+    return _jsxs(_Fragment, { children: [usageEvent ? _jsx(UsageSummary, { usage: usageEvent, showTotal: showUsageTotal, message: message, awaitingAnswer: isAwaitingAnswer({ events: message.events }, { isAnsweredCard }) }) : null, terminalNotice ? _jsx("div", { className: "jini-message-error", role: "status", children: t(terminalNotice) }) : null, !pending && !runInProgress ? (_jsx("div", { className: "jini-message-actions jini-message-actions--assistant", children: _jsx(CopyMessageButton, { text: visibleContent, label: t('Copy message') }) })) : null, runInProgress ? _jsx(RunActivityLine, { events: message.events, active: pending || (runStreaming === true && runInProgress), isAnsweredCard: isAnsweredCard }) : null] });
 }
 /**
  * Quiet, icon-only copy affordance shared by the user- and assistant-message
@@ -207,8 +208,11 @@ function AssistantMessageRow({ message, usageSummary, showUsageTotal, showUsageL
     const pending = isPendingWithNoContent(message, visibleContent, timeline.rows.length);
     const runInProgress = isRunInProgress(message.runStatus);
     const awaitingAnswer = messageAwaitingAnswer({ runStreaming, runInProgress, events: message.events }, { isAnsweredCard: answeredCards.isAnsweredCard });
-    const usage = usageLayout({ usage: messageUsage, interleaved: blocks !== null, runInProgress }, { runStreaming });
+    const usage = usageLayout({ usage: messageUsage, interleaved: blocks !== null, runInProgress }, {
+        runStreaming: runStreaming && !isTerminalRunStatus({ status: message.runStatus }),
+    });
     const footerUsage = showUsageLine ? usage.footer : undefined;
+    const lastFinishedReply = !runInProgress && !usage.footer ? usage.replies.findLastIndex(value => value !== undefined) : -1;
     const renderToolCard = (row) => (_jsx(ToolCard, { use: row.use, result: row.result, runStreaming: runStreaming, runSucceeded: runSucceeded, ...(projectFileNames !== undefined ? { projectFileNames } : {}), ...(onRequestOpenFile !== undefined ? { onRequestOpenFile } : {}) }, row.id));
     // Hidden mode reuses the same disclosure and card renderer for unrecovered failures.
     const renderTools = (rows, key) => (toolCallDisplay !== 'show'
@@ -251,7 +255,8 @@ function AssistantMessageRow({ message, usageSummary, showUsageTotal, showUsageL
         }
         if (block.kind === 'reply-end') {
             const reply = usage.replies[block.index];
-            return reply && showUsageLine ? _jsx(UsageSummary, { usage: reply, showTotal: showUsageTotal }, block.key) : null;
+            // A trailing input may have no reply: its predecessor's usage belongs above that input.
+            return reply && showUsageLine ? _jsx(UsageSummary, { usage: reply, showTotal: showUsageTotal, ...(block.index === lastFinishedReply ? { message } : {}) }, block.key) : null;
         }
         if (block.kind === 'tools')
             return renderTools(block.rows, block.key);

package/dist/react/components/MessageRow.usage.d.ts

@@ -1,5 +1,12 @@
 import type { ChatMessage } from '../../core/messages.js';
 import { type ChatUsageSummary } from '../../core/turn-usage.js';
+/** A run's terminal state wins over its last model response; interrupted usage never claims success.
+ * Missing lifecycle data keeps the legacy completed label. O(n) in terminal notice events. */
+export declare function usageEndLabel({ usage, message, awaitingAnswer }: {
+    usage: ChatUsageSummary;
+    message?: ChatMessage;
+    awaitingAnswer?: boolean;
+}, _options?: {}): string;
 /** A standalone row has one turn; MessageList supplies the full conversation projection. */
 export declare function useMessageUsage({ message, summary }: {
     message: ChatMessage;
@@ -41,8 +48,9 @@ export declare function usageLineMeetsActions({ footer, terminalNotice, pending,
  * the current turn's cost is unknown. `showTotal: false` turns the total off. */
 export declare function useUsageSummary({ usage }: {
     usage: ChatUsageSummary;
-}, { showTotal }?: {
+}, { showTotal, label }?: {
     showTotal?: boolean;
+    label?: string;
 }): {
     text: string;
     title: string | undefined;

package/dist/react/components/MessageRow.usage.js

@@ -1,7 +1,24 @@
 import { useMemo } from 'react';
+import { terminalMessageNotice } from '../../core/durable-projection.js';
 import { conversationUsage } from '../../core/turn-usage.js';
 import { formatUsageCost } from '../../core/usage-format.js';
-import { useT } from '../hooks/context.js';
+import { useI18n } from '../hooks/context.js';
+/** A run's terminal state wins over its last model response; interrupted usage never claims success.
+ * Missing lifecycle data keeps the legacy completed label. O(n) in terminal notice events. */
+export function usageEndLabel({ usage, message, awaitingAnswer = false }, _options = {}) {
+    const status = message?.runStatus;
+    if (status === 'failed')
+        return 'Failed';
+    if (status === 'canceled') {
+        return /stopped/i.test(terminalMessageNotice({ message: message }) ?? '') ? 'Stopped' : 'Canceled';
+    }
+    if (awaitingAnswer)
+        return 'Waiting for your answer';
+    const reason = usage.stopReason ?? '';
+    if (/error|fail/i.test(reason))
+        return 'Failed';
+    return /abort|interrupt|cancel|max_tokens|max_tool_turns|length|tool_use/i.test(reason) ? 'Interrupted' : 'Done';
+}
 /** A standalone row has one turn; MessageList supplies the full conversation projection. */
 export function useMessageUsage({ message, summary }, _optional = {}) {
     return useMemo(() => summary ?? conversationUsage({ messages: [message] }).get(message.id), [message, summary]);
@@ -31,13 +48,13 @@ export function usageLineMeetsActions({ footer, terminalNotice, pending, runInPr
  * Each line carries the chat's running total as of that reply, "Done · 16s · $0.39 · total $3.95" (owner,
  * 2026-10-10: keep the total, always shown, even on the first turn). Known totals remain visible when
  * the current turn's cost is unknown. `showTotal: false` turns the total off. */
-export function useUsageSummary({ usage }, { showTotal = true } = {}) {
-    const t = useT();
+export function useUsageSummary({ usage }, { showTotal = true, label = 'Done' } = {}) {
+    const { t, locale } = useI18n();
     const parts = [usageDuration({ durationMs: usage.durationMs }), usageCost({ usage }, { showTotal })]
         .filter((part) => part !== undefined);
     const text = parts.join(' · ');
-    const title = usage.outputTokens === undefined ? undefined : t('{n} out', { n: usage.outputTokens });
-    return { text, title, ariaLabel: title === undefined ? undefined : `${t('Done')} · ${text} · ${title}` };
+    const title = usage.outputTokens === undefined ? undefined : t('{n} output tokens', { n: usage.outputTokens.toLocaleString(locale) });
+    return { text, title, ariaLabel: title === undefined ? undefined : `${t(label)} · ${text} · ${title}` };
 }
 function usageDuration({ durationMs }, _options = {}) {
     if (durationMs === undefined)

package/dist/react/components/ToolCallGroup.hooks.d.ts

@@ -3,8 +3,10 @@ export interface ToolCallGroupState {
     /** Whether the turn's tool cards are showing under the line. Starts closed. */
     open: boolean;
     toggle: () => void;
-    /** "Used 3 tools", "Used 3 tools · 1 failed", or "Running Bash…" while a tool runs. */
+    /** "Used 3 tools", or "Running Bash…" while a tool runs. */
     label: string;
+    /** The failure suffix, styled independently of the tool count. */
+    failureLabel: string | undefined;
     running: boolean;
     failed: boolean;
 }

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

@@ -15,7 +15,8 @@ export function useToolCallGroup({ rows }, _optional = {}) {
     return {
         open,
         toggle,
-        label: toolGroupLabel({ summary, t }),
+        label: toolGroupLabel({ summary: summary.kind === 'done' ? { ...summary, failed: 0 } : summary, t }),
+        failureLabel: summary.kind === 'done' && summary.failed > 0 ? t('{count} failed', { count: summary.failed }) : undefined,
         running: summary.kind === 'running',
         failed: summary.kind === 'done' && summary.failed > 0,
     };

package/dist/react/components/ToolCallGroup.js

@@ -10,6 +10,6 @@ import { Icon } from './Icon.js';
 export function ToolCallGroup({ rows, renderRow, failureOnly = false }) {
     const group = useToolCallGroup({ rows });
     const t = useT();
-    return (_jsxs("div", { className: "jini-tool-group", "data-failed": group.failed ? 'true' : undefined, children: [failureOnly ? _jsxs("span", { className: "jini-tool-group__label", children: [t('A step failed'), " "] }) : null, _jsxs("button", { type: "button", className: "jini-tool-group__toggle", "aria-expanded": group.open, onClick: group.toggle, children: [_jsx("span", { className: `jini-tool-group__label${group.running ? ' shimmer-text' : ''}`, children: failureOnly ? t('Show') : group.label }), _jsx(Icon, { name: group.open ? 'chevron-down' : 'chevron-right', size: 12 })] }), group.open ? _jsx("div", { className: "jini-message-tools", children: rows.map(renderRow) }) : null] }));
+    return (_jsxs("div", { className: "jini-tool-group", "data-failed": group.failed ? 'true' : undefined, children: [failureOnly ? _jsxs("span", { className: "jini-tool-group__label", children: [t('A step failed'), " "] }) : null, _jsxs("button", { type: "button", className: "jini-tool-group__toggle", "aria-expanded": group.open, onClick: group.toggle, children: [_jsx("span", { className: `jini-tool-group__label${group.running ? ' shimmer-text' : ''}`, children: failureOnly ? t('Show') : group.label }), !failureOnly && group.failureLabel ? _jsxs("span", { className: "jini-tool-group__failed", children: [" \u00B7 ", group.failureLabel] }) : null, _jsx(Icon, { name: group.open ? 'chevron-down' : 'chevron-right', size: 12 })] }), group.open ? _jsx("div", { className: "jini-message-tools", children: rows.map(renderRow) }) : null] }));
 }
 //# sourceMappingURL=ToolCallGroup.js.map

package/dist/react/features/chat-pane/create-mid-run-message-poster.d.ts

@@ -15,11 +15,11 @@
  *
  * ## Why it resolves an outcome instead of throwing
  *
- * The pane acts differently on each outcome and must never drop the text: `'unsupported'` stops the
- * run for text-only turns, or queues an attachment turn intact; `'not-running'` queues behind the
+ * The pane acts differently on each outcome and must never drop the text: `'unsupported'` queues
+ * the whole turn; `'not-running'` queues behind the
  * ending run; `'failed'` retains the draft for retry. A 404 means
  * the daemon never saw this run (a host-side run such as a BYOK API turn), so it is `'unsupported'`
- * too: no live process to steer, but an interrupt still works.
+ * too: no live process to steer. Accepted inputs retain their fallback copy until consumed.
  */
 import { type UserTextRedactionOptions } from '../../../core/user-text-redaction.js';
 import type { DeliverMidRunMessage } from './types.js';

package/dist/react/features/chat-pane/create-mid-run-message-poster.js

@@ -15,11 +15,11 @@
  *
  * ## Why it resolves an outcome instead of throwing
  *
- * The pane acts differently on each outcome and must never drop the text: `'unsupported'` stops the
- * run for text-only turns, or queues an attachment turn intact; `'not-running'` queues behind the
+ * The pane acts differently on each outcome and must never drop the text: `'unsupported'` queues
+ * the whole turn; `'not-running'` queues behind the
  * ending run; `'failed'` retains the draft for retry. A 404 means
  * the daemon never saw this run (a host-side run such as a BYOK API turn), so it is `'unsupported'`
- * too: no live process to steer, but an interrupt still works.
+ * too: no live process to steer. Accepted inputs retain their fallback copy until consumed.
  */
 import { redactUserText } from '../../../core/user-text-redaction.js';
 const DEFAULT_TIMEOUT_MS = 30_000;
@@ -31,8 +31,11 @@ async function conflictDelivery(response) {
 }
 /** Maps the route's response onto an outcome. Only 202 is a delivery. */
 async function deliveryFor(response) {
-    if (response.status === 202)
-        return 'delivered';
+    if (response.status === 202) {
+        const body = await response.json().catch(() => null);
+        const id = body?.id;
+        return typeof id === 'string' && id.length > 0 ? { delivery: 'delivered', id } : 'delivered';
+    }
     if (response.status === 409)
         return conflictDelivery(response);
     return response.status === 404 ? 'unsupported' : 'failed';

package/dist/react/features/chat-pane/hooks/useChatPane.hooks.js

@@ -8,6 +8,35 @@ import { readCachedAttachmentBatchId, writeCachedAttachmentBatchId, } from '../.
 import { useComposer } from '../../../hooks/useComposer.js';
 import { useConversation, } from '../../../hooks/useConversation.js';
 import { useChatPaneWorkingDirectory, } from './useChatPaneWorkingDirectory.hooks.js';
+/** Filter during render so a consumed receipt followed by end in the same batch cannot flush twice.
+ * Legacy host receipts can replace optimistic IDs; the accepted-input owner retains their aliases.
+ * @complexity O(e + q) time and space for receipt events and locally queued inputs.
+ */
+function unconsumedQueuedInputs({ inputs, messages }) {
+    const consumed = new Set();
+    for (const message of messages) {
+        for (const event of projectAcceptedInputEvents({ events: message.events ?? [] })) {
+            const receipt = acceptedInputEvent({ event });
+            if (receipt?.data.deliveryState !== 'consumed')
+                continue;
+            for (const input of [receipt.data, ...(receipt.data.inputs ?? [])]) {
+                consumed.add(input.id);
+                for (const alias of input.aliases ?? [])
+                    consumed.add(alias);
+            }
+        }
+    }
+    return inputs.filter(input => !consumed.has(input.liveMessageId ?? input.id));
+}
+/** The conversation copies run events onto its messages one effect after streaming stops, so a
+ * consumed receipt can still be missing from the transcript when the send blocker clears. A
+ * live-accepted copy therefore waits until the run's own message reaches a terminal status. */
+function awaitingRunReceipts({ inputs, messages }) {
+    if (!inputs.some(input => input.liveMessageId !== undefined))
+        return false;
+    const status = messages.at(-1)?.runStatus;
+    return status === 'queued' || status === 'running';
+}
 /** The stand-in prompt for a turn that carries only attachments. */
 const ATTACHMENTS_ONLY_PROMPT = 'Review the attached file(s).';
 /**
@@ -149,11 +178,7 @@ export function useChatPane(options) {
     const [activeUploadCount, setActiveUploadCount] = useState(0);
     const [attachmentError, setAttachmentError] = useState(null);
     // MOVE: Keep the signal with each sanitized input; re-redaction cannot detect the original paste.
-    const [queuedInputs, setQueuedInputs] = useState([]);
-    const queuedTurn = useMemo(() => queuedInputs.reduce((queued, input) => appendQueuedTurn({
-        queued, next: { text: input.text, secretRedacted: input.secretRedaction?.secretRedacted ?? false,
-            count: input.secretRedaction?.count ?? 0 },
-    }), null), [queuedInputs]);
+    const [storedQueuedInputs, setQueuedInputs] = useState([]);
     // MOVE: Uploads belong to the input that submitted them, even if a later message is queued first.
     const queuedUploadOwnersRef = useRef(new Map());
     // A send during upload resumes once pixels arrive; a rejected live delivery waits for run end.
@@ -221,6 +246,16 @@ export function useChatPane(options) {
             validateAttachments: options.validateAttachments,
         } }));
     const activity = resolveChatPaneActivity(selectedAgent, conversation);
+    const queuedInputs = useMemo(() => unconsumedQueuedInputs({ inputs: storedQueuedInputs, messages: conversation.messages }), [storedQueuedInputs, conversation.messages]);
+    const queuedTurn = useMemo(() => queuedInputs.reduce((queued, input) => appendQueuedTurn({
+        queued, next: { text: input.text, secretRedacted: input.secretRedaction?.secretRedacted ?? false,
+            count: input.secretRedaction?.count ?? 0 },
+    }), null), [queuedInputs]);
+    // Release consumed text/files locally as well as hiding them; next-turn fallback uses this same projection.
+    useEffect(() => {
+        if (queuedInputs.length !== storedQueuedInputs.length)
+            setQueuedInputs(queuedInputs);
+    }, [queuedInputs, storedQueuedInputs.length]);
     useEffect(() => {
         options.onActivityChange?.(activity);
     }, [activity, options.onActivityChange]);
@@ -363,7 +398,7 @@ export function useChatPane(options) {
         }
     }, [composer, options.conversationId, options.uploadAttachments]);
     /** Acceptance is the only writer of local recall and optimistic in-run bubbles. */
-    const recordAcceptedInput = useCallback(({ inputs, bubble }, _options = {}) => {
+    const recordAcceptedInput = useCallback(({ inputs, bubble }, { receipt = 'optimistic' } = {}) => {
         composer.history?.record({ inputs });
         submittedComposerRef.current = composer;
         if (bubble === undefined)
@@ -372,8 +407,9 @@ export function useChatPane(options) {
             const last = messages.at(-1);
             if (last?.role !== 'assistant')
                 return messages;
-            const event = acceptedInputUserEvent({ input: { id: inputs[0].id, text: bubble.text },
-                inputs, ...bubble });
+            const event = acceptedInputUserEvent({ input: { id: inputs[0].id, text: bubble.text,
+                    ...(inputs[0].deliveryState ? { deliveryState: inputs[0].deliveryState } : {}) },
+                inputs, ...bubble }, { receipt });
             return [...messages.slice(0, -1), { ...last,
                     events: projectAcceptedInputEvents({ events: [...(last.events ?? []), event] }) }];
         });
@@ -495,24 +531,37 @@ export function useChatPane(options) {
         if (inputs === undefined && latestDraftRef.current === submittedDraft)
             latestComposerRef.current.setDraft('');
     }, []);
+    /** HTTP acceptance retains fallback ownership; only an actual consumption receipt removes it. */
+    const retainAcceptedMidRunInput = useCallback(({ outcome, inputs, turn, attachments, afterInputId }, _options = {}) => {
+        const accepted = inputs ?? [{ id: createChatLocalId({}), text: turn.text, attachments,
+                ...(turn.secretRedacted ? { secretRedaction: { secretRedacted: true, count: turn.count } } : {}) }];
+        const id = typeof outcome === 'object' ? outcome.id : accepted[0].id;
+        // A known HTTP id is already authoritative. Do not let equal text reconcile an unrelated
+        // wire receipt into this bubble; legacy hosts alone still need optimistic reconciliation.
+        const retained = accepted.map((input, index) => ({ ...input,
+            ...(index === 0 ? { id, aliases: [...(input.aliases ?? []), input.id] } : {}),
+            liveMessageId: id, deliveryState: 'queued',
+        }));
+        queuedConversationIdRef.current = options.conversationId;
+        setQueuedInputs(queued => [...queued, ...retained]);
+        recordAcceptedInput({ inputs: retained,
+            bubble: { text: turn.text, ...(afterInputId === undefined ? {} : { afterInputId }) } }, typeof outcome === 'object' ? { receipt: 'accepted' } : {});
+    }, [options.conversationId, recordAcceptedInput]);
     const finishMidRunSend = useCallback(({ outcome, inputs, turn, attachments, afterInputId, submittedDraft }, _options = {}) => {
         if (outcome === 'failed') {
             restoreQueuedDraft({ inputs, text: turn.text, attachments });
             setTypedAnswerNotice('failed');
             return;
         }
-        if (outcome === 'delivered') {
-            recordAcceptedInput({ inputs: inputs ?? [{ id: createChatLocalId({}), text: turn.text }],
-                bubble: { text: turn.text, ...(afterInputId === undefined ? {} : { afterInputId }) } });
+        if (outcome === 'delivered' || typeof outcome === 'object') {
+            retainAcceptedMidRunInput({ outcome, inputs, turn, attachments, afterInputId });
             clearDeliveredDraft({ inputs, submittedDraft });
             consumeDeliveredAttachments({ attachments });
             return;
         }
         enqueueTurn({ turn, attachments, ...(inputs === undefined ? {} : { inputs }) });
         clearDeliveredDraft({ inputs, submittedDraft });
-        if (outcome === 'unsupported' && attachments.length === 0)
-            conversation.cancel();
-    }, [conversation.cancel, enqueueTurn, recordAcceptedInput, clearDeliveredDraft, consumeDeliveredAttachments, restoreQueuedDraft]);
+    }, [enqueueTurn, retainAcceptedMidRunInput, clearDeliveredDraft, consumeDeliveredAttachments, restoreQueuedDraft]);
     // A delivered steer belongs to the existing run; unsupported turns use the same accepted queue.
     // A failed delivery keeps the working draft so retry cannot silently become another run.
     const sendIntoRunningTurn = useCallback(async ({ deliver, runId, turn, inputs, attachments = composer.attachments }, _options = {}) => {
@@ -544,7 +593,7 @@ export function useChatPane(options) {
         if (uploadPending)
             queuedForUploadRef.current = queuedTurn === null || queuedForUploadRef.current;
         // MOVE: The existing queue owns its files; a later steer must join it to preserve send order.
-        const target = uploadPending || queuedTurn !== null ? null : findMidRunTarget({
+        const target = uploadPending || queuedInputs.some(input => input.liveMessageId === undefined) ? null : findMidRunTarget({
             deliver: options.deliverMidRunMessage,
             blocker: sendBlocker,
             attachmentCount: composer.attachments.length,
@@ -565,6 +614,7 @@ export function useChatPane(options) {
         enqueueTurn,
         options.deliverMidRunMessage,
         queuedTurn,
+        queuedInputs,
         sendBlocker,
         sendIntoRunningTurn,
         sendPrompt,
@@ -659,7 +709,7 @@ export function useChatPane(options) {
             deliver: options.deliverMidRunMessage,
             blocker: sendBlocker, attachmentCount: queuedInputs.flatMap(input => input.attachments).length, messages: conversation.messages,
         }) : null;
-        if (sendBlocker !== null && target === null)
+        if (target === null && (sendBlocker !== null || awaitingRunReceipts({ inputs: queuedInputs, messages: conversation.messages })))
             return;
         queuedForUploadRef.current = false;
         const inputs = queuedInputs;
@@ -712,7 +762,9 @@ export function useChatPane(options) {
         send,
         sendPrompt,
         queuedPrompt: queuedTurn?.text ?? null,
-        queuedMessages: queuedInputs,
+        // Accepted live messages already have queued bubbles in the transcript. Their private fallback
+        // copy must not create a second composer row whose Cancel button cannot revoke daemon input.
+        queuedMessages: queuedInputs.filter(input => input.liveMessageId === undefined),
         cancelQueuedMessage,
         cancelQueued,
         typedAnswerNotice,

package/dist/react/features/chat-pane/types.d.ts

@@ -176,11 +176,16 @@ export type DeliverTypedAnswer = ((input: {
 };
 /**
  * What happened to a message sent while a run streams (see {@link ChatPaneProps.deliverMidRunMessage}):
- * `'delivered'` — the live agent took it into the running turn; `'unsupported'` — this agent cannot
+ * `{delivery:'delivered', id}` — accepted by the live agent; keep the local copy until an id-matched
+ * consumed event. Legacy hosts may still return `'delivered'`; their receipts reconcile optimistic ids.
+ * `'unsupported'` — this agent cannot
  * take input mid-run (it reads one prompt per turn); `'not-running'` — the run has no live process
  * any more (it is ending); `'failed'` — the host could not tell (network error, unexpected status).
  */
-export type MidRunMessageDelivery = 'delivered' | 'unsupported' | 'not-running' | 'failed';
+export type MidRunMessageDelivery = 'delivered' | 'unsupported' | 'not-running' | 'failed' | {
+    readonly delivery: 'delivered';
+    readonly id: string;
+};
 /** Delivers a complete turn to the live agent; unsupported attachments must reject the whole turn. */
 export type DeliverMidRunMessage = (input: {
     runId: string;

package/dist/server/durable-runs/recover.js

@@ -17,22 +17,29 @@ function lastIndexWhere({ events, match }, _optional = {}) {
             return index;
     return -1;
 }
-/** One saved event's contribution to the executor diagnostics. */
-function diagnosticLines({ event }, _optional = {}) {
-    if (event.kind === "status")
-        return [event.label, event.detail ?? ""];
-    if (event.kind !== "raw")
-        return [];
+/** One complete stdout line's contribution to executor diagnostics. */
+function diagnosticLine({ line }, _optional = {}) {
     try {
-        const result = JSON.parse(event.line);
+        const result = JSON.parse(line);
         // Successful CLI summaries contain usage metadata and answer prose, not failure evidence.
         if (result?.type === "result" && result.is_error === false)
             return [];
+        // A subagent report can discuss billing/auth in completed work; it is not executor evidence.
+        if (result?.type === "system" && result.subtype === "task_notification")
+            return [];
     }
     catch {
         // Non-JSON stdout can still contain the executor's failure reason.
     }
-    return [event.line];
+    return [line];
+}
+/** A saved raw event may hold several JSONL lines; filter each before failure classification. */
+function diagnosticLines({ event }, _optional = {}) {
+    if (event.kind === "status")
+        return [event.label, event.detail ?? ""];
+    if (event.kind !== "raw")
+        return [];
+    return event.line.split(/\r?\n/).flatMap(line => diagnosticLine({ line }));
 }
 /** Retryability is independent of session resumability. Inspect executor diagnostics, never
  * answer text or tool results: those can quote unrelated failures from completed work. Old
@@ -118,8 +125,8 @@ function savedWork({ run }, _optional = {}) {
     return saved;
 }
 /** A dead attempt continues now; a fresh queued one waits (see the caller's comment). */
-function continuesNow({ run, probe, trigger, now }, _optional = {}) {
-    return probe === "dead" && (trigger === "attempt-failed" || now - run.attemptStartedAt >= 10_000);
+function continuesNow({ run, trigger, now }, _optional = {}) {
+    return trigger === "attempt-failed" || now - run.attemptStartedAt >= 10_000;
 }
 /** Recovery coordinator behind explicit host ports. One CAS owns both the attempt and its conversation slot.
  * Each recovery decision logs one `logger.info` line (default console) of run metadata. */
@@ -193,37 +200,66 @@ export function createDurableRecovery(ports, { logger = console } = {}) {
         if (exclusion(run))
             return { decision: await finalize(run, STOPPED_NOTICE, { canceled: true }) };
         const probe = await probeAttempt({ run, trigger, liveRunId });
+        // HTTP/storage awaits can cross cancellation, settlement, or an attempt-generation change.
+        // Re-read before attaching or applying diagnostics to the probed attempt.
+        const current = await reload(run);
+        if (typeof current === "string")
+            return { probe, decision: current };
         if (probe === "live")
-            return { probe, decision: await reattach(run) };
+            return { probe, decision: await reattach(current) };
+        if (probe === "uncertain") {
+            // Transport uncertainty is not proof of death and spends no restart/time budget. The
+            // existing watcher waits and probes again; even an expired budget cannot kill a live child.
+            await reattach(current);
+            return { probe, decision: "waiting" };
+        }
+        return decideDead(current, trigger);
+    }
+    async function decideDead(run, trigger) {
+        const probe = "dead";
         // A pending human answer takes precedence over executor exit diagnostics.
-        if (probe === "dead" && awaitingAnswer({ run }))
-            return { probe, decision: await resolveMissing(run, probe, trigger) };
+        if (awaitingAnswer({ run }))
+            return { probe, decision: await resolveMissing(run, trigger) };
         // Diagnostics decide only the fate of an attempt that is no longer running. Read before the
         // probe, raw stdout quoting a tool description ("OAuth-authenticated") canceled a live turn
         // as "Not logged in" (luvira, 2026-10-08).
         const diagnostics = attemptDiagnostics({ run });
         const failure = attemptFailure({ diagnostics });
-        const decision = failure === "retryable" ? await resolveMissing(run, probe, trigger) : await finalizeFailure({ run, failure, diagnostics });
+        const decision = failure === "retryable" ? await resolveMissing(run, trigger) : await finalizeFailure({ run, failure, diagnostics });
         return { probe, failure, decision };
     }
-    async function resolveMissing(run, probe, trigger) {
+    async function resolveMissing(run, trigger) {
         await ports.store.recoveryClock({ runId: run.runId, now: ports.now(), active: true }, {});
-        const timed = await ports.store.load({ messageId: run.messageId }, {}) ?? run;
+        const timed = await reload(run);
+        return typeof timed === "string" ? timed : resolveDead(timed, trigger);
+    }
+    /** The saved row after an await, or the outcome that ends this decision. O(1) store reads. */
+    async function reload(run) {
+        const current = await ports.store.load({ messageId: run.messageId }, {});
+        if (!current)
+            return "gone";
         // A probe only speaks about the generation it inspected. Never apply its dead result to
         // a newer attempt committed by another caller while this one was awaiting storage/HTTP.
-        if (timed.runId !== run.runId)
+        if (current.runId !== run.runId)
             return "superseded";
+        if (current.message.runStatus !== "queued" && current.message.runStatus !== "running")
+            return "terminal";
+        if (exclusion(current))
+            return finalize(current, STOPPED_NOTICE, { canceled: true });
+        return current;
+    }
+    async function resolveDead(run, trigger) {
         // A dead process cannot resume its question. End this turn with the existing card intact,
         // rather than minting an attempt that runs preflight and asks the same question again.
-        if (probe === "dead" && awaitingAnswer({ run: timed }))
-            return finalize(timed, AWAITING_ANSWER_NOTICE);
-        const notice = budgetNotice(timed, ports.now());
+        if (awaitingAnswer({ run }))
+            return finalize(run, AWAITING_ANSWER_NOTICE);
+        const notice = budgetNotice(run, ports.now());
         if (notice)
-            return finalize(run, notice, { detail: notice === EXHAUSTED_NOTICE ? exhaustedDetail({ run: timed }) : undefined });
+            return finalize(run, notice, { detail: notice === EXHAUSTED_NOTICE ? exhaustedDetail({ run }) : undefined });
         // A queued attempt may be between durable acceptance and the daemon's start transaction.
         // Give that idempotent launch time to appear before a 404 can advance its generation.
-        if (continuesNow({ run, probe, trigger, now: ports.now() }))
-            return continueDead(timed);
+        if (continuesNow({ run, trigger, now: ports.now() }))
+            return continueDead(run);
         ports.attach(run, {});
         return "waiting";
     }

package/dist/store/sql/store.d.ts

@@ -28,8 +28,8 @@ export declare function toMessage(row: MessageRow): ChatMessage;
  * @param scope the isolation predicate, resolved from the host's authentication. For a guest,
  *   `ownerId` must already be a hash of the session key (`tenant-scope.ts`).
  * @param optional Optional core Clock for deterministic host/tests; defaults to system wall time.
- * @complexity each method is one to four indexed statements; `list` is O(owned conversations),
- *   `messages` O(messages in the conversation).
+ * @complexity each method is one to four indexed statements; conversation summaries scan their
+ *   messages and embedded events in SQL; `messages` is O(messages in the conversation).
  */
 export declare function createSqlChatStore<DB extends ChatDatabase>({ kernel, scope: inputScope }: {
     kernel: StorageKernel<DB>;

package/dist/store/sql/store.js

@@ -13,6 +13,7 @@ import { sql } from 'kysely';
 import { createSystemClock } from '@jini-ai/core/primitives';
 import { isUniqueViolation } from '@jini-ai/db/kernel';
 import { redactUserMessage } from '../../core/user-text-redaction.js';
+import { MID_RUN_USER_MESSAGE_EVENT_NAME } from '../../core/turn-usage.js';
 import { ChatStoreError } from '../errors.js';
 import { copyScope, atStoreBoundary, runChatQuery } from './boundary.js';
 import { pageLimit, decodeCursor, encodeCursor } from './cursor.js';
@@ -113,8 +114,8 @@ function toHistoryMessage(row, { includeToolEvents }) {
  * @param scope the isolation predicate, resolved from the host's authentication. For a guest,
  *   `ownerId` must already be a hash of the session key (`tenant-scope.ts`).
  * @param optional Optional core Clock for deterministic host/tests; defaults to system wall time.
- * @complexity each method is one to four indexed statements; `list` is O(owned conversations),
- *   `messages` O(messages in the conversation).
+ * @complexity each method is one to four indexed statements; conversation summaries scan their
+ *   messages and embedded events in SQL; `messages` is O(messages in the conversation).
  */
 export function createSqlChatStore({ kernel, scope: inputScope }, { clock = createSystemClock(), ...redactionOptions } = {}) {
     const scope = copyScope({ scope: inputScope });
@@ -122,6 +123,13 @@ export function createSqlChatStore({ kernel, scope: inputScope }, { clock = crea
     // The single subset boundary: DB must contain both required table definitions. Extra host tables
     // stay on the exact borrowed kernel; its transaction context is never projected or recreated.
     const run = (body) => runChatQuery({ kernel: kernel, body: body });
+    // Count embedded user messages in SQL: list/get still return summaries, never whole transcripts.
+    // Writers store `JSON.stringify` output (no whitespace, as appendedEventsJson also relies on), so
+    // each mid-run event holds this exact text once; text inside a JSON string has escaped quotes and
+    // cannot match, and invalid JSON stays readable (it counts what it holds, never throws). Plain
+    // length/replace run on SQLite and PostgreSQL 14+, unlike `IS JSON` (PostgreSQL 16+).
+    const needle = `"name":"${MID_RUN_USER_MESSAGE_EVENT_NAME}"`;
+    const midRunCount = sql `((length(coalesce(m.events_json, '')) - length(replace(coalesce(m.events_json, ''), ${sql.lit(needle)}, ''))) / ${sql.lit(needle.length)})`;
     /** This scope's conversations, projected as {@link ConversationRow}s with their message count. */
     function ownedConversations(db) {
         return db
@@ -135,7 +143,7 @@ export function createSqlChatStore({ kernel, scope: inputScope }, { clock = crea
             "c.expires_at",
             eb
                 .selectFrom("ai_chat_messages as m")
-                .select((sb) => sb.fn.countAll().as("n"))
+                .select(sql `coalesce(sum(1 + case when m.role = 'assistant' then ${midRunCount} else 0 end), 0)`.as("n"))
                 .whereRef("m.conversation_id", "=", "c.id")
                 .as("message_count"),
         ])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/chat",
-  "version": "0.6.10",
+  "version": "0.6.11",
   "description": "Jini's chat/artifact frontend, consolidated into one package with two subpaths: framework-free chat vocabulary and pure parsers in `/core`, headless hooks + presentational components + slots in `/react`. Import only the layer you need.",
   "license": "Apache-2.0",
   "repository": {
@@ -196,7 +196,7 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@jini-ai/core": "^0.6.10"
+    "@jini-ai/core": "^0.6.11"
   },
   "peerDependencies": {
     "react": "^18.3.0 || ^19.0.0",
@@ -303,13 +303,13 @@
     "pg": "8.23.0",
     "@ag-ui/core": "0.0.58",
     "fast-check": "4.3.0",
-    "@jini-ai/agentic": "^0.6.10",
-    "@jini-ai/db": "0.6.10",
-    "@jini-ai/agent-runtime": "0.6.10",
-    "@jini-ai/ui": "^0.6.10",
-    "@jini-ai/core": "^0.6.10",
-    "@jini-ai/diagnostics": "^0.6.10",
-    "@jini-ai/protocol": "^0.6.10"
+    "@jini-ai/db": "0.6.11",
+    "@jini-ai/agent-runtime": "0.6.11",
+    "@jini-ai/protocol": "^0.6.11",
+    "@jini-ai/core": "^0.6.11",
+    "@jini-ai/diagnostics": "^0.6.11",
+    "@jini-ai/ui": "^0.6.11",
+    "@jini-ai/agentic": "^0.6.11"
   },
   "typesVersions": {
     "*": {