fix(shortcuts): New Chat fires from composer + never reopens a pending send

Two review fixes:
- chat.new (⌘N/Ctrl+N) gains allowInInput: true so it fires while the chat
  composer textarea is focused (the normal state when starting fresh) and
  preventDefault stops the OS "new window" accelerator swallowing it.
- Lift the optimistic-send signal into Redux: chatRuntimeSlice gains
  pendingSendThreadIds with mark/clear reducers, set synchronously the instant a
  user sends (mirrored from Conversations' existing pending-send helpers, before
  addMessageLocal is awaited). useNewChat now also excludes pending-send threads,
  closing the earliest window where messageCount, messagesByThreadId and
  streamingAssistantByThread are all still empty.

Author: senamakel

app/src/components/layout/shell/useNewChat.test.tsx

@@ -32,12 +32,16 @@ const mockDispatch = vi.fn();
 let mockThreads: MockThread[] = [];
 let mockMessagesByThreadId: Record<string, unknown[]> = {};
 let mockStreamingByThread: Record<string, unknown> = {};
+let mockPendingSendThreadIds: Record<string, true> = {};
 vi.mock('../../../store/hooks', () => ({
   useAppDispatch: () => mockDispatch,
   useAppSelector: (sel: (s: unknown) => unknown) =>
     sel({
       thread: { threads: mockThreads, messagesByThreadId: mockMessagesByThreadId },
-      chatRuntime: { streamingAssistantByThread: mockStreamingByThread },
+      chatRuntime: {
+        streamingAssistantByThread: mockStreamingByThread,
+        pendingSendThreadIds: mockPendingSendThreadIds,
+      },
     }),
 }));
 
@@ -64,6 +68,7 @@ describe('useNewChat', () => {
     mockThreads = [];
     mockMessagesByThreadId = {};
     mockStreamingByThread = {};
+    mockPendingSendThreadIds = {};
     mockDispatch.mockImplementation((action: MockAction) => {
       if (action?.type === 'thread/createNewThread') {
         return { unwrap: () => Promise.resolve({ id: 'fresh-thread' }) };
@@ -129,6 +134,23 @@ describe('useNewChat', () => {
     });
   });
 
+  it('does not reuse a thread with an optimistic send pending (pre-fulfillment window)', async () => {
+    // Earliest window: send recorded in pendingSendThreadIds before
+    // addMessageLocal resolves and before any streaming state exists.
+    mockThreads = [{ id: 'optimistic', messageCount: 0 }];
+    mockMessagesByThreadId = {};
+    mockStreamingByThread = {};
+    mockPendingSendThreadIds = { optimistic: true };
+    const { result } = renderHook(() => useNewChat(), { wrapper });
+    result.current();
+
+    expect(mockNavigate).not.toHaveBeenCalledWith('/chat/optimistic');
+    expect(dispatchedTypes()).toContain('thread/createNewThread');
+    await waitFor(() => {
+      expect(mockNavigate).toHaveBeenCalledWith('/chat/fresh-thread');
+    });
+  });
+
   it('reuses a genuinely-blank thread (count-empty, no cache, no in-flight turn)', () => {
     // Round-trip of the earlier review: a blank current chat must be reused
     // rather than spawning yet another empty thread.

app/src/components/layout/shell/useNewChat.ts

@@ -30,12 +30,12 @@ import { chatThreadPath } from '../../../utils/chatRoutes';
  * count, no locally-cached messages, and no in-flight assistant turn. The first
  * two guard the post-send window where `addMessageLocal` has populated
  * `messagesByThreadId` (or the thread-list `messageCount`) but the other lags;
- * the streaming check (`chatRuntime.streamingAssistantByThread`, whose
- * `started` lifecycle is set the moment the user sends) covers the
- * pre-fulfillment window. We intentionally key off "is this thread actually
- * occupied?" rather than "is it selected?" so a genuinely-blank current chat is
- * still reused (no piling up of empties) while a chat with a send in flight is
- * never reopened.
+ * the `pendingSendThreadIds` marker (set synchronously the instant the user
+ * sends, before `addMessageLocal` is even awaited) closes the earliest
+ * optimistic-send window, and the streaming buffer covers later ones. We key
+ * off "is this thread actually occupied?" rather than "is it selected?" so a
+ * genuinely-blank current chat is still reused (no piling up of empties) while
+ * a chat with a send in flight is never reopened.
  */
 export function useNewChat(): () => void {
   const navigate = useNavigate();
@@ -45,6 +45,7 @@ export function useNewChat(): () => void {
   // Optional-chained so minimal test stores without the chatRuntime reducer
   // still resolve (mirrors `selectPanelLayout`'s defensive access).
   const streamingByThread = useAppSelector(state => state.chatRuntime?.streamingAssistantByThread);
+  const pendingSendThreadIds = useAppSelector(state => state.chatRuntime?.pendingSendThreadIds);
 
   return useCallback(() => {
     dispatch(setActiveAccount(AGENT_ACCOUNT_ID));
@@ -53,7 +54,8 @@ export function useNewChat(): () => void {
       thr =>
         (thr.messageCount ?? 0) === 0 &&
         (messagesByThreadId[thr.id]?.length ?? 0) === 0 &&
-        !streamingByThread?.[thr.id]
+        !streamingByThread?.[thr.id] &&
+        !pendingSendThreadIds?.[thr.id]
     );
     if (empty) {
       dispatch(setSelectedThread(empty.id));
@@ -74,5 +76,5 @@ export function useNewChat(): () => void {
         // diagnosable. The user stays where they are (no broken navigation).
         console.error('[new-chat] createNewThread failed', err);
       });
-  }, [navigate, dispatch, threads, messagesByThreadId, streamingByThread]);
+  }, [navigate, dispatch, threads, messagesByThreadId, streamingByThread, pendingSendThreadIds]);
 }

app/src/lib/commands/globalActions.ts

@@ -180,6 +180,10 @@ function buildGlobalActions(h: GlobalActionHandlers): GlobalActionDef[] {
       labelKey: 'shortcuts.action.newChat',
       group: 'Chat',
       shortcut: 'mod+n',
+      // Must fire from the composer too — that's the normal focus state when a
+      // user decides to start fresh — and preventDefault keeps the OS "new
+      // window" accelerator from swallowing it.
+      allowInInput: true,
       handler: h.newChat,
       keywords: ['new', 'thread', 'compose', 'conversation', 'session'],
     },

app/src/pages/Conversations.tsx

@@ -48,9 +48,11 @@ import {
   beginInferenceTurn,
   clearFollowupsForThread,
   clearRuntimeForThread,
+  clearThreadSendPending,
   enqueueFollowup,
   fetchAndHydrateTurnState,
   markSubagentCancelled,
+  markThreadSendPending,
   type QueuedFollowup,
   registerParallelRequest,
   setTaskBoardForThread,
@@ -287,22 +289,32 @@ const Conversations = ({
   const [pendingSendingThreadIds, setPendingSendingThreadIds] = useState<ReadonlySet<string>>(
     () => new Set()
   );
-  const addPendingSendingThread = useCallback((threadId: string) => {
-    setPendingSendingThreadIds(prev => {
-      if (prev.has(threadId)) return prev;
-      const next = new Set(prev);
-      next.add(threadId);
-      return next;
-    });
-  }, []);
-  const removePendingSendingThread = useCallback((threadId: string) => {
-    setPendingSendingThreadIds(prev => {
-      if (!prev.has(threadId)) return prev;
-      const next = new Set(prev);
-      next.delete(threadId);
-      return next;
-    });
-  }, []);
+  const addPendingSendingThread = useCallback(
+    (threadId: string) => {
+      // Mirror to Redux so global surfaces (e.g. the New Chat shortcut) can see
+      // an in-flight send before any message/streaming state exists.
+      dispatch(markThreadSendPending({ threadId }));
+      setPendingSendingThreadIds(prev => {
+        if (prev.has(threadId)) return prev;
+        const next = new Set(prev);
+        next.add(threadId);
+        return next;
+      });
+    },
+    [dispatch]
+  );
+  const removePendingSendingThread = useCallback(
+    (threadId: string) => {
+      dispatch(clearThreadSendPending({ threadId }));
+      setPendingSendingThreadIds(prev => {
+        if (!prev.has(threadId)) return prev;
+        const next = new Set(prev);
+        next.delete(threadId);
+        return next;
+      });
+    },
+    [dispatch]
+  );
   const socketStatus = useAppSelector(selectSocketStatus);
   const agentProfiles = useAppSelector(selectAgentProfiles);
   const selectedAgentProfileId = useAppSelector(selectActiveAgentProfileId);

app/src/store/chatRuntimeSlice.ts

@@ -313,6 +313,13 @@ export type QueueMode = 'interrupt' | 'steer' | 'followup' | 'collect' | 'parall
 interface ChatRuntimeState {
   inferenceStatusByThread: Record<string, InferenceStatus>;
   streamingAssistantByThread: Record<string, StreamingAssistantState>;
+  /**
+   * Threads with an optimistic user send in flight, set the instant the user
+   * sends (before `addMessageLocal` resolves and before any streaming state
+   * exists). Lets global surfaces — e.g. the New Chat shortcut — tell a
+   * mid-send conversation apart from a genuinely-blank one.
+   */
+  pendingSendThreadIds: Record<string, true>;
   /**
    * Live streams for concurrent PARALLEL (forked) turns on a thread, nested
    * `threadId -> requestId -> stream`. A separate lane from
@@ -390,6 +397,7 @@ export interface QueuedFollowup {
 const initialState: ChatRuntimeState = {
   inferenceStatusByThread: {},
   streamingAssistantByThread: {},
+  pendingSendThreadIds: {},
   parallelStreamsByThread: {},
   parallelRequestThreads: {},
   toolTimelineByThread: {},
@@ -657,6 +665,14 @@ const chatRuntimeSlice = createSlice({
     clearStreamingAssistantForThread: (state, action: PayloadAction<{ threadId: string }>) => {
       delete state.streamingAssistantByThread[action.payload.threadId];
     },
+    /** Mark a thread as having an optimistic user send in flight. */
+    markThreadSendPending: (state, action: PayloadAction<{ threadId: string }>) => {
+      state.pendingSendThreadIds[action.payload.threadId] = true;
+    },
+    /** Clear the in-flight-send marker once the send settles (or fails). */
+    clearThreadSendPending: (state, action: PayloadAction<{ threadId: string }>) => {
+      delete state.pendingSendThreadIds[action.payload.threadId];
+    },
     /**
      * Register a parallel (forked) turn so its socket events route to the
      * parallel lane. Called when a `queueMode: 'parallel'` send is accepted.
@@ -1068,6 +1084,7 @@ const chatRuntimeSlice = createSlice({
       delete state.pendingPlanReviewByThread[action.payload.threadId];
       delete state.queueStatusByThread[action.payload.threadId];
       delete state.queuedFollowupsByThread[action.payload.threadId];
+      delete state.pendingSendThreadIds[action.payload.threadId];
       // Note: artifactsByThread intentionally NOT cleared here. The
       // ArtifactCard renders inline in the message timeline, so the
       // snapshot needs to survive turn boundaries — historic artifacts
@@ -1088,6 +1105,7 @@ const chatRuntimeSlice = createSlice({
       state.artifactsByThread = {};
       state.queueStatusByThread = {};
       state.queuedFollowupsByThread = {};
+      state.pendingSendThreadIds = {};
     },
     recordChatTurnUsage: (
       state,
@@ -1224,6 +1242,8 @@ export const {
   clearInferenceStatusForThread,
   setStreamingAssistantForThread,
   clearStreamingAssistantForThread,
+  markThreadSendPending,
+  clearThreadSendPending,
   registerParallelRequest,
   setParallelStream,
   clearParallelRequest,