@nextclaw/ui 0.27.0 → 0.27.2

package/src/features/chat/features/conversation/hooks/__tests__/use-session-conversation-controller.test.tsx

@@ -2,8 +2,13 @@ import { act, renderHook, waitFor } from '@testing-library/react';
 import { describe, expect, it, vi } from 'vitest';
 import { NextClawClientError, type UiNcpSessionQueuedInputView } from '@nextclaw/client-sdk';
 import type { NcpAgentSendEnvelope, NcpMessage, NcpRunHandle } from '@nextclaw/ncp';
+import { NcpHttpSendError } from '@nextclaw/ncp-http-agent-client';
+
+const fetchNcpSessionMessages = vi.hoisted(() => vi.fn());
+vi.mock('@/shared/lib/api', () => ({ fetchNcpSessionMessages }));
 
 import { useSessionConversationController } from '@/features/chat/features/conversation/hooks/use-session-conversation-controller';
+import type { ChatComposerSubmission } from '@/features/chat/stores/chat-composer-draft.store';
 
 type TestAgentSend = (envelope: NcpAgentSendEnvelope) => Promise<NcpRunHandle | null>;
 
@@ -107,6 +112,7 @@ function createControllerParams(params: {
       composerFocusRequestId: 0,
       nodes: [createTextNode('next task')],
       pendingProjectRoot: null,
+      pendingSubmission: null as ChatComposerSubmission | null,
       pendingSessionType: 'default',
       selectedModel: undefined,
       selectedSessionType: 'default',
@@ -126,13 +132,58 @@ function createControllerParams(params: {
     },
     selectedAgentId: 'main',
     sessionKey: 'session-1',
-    resetComposer: vi.fn(),
     restoreComposer: vi.fn(),
+    beginSubmission: vi.fn(),
+    acceptSubmission: vi.fn(),
+    failSubmission: vi.fn(),
+    restoreSubmission: vi.fn(),
+    discardSubmission: vi.fn(),
     onSessionMaterialized: vi.fn(),
     setSendError: vi.fn(),
   };
 }
 
+describe('useSessionConversationController HTTP message identity', () => {
+  it.each(['send', 'sendSteering', 'sendPresetMessage'] as const)(
+    'supports %s over HTTP without randomUUID and keeps submission identities distinct',
+    async (action) => {
+      const params = createControllerParams({ isRunning: false });
+      const { result } = renderHook(() => useSessionConversationController(params));
+      const getRandomValues = globalThis.crypto.getRandomValues.bind(globalThis.crypto);
+      const now = vi.spyOn(Date, 'now').mockReturnValue(1780000000000);
+      vi.stubGlobal('crypto', { getRandomValues });
+      try {
+        await act(async () => {
+          if (action === 'sendPresetMessage') {
+            await result.current.sendPresetMessage('Update this session title');
+            await result.current.sendPresetMessage('Update this session title again');
+          } else {
+            await result.current[action]();
+            await result.current[action]();
+          }
+        });
+      } finally {
+        now.mockRestore();
+        vi.unstubAllGlobals();
+      }
+
+      expect(params.agent.send).toHaveBeenCalledTimes(2);
+      const envelopes = params.agent.send.mock.calls.map(([envelope]) => envelope);
+      expect(envelopes[0].message.id).not.toBe(envelopes[1].message.id);
+      for (const envelope of envelopes) {
+        expect(envelope.message.id).toMatch(/^user-/);
+        expect(envelope.idempotencyKey).toBe(envelope.message.id);
+        expect(envelope.sessionId).toBe('session-1');
+        if (action !== 'sendPresetMessage') {
+          expect(params.beginSubmission).toHaveBeenCalledWith(envelope, expect.any(Object));
+          expect(params.acceptSubmission).toHaveBeenCalledWith(envelope.message.id);
+        }
+      }
+      if (action === 'sendPresetMessage') expect(params.beginSubmission).not.toHaveBeenCalled();
+    },
+  );
+});
+
 describe('useSessionConversationController backend run queue', () => {
   it('preallocates one stable session identity for the first root message', async () => {
     const send = vi.fn<TestAgentSend>(async (envelope) => {
@@ -162,6 +213,7 @@ describe('useSessionConversationController backend run queue', () => {
     const envelope = send.mock.calls[0]?.[0];
     expect(envelope?.sessionId).toMatch(/^ncp-/);
     expect(envelope?.message.sessionId).toBe(envelope?.sessionId);
+    expect(envelope?.idempotencyKey).toBe(envelope?.message.id);
     expect(params.onSessionMaterialized).toHaveBeenCalledWith(envelope?.sessionId);
   });
 
@@ -182,7 +234,21 @@ describe('useSessionConversationController backend run queue', () => {
         parts: [{ type: 'text', text: 'next task' }],
       }),
     });
-    expect(params.resetComposer).toHaveBeenCalledTimes(1);
+    expect(params.beginSubmission).toHaveBeenCalledTimes(1);
+  });
+
+  it('attempts a send when a nonempty draft has a stale blocked runtime status', async () => {
+    const send = createSendMock();
+    const params = { ...createControllerParams({ isRunning: false, send }), isRuntimeBlocked: true };
+    const { result } = renderHook(() => useSessionConversationController(params));
+
+    expect(result.current.sendDisabled).toBe(false);
+    await act(async () => {
+      await result.current.send();
+    });
+
+    expect(send).toHaveBeenCalledTimes(1);
+    expect(params.setSendError).toHaveBeenLastCalledWith(null);
   });
 
   it('uses prefer-steer for command/control-enter submission without changing the send button path', async () => {
@@ -241,7 +307,7 @@ describe('useSessionConversationController backend run queue', () => {
       }),
     });
     expect(envelope?.metadata).not.toHaveProperty('ui_inline_tokens');
-    expect(params.resetComposer).not.toHaveBeenCalled();
+    expect(params.beginSubmission).not.toHaveBeenCalled();
     expect(params.restoreComposer).not.toHaveBeenCalled();
   });
 
@@ -257,7 +323,7 @@ describe('useSessionConversationController backend run queue', () => {
       await expect(result.current.sendPresetMessage('Update title')).rejects.toThrow(sendError);
     });
 
-    expect(params.resetComposer).not.toHaveBeenCalled();
+    expect(params.beginSubmission).not.toHaveBeenCalled();
     expect(params.restoreComposer).not.toHaveBeenCalled();
     expect(params.setSendError).toHaveBeenLastCalledWith(sendError.message);
   });
@@ -275,7 +341,7 @@ describe('useSessionConversationController backend run queue', () => {
       submission = result.current.send();
     });
 
-    expect(params.resetComposer).toHaveBeenCalledTimes(1);
+    expect(params.beginSubmission).toHaveBeenCalledTimes(1);
     expect(result.current.queuedInputs).toEqual([
       expect.objectContaining({
         isSubmitting: true,
@@ -306,13 +372,64 @@ describe('useSessionConversationController backend run queue', () => {
     });
 
     expect(result.current.queuedInputs).toEqual([]);
-    expect(params.restoreComposer).toHaveBeenCalledWith(expect.objectContaining({
-      text: 'next task',
-    }));
-    expect(params.setSendError).toHaveBeenLastCalledWith(sendError.message);
+    expect(params.failSubmission).toHaveBeenCalledWith(expect.any(String), 'uncertain', sendError.message);
     expect(params.runQueue.refreshQueuedInputs).not.toHaveBeenCalled();
   });
 
+  it('shows a send failure and restores the draft when the client returns no acceptance handle', async () => {
+    const send = createSendMock(null);
+    const params = createControllerParams({ isRunning: false, send });
+    const { result } = renderHook(() => useSessionConversationController(params));
+
+    await act(async () => {
+      await expect(result.current.send()).rejects.toThrow('Failed to send message');
+    });
+
+    expect(params.failSubmission).toHaveBeenCalledWith(expect.any(String), 'rejected', 'Failed to send message');
+    expect(params.onSessionMaterialized).not.toHaveBeenCalled();
+  });
+
+  it('classifies an explicit HTTP rejection so the draft can be restored', async () => {
+    const error = new NcpHttpSendError('invalid request', true);
+    const send = vi.fn<TestAgentSend>(async () => { throw error; });
+    const params = createControllerParams({ isRunning: false, send });
+    const { result } = renderHook(() => useSessionConversationController(params));
+    await act(async () => {
+      await expect(result.current.send()).rejects.toThrow(error);
+    });
+    expect(params.failSubmission).toHaveBeenCalledWith(expect.any(String), 'rejected', 'invalid request');
+  });
+
+  it('rechecks the original message before retrying with the same identity', async () => {
+    fetchNcpSessionMessages.mockResolvedValue({ messages: [] });
+    const params = createControllerParams({ isRunning: false });
+    const envelope: NcpAgentSendEnvelope = {
+      sessionId: 'session-1', idempotencyKey: 'user-original',
+      message: {
+        id: 'user-original', sessionId: 'session-1', role: 'user', status: 'final',
+        timestamp: '2026-09-24T00:00:00.000Z', parts: [{ type: 'text', text: 'next task' }],
+      },
+    };
+    params.inputSnapshot.pendingSubmission = {
+      envelope,
+      composer: {
+        text: 'next task', nodes: [createTextNode('next task')],
+        selectedSkills: [], skillRecords: [], attachments: [],
+      },
+      status: 'uncertain',
+    };
+    const { result } = renderHook(() => useSessionConversationController(params));
+    expect(result.current.sendDisabled).toBe(true);
+    await act(async () => {
+      await result.current.send();
+      await result.current.retryPendingSubmission();
+    });
+    expect(fetchNcpSessionMessages).toHaveBeenCalledWith('session-1', { limit: 100 });
+    expect(params.agent.send).toHaveBeenCalledTimes(1);
+    expect(params.agent.send).toHaveBeenCalledWith(envelope);
+    expect(params.acceptSubmission).toHaveBeenCalledWith('user-original');
+  });
+
   it('keeps an existing session bound to its agent instead of the global draft selection', async () => {
     const send = createSendMock();
     const params = createControllerParams({ isRunning: false, send });
@@ -406,7 +523,7 @@ describe('useSessionConversationController backend run queue', () => {
 
     expect(params.agent.continueRun).toHaveBeenCalledWith({ sessionId: 'session-1' });
     expect(params.agent.send).not.toHaveBeenCalled();
-    expect(params.resetComposer).not.toHaveBeenCalled();
+    expect(params.beginSubmission).not.toHaveBeenCalled();
   });
 
   it('keeps continuation available but restores send as primary when the user types', () => {

package/src/features/chat/features/conversation/hooks/__tests__/use-session-conversation-input-state.test.tsx

@@ -36,7 +36,7 @@ const THINKING_MODEL_OPTIONS: ChatModelOption[] = [
 describe('useSessionConversationInputState session preferences', () => {
   beforeEach(() => {
     window.localStorage.clear();
-    useChatComposerDraftStore.setState({ drafts: {} });
+    useChatComposerDraftStore.setState({ drafts: {}, submissions: {}, recentSubmittedNodes: {} });
     useChatThreadStore.getState().setSnapshot({ draftProjectRoot: null });
   });
 
@@ -213,7 +213,17 @@ describe('useSessionConversationInputState session preferences', () => {
         selectedSkills: [],
         skillRecords: [],
       });
-      result.current.inputActions.resetComposer();
+      result.current.inputActions.beginSubmission({
+        sessionId: 'session-sent',
+        message: {
+          id: 'user-sent', sessionId: 'session-sent', role: 'user', status: 'final',
+          timestamp: '2026-09-24T00:00:00.000Z',
+          parts: [{ type: 'text', text: '已经发送的消息' }],
+        },
+      }, {
+        text: '已经发送的消息', nodes: [], selectedSkills: [], skillRecords: [], attachments: [],
+      });
+      result.current.inputActions.acceptSubmission('user-sent');
     });
     rerender({ sessionKey: 'session-unsent' });
     act(() => {

package/src/features/chat/features/conversation/hooks/use-session-conversation-controller.ts

@@ -5,12 +5,14 @@ import type {
   UiNcpSessionQueuedInputView,
 } from '@nextclaw/client-sdk';
 import type { NcpAgentSendEnvelope, NcpRunHandle } from '@nextclaw/ncp';
+import { NcpHttpSendError } from '@nextclaw/ncp-http-agent-client';
 
 import {
   createChatComposerNodesFromDraft,
   deriveNcpMessagePartsFromComposer,
 } from '@/features/chat/features/input/utils/chat-composer-state.utils';
 import { isNcpChatSendDisabled } from '@/features/chat/features/input/utils/ncp-chat-input-availability.utils';
+import { t } from '@/shared/lib/i18n';
 import { buildChatRunMetadata } from '@/features/chat/features/session/utils/chat-run-metadata.utils';
 import { createNcpSessionId } from '@/features/chat/features/session/utils/ncp-session-adapter.utils';
 import type { SessionQueuedInputAttachmentPreview } from '@/features/chat/features/conversation/utils/session-queued-input.utils';
@@ -25,6 +27,7 @@ import {
   useSessionConversationRecoveryActions,
   type SessionConversationRecoveryAgent,
 } from './use-session-conversation-recovery-actions';
+import { useSessionSubmissionRecovery } from './use-session-submission-recovery';
 
 type SessionConversationInputQuery = ReturnType<typeof useSessionConversationInputQuery>;
 type ComposerDraftSnapshot = Pick<
@@ -80,8 +83,12 @@ type UseSessionConversationControllerParams = {
   readonly selectedAgentId: string;
   readonly sessionKey: string | null;
   readonly onSessionMaterialized?: (sessionKey: string) => void;
-  readonly resetComposer: () => void;
   readonly restoreComposer: (snapshot: ComposerDraftSnapshot) => void;
+  readonly beginSubmission: (envelope: NcpAgentSendEnvelope, composer: ComposerDraftSnapshot) => void;
+  readonly acceptSubmission: (messageId: string) => void;
+  readonly failSubmission: (messageId: string, status: 'uncertain' | 'rejected', message: string) => void;
+  readonly restoreSubmission: (messageId: string) => void;
+  readonly discardSubmission: (messageId: string) => void;
   readonly setSendError: (message: string | null) => void;
 };
 
@@ -90,7 +97,6 @@ type BuildSubmissionDraftParams = {
   readonly composerSnapshot?: ComposerDraftSnapshot;
   readonly inputSnapshot: SessionConversationInputSnapshot;
   readonly inputQuery: SessionConversationInputQuery;
-  readonly isRuntimeBlocked: boolean;
   readonly materializationContext?: SessionConversationMaterializationContext | null;
   readonly selectedAgentId: string;
   readonly sessionKey: string | null;
@@ -111,21 +117,12 @@ const resolveModelForSend = (value: string | null | undefined): string | undefin
   return trimmed || undefined;
 };
 
-function buildInputAvailabilitySnapshot(inputQuery: SessionConversationInputQuery) {
-  return {
-    isProviderStateResolved: inputQuery.isProviderStateResolved,
-    modelOptions: inputQuery.modelOptions,
-    sessionTypeUnavailable: inputQuery.sessionTypeState.sessionTypeUnavailable,
-  };
-}
-
 function buildSubmissionDraft(params: BuildSubmissionDraftParams): SubmissionDraft | null {
   const {
     agentIsSending,
     composerSnapshot: requestedComposerSnapshot,
     inputQuery,
     inputSnapshot,
-    isRuntimeBlocked,
     materializationContext,
     selectedAgentId,
     sessionKey,
@@ -142,10 +139,9 @@ function buildSubmissionDraft(params: BuildSubmissionDraftParams): SubmissionDra
     composerSnapshot.attachments,
   );
   if (
+    inputSnapshot.pendingSubmission ||
     isNcpChatSendDisabled({
-      snapshot: buildInputAvailabilitySnapshot(inputQuery),
       hasSendableDraft: hasSendableMessagePart(currentParts),
-      isRuntimeBlocked,
     }) ||
     agentIsSending
   ) {
@@ -195,8 +191,12 @@ function buildSubmissionEnvelope(
   sessionKey: string | null,
   delivery: NcpAgentSendEnvelope['delivery'] = 'queue',
 ): NcpAgentSendEnvelope | null {
+  // getRandomValues is also available on HTTP origins, unlike randomUUID.
+  const messageIdBytes = crypto.getRandomValues(new Uint8Array(16));
+  const messageId = `user-${Array.from(messageIdBytes, (byte) => byte.toString(16).padStart(2, '0')).join('')}`;
   const envelope = buildNcpRequestEnvelope({
     sessionId: sessionKey ?? undefined,
+    messageId,
     text: draft.composerSnapshot.text.trim(),
     attachments: [...draft.composerSnapshot.attachments],
     parts: deriveNcpMessagePartsFromComposer(
@@ -205,7 +205,7 @@ function buildSubmissionEnvelope(
     ),
     metadata: draft.metadata,
   });
-  return envelope ? { ...envelope, delivery } : null;
+  return envelope ? { ...envelope, delivery, idempotencyKey: envelope.message.id } : null;
 }
 
 function useSubmissionDraftRunner(params: {
@@ -213,8 +213,9 @@ function useSubmissionDraftRunner(params: {
   readonly clearSubmittingInput: (input: SubmittingQueuedInput) => void;
   readonly materializationContext?: SessionConversationMaterializationContext | null;
   readonly onSessionMaterialized?: (sessionKey: string) => void;
-  readonly resetComposer: () => void;
-  readonly restoreComposer: (snapshot: ComposerDraftSnapshot) => void;
+  readonly beginSubmission: (envelope: NcpAgentSendEnvelope, composer: ComposerDraftSnapshot) => void;
+  readonly acceptSubmission: (messageId: string) => void;
+  readonly failSubmission: (messageId: string, status: 'uncertain' | 'rejected', message: string) => void;
   readonly runQueue: SessionRunQueue;
   readonly sessionKey: string | null;
   readonly setSendError: (message: string | null) => void;
@@ -225,8 +226,9 @@ function useSubmissionDraftRunner(params: {
     clearSubmittingInput,
     materializationContext,
     onSessionMaterialized,
-    resetComposer,
-    restoreComposer,
+    beginSubmission,
+    acceptSubmission,
+    failSubmission,
     runQueue,
     sessionKey,
     setSendError,
@@ -244,10 +246,16 @@ function useSubmissionDraftRunner(params: {
     const queuedSubmission = agent.isRunning && delivery === 'queue'
       ? stageSubmittingInput(envelope)
       : null;
-    if (composerBehavior === 'reset-and-restore') resetComposer();
+    if (composerBehavior === 'reset-and-restore') beginSubmission(envelope, draft.composerSnapshot);
     setSendError(null);
+    let definitelyRejected = false;
     try {
       const handle = await agent.send(envelope);
+      if (!handle) {
+        definitelyRejected = true;
+        throw new Error(t('chatSendFailed'));
+      }
+      if (composerBehavior === 'reset-and-restore') acceptSubmission(envelope.message.id);
       if (handle?.delivery === 'steered') {
         await runQueue.refreshPendingInputs().catch(() => undefined);
       } else if (handle?.delivery === 'queued') {
@@ -261,8 +269,12 @@ function useSubmissionDraftRunner(params: {
       }
     } catch (error) {
       if (queuedSubmission) clearSubmittingInput(queuedSubmission);
-      if (composerBehavior === 'reset-and-restore') restoreComposer(draft.composerSnapshot);
-      setSendError(error instanceof Error ? error.message : String(error));
+      const message = error instanceof Error ? error.message : String(error);
+      if (composerBehavior === 'reset-and-restore') {
+        failSubmission(envelope.message.id,
+          definitelyRejected || (error instanceof NcpHttpSendError && error.sendRejected) ? 'rejected' : 'uncertain',
+          message);
+      } else setSendError(message);
       throw error;
     }
   }, [
@@ -270,8 +282,9 @@ function useSubmissionDraftRunner(params: {
     clearSubmittingInput,
     materializationContext,
     onSessionMaterialized,
-    resetComposer,
-    restoreComposer,
+    beginSubmission,
+    acceptSubmission,
+    failSubmission,
     runQueue,
     sessionKey,
     setSendError,
@@ -283,7 +296,6 @@ function useSteeringSubmission(params: {
   readonly agent: SessionConversationAgent;
   readonly inputSnapshot: SessionConversationInputSnapshot;
   readonly inputQuery: SessionConversationInputQuery;
-  readonly isRuntimeBlocked: boolean;
   readonly materializationContext?: SessionConversationMaterializationContext | null;
   readonly selectedAgentId: string;
   readonly sessionKey: string | null;
@@ -297,7 +309,6 @@ function useSteeringSubmission(params: {
     agent,
     inputQuery,
     inputSnapshot,
-    isRuntimeBlocked,
     materializationContext,
     selectedAgentId,
     sessionKey,
@@ -308,7 +319,6 @@ function useSteeringSubmission(params: {
       agentIsSending: agent.isSending,
       inputSnapshot,
       inputQuery,
-      isRuntimeBlocked,
       materializationContext,
       selectedAgentId,
       sessionKey,
@@ -318,7 +328,6 @@ function useSteeringSubmission(params: {
     agent.isSending,
     inputQuery,
     inputSnapshot,
-    isRuntimeBlocked,
     materializationContext,
     selectedAgentId,
     sessionKey,
@@ -331,7 +340,6 @@ function usePrimarySubmission(params: {
   readonly continueRun: () => Promise<void>;
   readonly inputSnapshot: SessionConversationInputSnapshot;
   readonly inputQuery: SessionConversationInputQuery;
-  readonly isRuntimeBlocked: boolean;
   readonly materializationContext?: SessionConversationMaterializationContext | null;
   readonly primaryAction: 'continue' | 'send';
   readonly selectedAgentId: string;
@@ -346,7 +354,6 @@ function usePrimarySubmission(params: {
     continueRun,
     inputQuery,
     inputSnapshot,
-    isRuntimeBlocked,
     materializationContext,
     primaryAction,
     selectedAgentId,
@@ -359,7 +366,6 @@ function usePrimarySubmission(params: {
       agentIsSending: agent.isSending,
       inputSnapshot,
       inputQuery,
-      isRuntimeBlocked,
       materializationContext,
       selectedAgentId,
       sessionKey,
@@ -370,7 +376,6 @@ function usePrimarySubmission(params: {
     continueRun,
     inputQuery,
     inputSnapshot,
-    isRuntimeBlocked,
     materializationContext,
     primaryAction,
     selectedAgentId,
@@ -379,6 +384,32 @@ function usePrimarySubmission(params: {
   ]);
 }
 
+function usePresetSubmission(params: {
+  readonly agent: SessionConversationAgent;
+  readonly inputSnapshot: SessionConversationInputSnapshot;
+  readonly inputQuery: SessionConversationInputQuery;
+  readonly materializationContext?: SessionConversationMaterializationContext | null;
+  readonly selectedAgentId: string;
+  readonly sessionKey: string | null;
+  readonly submitDraft: (draft: SubmissionDraft, behavior: SubmissionComposerBehavior) => Promise<void>;
+}) {
+  const { agent, inputSnapshot, inputQuery, materializationContext, selectedAgentId, sessionKey, submitDraft } = params;
+  return useCallback(async (message: string) => {
+    const text = message.trim();
+    if (!text) return;
+    const draft = buildSubmissionDraft({
+      agentIsSending: agent.isSending,
+      composerSnapshot: {
+        text,
+        nodes: createChatComposerNodesFromDraft(text),
+        selectedSkills: [], skillRecords: [], attachments: [],
+      },
+      inputSnapshot, inputQuery, materializationContext, selectedAgentId, sessionKey,
+    });
+    if (draft) await submitDraft(draft, 'preserve');
+  }, [agent.isSending, inputQuery, inputSnapshot, materializationContext, selectedAgentId, sessionKey, submitDraft]);
+}
+
 export function useSessionConversationController(params: UseSessionConversationControllerParams) {
   const {
     agent,
@@ -390,8 +421,12 @@ export function useSessionConversationController(params: UseSessionConversationC
     selectedAgentId,
     sessionKey,
     onSessionMaterialized,
-    resetComposer,
     restoreComposer,
+    beginSubmission,
+    acceptSubmission,
+    failSubmission,
+    restoreSubmission,
+    discardSubmission,
     setSendError,
   } = params;
   const {
@@ -421,12 +456,10 @@ export function useSessionConversationController(params: UseSessionConversationC
   );
   const primaryAction: 'continue' | 'send' =
     canContinue && !hasSendableDraft ? 'continue' : 'send';
-  const sendDisabled = primaryAction === 'continue'
+  const sendDisabled = inputSnapshot.pendingSubmission ? true : primaryAction === 'continue'
     ? false
     : isNcpChatSendDisabled({
-        snapshot: buildInputAvailabilitySnapshot(inputQuery),
         hasSendableDraft,
-        isRuntimeBlocked,
       }) || agent.isSending;
 
   const { continueRun, editMessage } = useSessionConversationRecoveryActions({
@@ -440,8 +473,9 @@ export function useSessionConversationController(params: UseSessionConversationC
     clearSubmittingInput,
     materializationContext,
     onSessionMaterialized,
-    resetComposer,
-    restoreComposer,
+    beginSubmission,
+    acceptSubmission,
+    failSubmission,
     runQueue,
     sessionKey,
     setSendError,
@@ -453,7 +487,6 @@ export function useSessionConversationController(params: UseSessionConversationC
     continueRun,
     inputQuery,
     inputSnapshot,
-    isRuntimeBlocked,
     materializationContext,
     primaryAction,
     selectedAgentId,
@@ -465,52 +498,33 @@ export function useSessionConversationController(params: UseSessionConversationC
     agent,
     inputQuery,
     inputSnapshot,
-    isRuntimeBlocked,
     materializationContext,
     selectedAgentId,
     sessionKey,
     submitDraft,
   });
 
-  const sendPresetMessage = useCallback(async (message: string) => {
-    const text = message.trim();
-    if (!text) {
-      return;
-    }
-    const draft = buildSubmissionDraft({
-      agentIsSending: agent.isSending,
-      composerSnapshot: {
-        text,
-        nodes: createChatComposerNodesFromDraft(text),
-        selectedSkills: [],
-        skillRecords: [],
-        attachments: [],
-      },
-      inputSnapshot,
-      inputQuery,
-      isRuntimeBlocked,
-      materializationContext,
-      selectedAgentId,
-      sessionKey,
-    });
-    if (draft) {
-      await submitDraft(draft, 'preserve');
-    }
-  }, [
-    agent.isSending,
-    inputQuery,
-    inputSnapshot,
-    isRuntimeBlocked,
-    materializationContext,
-    selectedAgentId,
-    sessionKey,
-    submitDraft,
-  ]);
+  const sendPresetMessage = usePresetSubmission({
+    agent, inputSnapshot, inputQuery, materializationContext,
+    selectedAgentId, sessionKey, submitDraft,
+  });
 
   const stop = useCallback(async () => {
     await agent.abort();
   }, [agent]);
 
+  const submissionRecovery = useSessionSubmissionRecovery({
+    agent,
+    submission: inputSnapshot.pendingSubmission,
+    sessionKey,
+    onSessionMaterialized,
+    acceptSubmission,
+    failSubmission,
+    restoreSubmission,
+    discardSubmission,
+    setSendError,
+  });
+
   return {
     canContinue,
     canStopGeneration: agent.isRunning,
@@ -525,6 +539,7 @@ export function useSessionConversationController(params: UseSessionConversationC
     send,
     sendSteering,
     sendPresetMessage,
+    ...submissionRecovery,
     sendDisabled,
     primaryAction,
     stop,

package/src/features/chat/features/conversation/hooks/use-session-conversation-input-query.ts

@@ -12,7 +12,7 @@ import {
   filterNcpChatModelOptionsBySessionType,
 } from '@/features/chat/features/ncp/utils/ncp-chat-query-derived.utils';
 import { adaptNcpSessionSummaries } from '@/features/chat/features/session/utils/ncp-session-adapter.utils';
-import { resolveRecentSessionPreferredValue } from '@/features/chat/features/session/utils/chat-session-preference-governance.utils';
+import { resolveRecentSessionPreferenceSnapshot } from '@/features/chat/features/session/utils/chat-session-preference-governance.utils';
 import { useChatSessionTypeState } from '@/features/chat/features/session-type/hooks/use-chat-session-type-state';
 import { chatRecentModelsManager } from '@/features/chat/managers/chat-recent-models.manager';
 import { useChatQueryStore } from '@/features/chat/stores/ncp-chat-query.store';
@@ -112,27 +112,17 @@ export function useSessionConversationInputQuery(params: UseSessionConversationI
   const recentSessionTypeModel = chatRecentModelsManager
     .read({ namespace: sessionTypeState.selectedSessionType })
     .find((value) => availableModelValueSet.has(value));
-  const fallbackPreferredModel = useMemo(
+  const recentSessionPreferences = useMemo(
     () =>
-      recentSessionTypeModel ??
-      resolveRecentSessionPreferredValue<string>({
+      resolveRecentSessionPreferenceSnapshot({
         sessions,
         selectedSessionKey,
         sessionType: sessionTypeState.selectedSessionType,
-        readPreference: (session) => session.preferredModel?.trim() || undefined,
-      }),
-    [recentSessionTypeModel, selectedSessionKey, sessionTypeState.selectedSessionType, sessions],
-  );
-  const fallbackPreferredThinking = useMemo(
-    () =>
-      resolveRecentSessionPreferredValue({
-        sessions,
-        selectedSessionKey,
-        sessionType: sessionTypeState.selectedSessionType,
-        readPreference: (session) => session.preferredThinking ?? undefined,
       }),
     [selectedSessionKey, sessionTypeState.selectedSessionType, sessions],
   );
+  const fallbackPreferredModel = recentSessionPreferences?.model ?? recentSessionTypeModel;
+  const fallbackPreferredThinking = recentSessionPreferences?.thinking;
 
   const defaultProjectRoot = normalizeSessionProjectRootValue(
     config?.agents.defaults.workspace,