@jini-ai/chat 0.6.6 → 0.6.7

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

@@ -1,12 +1,15 @@
+import { acceptedInputEvent, acceptedInputUserEvent, projectAcceptedInputEvents } from '../../../../core/accepted-input.js';
 import { useUserTextGuard } from '../../../hooks/useUserTextGuard.js';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { appendQueuedTurn, describeChatPaneSendBlocker, findAwaitedTypedAnswerId, findChatPaneSendBlocker, findMidRunMessageRunId, isChatPaneQueueableBlocker, isTypedAnswerTurn, resolveChatPaneSelection, } from '../rules.js';
+import { appendQueuedTurn, describeChatPaneSendBlocker, findAwaitedTypedAnswerId, findChatPaneSendBlocker, findMidRunMessageRunId, isChatPaneQueueableBlocker, resolveChatPaneSelection, } from '../rules.js';
 import { definedProps } from '../../../util/defined-props.js';
 import { cacheAttachmentPreviewSource } from '../../../hooks/attachment-preview-cache.js';
 import { readCachedAttachmentBatchId, writeCachedAttachmentBatchId, } from '../../../hooks/composer-draft-cache.js';
 import { useComposer } from '../../../hooks/useComposer.js';
 import { useConversation, } from '../../../hooks/useConversation.js';
 import { useChatPaneWorkingDirectory, } from './useChatPaneWorkingDirectory.hooks.js';
+/** The stand-in prompt for a turn that carries only attachments. */
+const ATTACHMENTS_ONLY_PROMPT = 'Review the attached file(s).';
 /**
  * The prompt a composer-driven send would carry: the trimmed draft, or a stand-in when only
  * attachments are staged. Module scope so `send()` and `interruptSend()` cannot drift apart on
@@ -14,9 +17,26 @@ import { useChatPaneWorkingDirectory, } from './useChatPaneWorkingDirectory.hook
  */
 function composerPrompt(composer) {
     return composer.draft.trim()
-        || (composer.attachments.length > 0 ? 'Review the attached file(s).' : '');
+        || (composer.attachments.length > 0 ? ATTACHMENTS_ONLY_PROMPT : '');
 }
-function createAttachmentBatchId() {
+/** History hydration can replace a controller without an edit. Compare the accepted empty draft
+ * and staged files so holding Enter cannot requeue an attachment-only submission on that render. */
+function isRepeatedComposerSubmission({ composer, submitted }, _options = {}) {
+    return submitted === composer || (submitted !== null && composer.draft.trim() === '' && submitted.attachments === composer.attachments);
+}
+function composerDeliveryBlocked({ delivering, starting, composer, submitted }, _options = {}) {
+    return delivering || starting || isRepeatedComposerSubmission({ composer, submitted });
+}
+function resolveRunContext({ context, input }, _options = {}) {
+    return typeof context === 'function' ? context(input) : context;
+}
+function assertPromptSendable({ trimmed, sendBlocker }, _options = {}) {
+    if (!trimmed)
+        throw new Error('cannot send: the prompt is empty');
+    if (sendBlocker !== null)
+        throw new Error(`cannot send: ${describeChatPaneSendBlocker(sendBlocker)}`);
+}
+function createChatLocalId(_required, _options = {}) {
     return globalThis.crypto?.randomUUID?.()
         ?? `chat-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
 }
@@ -35,14 +55,14 @@ async function deliverTypedAnswerSafely({ deliver, text }) {
     }
 }
 /**
- * Hands one mid-run message to the host. A throw counts as `'failed'`, which queues the text — the
- * host could not say whether the run took it, and a message must never be dropped.
+ * Hands one mid-run message to the host. A throw counts as `'failed'`: retain the draft because
+ * the host could not establish delivery, rather than starting another run on a network failure.
  *
  * @complexity O(1) plus the host's own request.
  */
-async function deliverMidRunMessageSafely({ deliver, runId, text }) {
+async function deliverMidRunMessageSafely({ deliver, ...input }) {
     try {
-        return await deliver({ runId, text });
+        return await deliver(input);
     }
     catch {
         return 'failed';
@@ -59,6 +79,43 @@ function resolveChatPaneActivity(selectedAgent, conversation) {
         return 'streaming';
     return 'ready';
 }
+/**
+ * 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).
+ */
+function findMidRunTarget({ deliver, blocker, attachmentCount, messages }) {
+    if (deliver === undefined)
+        return null;
+    const runId = findMidRunMessageRunId({ blocker, attachmentCount, messages });
+    return runId === null ? null : { deliver, runId };
+}
+/**
+ * The host's typed-answer delivery and the id of the question it answers when this send answers
+ * the question the run is waiting on, else `null`. The same test as `isTypedAnswerTurn` in
+ * `rules.ts`, unfolded so the awaited question's id comes back with the deliverer — a typed answer
+ * therefore always carries the id of the question it answers.
+ *
+ * @complexity O(m) over the messages scanned for the open question.
+ */
+function findTypedAnswerTarget({ deliver, blocker, attachmentCount, messages }) {
+    if (deliver === undefined || !isChatPaneQueueableBlocker({ blocker }) || attachmentCount !== 0)
+        return null;
+    const questionId = findAwaitedTypedAnswerId({ messages, toolName: deliver.toolName });
+    return questionId === null ? null : { deliver, questionId };
+}
+/**
+ * Whether a delivered mid-run turn took every staged attachment with it, so the next staged file
+ * starts a fresh upload batch. Not while an upload is still landing: that file joins this batch.
+ *
+ * @complexity O(s * t) over the staged and sent attachments (both a handful).
+ */
+function deliveredEveryStagedAttachment({ sent, staged, activeUploadCount }) {
+    if (activeUploadCount > 0 || sent.length === 0)
+        return false;
+    return staged.every(attachment => sent.some(item => item.path === attachment.path));
+}
 /**
  * Runs one attachment upload and, unless superseded/unmounted/aborted by the time it resolves,
  * hands the results (or error) to the caller's effects. Concurrent by design — unlike
@@ -91,23 +148,27 @@ export function useChatPane(options) {
     const guard = useUserTextGuard(options);
     const [activeUploadCount, setActiveUploadCount] = useState(0);
     const [attachmentError, setAttachmentError] = useState(null);
-    // Keep the signal with sanitized queue text; re-redacting it later cannot detect the original paste.
-    const [queuedTurn, setQueuedTurn] = 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]);
+    // 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);
+    const submittedComposerRef = useRef(null);
+    const startingPromptRef = useRef(false);
     const [typedAnswerNotice, setTypedAnswerNotice] = useState(null);
-    // Set across the await of one typed-answer delivery so a second Enter cannot post the same text
-    // twice — the second post would find the question already answered and wrongly report it closed.
+    // Shared delivery lock: a second Enter cannot submit the same answer or screenshot twice.
     const deliveringTypedAnswerRef = useRef(false);
-    // The question (tool-use id) the current draft was typed for, or null. Set while a non-empty draft
-    // sits in the composer as a question waits, and kept after that question closes (answered
-    // elsewhere, expired, 409), so `send` cannot slip the draft into the queue as a new paid run.
-    // Released only by an empty draft, a delivery, `reset()`, or `sendAsNewMessage`.
-    const heldAnswerQuestionIdRef = useRef(null);
-    // The question the last delivery answered: typing more while its card is still drawn open (its
-    // tool_result has not streamed in yet) is a follow-up, not another answer to hold.
+    // MOVE: A delivered or definitively closed question cannot consume the next draft before tool_result arrives.
     const answeredQuestionIdRef = useRef(null);
     // Bumped by `reset()` and a conversation switch; a delivery that settles under a different value
     // belongs to a composer that no longer exists and must neither clear the draft nor set a notice.
     const typedAnswerGenerationRef = useRef(0);
+    const typedAnswerConversationRef = useRef(options.conversationId);
     // The conversation `queuedPrompt` was queued against. Compared with `options.conversationId` at
     // flush time so a prompt queued behind a streaming run in one conversation can never be posted
     // into a different one the caller switched to before that run finished.
@@ -117,7 +178,7 @@ export function useChatPane(options) {
     // Every attachment staged for one turn must share one upload batch (the daemon refuses a turn
     // spanning two). So a mount that will restore cached attachments starts in THEIR batch rather
     // than a new one; see `readCachedAttachmentBatchId`.
-    const [initialAttachmentBatchId] = useState(() => readCachedAttachmentBatchId({ conversationId: options.conversationId }) ?? createAttachmentBatchId());
+    const [initialAttachmentBatchId] = useState(() => readCachedAttachmentBatchId({ conversationId: options.conversationId }) ?? createChatLocalId({}));
     const attachmentBatchIdRef = useRef(initialAttachmentBatchId);
     const batchConversationIdRef = useRef(options.conversationId);
     const activeUploadsRef = useRef(new Set());
@@ -154,6 +215,7 @@ export function useChatPane(options) {
             historyMessages: conversation.messages,
             historyScope: options.composerHistoryScope,
             historyStorage: options.composerHistoryStorage,
+            historyCap: options.composerHistoryCap,
             initialAgent: selection,
             conversationId: options.conversationId,
             validateAttachments: options.validateAttachments,
@@ -219,24 +281,19 @@ export function useChatPane(options) {
     });
     const canSend = sendBlocker === null && composer.canSubmit;
     // Read after `await` in `answerWaitingQuestion`, where the render-time `composer.draft` is stale.
+    const latestComposerRef = useRef(composer);
+    latestComposerRef.current = composer;
     const latestDraftRef = useRef(composer.draft);
     latestDraftRef.current = composer.draft;
-    const awaitedQuestionId = options.deliverTypedAnswer === undefined
-        ? null
-        : findAwaitedTypedAnswerId({ messages: conversation.messages, toolName: options.deliverTypedAnswer.toolName });
-    const hasDraft = composer.draft.trim() !== '';
+    const latestAttachmentsRef = useRef(composer.attachments);
+    latestAttachmentsRef.current = composer.attachments;
     useEffect(() => {
-        if (!hasDraft) {
-            heldAnswerQuestionIdRef.current = null;
+        const previous = typedAnswerConversationRef.current;
+        typedAnswerConversationRef.current = options.conversationId;
+        // First-turn adoption gives the existing composer its server key; it does not replace it.
+        if (previous === options.conversationId || (previous == null && options.conversationId != null))
             return;
-        }
-        if (awaitedQuestionId !== null && awaitedQuestionId !== answeredQuestionIdRef.current) {
-            heldAnswerQuestionIdRef.current = awaitedQuestionId;
-        }
-    }, [awaitedQuestionId, hasDraft]);
-    useEffect(() => {
         typedAnswerGenerationRef.current += 1;
-        heldAnswerQuestionIdRef.current = null;
     }, [options.conversationId]);
     // A conversation switch without a remount: adopt the batch of the attachments the composer is
     // about to restore for the new conversation, else start a fresh one so two conversations never
@@ -255,11 +312,13 @@ export function useChatPane(options) {
         }
         if (previousConversationId == null)
             return;
-        attachmentBatchIdRef.current = createAttachmentBatchId();
+        attachmentBatchIdRef.current = createChatLocalId({});
     }, [options.conversationId]);
     const addAttachments = useCallback(async (files) => {
         if (files.length === 0 || options.uploadAttachments === undefined)
             return;
+        // MOVE: A new upload is a fresh submission, including before its first attachment resolves.
+        submittedComposerRef.current = null;
         const generation = attachmentGenerationRef.current;
         const batchId = attachmentBatchIdRef.current;
         const conversationId = options.conversationId;
@@ -284,7 +343,12 @@ export function useChatPane(options) {
                     // Recorded before staging so the cache entry that persists this attachment carries its
                     // batch, which is what lets a later mount restore the batch along with the attachment.
                     writeCachedAttachmentBatchId({ conversationId, batchId });
-                    composer.addAttachment(attachment);
+                    const inputId = queuedUploadOwnersRef.current.get(controller);
+                    if (inputId === undefined)
+                        composer.addAttachment(attachment);
+                    else
+                        setQueuedInputs(inputs => inputs.map(input => input.id === inputId
+                            ? { ...input, attachments: [...input.attachments, attachment] } : input));
                     if (file)
                         cacheAttachmentPreviewSource({ path: attachment.path, file });
                 },
@@ -292,154 +356,246 @@ export function useChatPane(options) {
             });
         }
         finally {
+            queuedUploadOwnersRef.current.delete(controller);
             if (activeUploadsRef.current.delete(controller) && mountedRef.current) {
                 setActiveUploadCount(activeUploadsRef.current.size);
             }
         }
     }, [composer, options.conversationId, options.uploadAttachments]);
-    const sendGuardedPrompt = useCallback(async ({ redaction }, _optional = {}) => {
+    /** Acceptance is the only writer of local recall and optimistic in-run bubbles. */
+    const recordAcceptedInput = useCallback(({ inputs, bubble }, _options = {}) => {
+        composer.history?.record({ inputs });
+        submittedComposerRef.current = composer;
+        if (bubble === undefined)
+            return;
+        conversation.setMessages(messages => {
+            const last = messages.at(-1);
+            if (last?.role !== 'assistant')
+                return messages;
+            const event = acceptedInputUserEvent({ input: { id: inputs[0].id, text: bubble.text },
+                inputs, ...bubble });
+            return [...messages.slice(0, -1), { ...last,
+                    events: projectAcceptedInputEvents({ events: [...(last.events ?? []), event] }) }];
+        });
+    }, [composer, conversation.setMessages]);
+    /** Both accepted send paths consume the sent files and rotate the same upload batch. */
+    const consumeDeliveredAttachments = useCallback(({ attachments }, _options = {}) => {
+        for (const attachment of attachments)
+            latestComposerRef.current.removeAttachment(attachment.path);
+        if (deliveredEveryStagedAttachment({
+            sent: attachments, staged: latestAttachmentsRef.current, activeUploadCount: activeUploadsRef.current.size,
+        }))
+            attachmentBatchIdRef.current = createChatLocalId({});
+    }, []);
+    /** MOVE: A rejected queue flush restores its captured files alongside the text for an honest retry. */
+    const restoreQueuedDraft = useCallback(({ inputs, text, attachments }, _options = {}) => {
+        if (inputs === undefined)
+            return;
+        latestComposerRef.current.setDraft([text, latestDraftRef.current].filter(Boolean).join('\n\n'));
+        const staged = new Set(latestAttachmentsRef.current.map(attachment => attachment.path));
+        for (const attachment of attachments) {
+            if (!staged.has(attachment.path))
+                latestComposerRef.current.addAttachment(attachment);
+        }
+    }, []);
+    const finishPromptSend = useCallback(({ accepted, inputs, redaction, submittedDraft, attachments }, _options = {}) => {
+        if (!accepted) {
+            restoreQueuedDraft({ inputs, text: redaction.text, attachments });
+            return;
+        }
+        if (inputs === undefined && latestDraftRef.current === submittedDraft) {
+            latestComposerRef.current.setDraft('');
+            latestComposerRef.current.closeMention();
+        }
+        consumeDeliveredAttachments({ attachments });
+    }, [consumeDeliveredAttachments, restoreQueuedDraft]);
+    const sendGuardedPrompt = useCallback(async ({ redaction, inputs, attachments = composer.attachments }, _options = {}) => {
         const trimmed = redaction.text.trim();
-        if (!trimmed)
-            throw new Error('cannot send: the prompt is empty');
-        if (sendBlocker !== null) {
-            throw new Error(`cannot send: ${describeChatPaneSendBlocker(sendBlocker)}`);
+        assertPromptSendable({ trimmed, sendBlocker });
+        if (startingPromptRef.current)
+            return;
+        startingPromptRef.current = true;
+        const generation = typedAnswerGenerationRef.current;
+        const submittedDraft = latestDraftRef.current;
+        try {
+            const context = resolveRunContext({ context: options.runContext,
+                input: { prompt: trimmed, selection, workingDirectory: workingDirectoryState.workingDirectory } });
+            options.onActivityChange?.('queued');
+            let accepted = false;
+            await conversation.sendMessage(trimmed, definedProps({ source: {
+                    secretRedaction: redaction.secretRedacted ? { secretRedacted: true, count: redaction.count } : undefined,
+                    agentId: selection.agentId,
+                    // Empty attachment arrays remain absent at the transport boundary.
+                    attachments: attachments.length === 0 ? undefined : attachments,
+                    context,
+                    acceptedInputs: inputs,
+                    onAccepted: ({ inputs: acceptedInputs }) => {
+                        accepted = true;
+                        if (mountedRef.current && generation === typedAnswerGenerationRef.current)
+                            recordAcceptedInput({ inputs: acceptedInputs });
+                    },
+                } }));
+            if (!mountedRef.current || generation !== typedAnswerGenerationRef.current)
+                return;
+            finishPromptSend({ accepted, inputs, redaction, submittedDraft, attachments });
         }
-        const attachments = composer.attachments;
-        const context = typeof options.runContext === 'function'
-            ? options.runContext({
-                prompt: trimmed,
-                selection,
-                workingDirectory: workingDirectoryState.workingDirectory,
-            })
-            : options.runContext;
-        composer.reset();
-        attachmentGenerationRef.current += 1;
-        attachmentBatchIdRef.current = createAttachmentBatchId();
-        options.onActivityChange?.('queued');
-        await conversation.sendMessage(trimmed, definedProps({ source: {
-                secretRedaction: redaction.secretRedacted ? { secretRedacted: true, count: redaction.count } : undefined,
-                agentId: selection.agentId,
-                // Omitted when the array is EMPTY, not merely absent — an empty `attachments: []` would be a
-                // different (valid, present) value to the transport than "no attachments key at all".
-                attachments: attachments.length === 0 ? undefined : attachments,
-                context,
-            } }));
-    }, [
-        composer,
-        conversation,
-        options.onActivityChange,
-        options.runContext,
-        selection,
-        sendBlocker,
-        workingDirectoryState.workingDirectory,
-    ]);
+        finally {
+            startingPromptRef.current = false;
+        }
+    }, [composer, conversation, options.onActivityChange, options.runContext, recordAcceptedInput, finishPromptSend,
+        selection, sendBlocker, workingDirectoryState.workingDirectory]);
     const sendPrompt = useCallback(async (prompt) => {
-        await sendGuardedPrompt({ redaction: guard.redact({ text: prompt.trim() }, {}) }, {});
+        await sendGuardedPrompt({ redaction: guard.redact({ text: prompt.trim() }, {}) });
     }, [guard.redact, sendGuardedPrompt]);
-    const answerWaitingQuestion = useCallback(async ({ deliver, text }) => {
+    // MOVE: Every queue path retains per-message receipts; appendQueuedTurn owns their one-turn delivery.
+    // A turn queued against another conversation is not joined — it would never be flushed there anyway.
+    const enqueueTurn = useCallback(({ turn, inputs, attachments = composer.attachments }, _options = {}) => {
+        const accepted = inputs ?? [{ id: createChatLocalId({}), text: turn.text, attachments,
+                ...(turn.secretRedacted ? { secretRedaction: { secretRedacted: true, count: turn.count } } : {}) }];
+        const sameConversation = queuedConversationIdRef.current === options.conversationId;
+        queuedConversationIdRef.current = options.conversationId;
+        for (const controller of activeUploadsRef.current) {
+            if (!queuedUploadOwnersRef.current.has(controller))
+                queuedUploadOwnersRef.current.set(controller, accepted.at(-1).id);
+        }
+        recordAcceptedInput({ inputs: accepted });
+        setQueuedInputs(queued => [...(sameConversation ? queued : []), ...accepted]);
+        // MOVE: Take files out of the composer without rotating their batch: every queued message ships together.
+        for (const attachment of attachments)
+            latestComposerRef.current.removeAttachment(attachment.path);
+    }, [composer.attachments, options.conversationId, recordAcceptedInput]);
+    const answerWaitingQuestion = useCallback(async ({ deliver, questionId, text }) => {
         const safeText = guard.redactText(text);
         const generation = typedAnswerGenerationRef.current;
         const submittedDraft = latestDraftRef.current;
-        const questionId = awaitedQuestionId;
         deliveringTypedAnswerRef.current = true;
         const outcome = await deliverTypedAnswerSafely({ deliver, text: safeText });
         deliveringTypedAnswerRef.current = false;
         if (!mountedRef.current || generation !== typedAnswerGenerationRef.current)
             return;
-        // Anything but a delivery keeps the draft and says why — never the queue below, whose flush
-        // would post the answer as a brand-new (paid) run once this one ends.
-        if (outcome !== 'delivered') {
+        if (outcome === 'failed') {
             setTypedAnswerNotice(outcome);
             return;
         }
+        if (outcome === 'not-pending') {
+            // MOVE: A definitive refusal accepted no answer; the existing queue owns one normal-send fallback.
+            enqueueTurn({ turn: guard.redact({ text: safeText }, {}), attachments: [] });
+        }
+        else {
+            recordAcceptedInput({ inputs: [{ id: `answer:${questionId}`, text: safeText }],
+                bubble: { text: safeText, toolUseId: questionId } });
+        }
         answeredQuestionIdRef.current = questionId;
-        heldAnswerQuestionIdRef.current = null;
         // The textarea stays editable during delivery: clear only the text that went out, never a
         // correction or next message typed while the host answered.
         if (latestDraftRef.current === submittedDraft)
-            composer.setDraft('');
-    }, [awaitedQuestionId, composer, guard.redactText]);
-    // Every queue path goes through here: a message joins the turn already queued behind this run
-    // (`appendQueuedTurn`) instead of replacing it, which dropped the earlier message. A turn queued
-    // against another conversation is not joined — it would never be flushed there anyway.
-    const enqueueTurn = useCallback((turn) => {
-        const sameConversation = queuedConversationIdRef.current === options.conversationId;
-        queuedConversationIdRef.current = options.conversationId;
-        setQueuedTurn((queued) => appendQueuedTurn({ queued: sameConversation ? queued : null, next: turn }));
-    }, [options.conversationId]);
-    // A text-only message sent while a run streams goes INTO that run when the host can deliver it.
-    // The draft clears before the await so the human sees it go out; whatever the outcome, the text
-    // ends up somewhere — in the run, or queued as the next turn (after stopping the run when the
-    // agent cannot take input mid-run). Never cancel on 'not-running'/'failed': the run is ending.
-    const sendIntoRunningTurn = useCallback(async ({ deliver, runId, turn }) => {
-        composer.setDraft('');
-        const outcome = await deliverMidRunMessageSafely({ deliver, runId, text: turn.text });
-        if (outcome === 'delivered' || !mountedRef.current)
+            latestComposerRef.current.setDraft('');
+    }, [enqueueTurn, guard.redact, guard.redactText, recordAcceptedInput]);
+    const clearDeliveredDraft = useCallback(({ inputs, submittedDraft }, _options = {}) => {
+        if (inputs === undefined && latestDraftRef.current === submittedDraft)
+            latestComposerRef.current.setDraft('');
+    }, []);
+    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 }) } });
+            clearDeliveredDraft({ inputs, submittedDraft });
+            consumeDeliveredAttachments({ attachments });
             return;
-        enqueueTurn(turn);
-        if (outcome === 'unsupported')
+        }
+        enqueueTurn({ turn, attachments, ...(inputs === undefined ? {} : { inputs }) });
+        clearDeliveredDraft({ inputs, submittedDraft });
+        if (outcome === 'unsupported' && attachments.length === 0)
             conversation.cancel();
-    }, [composer, conversation, enqueueTurn]);
+    }, [conversation.cancel, enqueueTurn, recordAcceptedInput, 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 = {}) => {
+        const submittedDraft = latestDraftRef.current;
+        const priorEvents = conversation.messages.at(-1)?.events ?? [];
+        const afterInputId = projectAcceptedInputEvents({ events: priorEvents }).flatMap(event => {
+            const input = acceptedInputEvent({ event });
+            return input ? [input.data.id] : [];
+        }).at(-1);
+        const generation = typedAnswerGenerationRef.current;
+        deliveringTypedAnswerRef.current = true;
+        const outcome = await deliverMidRunMessageSafely({ deliver, runId, text: turn.text,
+            ...(attachments.length ? { attachments } : {}),
+        });
+        deliveringTypedAnswerRef.current = false;
+        if (!mountedRef.current || generation !== typedAnswerGenerationRef.current)
+            return;
+        finishMidRunSend({ outcome, inputs, turn, attachments, afterInputId, submittedDraft });
+    }, [composer, conversation, finishMidRunSend]);
     // The ordinary next-turn path: into the running run, else queue behind it, else send now.
     const sendOrdinaryTurn = useCallback(async (prompt) => {
-        if (isChatPaneQueueableBlocker({ blocker: sendBlocker })) {
-            const turn = guard.redact({ text: prompt }, {});
-            const deliver = options.deliverMidRunMessage;
-            const runId = deliver === undefined ? null : findMidRunMessageRunId({
-                blocker: sendBlocker,
-                attachmentCount: composer.attachments.length,
-                messages: conversation.messages,
-            });
-            if (deliver !== undefined && runId !== null) {
-                await sendIntoRunningTurn({ deliver, runId, turn });
-                return;
-            }
-            // Queue instead of no-op'ing. `setDraft('')` and NOT `composer.reset()`: reset also discards
-            // staged attachments, which this turn still needs when it finally goes out.
-            enqueueTurn(turn);
-            composer.setDraft('');
+        if (!isChatPaneQueueableBlocker({ blocker: sendBlocker })) {
+            if (canSend)
+                await sendPrompt(prompt);
             return;
         }
-        if (!canSend)
+        const turn = guard.redact({ text: prompt }, {});
+        const uploadPending = activeUploadsRef.current.size > 0 || attachmentError !== null;
+        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({
+            deliver: options.deliverMidRunMessage,
+            blocker: sendBlocker,
+            attachmentCount: composer.attachments.length,
+            messages: conversation.messages,
+        });
+        if (target !== null) {
+            await sendIntoRunningTurn({ ...target, turn });
             return;
-        await sendPrompt(prompt);
+        }
+        // MOVE: Queue owns the staged attachments before clearing the draft, so neither can be lost.
+        enqueueTurn({ turn });
+        composer.setDraft('');
     }, [
         canSend,
+        attachmentError,
         composer,
         conversation.messages,
         enqueueTurn,
         options.deliverMidRunMessage,
+        queuedTurn,
         sendBlocker,
         sendIntoRunningTurn,
         sendPrompt,
         guard.redact,
     ]);
     const send = useCallback(async () => {
-        const prompt = composerPrompt(composer);
-        if (!prompt || deliveringTypedAnswerRef.current)
+        const uploadingWhileStreaming = conversation.isStreaming && activeUploadsRef.current.size > 0;
+        const prompt = composerPrompt(composer) || (uploadingWhileStreaming ? ATTACHMENTS_ONLY_PROMPT : '');
+        if (!prompt || composerDeliveryBlocked({ delivering: deliveringTypedAnswerRef.current, starting: startingPromptRef.current, composer, submitted: submittedComposerRef.current }))
             return;
         setTypedAnswerNotice(null);
-        const deliver = options.deliverTypedAnswer;
-        if (deliver !== undefined && isTypedAnswerTurn({
+        // Until upload completes, an empty attachment list is not evidence of a text-only answer.
+        if (uploadingWhileStreaming) {
+            await sendOrdinaryTurn(prompt);
+            return;
+        }
+        const typedAnswer = findTypedAnswerTarget({
+            deliver: options.deliverTypedAnswer,
             blocker: sendBlocker,
             attachmentCount: composer.attachments.length,
             messages: conversation.messages,
-            toolName: deliver.toolName,
-        })) {
-            await answerWaitingQuestion({ deliver, text: prompt });
-            return;
-        }
-        // Typed for a question that has since closed: the human meant an answer, so going on to the
-        // queue would start a paid run they never asked for. Attachments mark a new turn (a typed answer
-        // carries text only), the same rule `isTypedAnswerTurn` applies.
-        if (heldAnswerQuestionIdRef.current !== null && composer.attachments.length === 0) {
-            setTypedAnswerNotice('not-pending');
+        });
+        if (typedAnswer !== null && typedAnswer.questionId !== answeredQuestionIdRef.current) {
+            await answerWaitingQuestion({ ...typedAnswer, text: prompt });
             return;
         }
         await sendOrdinaryTurn(prompt);
     }, [
         answerWaitingQuestion,
         composer,
+        conversation.isStreaming,
         conversation.messages,
         options.deliverTypedAnswer,
         sendBlocker,
@@ -447,47 +603,79 @@ export function useChatPane(options) {
     ]);
     const sendAsNewMessage = useCallback(async () => {
         const prompt = composerPrompt(composer);
-        if (!prompt || deliveringTypedAnswerRef.current)
+        if (!prompt || composerDeliveryBlocked({ delivering: deliveringTypedAnswerRef.current, starting: startingPromptRef.current, composer, submitted: submittedComposerRef.current }))
             return;
         setTypedAnswerNotice(null);
-        // Mark the question answered too, so the still-non-empty draft is not re-held by the effect
-        // while that question's card is drawn open.
-        answeredQuestionIdRef.current = heldAnswerQuestionIdRef.current ?? answeredQuestionIdRef.current;
-        heldAnswerQuestionIdRef.current = null;
         await sendOrdinaryTurn(prompt);
     }, [composer, sendOrdinaryTurn]);
     const interruptSend = useCallback(() => {
         const prompt = composerPrompt(composer);
-        if (!prompt)
+        if (!prompt || composerDeliveryBlocked({ delivering: deliveringTypedAnswerRef.current, starting: startingPromptRef.current, composer, submitted: submittedComposerRef.current }))
             return;
-        enqueueTurn(guard.redact({ text: prompt }, {}));
+        enqueueTurn({ turn: guard.redact({ text: prompt }, {}) });
         composer.setDraft('');
         conversation.cancel();
     }, [composer, conversation, enqueueTurn, guard.redact]);
+    /** Abort only uploads owned by the removed inputs; late completions must not refill the composer. */
+    const discardQueuedUploads = useCallback(({ id }, _options = {}) => {
+        for (const [controller, owner] of queuedUploadOwnersRef.current) {
+            if (id !== undefined && owner !== id)
+                continue;
+            controller.abort();
+            activeUploadsRef.current.delete(controller);
+            queuedUploadOwnersRef.current.delete(controller);
+        }
+        setActiveUploadCount(activeUploadsRef.current.size);
+    }, []);
     const cancelQueued = useCallback(() => {
+        submittedComposerRef.current = null;
+        queuedForUploadRef.current = false;
         queuedConversationIdRef.current = undefined;
-        setQueuedTurn(null);
-    }, []);
-    // Flush on a FULLY clear blocker, not merely on streaming ending — see
-    // `isChatPaneQueueableBlocker`'s note about `findChatPaneSendBlocker`'s ordering. Clearing the
-    // queue slot BEFORE awaiting keeps a re-render from double-sending the same prompt.
+        discardQueuedUploads({});
+        setQueuedInputs([]);
+    }, [discardQueuedUploads]);
+    const cancelQueuedMessage = useCallback(({ id }, _options = {}) => {
+        submittedComposerRef.current = null;
+        discardQueuedUploads({ id });
+        setQueuedInputs(inputs => inputs.filter(input => input.id !== id));
+    }, [discardQueuedUploads]);
+    // Upload-waiting sends can steer once the image arrives. Other queued turns wait for a fully
+    // clear blocker. Clear the slot before awaiting so re-renders cannot send it twice.
     useEffect(() => {
-        if (queuedTurn === null || sendBlocker !== null)
+        if (queuedTurn === null) {
+            queuedForUploadRef.current = false;
             return;
+        }
         if (queuedConversationIdRef.current !== options.conversationId) {
             // The conversation changed while this prompt waited behind a streaming run — sending it now
             // would post it into a conversation the user never saw it queued against. Drop it instead
             // (same as `cancelQueued`) rather than misrouting it.
-            queuedConversationIdRef.current = undefined;
-            setQueuedTurn(null);
+            cancelQueued();
+            return;
+        }
+        if (activeUploadCount > 0 || attachmentError !== null)
+            return;
+        const target = queuedForUploadRef.current ? findMidRunTarget({
+            deliver: options.deliverMidRunMessage,
+            blocker: sendBlocker, attachmentCount: queuedInputs.flatMap(input => input.attachments).length, messages: conversation.messages,
+        }) : null;
+        if (sendBlocker !== null && target === null)
+            return;
+        queuedForUploadRef.current = false;
+        const inputs = queuedInputs;
+        const attachments = inputs.flatMap(input => input.attachments);
+        setQueuedInputs([]);
+        if (target !== null) {
+            void sendIntoRunningTurn({ ...target, turn: queuedTurn, inputs, attachments });
             return;
         }
-        setQueuedTurn(null);
-        void sendGuardedPrompt({ redaction: queuedTurn }, {});
-    }, [options.conversationId, queuedTurn, sendBlocker, sendGuardedPrompt]);
+        void sendGuardedPrompt({ redaction: queuedTurn, inputs, attachments });
+    }, [activeUploadCount, attachmentError, cancelQueued, queuedInputs, conversation.messages,
+        options.conversationId, options.deliverMidRunMessage, queuedTurn, sendBlocker, sendGuardedPrompt, sendIntoRunningTurn]);
     const reset = useCallback(() => {
+        submittedComposerRef.current = null;
         attachmentGenerationRef.current += 1;
-        attachmentBatchIdRef.current = createAttachmentBatchId();
+        attachmentBatchIdRef.current = createChatLocalId({});
         for (const controller of activeUploadsRef.current)
             controller.abort();
         activeUploadsRef.current.clear();
@@ -498,12 +686,13 @@ export function useChatPane(options) {
         setAttachmentError(null);
         setTypedAnswerNotice(null);
         typedAnswerGenerationRef.current += 1;
-        heldAnswerQuestionIdRef.current = null;
         // Without this, a prompt queued behind a streaming run survives `reset()` and — once
         // `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;
-        setQueuedTurn(null);
+        queuedForUploadRef.current = false;
+        queuedUploadOwnersRef.current.clear();
+        setQueuedInputs([]);
     }, [composer, conversation, options.initialMessages]);
     return {
         secretRedacted: guard.secretRedacted,
@@ -523,6 +712,8 @@ export function useChatPane(options) {
         send,
         sendPrompt,
         queuedPrompt: queuedTurn?.text ?? null,
+        queuedMessages: queuedInputs,
+        cancelQueuedMessage,
         cancelQueued,
         typedAnswerNotice,
         sendAsNewMessage,