@nextclaw/ui 0.14.0 → 0.14.1-beta.1

package/src/features/chat/features/welcome/utils/__tests__/chat-welcome-visibility.utils.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+import { shouldShowChatWelcome } from "@/features/chat/features/welcome/utils/chat-welcome-visibility.utils";
+
+function createVisibilitySnapshot(
+  overrides: Partial<Parameters<typeof shouldShowChatWelcome>[0]> = {},
+): Parameters<typeof shouldShowChatWelcome>[0] {
+  return {
+    canDeleteSession: false,
+    hasSubmittedDraftMessage: false,
+    isSending: false,
+    messages: [],
+    ...overrides,
+  };
+}
+
+describe("shouldShowChatWelcome", () => {
+  it("shows the welcome entry for an untouched draft", () => {
+    expect(shouldShowChatWelcome(createVisibilitySnapshot())).toBe(true);
+  });
+
+  it("keeps the welcome entry hidden after a draft send attempt", () => {
+    expect(
+      shouldShowChatWelcome(
+        createVisibilitySnapshot({ hasSubmittedDraftMessage: true }),
+      ),
+    ).toBe(false);
+  });
+
+  it("keeps the welcome entry hidden for an existing session", () => {
+    expect(
+      shouldShowChatWelcome(createVisibilitySnapshot({ canDeleteSession: true })),
+    ).toBe(false);
+  });
+});

package/src/features/chat/features/welcome/utils/chat-welcome-project-options.utils.ts

@@ -0,0 +1,71 @@
+import type { NcpSessionSummaryView } from "@/shared/lib/api";
+import { adaptNcpSessionSummaries } from "@/features/chat/features/session/utils/ncp-session-adapter.utils";
+import { getSessionProjectName } from "@/shared/lib/session-project";
+
+export type ChatWelcomeProjectOption = {
+  projectRoot: string;
+  projectName: string;
+  sessionCount: number;
+  isDefault: boolean;
+};
+
+function readSessionActivityAt(session: {
+  createdAt: string;
+  lastMessageAt?: string;
+}): number {
+  return new Date(session.lastMessageAt ?? session.createdAt).getTime();
+}
+
+export function buildChatWelcomeProjectOptions(params: {
+  defaultProjectRoot: string | null;
+  sessionSummaries: readonly NcpSessionSummaryView[];
+}): ChatWelcomeProjectOption[] {
+  const { defaultProjectRoot, sessionSummaries } = params;
+  const groups = new Map<
+    string,
+    ChatWelcomeProjectOption & { latestUpdatedAt: number }
+  >();
+
+  for (const session of adaptNcpSessionSummaries([...sessionSummaries])) {
+    const projectRoot = session.projectRoot?.trim();
+    if (!projectRoot) {
+      continue;
+    }
+    const existing = groups.get(projectRoot);
+    const latestUpdatedAt = readSessionActivityAt(session);
+    if (existing) {
+      existing.sessionCount += 1;
+      existing.latestUpdatedAt = Math.max(existing.latestUpdatedAt, latestUpdatedAt);
+      continue;
+    }
+    groups.set(projectRoot, {
+      projectRoot,
+      projectName:
+        session.projectName?.trim() ||
+        getSessionProjectName(projectRoot) ||
+        projectRoot,
+      sessionCount: 1,
+      isDefault: projectRoot === defaultProjectRoot,
+      latestUpdatedAt,
+    });
+  }
+
+  if (defaultProjectRoot && !groups.has(defaultProjectRoot)) {
+    groups.set(defaultProjectRoot, {
+      projectRoot: defaultProjectRoot,
+      projectName: getSessionProjectName(defaultProjectRoot) ?? defaultProjectRoot,
+      sessionCount: 0,
+      isDefault: true,
+      latestUpdatedAt: Number.POSITIVE_INFINITY,
+    });
+  }
+
+  return [...groups.values()]
+    .sort((left, right) => {
+      if (left.isDefault !== right.isDefault) {
+        return left.isDefault ? -1 : 1;
+      }
+      return right.latestUpdatedAt - left.latestUpdatedAt;
+    })
+    .map(({ latestUpdatedAt: _latestUpdatedAt, ...option }) => option);
+}

package/src/features/chat/features/welcome/utils/chat-welcome-selection.utils.ts

@@ -0,0 +1,79 @@
+import {
+  normalizeSessionType,
+  resolveAgentRuntimeSessionType,
+} from "@/features/chat/features/session-type/utils/chat-session-type.utils";
+import type { AgentProfileView } from "@/shared/lib/api";
+
+type SessionTypeOptionLike = {
+  value: string;
+};
+
+export function resolveChatWelcomeAgents(params: {
+  agents: AgentProfileView[] | null | undefined;
+  fallbackAgentId: string;
+}): AgentProfileView[] {
+  const { agents, fallbackAgentId } = params;
+  return (agents?.length ?? 0) > 0 ? (agents ?? []) : [{ id: fallbackAgentId }];
+}
+
+export function resolveChatWelcomeSelectedAgent(params: {
+  agents: AgentProfileView[];
+  agentId: string;
+}): AgentProfileView | null {
+  return params.agents.find((agent) => agent.id === params.agentId) ?? null;
+}
+
+function resolveAvailableSessionType(
+  value: string | null | undefined,
+  options: readonly SessionTypeOptionLike[],
+): string | null {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return null;
+  }
+  const normalized = normalizeSessionType(value);
+  return options.some((option) => option.value === normalized) ? normalized : null;
+}
+
+export function resolveChatWelcomeSelectedSessionType(params: {
+  agents?: AgentProfileView[];
+  agentId?: string;
+  defaultSessionType: string;
+  pendingSessionType: string | null | undefined;
+  selectedSessionType: string | null | undefined;
+  sessionTypeOptions: readonly SessionTypeOptionLike[];
+}): string {
+  const {
+    agentId,
+    agents,
+    defaultSessionType,
+    pendingSessionType,
+    selectedSessionType,
+    sessionTypeOptions,
+  } = params;
+  const explicitSessionType =
+    resolveAvailableSessionType(selectedSessionType, sessionTypeOptions) ??
+    resolveAvailableSessionType(pendingSessionType, sessionTypeOptions);
+  if (explicitSessionType) {
+    return explicitSessionType;
+  }
+
+  const agentSessionType =
+    agents && agentId
+      ? resolveAvailableSessionType(
+          resolveAgentRuntimeSessionType(
+            resolveChatWelcomeSelectedAgent({
+              agents,
+              agentId,
+            }),
+            defaultSessionType,
+          ),
+          sessionTypeOptions,
+        )
+      : null;
+  return (
+    agentSessionType ??
+    resolveAvailableSessionType(defaultSessionType, sessionTypeOptions) ??
+    sessionTypeOptions[0]?.value ??
+    normalizeSessionType(defaultSessionType)
+  );
+}

package/src/features/chat/features/welcome/utils/chat-welcome-visibility.utils.ts

@@ -0,0 +1,17 @@
+import type { ChatThreadSnapshot } from "@/features/chat/stores/chat-thread.store";
+
+type ChatWelcomeVisibilitySnapshot = Pick<
+  ChatThreadSnapshot,
+  "canDeleteSession" | "hasSubmittedDraftMessage" | "isSending" | "messages"
+>;
+
+export function shouldShowChatWelcome(
+  snapshot: ChatWelcomeVisibilitySnapshot,
+): boolean {
+  return (
+    !snapshot.canDeleteSession &&
+    !snapshot.hasSubmittedDraftMessage &&
+    snapshot.messages.length === 0 &&
+    !snapshot.isSending
+  );
+}

package/src/features/chat/index.ts

@@ -3,6 +3,7 @@ export { ChatSidebar } from "./components/layout/chat-sidebar";
 export { ChatPresenterProvider } from "./components/providers/chat-presenter.provider";
 export { usePresenter } from "./components/providers/chat-presenter.provider";
 export { ChatPresenter } from "./presenters/chat.presenter";
+export { ChatDraftIntentManager } from "./managers/chat-draft-intent.manager";
 export { useChatInputStore } from "./stores/chat-input.store";
 export { useChatSessionListStore } from "./stores/chat-session-list.store";
 export { useChatThreadStore } from "./stores/chat-thread.store";

package/src/features/chat/managers/__tests__/chat-input.manager.test.ts

@@ -1,4 +1,5 @@
 import { createChatComposerTextNode } from '@nextclaw/agent-chat-ui';
+import { RUNTIME_DEFAULT_MODEL_VALUE } from '@nextclaw/shared';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { ChatInputManager } from '@/features/chat/managers/chat-input.manager';
 import { useChatInputStore } from '@/features/chat/stores/chat-input.store';
@@ -137,6 +138,46 @@ describe('ChatInputManager', () => {
     );
   });
 
+  it('uses the default workspace as the project root for a blank draft send', async () => {
+    useChatInputStore.setState({
+      snapshot: {
+        ...useChatInputStore.getState().snapshot,
+        defaultProjectRoot: '/Users/demo/.nextclaw/workspace',
+      },
+    });
+    useChatThreadStore.setState({
+      snapshot: {
+        ...useChatThreadStore.getState().snapshot,
+        sessionKey: null,
+      },
+    });
+    useChatSessionListStore.setState({
+      snapshot: {
+        ...useChatSessionListStore.getState().snapshot,
+        selectedSessionKey: null,
+      },
+    });
+    const chatRunManager = {
+      sendMessage: vi.fn().mockResolvedValue(undefined),
+      stopCurrentRun: vi.fn().mockResolvedValue(undefined),
+    } as unknown as ConstructorParameters<typeof ChatInputManager>[0];
+    const sessionListManager = {
+      ensureDraftSession: vi.fn(() => 'materialized-draft-session'),
+    } as unknown as ConstructorParameters<typeof ChatInputManager>[1];
+    const manager = new ChatInputManager(
+      chatRunManager,
+      sessionListManager,
+    );
+
+    await manager.send();
+
+    expect(chatRunManager.sendMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        projectRoot: '/Users/demo/.nextclaw/workspace',
+      }),
+    );
+  });
+
   it('does not send while the runtime is still blocked during startup', async () => {
     useChatInputStore.setState({
       snapshot: {
@@ -250,6 +291,11 @@ describe('ChatInputManager', () => {
     expect(useChatInputStore.getState().snapshot.composerNodes).toEqual(originalComposerNodes);
   });
 
+});
+
+describe('ChatInputManager composer focus', () => {
+  beforeEach(resetChatInputManagerStoreState);
+
   it('creates and consumes one-shot composer focus requests', () => {
     const manager = new ChatInputManager(
       {} as ConstructorParameters<typeof ChatInputManager>[0],
@@ -267,6 +313,26 @@ describe('ChatInputManager', () => {
     manager.consumeComposerFocusRequest(request!.id);
     expect(useChatInputStore.getState().snapshot.composerFocusRequest).toBeNull();
   });
+
+  it('applies prompt suggestions to the composer and requests focus', () => {
+    const manager = new ChatInputManager(
+      {} as ConstructorParameters<typeof ChatInputManager>[0],
+      {} as ConstructorParameters<typeof ChatInputManager>[1],
+    );
+
+    manager.applyPromptSuggestion('  Build a release plan  ');
+
+    expect(useChatInputStore.getState().snapshot).toMatchObject({
+      draft: 'Build a release plan',
+      composerNodes: [
+        expect.objectContaining({
+          type: 'text',
+          text: 'Build a release plan',
+        }),
+      ],
+      composerFocusRequest: { id: 1, placement: 'end' },
+    });
+  });
 });
 
 describe('ChatInputManager configuration sync', () => {
@@ -322,6 +388,33 @@ describe('ChatInputManager configuration sync', () => {
     });
   });
 
+  it('sends the runtime-default sentinel so the backend can ignore stale session model metadata', async () => {
+    useChatInputStore.setState({
+      snapshot: {
+        ...useChatInputStore.getState().snapshot,
+        selectedSessionType: 'codex',
+        selectedModel: RUNTIME_DEFAULT_MODEL_VALUE,
+      },
+    });
+    const chatRunManager = {
+      sendMessage: vi.fn().mockResolvedValue(undefined),
+      stopCurrentRun: vi.fn().mockResolvedValue(undefined),
+    } as unknown as ConstructorParameters<typeof ChatInputManager>[0];
+    const sessionListManager = {
+      ensureDraftSession: vi.fn(() => 'draft-session'),
+    } as unknown as ConstructorParameters<typeof ChatInputManager>[1];
+    const manager = new ChatInputManager(chatRunManager, sessionListManager);
+
+    await manager.send();
+
+    expect(chatRunManager.sendMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        sessionType: 'codex',
+        model: RUNTIME_DEFAULT_MODEL_VALUE,
+      }),
+    );
+  });
+
   it('resolves and clears pending project root overrides inside the input manager', () => {
     useChatInputStore.setState({
       snapshot: {

package/src/features/chat/managers/__tests__/chat-run-snapshot.manager.test.ts

@@ -0,0 +1,129 @@
+import type { NcpMessage } from '@nextclaw/ncp';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { ChatRunManager } from '@/features/chat/managers/chat-run.manager';
+import { useChatInputStore } from '@/features/chat/stores/chat-input.store';
+import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
+
+function createChatRunManager() {
+  const uiManager = {
+    isAtChatRoot: vi.fn(() => true),
+    goToSession: vi.fn(),
+  };
+  return new ChatRunManager(
+    uiManager as unknown as ConstructorParameters<typeof ChatRunManager>[0],
+  );
+}
+
+describe('ChatRunManager run snapshots', () => {
+  beforeEach(() => {
+    useChatInputStore.setState({
+      snapshot: {
+        ...useChatInputStore.getState().snapshot,
+        canStopGeneration: false,
+        sendError: null,
+        isSending: false,
+      },
+    });
+    useChatThreadStore.setState({
+      snapshot: {
+        ...useChatThreadStore.getState().snapshot,
+        sessionKey: null,
+        isHistoryLoading: false,
+        messages: [],
+        isSending: false,
+        isAwaitingAssistantOutput: false,
+        contextWindow: null,
+      },
+    });
+  });
+
+  it('syncs the run snapshot into chat input and thread state', () => {
+    const manager = createChatRunManager();
+    const message: NcpMessage = {
+      id: 'message-1',
+      sessionId: 'session-1',
+      role: 'assistant',
+      status: 'final',
+      parts: [{ type: 'text', text: 'done' }],
+      timestamp: '2026-06-10T00:00:00.000Z',
+    };
+
+    manager.applyRunSnapshot({
+      routeSessionKey: 'session-1',
+      isHydrating: true,
+      isSending: false,
+      isRunning: true,
+      visibleMessages: [message],
+      contextWindow: {
+        usedContextTokens: 10,
+        totalContextTokens: 100,
+        availableContextTokens: 90,
+        prunedUsedContextTokens: 10,
+        droppedHistoryCount: 0,
+        truncatedToolResultCount: 0,
+        truncatedSystemPrompt: false,
+        truncatedUserMessage: false,
+        compacted: false,
+        compactedUsedContextTokens: 10,
+        compactedMessageCount: 0,
+        updatedAt: '2026-06-10T00:00:00.000Z',
+      },
+      sendErrorMessage: 'failed',
+      materializedSessionKey: null,
+    });
+
+    expect(useChatInputStore.getState().snapshot).toMatchObject({
+      canStopGeneration: true,
+      sendError: 'failed',
+      isSending: true,
+    });
+    expect(useChatThreadStore.getState().snapshot).toMatchObject({
+      sessionKey: 'session-1',
+      isHistoryLoading: true,
+      messages: [message],
+      isSending: true,
+      isAwaitingAssistantOutput: true,
+      contextWindow: {
+        usedContextTokens: 10,
+        totalContextTokens: 100,
+      },
+    });
+  });
+
+  it('resets stale context window state when switching sessions', () => {
+    const manager = createChatRunManager();
+    useChatThreadStore.getState().setSnapshot({
+      sessionKey: 'session-previous',
+      contextWindow: {
+        usedContextTokens: 80,
+        totalContextTokens: 100,
+        availableContextTokens: 20,
+        prunedUsedContextTokens: 80,
+        droppedHistoryCount: 0,
+        truncatedToolResultCount: 0,
+        truncatedSystemPrompt: false,
+        truncatedUserMessage: false,
+        compacted: false,
+        compactedUsedContextTokens: 80,
+        compactedMessageCount: 0,
+        updatedAt: '2026-06-10T00:00:00.000Z',
+      },
+    });
+
+    manager.applyRunSnapshot({
+      routeSessionKey: 'session-next',
+      isHydrating: true,
+      isSending: false,
+      isRunning: false,
+      visibleMessages: [],
+      contextWindow: null,
+      sendErrorMessage: null,
+      materializedSessionKey: null,
+    });
+
+    expect(useChatThreadStore.getState().snapshot).toMatchObject({
+      sessionKey: 'session-next',
+      contextWindow: null,
+    });
+  });
+});

package/src/features/chat/managers/__tests__/chat-run.manager.test.ts

@@ -1,4 +1,5 @@
 import type { NcpMessage } from '@nextclaw/ncp';
+import { RUNTIME_DEFAULT_MODEL_VALUE } from '@nextclaw/shared';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { ChatRunManager } from '@/features/chat/managers/chat-run.manager';
 import { useChatInputStore } from '@/features/chat/stores/chat-input.store';
@@ -75,6 +76,39 @@ describe('ChatRunManager', () => {
     expect(uiManager.goToSession).toHaveBeenCalledWith('materialized-session', { replace: true });
   });
 
+  it('keeps the runtime-default sentinel in request metadata to override stale session model metadata', async () => {
+    const { manager } = createChatRunManager();
+    const sendEnvelope = vi.fn(async () => ({
+      sessionId: 'session-1',
+      userMessageId: 'user-message-1',
+      assistantMessageId: null,
+      runId: 'run-1',
+    }));
+    manager.setActiveRuntime({
+      sessionKey: 'session-1',
+      sendEnvelope,
+      abortCurrentRun: vi.fn(),
+      resumeCurrentSessionRun: vi.fn(),
+    });
+
+    await manager.sendMessage({
+      message: 'hello',
+      sessionKey: 'session-1',
+      agentId: 'main',
+      sessionType: 'codex',
+      model: RUNTIME_DEFAULT_MODEL_VALUE,
+    });
+
+    expect(sendEnvelope).toHaveBeenCalledWith(
+      expect.objectContaining({
+        metadata: expect.objectContaining({
+          model: RUNTIME_DEFAULT_MODEL_VALUE,
+          preferred_model: RUNTIME_DEFAULT_MODEL_VALUE,
+        }),
+      }),
+    );
+  });
+
   it('does not send through a runtime for another session', async () => {
     const { manager } = createChatRunManager();
     const sendEnvelope = vi.fn();

package/src/features/chat/managers/__tests__/chat-session-preference-sync.manager.test.ts

@@ -1,6 +1,7 @@
 import { afterEach, describe, expect, it, vi } from 'vitest';
+import { RUNTIME_DEFAULT_MODEL_VALUE } from '@nextclaw/shared';
 import { updateNcpSession } from '@/shared/lib/api';
-import { ChatSessionPreferenceSync } from '../chat-session-preference-sync.manager';
+import { ChatSessionPreferenceSync } from '@/features/chat/managers/chat-session-preference-sync.manager';
 import { useChatInputStore } from '@/features/chat/stores/chat-input.store';
 import { useChatSessionListStore } from '@/features/chat/stores/chat-session-list.store';
 import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
@@ -25,6 +26,7 @@ describe('ChatSessionPreferenceSync', () => {
     useChatInputStore.setState((state) => ({
       snapshot: {
         ...state.snapshot,
+        modelOptions: [],
         selectedModel: '',
         selectedThinkingLevel: null
       }
@@ -74,4 +76,144 @@ describe('ChatSessionPreferenceSync', () => {
       });
     });
   });
+
+  it('clears the persisted model preference when runtime default is selected', async () => {
+    useChatInputStore.setState((state) => ({
+      snapshot: {
+        ...state.snapshot,
+        selectedModel: RUNTIME_DEFAULT_MODEL_VALUE,
+        selectedThinkingLevel: null
+      }
+    }));
+    useChatSessionListStore.setState((state) => ({
+      snapshot: {
+        ...state.snapshot,
+        selectedSessionKey: 'session-1'
+      }
+    }));
+    useChatThreadStore.setState((state) => ({
+      snapshot: {
+        ...state.snapshot,
+        canDeleteSession: true
+      }
+    }));
+
+    const sync = new ChatSessionPreferenceSync(updateNcpSession);
+    sync.syncSelectedSessionPreferences();
+    await vi.waitFor(() => {
+      expect(updateNcpSession).toHaveBeenCalledWith('session-1', {
+        preferredModel: null,
+        preferredThinking: null
+      });
+    });
+  });
+
+  it('uses the runtime-default thinking capability default when no session thinking is persisted', () => {
+    useChatInputStore.setState((state) => ({
+      snapshot: {
+        ...state.snapshot,
+        modelOptions: [
+          {
+            value: RUNTIME_DEFAULT_MODEL_VALUE,
+            modelLabel: 'Runtime default',
+            providerLabel: '',
+            isRuntimeDefault: true,
+            thinkingCapability: {
+              supported: ['off', 'minimal', 'low', 'medium', 'high', 'xhigh'],
+              default: 'high',
+            },
+          },
+        ],
+        selectedModel: '',
+        selectedThinkingLevel: null,
+      }
+    }));
+
+    const sync = new ChatSessionPreferenceSync(updateNcpSession);
+    sync.syncInputSelection({
+      selectedSessionExists: true,
+      defaultModel: RUNTIME_DEFAULT_MODEL_VALUE,
+      selectedSessionPreferredThinking: null,
+      fallbackPreferredThinking: null,
+    });
+
+    expect(useChatInputStore.getState().snapshot).toMatchObject({
+      selectedModel: RUNTIME_DEFAULT_MODEL_VALUE,
+      selectedThinkingLevel: 'high',
+    });
+  });
+
+  it('does not rewrite the input snapshot when the resolved selection is unchanged', () => {
+    useChatInputStore.setState((state) => ({
+      snapshot: {
+        ...state.snapshot,
+        modelOptions: [
+          {
+            value: 'openai/gpt-5',
+            modelLabel: 'GPT-5',
+            providerLabel: 'OpenAI',
+            thinkingCapability: null,
+          },
+        ],
+        selectedModel: 'openai/gpt-5',
+        selectedThinkingLevel: null,
+      }
+    }));
+    const sync = new ChatSessionPreferenceSync(updateNcpSession);
+    const listener = vi.fn();
+    const unsubscribe = useChatInputStore.subscribe(listener);
+
+    sync.syncInputSelection({
+      selectedSessionExists: true,
+      selectedSessionPreferredModel: 'openai/gpt-5',
+      selectedSessionPreferredThinking: null,
+    });
+
+    unsubscribe();
+    expect(listener).not.toHaveBeenCalled();
+  });
+
+  it('applies a historical session preferred model after its summary arrives', () => {
+    useChatInputStore.setState((state) => ({
+      snapshot: {
+        ...state.snapshot,
+        modelOptions: [
+          {
+            value: 'anthropic/claude-sonnet-4',
+            modelLabel: 'Claude Sonnet 4',
+            providerLabel: 'Anthropic',
+            thinkingCapability: null,
+          },
+          {
+            value: 'openai/gpt-5',
+            modelLabel: 'GPT-5',
+            providerLabel: 'OpenAI',
+            thinkingCapability: null,
+          },
+        ],
+        selectedModel: 'anthropic/claude-sonnet-4',
+        selectedThinkingLevel: null,
+      }
+    }));
+    const sync = new ChatSessionPreferenceSync(updateNcpSession);
+
+    sync.syncInputSelection({
+      selectedSessionKey: 'session-2',
+      selectedSessionExists: false,
+      fallbackPreferredModel: 'anthropic/claude-sonnet-4',
+    });
+    expect(useChatInputStore.getState().snapshot.selectedModel).toBe(
+      'anthropic/claude-sonnet-4',
+    );
+
+    sync.syncInputSelection({
+      selectedSessionKey: 'session-2',
+      selectedSessionExists: true,
+      selectedSessionPreferredModel: 'openai/gpt-5',
+      selectedSessionPreferredThinking: null,
+      fallbackPreferredModel: 'anthropic/claude-sonnet-4',
+    });
+
+    expect(useChatInputStore.getState().snapshot.selectedModel).toBe('openai/gpt-5');
+  });
 });