Review fixes

ScriptSmith · ScriptSmith · commit 47443debfcce · 2026-05-25T18:42:59.000+10:00
diff --git a/ui/src/components/ChatInput/ChatInput.stories.tsx b/ui/src/components/ChatInput/ChatInput.stories.tsx
@@ -240,7 +240,10 @@ export const Streaming: Story = {
  */
 export const StreamingAllowsQueueing: Story = {
   args: {
+    // A queue-backed turn is in flight: both flags are set, so the primary
+    // button queues the next message rather than starting a concurrent turn.
     isStreaming: true,
+    isQueuing: true,
     placeholder: "Type a message...",
     onSend: fn(),
     onStop: fn(),
@@ -267,12 +270,48 @@ export const StreamingAllowsQueueing: Story = {
   },
 };
 
+/**
+ * Test: A stream started outside the queue (editAndRerun/regenerateResponse sets
+ * `isStreaming` but not `isQueuing`) disables the primary button, so a click or
+ * Enter can't start a second concurrent turn that would clobber the active one.
+ */
+export const NonQueueStreamBlocksSend: Story = {
+  args: {
+    isStreaming: true,
+    isQueuing: false,
+    placeholder: "Type a message...",
+    onSend: fn(),
+    onStop: fn(),
+  },
+  play: async ({ canvasElement, args }) => {
+    const canvas = within(canvasElement);
+
+    const textarea = canvas.getByPlaceholderText("Type a message...");
+    await userEvent.type(textarea, "Next question");
+
+    // The primary button is present but disabled in this state.
+    const queueButton = canvas.getByRole("button", { name: /queue message/i });
+    await expect(queueButton).toBeDisabled();
+
+    // Enter must not slip past the disabled button and dispatch a send.
+    await userEvent.type(textarea, "{Enter}");
+    await expect(args.onSend).not.toHaveBeenCalled();
+
+    // Stop remains available to abort the externally-started stream.
+    const stopButton = canvas.getByRole("button", { name: /stop response/i });
+    await userEvent.click(stopButton);
+    await expect(args.onStop).toHaveBeenCalled();
+  },
+};
+
 /**
  * Test: Queued messages render as removable chips above the input
  */
 export const WithQueuedMessages: Story = {
   args: {
+    // Messages are queued, so the queue is busy and queueing stays enabled.
     isStreaming: true,
+    isQueuing: true,
     placeholder: "Type a message...",
     onRemoveQueuedMessage: fn(),
     queuedMessages: [
diff --git a/ui/src/components/ChatInput/ChatInput.tsx b/ui/src/components/ChatInput/ChatInput.tsx
@@ -273,6 +273,11 @@ export function ChatInput({
   // Send always submits (queuing the message if a response is still streaming).
   // Stopping the current response is a separate button, shown while streaming.
   const handleSubmit = useCallback(() => {
+    // Mirror the Send button's `disabled` guard for the Enter-key path: block
+    // sending while a non-queue stream (editAndRerun/regenerateResponse) is in
+    // flight, since that would start a second concurrent turn and clobber it.
+    if (isStreaming && !isQueuing) return;
+
     const trimmedContent = content.trim();
     if (!trimmedContent && files.length === 0) return;
 
@@ -286,7 +291,7 @@ export function ChatInput({
     setContent("");
     setFiles([]);
     setPendingSkill(null);
-  }, [content, files, onSend, pendingSkill]);
+  }, [content, files, onSend, pendingSkill, isStreaming, isQueuing]);
 
   const enableSkill = useChatUIStore((s) => s.enableSkill);
 
@@ -778,7 +783,14 @@ export function ChatInput({
               size="sm"
               className="h-8 gap-1.5 rounded-xl px-3 transition-all"
               onClick={handleSubmit}
-              disabled={disabled || !canSend}
+              // Queueing is only safe when the in-flight turn is the queue's own
+              // (`isQueuing`): the queue serializes those off `sendMessage`'s
+              // promise. A stream started outside the queue — `editAndRerun` /
+              // `regenerateResponse` call `initStreaming` directly and never set
+              // `busy` — would otherwise let a click start a second concurrent
+              // turn that clobbers the active stream. Disable in that case; the
+              // separate Stop button still handles aborting it.
+              disabled={disabled || !canSend || (isStreaming && !isQueuing)}
               variant="primary"
               aria-label={isStreaming || isQueuing ? "Queue message" : "Send message"}
             >
