@jini-ai/chat 0.6.10 → 0.6.12

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'
@@ -218,7 +222,7 @@ function AssistantMessageRow({ message, usageSummary, showUsageTotal, showUsageL
     const renderExtGroup = (group) => {
         const renderer = registry.get({ name: group.name });
         if (!renderer && group.name === MID_RUN_USER_MESSAGE_EXT_EVENT_NAME)
-            return _jsx(MidRunUserMessage, { events: group.events });
+            return _jsx(MidRunUserMessage, { events: group.events, runStreaming: answeredCards.runStreaming }, group.slot);
         if (!renderer)
             return null;
         const answerText = answeredCards.answerText(group.slot);
@@ -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/MidRunUserMessage.d.ts

@@ -7,7 +7,7 @@ export declare function midRunUserMessageSlotKey({ data }: {
     data: unknown;
 }): string | undefined;
 /** The bubble for one mid-run message — the same classes as a sent user message, so it reads as one. */
-export declare function MidRunUserMessage({ events }: Pick<ExtEventRenderProps, 'events'>): import("react").JSX.Element | null;
+export declare function MidRunUserMessage({ events, runStreaming }: Pick<ExtEventRenderProps, 'events'> & Partial<Pick<ExtEventRenderProps, 'runStreaming'>>): import("react").JSX.Element | null;
 /**
  * Registers {@link MidRunUserMessage} against the ext-event registry.
  *

package/dist/react/components/MidRunUserMessage.js

@@ -14,6 +14,7 @@ import { acceptedInputEvent } from '../../core/accepted-input.js';
 import { SentAttachmentButton } from './SentAttachment.js';
 import { AttachmentPreviewModal } from './AttachmentPreviewModal.js';
 import { useAttachmentGallery } from './AttachmentGallery.hooks.js';
+import { useT } from '../hooks/context.js';
 import { MID_RUN_USER_MESSAGE_EVENT_NAME } from '../../core/turn-usage.js';
 import { registerExtEventRenderer } from '../ext-event-renderer-registry.js';
 /** The ext-event name the daemon's mid-run `user_message` run event arrives under. One source with
@@ -28,7 +29,7 @@ export function midRunUserMessageSlotKey({ data }) {
     return field(data, 'id');
 }
 /** The bubble for one mid-run message — the same classes as a sent user message, so it reads as one. */
-export function MidRunUserMessage({ events }) {
+export function MidRunUserMessage({ events, runStreaming = false }) {
     const data = events.at(-1);
     const text = field(data, 'text');
     if (text === undefined)
@@ -36,12 +37,14 @@ export function MidRunUserMessage({ events }) {
     const receipt = acceptedInputEvent({ event: { kind: 'ext', name: MID_RUN_USER_MESSAGE_EVENT_NAME, data } });
     // MOVE: A single live delivery may contain several queued inputs; display their original receipts.
     const inputs = receipt?.data.inputs ?? [{ id: field(data, 'id') ?? 'mid-run', text }];
-    return _jsx(_Fragment, { children: inputs.map(input => _jsx(MidRunInput, { input: input }, input.id)) });
+    // A run that ended without reading the message hands it to the next turn; it is no longer queued here.
+    return _jsx(_Fragment, { children: inputs.map(input => _jsx(MidRunInput, { input: input, queued: runStreaming && (input.deliveryState ?? receipt?.data.deliveryState) === 'queued' }, input.id)) });
 }
-function MidRunInput({ input }) {
+function MidRunInput({ input, queued }) {
+    const t = useT();
     const attachments = input.attachments ?? [];
     const gallery = useAttachmentGallery({ attachments });
-    return (_jsxs("div", { className: "jini-message jini-message-user jini-message-user--mid-run", "data-agent-role": "region", "data-agent-label": "A message from the user, sent while the agent was working", children: [_jsx("div", { className: "jini-message-content", children: input.text }), attachments.length > 0 && _jsx("div", { className: "jini-message-attachments", children: attachments.map(attachment => _jsx(SentAttachmentButton, { attachment: attachment, onOpen: gallery.open }, attachment.path)) }), gallery.opened !== null && _jsx(AttachmentPreviewModal, { attachment: gallery.opened, onClose: gallery.close, navigation: gallery.navigation })] }));
+    return (_jsxs("div", { className: "jini-message jini-message-user jini-message-user--mid-run", "data-agent-role": "region", "data-agent-label": "A message from the user, sent while the agent was working", children: [queued && _jsx("div", { className: "jini-message-user__queued", role: "status", children: t('Queued — read after the current step') }), _jsx("div", { className: "jini-message-content", children: input.text }), attachments.length > 0 && _jsx("div", { className: "jini-message-attachments", children: attachments.map(attachment => _jsx(SentAttachmentButton, { attachment: attachment, onOpen: gallery.open }, attachment.path)) }), gallery.opened !== null && _jsx(AttachmentPreviewModal, { attachment: gallery.opened, onClose: gallery.close, navigation: gallery.navigation })] }));
 }
 /**
  * Registers {@link MidRunUserMessage} against the ext-event registry.
@@ -49,6 +52,6 @@ function MidRunInput({ input }) {
  * @returns An unregister handle, so a test or a hot reload can dispose cleanly.
  */
 export function registerMidRunUserMessageRenderer() {
-    return registerExtEventRenderer({ name: MID_RUN_USER_MESSAGE_EXT_EVENT_NAME, renderer: (props) => _jsx(MidRunUserMessage, { events: props.events }) }, { slotKey: midRunUserMessageSlotKey });
+    return registerExtEventRenderer({ name: MID_RUN_USER_MESSAGE_EXT_EVENT_NAME, renderer: (props) => _jsx(MidRunUserMessage, { events: props.events, runStreaming: props.runStreaming }) }, { slotKey: midRunUserMessageSlotKey });
 }
 //# sourceMappingURL=MidRunUserMessage.js.map

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

@@ -1,5 +1,6 @@
 import { acceptedInputEvent, acceptedInputUserEvent, projectAcceptedInputEvents } from '../../../../core/accepted-input.js';
 import { useUserTextGuard } from '../../../hooks/useUserTextGuard.js';
+import { isAwaitingAnswer } from '../../../../core/run-activity.js';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { appendQueuedTurn, describeChatPaneSendBlocker, findAwaitedTypedAnswerId, findChatPaneSendBlocker, findMidRunMessageRunId, isChatPaneQueueableBlocker, resolveChatPaneSelection, } from '../rules.js';
 import { definedProps } from '../../../util/defined-props.js';
@@ -8,6 +9,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).';
 /**
@@ -79,11 +109,17 @@ function resolveChatPaneActivity(selectedAgent, conversation) {
         return 'streaming';
     return 'ready';
 }
+/** Hold new input until its uploads or human gate settle; the existing queue owns the retry.
+ * @complexity O(e) in the newest message's events, with no I/O.
+ */
+function waitingForLiveInput({ uploadPending, messages }, _options = {}) {
+    return uploadPending || isAwaitingAnswer({ events: messages.at(-1)?.events });
+}
 /**
  * The host delivery and live run a send can go INTO instead of queueing behind, or `null` when the
  * host offers no mid-run delivery or no run can take it ({@link findMidRunMessageRunId}).
  *
- * @complexity O(1).
+ * @complexity O(e) in the newest message's events.
  */
 function findMidRunTarget({ deliver, blocker, attachmentCount, messages }) {
     if (deliver === undefined)
@@ -149,15 +185,11 @@ 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.
-    const queuedForUploadRef = useRef(false);
+    // A send held for uploads or a human card resumes live; a refused delivery waits for run end.
+    const queuedForLiveDeliveryRef = useRef(false);
     const submittedComposerRef = useRef(null);
     const startingPromptRef = useRef(false);
     const [typedAnswerNotice, setTypedAnswerNotice] = useState(null);
@@ -221,6 +253,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 +405,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 +414,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 +538,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 = {}) => {
@@ -541,10 +597,12 @@ export function useChatPane(options) {
         }
         const turn = guard.redact({ text: prompt }, {});
         const uploadPending = activeUploadsRef.current.size > 0 || attachmentError !== null;
-        if (uploadPending)
-            queuedForUploadRef.current = queuedTurn === null || queuedForUploadRef.current;
+        // Retry live delivery after the human gate settles, using the same queue as pending uploads.
+        if (waitingForLiveInput({ uploadPending, messages: conversation.messages })) {
+            queuedForLiveDeliveryRef.current = queuedTurn === null || queuedForLiveDeliveryRef.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 +623,7 @@ export function useChatPane(options) {
         enqueueTurn,
         options.deliverMidRunMessage,
         queuedTurn,
+        queuedInputs,
         sendBlocker,
         sendIntoRunningTurn,
         sendPrompt,
@@ -629,7 +688,7 @@ export function useChatPane(options) {
     }, []);
     const cancelQueued = useCallback(() => {
         submittedComposerRef.current = null;
-        queuedForUploadRef.current = false;
+        queuedForLiveDeliveryRef.current = false;
         queuedConversationIdRef.current = undefined;
         discardQueuedUploads({});
         setQueuedInputs([]);
@@ -643,7 +702,7 @@ export function useChatPane(options) {
     // clear blocker. Clear the slot before awaiting so re-renders cannot send it twice.
     useEffect(() => {
         if (queuedTurn === null) {
-            queuedForUploadRef.current = false;
+            queuedForLiveDeliveryRef.current = false;
             return;
         }
         if (queuedConversationIdRef.current !== options.conversationId) {
@@ -655,13 +714,13 @@ export function useChatPane(options) {
         }
         if (activeUploadCount > 0 || attachmentError !== null)
             return;
-        const target = queuedForUploadRef.current ? findMidRunTarget({
+        const target = queuedForLiveDeliveryRef.current ? findMidRunTarget({
             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;
+        queuedForLiveDeliveryRef.current = false;
         const inputs = queuedInputs;
         const attachments = inputs.flatMap(input => input.attachments);
         setQueuedInputs([]);
@@ -690,7 +749,7 @@ export function useChatPane(options) {
         // `conversation.cancel()` above clears the streaming blocker — the flush effect fires it into
         // the just-reset conversation instead of discarding it like the rest of this turn's state.
         queuedConversationIdRef.current = undefined;
-        queuedForUploadRef.current = false;
+        queuedForLiveDeliveryRef.current = false;
         queuedUploadOwnersRef.current.clear();
         setQueuedInputs([]);
     }, [composer, conversation, options.initialMessages]);
@@ -712,7 +771,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/rules.d.ts

@@ -146,13 +146,16 @@ export declare function isTypedAnswerTurn({ blocker, attachmentCount, messages,
  * turn with a known `runId`.
  * Attachment support is decided by the host's delivery, never by dropping them here.
  *
- * @complexity O(1).
+ * A native live-input transport can reject a pending human gate when given another user turn.
+ * Keep ordinary text in the pane's queue until the card's tool settles; typed question answers
+ * have their own delivery path and never pass this guard.
+ * @complexity O(e) in the newest message's events.
  */
 export declare function findMidRunMessageRunId({ blocker, messages }: {
     blocker: ChatPaneSendBlocker | null;
     attachmentCount: number;
     messages: readonly ChatMessage[];
-}): string | null;
+}, _options?: {}): string | null;
 /**
  * MOVE: Display is per-message; delivery is ONE queued turn. A second message behind the same run
  * is appended to that delivery (a blank line apart) rather than replacing it:

package/dist/react/features/chat-pane/rules.js

@@ -1,6 +1,7 @@
 import { configuredPickerModel, pickerModelOptions, isConcretePickerModel } from './model-options.js';
 import { isTerminalRunStatus } from '../../../core/messages.js';
 import { acceptedInputEvent } from '../../../core/accepted-input.js';
+import { isAwaitingAnswer } from '../../../core/run-activity.js';
 function preferredOptionId(options) {
     return options?.find((option) => option.id === 'default')?.id ?? options?.[0]?.id;
 }
@@ -234,12 +235,17 @@ export function isTypedAnswerTurn({ blocker, attachmentCount, messages, toolName
  * turn with a known `runId`.
  * Attachment support is decided by the host's delivery, never by dropping them here.
  *
- * @complexity O(1).
+ * A native live-input transport can reject a pending human gate when given another user turn.
+ * Keep ordinary text in the pane's queue until the card's tool settles; typed question answers
+ * have their own delivery path and never pass this guard.
+ * @complexity O(e) in the newest message's events.
  */
-export function findMidRunMessageRunId({ blocker, messages }) {
+export function findMidRunMessageRunId({ blocker, messages }, _options = {}) {
     if (!isChatPaneQueueableBlocker({ blocker }))
         return null;
     const last = messages.at(-1);
+    if (isAwaitingAnswer({ events: last?.events }))
+        return null;
     return last?.role === 'assistant' && last.runId ? last.runId : null;
 }
 /**

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;