From 3e6558492e0668888cf5c6f94b068aa1370a33f5 Mon Sep 17 00:00:00 2001
From: Jwalin Shah <jwalinshah13@gmail.com>
Date: Tue, 5 May 2026 08:12:48 -0700
Subject: [PATCH 1/6] Extract conversations composer send decision logic

---
 app/src/pages/Conversations.tsx               | 65 +++++++++---------
 .../composerSendDecision.test.ts              | 68 +++++++++++++++++++
 .../conversations/composerSendDecision.ts     | 66 ++++++++++++++++++
 3 files changed, 168 insertions(+), 31 deletions(-)
 create mode 100644 app/src/pages/conversations/composerSendDecision.test.ts
 create mode 100644 app/src/pages/conversations/composerSendDecision.ts

diff --git a/app/src/pages/Conversations.tsx b/app/src/pages/Conversations.tsx
index 6a5ba541e..10c0f03db 100644
--- a/app/src/pages/Conversations.tsx
+++ b/app/src/pages/Conversations.tsx
@@ -47,6 +47,7 @@ import {
 } from '../utils/tauriCommands';
 import { formatTimelineEntry } from '../utils/toolTimelineFormatting';
 import { AgentMessageBubble, BubbleMarkdown } from './conversations/components/AgentMessageBubble';
+import { evaluateComposerSend, handleComposerSlashCommand } from './conversations/composerSendDecision';
 import { CitationChips, type MessageCitation } from './conversations/components/CitationChips';
 import { LimitPill } from './conversations/components/LimitPill';
 import { ToolTimelineBlock } from './conversations/components/ToolTimelineBlock';
@@ -439,48 +440,50 @@ const Conversations = ({ variant = 'page' }: ConversationsProps = {}) => {
   }, [inputMode, rustChat]);
 
   const handleSlashCommand = (command: string): boolean => {
-    const cmd = command.toLowerCase();
-    if (cmd === '/new' || cmd === '/clear') {
-      // Welcome lockdown (#883) — consume the command so it is not sent
-      // to the agent, but skip thread creation/reset so the user cannot
-      // escape the welcome conversation via `/new` or `/clear`.
-      if (welcomeLocked) {
-        setInputValue('');
-        return true;
-      }
-      setInputValue('');
-      void handleCreateNewThread();
-      return true;
-    }
-    return false;
+    const decision = handleComposerSlashCommand(command, welcomeLocked);
+    if (decision.kind === 'not_handled') return false;
+
+    // Welcome lockdown (#883) — consume the command so it is not sent
+    // to the agent, but skip thread creation/reset so the user cannot
+    // escape the welcome conversation via `/new` or `/clear`.
+    setInputValue('');
+    if (decision.blockedByWelcomeLock) return true;
+    void handleCreateNewThread();
+    return true;
   };
 
   const handleSendMessage = async (text?: string) => {
     const normalized = text ?? inputValue;
-    const trimmed = normalized.trim();
-
-    if (!trimmed || !selectedThreadId || composerInteractionBlocked) return;
+    const sendDecision = evaluateComposerSend({
+      rawText: normalized,
+      selectedThreadId,
+      composerInteractionBlocked,
+      isAtLimit,
+      socketStatus,
+    });
+    const trimmed = sendDecision.trimmedText;
 
     if (handleSlashCommand(trimmed)) return;
 
-    if (isAtLimit) {
-      setShowLimitModal(true);
-      setSendError(
-        chatSendError('usage_limit_reached', 'Usage limit reached. Upgrade or wait for reset.')
-      );
-      return;
-    }
-    if (socketStatus !== 'connected') {
-      setSendError(
-        chatSendError(
-          'socket_disconnected',
-          'Realtime socket is not connected — responses cannot be delivered without a client ID.'
-        )
-      );
+    if (!sendDecision.shouldSend) {
+      if (sendDecision.blockReason === 'usage_limit_reached') {
+        setShowLimitModal(true);
+        setSendError(
+          chatSendError('usage_limit_reached', 'Usage limit reached. Upgrade or wait for reset.')
+        );
+      } else if (sendDecision.blockReason === 'socket_disconnected') {
+        setSendError(
+          chatSendError(
+            'socket_disconnected',
+            'Realtime socket is not connected — responses cannot be delivered without a client ID.'
+          )
+        );
+      }
       return;
     }
 
     const sendingThreadId = selectedThreadId;
+    if (!sendingThreadId) return;
     const userMessage: ThreadMessage = {
       id: `msg_${globalThis.crypto.randomUUID()}`,
       content: trimmed,
diff --git a/app/src/pages/conversations/composerSendDecision.test.ts b/app/src/pages/conversations/composerSendDecision.test.ts
new file mode 100644
index 000000000..99ff7a561
--- /dev/null
+++ b/app/src/pages/conversations/composerSendDecision.test.ts
@@ -0,0 +1,68 @@
+import { describe, expect, it } from 'vitest';
+
+import { evaluateComposerSend, handleComposerSlashCommand } from './composerSendDecision';
+
+describe('evaluateComposerSend', () => {
+  it('blocks empty input', () => {
+    const decision = evaluateComposerSend({
+      rawText: '   ',
+      selectedThreadId: 'thread-1',
+      composerInteractionBlocked: false,
+      isAtLimit: false,
+      socketStatus: 'connected',
+    });
+
+    expect(decision).toEqual({
+      shouldSend: false,
+      trimmedText: '',
+      blockReason: 'empty_input',
+    });
+  });
+
+  it('blocks usage limit', () => {
+    const decision = evaluateComposerSend({
+      rawText: 'hello',
+      selectedThreadId: 'thread-1',
+      composerInteractionBlocked: false,
+      isAtLimit: true,
+      socketStatus: 'connected',
+    });
+
+    expect(decision.blockReason).toBe('usage_limit_reached');
+    expect(decision.shouldSend).toBe(false);
+  });
+
+  it('blocks when socket is disconnected', () => {
+    const decision = evaluateComposerSend({
+      rawText: 'hello',
+      selectedThreadId: 'thread-1',
+      composerInteractionBlocked: false,
+      isAtLimit: false,
+      socketStatus: 'disconnected',
+    });
+
+    expect(decision.blockReason).toBe('socket_disconnected');
+    expect(decision.shouldSend).toBe(false);
+  });
+
+  it('allows send path setup for valid chat send input', () => {
+    const decision = evaluateComposerSend({
+      rawText: ' hello ',
+      selectedThreadId: 'thread-1',
+      composerInteractionBlocked: false,
+      isAtLimit: false,
+      socketStatus: 'connected',
+    });
+
+    expect(decision).toEqual({ shouldSend: true, trimmedText: 'hello' });
+  });
+});
+
+describe('handleComposerSlashCommand', () => {
+  it('consumes /new and blocks thread reset when welcome lock is active', () => {
+    expect(handleComposerSlashCommand('/new', true)).toEqual({
+      kind: 'new_or_clear',
+      blockedByWelcomeLock: true,
+    });
+  });
+});
diff --git a/app/src/pages/conversations/composerSendDecision.ts b/app/src/pages/conversations/composerSendDecision.ts
new file mode 100644
index 000000000..a31ab2af6
--- /dev/null
+++ b/app/src/pages/conversations/composerSendDecision.ts
@@ -0,0 +1,66 @@
+export type ComposerSendBlockReason =
+  | 'empty_input'
+  | 'missing_thread'
+  | 'composer_blocked'
+  | 'usage_limit_reached'
+  | 'socket_disconnected';
+
+export type SlashCommandDecision =
+  | { kind: 'new_or_clear'; blockedByWelcomeLock: boolean }
+  | { kind: 'not_handled' };
+
+export interface ComposerSendDecisionArgs {
+  rawText: string;
+  selectedThreadId: string | null;
+  composerInteractionBlocked: boolean;
+  isAtLimit: boolean;
+  socketStatus: string;
+}
+
+export interface ComposerSendDecision {
+  shouldSend: boolean;
+  trimmedText: string;
+  blockReason?: ComposerSendBlockReason;
+}
+
+export const handleComposerSlashCommand = (
+  command: string,
+  welcomeLocked: boolean
+): SlashCommandDecision => {
+  const cmd = command.toLowerCase();
+  if (cmd === '/new' || cmd === '/clear') {
+    return { kind: 'new_or_clear', blockedByWelcomeLock: welcomeLocked };
+  }
+  return { kind: 'not_handled' };
+};
+
+export const evaluateComposerSend = (
+  args: ComposerSendDecisionArgs
+): ComposerSendDecision => {
+  const trimmedText = args.rawText.trim();
+
+  if (!trimmedText) {
+    return { shouldSend: false, trimmedText, blockReason: 'empty_input' };
+  }
+
+  if (!args.selectedThreadId) {
+    return { shouldSend: false, trimmedText, blockReason: 'missing_thread' };
+  }
+
+  if (args.composerInteractionBlocked) {
+    return { shouldSend: false, trimmedText, blockReason: 'composer_blocked' };
+  }
+
+  if (args.isAtLimit) {
+    return { shouldSend: false, trimmedText, blockReason: 'usage_limit_reached' };
+  }
+
+  if (args.socketStatus !== 'connected') {
+    return { shouldSend: false, trimmedText, blockReason: 'socket_disconnected' };
+  }
+
+  return {
+    shouldSend: true,
+    trimmedText,
+  };
+};

From 23690d89fd74dd13d16211f05e3d92ac99b21581 Mon Sep 17 00:00:00 2001
From: Jwalin Shah <jshah1331@gmail.com>
Date: Tue, 5 May 2026 08:17:46 -0700
Subject: [PATCH 2/6] style: format composer send decision extraction

---
 app/src/pages/Conversations.tsx                          | 5 ++++-
 app/src/pages/conversations/composerSendDecision.test.ts | 6 +-----
 app/src/pages/conversations/composerSendDecision.ts      | 9 ++-------
 3 files changed, 7 insertions(+), 13 deletions(-)

diff --git a/app/src/pages/Conversations.tsx b/app/src/pages/Conversations.tsx
index 10c0f03db..13a22ccb8 100644
--- a/app/src/pages/Conversations.tsx
+++ b/app/src/pages/Conversations.tsx
@@ -47,10 +47,13 @@ import {
 } from '../utils/tauriCommands';
 import { formatTimelineEntry } from '../utils/toolTimelineFormatting';
 import { AgentMessageBubble, BubbleMarkdown } from './conversations/components/AgentMessageBubble';
-import { evaluateComposerSend, handleComposerSlashCommand } from './conversations/composerSendDecision';
 import { CitationChips, type MessageCitation } from './conversations/components/CitationChips';
 import { LimitPill } from './conversations/components/LimitPill';
 import { ToolTimelineBlock } from './conversations/components/ToolTimelineBlock';
+import {
+  evaluateComposerSend,
+  handleComposerSlashCommand,
+} from './conversations/composerSendDecision';
 import {
   type AgentBubblePosition,
   buildAcceptedInlineCompletion,
diff --git a/app/src/pages/conversations/composerSendDecision.test.ts b/app/src/pages/conversations/composerSendDecision.test.ts
index 99ff7a561..906a361a4 100644
--- a/app/src/pages/conversations/composerSendDecision.test.ts
+++ b/app/src/pages/conversations/composerSendDecision.test.ts
@@ -12,11 +12,7 @@ describe('evaluateComposerSend', () => {
       socketStatus: 'connected',
     });
 
-    expect(decision).toEqual({
-      shouldSend: false,
-      trimmedText: '',
-      blockReason: 'empty_input',
-    });
+    expect(decision).toEqual({ shouldSend: false, trimmedText: '', blockReason: 'empty_input' });
   });
 
   it('blocks usage limit', () => {
diff --git a/app/src/pages/conversations/composerSendDecision.ts b/app/src/pages/conversations/composerSendDecision.ts
index a31ab2af6..90725bf76 100644
--- a/app/src/pages/conversations/composerSendDecision.ts
+++ b/app/src/pages/conversations/composerSendDecision.ts
@@ -34,9 +34,7 @@ export const handleComposerSlashCommand = (
   return { kind: 'not_handled' };
 };
 
-export const evaluateComposerSend = (
-  args: ComposerSendDecisionArgs
-): ComposerSendDecision => {
+export const evaluateComposerSend = (args: ComposerSendDecisionArgs): ComposerSendDecision => {
   const trimmedText = args.rawText.trim();
 
   if (!trimmedText) {
@@ -59,8 +57,5 @@ export const evaluateComposerSend = (
     return { shouldSend: false, trimmedText, blockReason: 'socket_disconnected' };
   }
 
-  return {
-    shouldSend: true,
-    trimmedText,
-  };
+  return { shouldSend: true, trimmedText };
 };

From 31bf54a33e434d572e4a32fbfdef74249909afee Mon Sep 17 00:00:00 2001
From: Jwalin Shah <jshah1331@gmail.com>
Date: Tue, 5 May 2026 08:25:04 -0700
Subject: [PATCH 3/6] fix: preserve composer slash command gating

---
 app/src/pages/Conversations.tsx | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/app/src/pages/Conversations.tsx b/app/src/pages/Conversations.tsx
index 13a22ccb8..8ec6ac489 100644
--- a/app/src/pages/Conversations.tsx
+++ b/app/src/pages/Conversations.tsx
@@ -466,6 +466,14 @@ const Conversations = ({ variant = 'page' }: ConversationsProps = {}) => {
     });
     const trimmed = sendDecision.trimmedText;
 
+    if (
+      sendDecision.blockReason === 'empty_input' ||
+      sendDecision.blockReason === 'missing_thread' ||
+      sendDecision.blockReason === 'composer_blocked'
+    ) {
+      return;
+    }
+
     if (handleSlashCommand(trimmed)) return;
 
     if (!sendDecision.shouldSend) {

From fb9c0c74b387eb4082a078aa8cb5b71f7ba79e87 Mon Sep 17 00:00:00 2001
From: Jwalin Shah <jshah1331@gmail.com>
Date: Tue, 5 May 2026 15:58:16 -0700
Subject: [PATCH 4/6] test: cover composer send decisions

---
 app/src/pages/Conversations.tsx               |  19 ++-
 .../__tests__/Conversations.render.test.tsx   | 115 ++++++++++++++++++
 .../composerSendDecision.test.ts              |  71 ++++++++++-
 .../conversations/composerSendDecision.ts     |  32 +++++
 4 files changed, 225 insertions(+), 12 deletions(-)

diff --git a/app/src/pages/Conversations.tsx b/app/src/pages/Conversations.tsx
index 722221349..8644a07c1 100644
--- a/app/src/pages/Conversations.tsx
+++ b/app/src/pages/Conversations.tsx
@@ -59,6 +59,7 @@ import { LimitPill } from './conversations/components/LimitPill';
 import { ToolTimelineBlock } from './conversations/components/ToolTimelineBlock';
 import {
   evaluateComposerSend,
+  getComposerBlockedSendFeedback,
   handleComposerSlashCommand,
 } from './conversations/composerSendDecision';
 import {
@@ -521,18 +522,12 @@ const Conversations = ({ variant = 'page' }: ConversationsProps = {}) => {
     }
 
     if (!sendDecision.shouldSend) {
-      if (sendDecision.blockReason === 'usage_limit_reached') {
+      const blockedFeedback = getComposerBlockedSendFeedback(sendDecision.blockReason);
+      if (blockedFeedback?.showLimitModal) {
         setShowLimitModal(true);
-        setSendError(
-          chatSendError('usage_limit_reached', 'Usage limit reached. Upgrade or wait for reset.')
-        );
-      } else if (sendDecision.blockReason === 'socket_disconnected') {
-        setSendError(
-          chatSendError(
-            'socket_disconnected',
-            'Realtime socket is not connected — responses cannot be delivered without a client ID.'
-          )
-        );
+      }
+      if (blockedFeedback) {
+        setSendError(chatSendError(blockedFeedback.error.code, blockedFeedback.error.message));
       }
       return;
     }
@@ -1613,6 +1608,8 @@ const Conversations = ({ variant = 'page' }: ConversationsProps = {}) => {
                 {/* Voice input mic hidden per #717 (inputMode='voice' path retained). */}
               </div>
               <button
+                aria-label="Send message"
+                title="Send message"
                 onClick={() => {
                   void handleSendMessage();
                 }}
diff --git a/app/src/pages/__tests__/Conversations.render.test.tsx b/app/src/pages/__tests__/Conversations.render.test.tsx
index a95b41358..a100f2147 100644
--- a/app/src/pages/__tests__/Conversations.render.test.tsx
+++ b/app/src/pages/__tests__/Conversations.render.test.tsx
@@ -74,6 +74,11 @@ vi.mock('../../services/api/threadApi', () => ({
 
 vi.mock('../../hooks/useUsageState', () => ({ useUsageState: mockUseUsageState }));
 
+vi.mock('../../store/socketSelectors', () => ({
+  selectSocketStatus: (state: { socket?: { byUser?: Record<string, { status: string }> } }) =>
+    state.socket?.byUser?.__pending__?.status ?? 'disconnected',
+}));
+
 // useStickToBottom returns refs; mock it so layout-effects don't fire in jsdom.
 vi.mock('../../hooks/useStickToBottom', () => ({
   useStickToBottom: vi.fn(() => ({ containerRef: { current: null }, endRef: { current: null } })),
@@ -162,6 +167,69 @@ const emptyThreadState = {
   messagesError: null,
 };
 
+function selectedThreadState(thread: Thread) {
+  return {
+    ...emptyThreadState,
+    threads: [thread],
+    selectedThreadId: thread.id,
+    messagesByThreadId: { [thread.id]: [] },
+    messages: [],
+  };
+}
+
+function socketState(status: 'connected' | 'disconnected') {
+  return {
+    byUser: { __pending__: { status, socketId: status === 'connected' ? 'socket-1' : null } },
+  };
+}
+
+async function renderSelectedConversation(
+  options: { isAtLimit?: boolean; socketStatus?: 'connected' | 'disconnected' } = {}
+) {
+  const thread = makeThread({ id: 'send-thread', title: 'Send Thread' });
+  mockGetThreads.mockResolvedValue({ threads: [thread], count: 1 });
+  mockGetThreadMessages.mockResolvedValue({ messages: [], count: 0 });
+  mockUseUsageState.mockReturnValue({
+    teamUsage: null,
+    currentPlan: null,
+    currentTier: 'FREE' as const,
+    isFreeTier: true,
+    usagePct10h: options.isAtLimit ? 1 : 0,
+    usagePct7d: options.isAtLimit ? 1 : 0,
+    isNearLimit: Boolean(options.isAtLimit),
+    isAtLimit: Boolean(options.isAtLimit),
+    isRateLimited: Boolean(options.isAtLimit),
+    isBudgetExhausted: false,
+    shouldShowBudgetCompletedMessage: false,
+    isLoading: false,
+    refresh: vi.fn(),
+  });
+
+  let renderedStore: ReturnType<typeof buildStore> | undefined;
+  await act(async () => {
+    renderedStore = await renderConversations({
+      thread: selectedThreadState(thread),
+      socket: socketState(options.socketStatus ?? 'connected'),
+    });
+  });
+
+  const textarea = await screen.findByPlaceholderText('Type a message...');
+  return { store: renderedStore, textarea, thread };
+}
+
+async function submitComposerText(textarea: HTMLElement, text: string) {
+  await act(async () => {
+    fireEvent.change(textarea, { target: { value: text } });
+  });
+  await waitFor(() => {
+    expect(textarea).toHaveValue(text);
+    expect(screen.getByRole('button', { name: 'Send message' })).not.toBeDisabled();
+  });
+  await act(async () => {
+    fireEvent.click(screen.getByRole('button', { name: 'Send message' }));
+  });
+}
+
 // ── Tests ──────────────────────────────────────────────────────────────────
 
 describe('Conversations — smoke render (#1123 welcome-lock removal)', () => {
@@ -553,4 +621,51 @@ describe('Conversations — smoke render (#1123 welcome-lock removal)', () => {
     // isRateLimited=true, shouldShowBudgetCompletedMessage=false → rate-limit branch (line 1437)
     expect(screen.getByText(/10-hour rate limit reached/i)).toBeInTheDocument();
   });
+
+  it('handles /new from the composer without sending chat text', async () => {
+    const { textarea } = await renderSelectedConversation();
+    const { chatSend } = await import('../../services/chatService');
+    const { threadApi } = await import('../../services/api/threadApi');
+
+    await submitComposerText(textarea, '/new');
+
+    await waitFor(() => {
+      expect(threadApi.createNewThread).toHaveBeenCalled();
+    });
+    expect(chatSend).not.toHaveBeenCalled();
+    expect(textarea).toHaveValue('');
+  });
+
+  it('shows the usage-limit modal instead of sending when the account is at limit', async () => {
+    const { textarea } = await renderSelectedConversation({ isAtLimit: true });
+    const { chatSend } = await import('../../services/chatService');
+
+    await submitComposerText(textarea, 'hello at limit');
+
+    await waitFor(() => {
+      expect(screen.getByText('Usage Limit Reached')).toBeInTheDocument();
+    });
+    expect(screen.getByText(/Usage limit reached/i)).toBeInTheDocument();
+    expect(chatSend).not.toHaveBeenCalled();
+  });
+
+  it('persists a local user message and sends through chat service for valid input', async () => {
+    const { textarea, thread } = await renderSelectedConversation();
+    const { chatSend } = await import('../../services/chatService');
+    const { threadApi } = await import('../../services/api/threadApi');
+
+    await submitComposerText(textarea, ' hello cloud ');
+
+    await waitFor(() => {
+      expect(threadApi.appendMessage).toHaveBeenCalledWith(
+        thread.id,
+        expect.objectContaining({ content: 'hello cloud', sender: 'user', type: 'text' })
+      );
+    });
+    expect(chatSend).toHaveBeenCalledWith({
+      threadId: thread.id,
+      message: 'hello cloud',
+      model: 'reasoning-v1',
+    });
+  });
 });
diff --git a/app/src/pages/conversations/composerSendDecision.test.ts b/app/src/pages/conversations/composerSendDecision.test.ts
index 906a361a4..abbfa0157 100644
--- a/app/src/pages/conversations/composerSendDecision.test.ts
+++ b/app/src/pages/conversations/composerSendDecision.test.ts
@@ -1,6 +1,10 @@
 import { describe, expect, it } from 'vitest';
 
-import { evaluateComposerSend, handleComposerSlashCommand } from './composerSendDecision';
+import {
+  evaluateComposerSend,
+  getComposerBlockedSendFeedback,
+  handleComposerSlashCommand,
+} from './composerSendDecision';
 
 describe('evaluateComposerSend', () => {
   it('blocks empty input', () => {
@@ -28,6 +32,32 @@ describe('evaluateComposerSend', () => {
     expect(decision.shouldSend).toBe(false);
   });
 
+  it('blocks when no thread is selected', () => {
+    const decision = evaluateComposerSend({
+      rawText: 'hello',
+      selectedThreadId: null,
+      composerInteractionBlocked: false,
+      isAtLimit: false,
+      socketStatus: 'connected',
+    });
+
+    expect(decision.blockReason).toBe('missing_thread');
+    expect(decision.shouldSend).toBe(false);
+  });
+
+  it('blocks while composer interaction is disabled', () => {
+    const decision = evaluateComposerSend({
+      rawText: 'hello',
+      selectedThreadId: 'thread-1',
+      composerInteractionBlocked: true,
+      isAtLimit: false,
+      socketStatus: 'connected',
+    });
+
+    expect(decision.blockReason).toBe('composer_blocked');
+    expect(decision.shouldSend).toBe(false);
+  });
+
   it('blocks when socket is disconnected', () => {
     const decision = evaluateComposerSend({
       rawText: 'hello',
@@ -61,4 +91,43 @@ describe('handleComposerSlashCommand', () => {
       blockedByWelcomeLock: true,
     });
   });
+
+  it('consumes /clear when welcome lock is inactive', () => {
+    expect(handleComposerSlashCommand('/CLEAR', false)).toEqual({
+      kind: 'new_or_clear',
+      blockedByWelcomeLock: false,
+    });
+  });
+
+  it('ignores normal chat text', () => {
+    expect(handleComposerSlashCommand('hello', false)).toEqual({ kind: 'not_handled' });
+  });
+});
+
+describe('getComposerBlockedSendFeedback', () => {
+  it('returns modal and error feedback for usage-limit blocking', () => {
+    expect(getComposerBlockedSendFeedback('usage_limit_reached')).toEqual({
+      showLimitModal: true,
+      error: {
+        code: 'usage_limit_reached',
+        message: 'Usage limit reached. Upgrade or wait for reset.',
+      },
+    });
+  });
+
+  it('returns send error feedback for socket-disconnected blocking', () => {
+    expect(getComposerBlockedSendFeedback('socket_disconnected')).toEqual({
+      showLimitModal: false,
+      error: {
+        code: 'socket_disconnected',
+        message:
+          'Realtime socket is not connected — responses cannot be delivered without a client ID.',
+      },
+    });
+  });
+
+  it('ignores block reasons that do not surface user feedback', () => {
+    expect(getComposerBlockedSendFeedback('empty_input')).toBeNull();
+    expect(getComposerBlockedSendFeedback(undefined)).toBeNull();
+  });
 });
diff --git a/app/src/pages/conversations/composerSendDecision.ts b/app/src/pages/conversations/composerSendDecision.ts
index 90725bf76..e6068b0d8 100644
--- a/app/src/pages/conversations/composerSendDecision.ts
+++ b/app/src/pages/conversations/composerSendDecision.ts
@@ -23,6 +23,11 @@ export interface ComposerSendDecision {
   blockReason?: ComposerSendBlockReason;
 }
 
+export interface ComposerBlockedSendFeedback {
+  showLimitModal: boolean;
+  error: { code: 'usage_limit_reached' | 'socket_disconnected'; message: string };
+}
+
 export const handleComposerSlashCommand = (
   command: string,
   welcomeLocked: boolean
@@ -59,3 +64,30 @@ export const evaluateComposerSend = (args: ComposerSendDecisionArgs): ComposerSe
 
   return { shouldSend: true, trimmedText };
 };
+
+export const getComposerBlockedSendFeedback = (
+  blockReason: ComposerSendBlockReason | undefined
+): ComposerBlockedSendFeedback | null => {
+  if (blockReason === 'usage_limit_reached') {
+    return {
+      showLimitModal: true,
+      error: {
+        code: 'usage_limit_reached',
+        message: 'Usage limit reached. Upgrade or wait for reset.',
+      },
+    };
+  }
+
+  if (blockReason === 'socket_disconnected') {
+    return {
+      showLimitModal: false,
+      error: {
+        code: 'socket_disconnected',
+        message:
+          'Realtime socket is not connected — responses cannot be delivered without a client ID.',
+      },
+    };
+  }
+
+  return null;
+};

From 2b3fffb5971d7bd3235bdc8eacf5b407137bfb78 Mon Sep 17 00:00:00 2001
From: Jwalin Shah <jshah1331@gmail.com>
Date: Tue, 5 May 2026 18:26:34 -0700
Subject: [PATCH 5/6] fix: address composer review feedback

---
 app/src/pages/Conversations.tsx               |  6 ++++--
 .../__tests__/Conversations.render.test.tsx   | 20 ++++++++++---------
 2 files changed, 15 insertions(+), 11 deletions(-)

diff --git a/app/src/pages/Conversations.tsx b/app/src/pages/Conversations.tsx
index 8644a07c1..162c4a3e3 100644
--- a/app/src/pages/Conversations.tsx
+++ b/app/src/pages/Conversations.tsx
@@ -495,6 +495,10 @@ const Conversations = ({ variant = 'page' }: ConversationsProps = {}) => {
 
   const handleSendMessage = async (text?: string) => {
     const normalized = text ?? inputValue;
+    const trimmedInput = normalized.trim();
+
+    if (handleSlashCommand(trimmedInput)) return;
+
     const sendDecision = evaluateComposerSend({
       rawText: normalized,
       selectedThreadId,
@@ -512,8 +516,6 @@ const Conversations = ({ variant = 'page' }: ConversationsProps = {}) => {
       return;
     }
 
-    if (handleSlashCommand(trimmed)) return;
-
     const promptGuard = checkPromptInjection(trimmed);
     if (promptGuard.verdict === 'review' || promptGuard.verdict === 'block') {
       setSendAdvisory(promptGuardMessage(promptGuard));
diff --git a/app/src/pages/__tests__/Conversations.render.test.tsx b/app/src/pages/__tests__/Conversations.render.test.tsx
index a100f2147..1b81bb0d5 100644
--- a/app/src/pages/__tests__/Conversations.render.test.tsx
+++ b/app/src/pages/__tests__/Conversations.render.test.tsx
@@ -13,6 +13,8 @@ import { Provider } from 'react-redux';
 import { MemoryRouter } from 'react-router-dom';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
+import { threadApi } from '../../services/api/threadApi';
+import { chatSend } from '../../services/chatService';
 import chatRuntimeReducer from '../../store/chatRuntimeSlice';
 import socketReducer from '../../store/socketSlice';
 import threadReducer from '../../store/threadSlice';
@@ -416,7 +418,6 @@ describe('Conversations — smoke render (#1123 welcome-lock removal)', () => {
     });
 
     // createNewThread was called — verifies line 919 callback executed
-    const { threadApi } = await import('../../services/api/threadApi');
     expect(threadApi.createNewThread).toHaveBeenCalled();
   });
 
@@ -440,7 +441,6 @@ describe('Conversations — smoke render (#1123 welcome-lock removal)', () => {
     });
 
     // createNewThread was called — verifies line 1061 callback executed
-    const { threadApi } = await import('../../services/api/threadApi');
     expect(threadApi.createNewThread).toHaveBeenCalled();
   });
 
@@ -622,10 +622,15 @@ describe('Conversations — smoke render (#1123 welcome-lock removal)', () => {
     expect(screen.getByText(/10-hour rate limit reached/i)).toBeInTheDocument();
   });
 
-  it('handles /new from the composer without sending chat text', async () => {
-    const { textarea } = await renderSelectedConversation();
-    const { chatSend } = await import('../../services/chatService');
-    const { threadApi } = await import('../../services/api/threadApi');
+  it('handles /new from the composer without a selected thread or sending chat text', async () => {
+    mockGetThreads.mockReturnValue(new Promise(() => {}));
+
+    await act(async () => {
+      await renderConversations({ thread: emptyThreadState, socket: socketState('connected') });
+    });
+    const textarea = await screen.findByPlaceholderText('Type a message...');
+    vi.mocked(threadApi.createNewThread).mockClear();
+    vi.mocked(chatSend).mockClear();
 
     await submitComposerText(textarea, '/new');
 
@@ -638,7 +643,6 @@ describe('Conversations — smoke render (#1123 welcome-lock removal)', () => {
 
   it('shows the usage-limit modal instead of sending when the account is at limit', async () => {
     const { textarea } = await renderSelectedConversation({ isAtLimit: true });
-    const { chatSend } = await import('../../services/chatService');
 
     await submitComposerText(textarea, 'hello at limit');
 
@@ -651,8 +655,6 @@ describe('Conversations — smoke render (#1123 welcome-lock removal)', () => {
 
   it('persists a local user message and sends through chat service for valid input', async () => {
     const { textarea, thread } = await renderSelectedConversation();
-    const { chatSend } = await import('../../services/chatService');
-    const { threadApi } = await import('../../services/api/threadApi');
 
     await submitComposerText(textarea, ' hello cloud ');
 

From dc8058c8a00796cbe9857d4bc4ded8d780430068 Mon Sep 17 00:00:00 2001
From: Jwalin Shah <jshah1331@gmail.com>
Date: Tue, 5 May 2026 19:13:04 -0700
Subject: [PATCH 6/6] Stabilize core state current user assertion

---
 app/src/providers/__tests__/CoreStateProvider.test.tsx | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/app/src/providers/__tests__/CoreStateProvider.test.tsx b/app/src/providers/__tests__/CoreStateProvider.test.tsx
index f8a0d0847..dba627f3d 100644
--- a/app/src/providers/__tests__/CoreStateProvider.test.tsx
+++ b/app/src/providers/__tests__/CoreStateProvider.test.tsx
@@ -237,6 +237,8 @@ describe('CoreStateProvider — identity-change cache clearing', () => {
     );
 
     await waitFor(() => expect(screen.getByTestId('ready').textContent).toBe('ready'));
-    expect(ctx?.snapshot.currentUser).toEqual({ first_name: 'Ada', username: 'ada' });
+    await waitFor(() =>
+      expect(ctx?.snapshot.currentUser).toEqual({ first_name: 'Ada', username: 'ada' })
+    );
   });
 });