@nextclaw/ui 0.7.0 → 0.9.0

package/src/components/chat/adapters/chat-message.adapter.ts

@@ -61,6 +61,8 @@ export type ChatMessageAdapterTexts = {
   unknownPartLabel: string;
 };
 
+const INVISIBLE_ONLY_TEXT_PATTERN = /\u200B|\u200C|\u200D|\u2060|\uFEFF/g;
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null;
 }
@@ -95,7 +97,10 @@ function resolveMessageTimestamp(message: ChatMessageSource): string {
   return new Date().toISOString();
 }
 
-function resolveRoleLabel(role: string, texts: ChatMessageAdapterTexts['roleLabels']): string {
+function resolveRoleLabel(
+  role: string,
+  texts: ChatMessageAdapterTexts['roleLabels']
+): string {
   if (role === 'user') {
     return texts.user;
   }
@@ -118,7 +123,10 @@ function resolveUiRole(role: string): ChatMessageRole {
   return 'message';
 }
 
-function buildToolCard(toolCard: ToolCard, texts: ChatMessageAdapterTexts): ChatToolPartViewModel {
+function buildToolCard(
+  toolCard: ToolCard,
+  texts: ChatMessageAdapterTexts
+): ChatToolPartViewModel {
   return {
     kind: toolCard.kind,
     toolName: toolCard.name,
@@ -131,6 +139,15 @@ function buildToolCard(toolCard: ToolCard, texts: ChatMessageAdapterTexts): Chat
   };
 }
 
+function toRenderableText(value: string): string | null {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const visible = trimmed.replace(INVISIBLE_ONLY_TEXT_PATTERN, "").trim();
+  return visible ? trimmed : null;
+}
+
 export function adaptChatMessages(params: {
   uiMessages: ChatMessageSource[];
   texts: ChatMessageAdapterTexts;
@@ -145,7 +162,7 @@ export function adaptChatMessages(params: {
     parts: message.parts
       .map((part) => {
         if (isTextPart(part)) {
-          const text = part.text.trim();
+          const text = toRenderableText(part.text);
           if (!text) {
             return null;
           }
@@ -155,7 +172,7 @@ export function adaptChatMessages(params: {
           };
         }
         if (isReasoningPart(part)) {
-          const text = part.reasoning.trim();
+          const text = toRenderableText(part.reasoning);
           if (!text) {
             return null;
           }
@@ -168,11 +185,12 @@ export function adaptChatMessages(params: {
         if (isToolInvocationPart(part)) {
           const invocation = part.toolInvocation;
           const detail = summarizeToolArgs(invocation.parsedArgs ?? invocation.args);
-          const rawResult = typeof invocation.error === 'string' && invocation.error.trim()
-            ? invocation.error.trim()
-            : invocation.result != null
-              ? stringifyUnknown(invocation.result).trim()
-              : '';
+          const rawResult =
+            typeof invocation.error === 'string' && invocation.error.trim()
+              ? invocation.error.trim()
+              : invocation.result != null
+                ? stringifyUnknown(invocation.result).trim()
+                : '';
           const hasResult =
             invocation.status === 'result' || invocation.status === 'error' || invocation.status === 'cancelled';
           const card: ToolCard = {

package/src/components/chat/chat-chain.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it, vi } from 'vitest';
+import { resolveChatChain } from '@/components/chat/chat-chain';
+
+describe('resolveChatChain', () => {
+  it('defaults to ncp when no query or env override is provided', () => {
+    vi.stubEnv('VITE_CHAT_CHAIN', '');
+
+    expect(resolveChatChain('')).toBe('ncp');
+  });
+
+  it('allows explicit legacy rollback from query string', () => {
+    vi.stubEnv('VITE_CHAT_CHAIN', 'ncp');
+
+    expect(resolveChatChain('?chatChain=legacy')).toBe('legacy');
+  });
+
+  it('accepts env override when query string is absent', () => {
+    vi.stubEnv('VITE_CHAT_CHAIN', 'legacy');
+
+    expect(resolveChatChain('')).toBe('legacy');
+  });
+});

package/src/components/chat/chat-chain.ts

@@ -0,0 +1,23 @@
+export type ChatChain = 'legacy' | 'ncp';
+
+const DEFAULT_CHAT_CHAIN: ChatChain = 'ncp';
+
+function normalizeChatChain(value: string | null | undefined): ChatChain | null {
+  if (typeof value !== 'string') {
+    return null;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === 'legacy' || normalized === 'ncp') {
+    return normalized;
+  }
+  return null;
+}
+
+export function resolveChatChain(search: string): ChatChain {
+  const fromSearch = normalizeChatChain(new URLSearchParams(search).get('chatChain'));
+  if (fromSearch) {
+    return fromSearch;
+  }
+  const fromEnv = normalizeChatChain(import.meta.env.VITE_CHAT_CHAIN);
+  return fromEnv ?? DEFAULT_CHAT_CHAIN;
+}

package/src/components/chat/chat-page-data.ts

@@ -3,7 +3,11 @@ import type { Dispatch, SetStateAction } from 'react';
 import type { SessionEntryView, ThinkingLevel } from '@/api/types';
 import type { ChatModelOption } from '@/components/chat/chat-input.types';
 import { useChatSessionTypeState } from '@/components/chat/useChatSessionTypeState';
-import { useSyncSelectedModel } from '@/components/chat/chat-page-runtime';
+import {
+  resolveSelectedModelValue,
+  resolveRecentSessionPreferredModel,
+  useSyncSelectedModel
+} from '@/components/chat/chat-page-runtime';
 import {
   useChatCapabilities,
   useChatSessionTypes,
@@ -98,14 +102,38 @@ export function useChatPageData(params: UseChatPageDataParams) {
     setPendingSessionType: params.setPendingSessionType,
     sessionTypesData: sessionTypesQuery.data
   });
+  const recentSessionPreferredModel = useMemo(
+    () =>
+      resolveRecentSessionPreferredModel({
+        sessions,
+        selectedSessionKey: params.selectedSessionKey,
+        sessionType: sessionTypeState.selectedSessionType
+      }),
+    [params.selectedSessionKey, sessionTypeState.selectedSessionType, sessions]
+  );
 
   useSyncSelectedModel({
     modelOptions,
+    selectedSessionKey: params.selectedSessionKey,
     selectedSessionPreferredModel: selectedSession?.preferredModel,
+    fallbackPreferredModel: recentSessionPreferredModel,
     defaultModel: configQuery.data?.agents.defaults.model,
     setSelectedModel: params.setSelectedModel
   });
 
+  const hydratedSessionModel = useMemo(
+    () =>
+      resolveSelectedModelValue({
+        currentSelectedModel: '',
+        modelOptions,
+        selectedSessionPreferredModel: selectedSession?.preferredModel,
+        fallbackPreferredModel: recentSessionPreferredModel,
+        defaultModel: configQuery.data?.agents.defaults.model,
+        preferSessionPreferredModel: true
+      }),
+    [configQuery.data?.agents.defaults.model, modelOptions, recentSessionPreferredModel, selectedSession?.preferredModel]
+  );
+
   const historyMessages = useMemo(() => historyQuery.data?.messages ?? [], [historyQuery.data?.messages]);
   const selectedSessionThinkingLevel = useMemo(() => {
     if (!params.selectedSessionKey) {
@@ -143,6 +171,7 @@ export function useChatPageData(params: UseChatPageDataParams) {
     sessions,
     skillRecords,
     selectedSession,
+    hydratedSessionModel,
     historyMessages,
     selectedSessionThinkingLevel,
     ...sessionTypeState

package/src/components/chat/chat-page-runtime.test.ts

@@ -0,0 +1,181 @@
+import { describe, expect, it } from 'vitest';
+import type { SessionEntryView } from '@/api/types';
+import { resolveRecentSessionPreferredModel, resolveSelectedModelValue } from '@/components/chat/chat-page-runtime';
+
+const 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
+  }
+];
+
+function createSession(overrides: Partial<SessionEntryView> & Pick<SessionEntryView, 'key'>): SessionEntryView {
+  return {
+    key: overrides.key,
+    createdAt: overrides.createdAt ?? '2026-03-19T00:00:00.000Z',
+    updatedAt: overrides.updatedAt ?? '2026-03-19T00:00:00.000Z',
+    sessionType: overrides.sessionType ?? 'native',
+    sessionTypeMutable: overrides.sessionTypeMutable ?? false,
+    messageCount: overrides.messageCount ?? 0,
+    ...(overrides.label ? { label: overrides.label } : {}),
+    ...(overrides.preferredModel ? { preferredModel: overrides.preferredModel } : {}),
+    ...(overrides.lastRole ? { lastRole: overrides.lastRole } : {}),
+    ...(overrides.lastTimestamp ? { lastTimestamp: overrides.lastTimestamp } : {})
+  };
+}
+
+describe('resolveSelectedModelValue', () => {
+  it('keeps the current selected model when it is still available', () => {
+    expect(
+      resolveSelectedModelValue({
+        currentSelectedModel: 'openai/gpt-5',
+        modelOptions,
+        selectedSessionPreferredModel: 'anthropic/claude-sonnet-4',
+        fallbackPreferredModel: 'anthropic/claude-sonnet-4',
+        defaultModel: 'anthropic/claude-sonnet-4'
+      })
+    ).toBe('openai/gpt-5');
+  });
+
+  it('prefers the current session preferred model over runtime fallback and global default', () => {
+    expect(
+      resolveSelectedModelValue({
+        currentSelectedModel: 'missing/model',
+        modelOptions,
+        selectedSessionPreferredModel: 'openai/gpt-5',
+        fallbackPreferredModel: 'anthropic/claude-sonnet-4',
+        defaultModel: 'anthropic/claude-sonnet-4'
+      })
+    ).toBe('openai/gpt-5');
+  });
+
+  it('prefers the current session preferred model over a stale in-memory selection after switching sessions', () => {
+    expect(
+      resolveSelectedModelValue({
+        currentSelectedModel: 'anthropic/claude-sonnet-4',
+        modelOptions,
+        selectedSessionPreferredModel: 'openai/gpt-5',
+        fallbackPreferredModel: 'anthropic/claude-sonnet-4',
+        defaultModel: 'anthropic/claude-sonnet-4',
+        preferSessionPreferredModel: true
+      })
+    ).toBe('openai/gpt-5');
+  });
+
+  it('ignores the stale in-memory selection when a switched session has no explicit preferred model', () => {
+    expect(
+      resolveSelectedModelValue({
+        currentSelectedModel: 'anthropic/claude-sonnet-4',
+        modelOptions,
+        fallbackPreferredModel: 'openai/gpt-5',
+        defaultModel: 'anthropic/claude-sonnet-4',
+        preferSessionPreferredModel: true
+      })
+    ).toBe('openai/gpt-5');
+  });
+
+  it('uses the recent same-runtime model when the current session has no valid preferred model', () => {
+    expect(
+      resolveSelectedModelValue({
+        currentSelectedModel: 'missing/model',
+        modelOptions,
+        fallbackPreferredModel: 'openai/gpt-5',
+        defaultModel: 'anthropic/claude-sonnet-4'
+      })
+    ).toBe('openai/gpt-5');
+  });
+
+  it('falls back to the global default model when the recent same-runtime model is unavailable', () => {
+    expect(
+      resolveSelectedModelValue({
+        currentSelectedModel: 'missing/model',
+        modelOptions,
+        fallbackPreferredModel: 'missing/model',
+        defaultModel: 'anthropic/claude-sonnet-4'
+      })
+    ).toBe('anthropic/claude-sonnet-4');
+  });
+
+  it('falls back to the first available model when no candidate is valid', () => {
+    expect(
+      resolveSelectedModelValue({
+        currentSelectedModel: 'missing/model',
+        modelOptions,
+        selectedSessionPreferredModel: 'missing/model',
+        fallbackPreferredModel: 'missing/model',
+        defaultModel: 'missing/model'
+      })
+    ).toBe('anthropic/claude-sonnet-4');
+  });
+});
+
+describe('resolveRecentSessionPreferredModel', () => {
+  it('returns the most recent preferred model from the same runtime', () => {
+    const sessions = [
+      createSession({
+        key: 'native-1',
+        sessionType: 'native',
+        preferredModel: 'anthropic/claude-sonnet-4',
+        updatedAt: '2026-03-18T01:00:00.000Z'
+      }),
+      createSession({
+        key: 'codex-1',
+        sessionType: 'codex',
+        preferredModel: 'openai/gpt-5',
+        updatedAt: '2026-03-18T03:00:00.000Z'
+      }),
+      createSession({
+        key: 'codex-2',
+        sessionType: 'codex',
+        preferredModel: 'anthropic/claude-sonnet-4',
+        updatedAt: '2026-03-18T02:00:00.000Z'
+      })
+    ];
+
+    expect(
+      resolveRecentSessionPreferredModel({
+        sessions,
+        selectedSessionKey: 'draft',
+        sessionType: 'codex'
+      })
+    ).toBe('openai/gpt-5');
+  });
+
+  it('ignores the currently selected session and sessions without preferred models', () => {
+    const sessions = [
+      createSession({
+        key: 'codex-current',
+        sessionType: 'codex',
+        preferredModel: 'openai/gpt-5',
+        updatedAt: '2026-03-18T03:00:00.000Z'
+      }),
+      createSession({
+        key: 'codex-empty',
+        sessionType: 'codex',
+        updatedAt: '2026-03-18T04:00:00.000Z'
+      }),
+      createSession({
+        key: 'codex-fallback',
+        sessionType: 'codex',
+        preferredModel: 'anthropic/claude-sonnet-4',
+        updatedAt: '2026-03-18T02:00:00.000Z'
+      })
+    ];
+
+    expect(
+      resolveRecentSessionPreferredModel({
+        sessions,
+        selectedSessionKey: 'codex-current',
+        sessionType: 'codex'
+      })
+    ).toBe('anthropic/claude-sonnet-4');
+  });
+});

package/src/components/chat/chat-page-runtime.ts

@@ -1,39 +1,125 @@
 import { useEffect, useMemo, useRef, useState } from 'react';
 import type { Dispatch, SetStateAction } from 'react';
-import type { ChatRunView } from '@/api/types';
+import type { ChatRunView, SessionEntryView } from '@/api/types';
 import type { ChatModelOption } from '@/components/chat/chat-input.types';
 import { useChatRuns } from '@/hooks/useConfig';
 import { buildActiveRunBySessionKey, buildSessionRunStatusByKey } from '@/lib/session-run-status';
 
 export type ChatMainPanelView = 'chat' | 'cron' | 'skills';
 
+function normalizeSessionType(value: string | null | undefined): string {
+  const normalized = value?.trim().toLowerCase();
+  return normalized || 'native';
+}
+
+function hasModelOption(modelOptions: ChatModelOption[], value: string | null | undefined): value is string {
+  const normalized = value?.trim();
+  if (!normalized) {
+    return false;
+  }
+  return modelOptions.some((option) => option.value === normalized);
+}
+
+export function resolveSelectedModelValue(params: {
+  currentSelectedModel?: string;
+  modelOptions: ChatModelOption[];
+  selectedSessionPreferredModel?: string;
+  fallbackPreferredModel?: string;
+  defaultModel?: string;
+  preferSessionPreferredModel?: boolean;
+}): string {
+  const {
+    currentSelectedModel,
+    modelOptions,
+    selectedSessionPreferredModel,
+    fallbackPreferredModel,
+    defaultModel,
+    preferSessionPreferredModel = false
+  } = params;
+  if (modelOptions.length === 0) {
+    return '';
+  }
+  if (!preferSessionPreferredModel && hasModelOption(modelOptions, currentSelectedModel)) {
+    return currentSelectedModel.trim();
+  }
+  if (hasModelOption(modelOptions, selectedSessionPreferredModel)) {
+    return selectedSessionPreferredModel.trim();
+  }
+  if (hasModelOption(modelOptions, fallbackPreferredModel)) {
+    return fallbackPreferredModel.trim();
+  }
+  if (hasModelOption(modelOptions, defaultModel)) {
+    return defaultModel.trim();
+  }
+  return modelOptions[0]?.value ?? '';
+}
+
+export function resolveRecentSessionPreferredModel(params: {
+  sessions: readonly SessionEntryView[];
+  selectedSessionKey?: string | null;
+  sessionType?: string | null;
+}): string | undefined {
+  const targetSessionType = normalizeSessionType(params.sessionType);
+  let bestSession: SessionEntryView | null = null;
+  let bestTimestamp = Number.NEGATIVE_INFINITY;
+  for (const session of params.sessions) {
+    if (session.key === params.selectedSessionKey) {
+      continue;
+    }
+    if (normalizeSessionType(session.sessionType) !== targetSessionType) {
+      continue;
+    }
+    const preferredModel = session.preferredModel?.trim();
+    if (!preferredModel) {
+      continue;
+    }
+    const updatedAtTimestamp = Date.parse(session.updatedAt);
+    const comparableTimestamp = Number.isFinite(updatedAtTimestamp) ? updatedAtTimestamp : Number.NEGATIVE_INFINITY;
+    if (!bestSession || comparableTimestamp > bestTimestamp) {
+      bestSession = session;
+      bestTimestamp = comparableTimestamp;
+    }
+  }
+  return bestSession?.preferredModel?.trim();
+}
+
 export function useSyncSelectedModel(params: {
   modelOptions: ChatModelOption[];
+  selectedSessionKey?: string | null;
   selectedSessionPreferredModel?: string;
+  fallbackPreferredModel?: string;
   defaultModel?: string;
   setSelectedModel: Dispatch<SetStateAction<string>>;
 }) {
-  const { modelOptions, selectedSessionPreferredModel, defaultModel, setSelectedModel } = params;
+  const {
+    modelOptions,
+    selectedSessionKey,
+    selectedSessionPreferredModel,
+    fallbackPreferredModel,
+    defaultModel,
+    setSelectedModel
+  } = params;
+  const previousSessionKeyRef = useRef<string | null | undefined>(undefined);
+
   useEffect(() => {
+    const sessionChanged = previousSessionKeyRef.current !== selectedSessionKey;
     if (modelOptions.length === 0) {
       setSelectedModel('');
+      previousSessionKeyRef.current = selectedSessionKey;
       return;
     }
     setSelectedModel((prev) => {
-      if (modelOptions.some((option) => option.value === prev)) {
-        return prev;
-      }
-      const sessionPreferred = selectedSessionPreferredModel?.trim();
-      if (sessionPreferred && modelOptions.some((option) => option.value === sessionPreferred)) {
-        return sessionPreferred;
-      }
-      const fallback = defaultModel?.trim();
-      if (fallback && modelOptions.some((option) => option.value === fallback)) {
-        return fallback;
-      }
-      return modelOptions[0]?.value ?? '';
+      return resolveSelectedModelValue({
+        currentSelectedModel: prev,
+        modelOptions,
+        selectedSessionPreferredModel,
+        fallbackPreferredModel,
+        defaultModel,
+        preferSessionPreferredModel: sessionChanged
+      });
     });
-  }, [defaultModel, modelOptions, selectedSessionPreferredModel, setSelectedModel]);
+    previousSessionKeyRef.current = selectedSessionKey;
+  }, [defaultModel, fallbackPreferredModel, modelOptions, selectedSessionKey, selectedSessionPreferredModel, setSelectedModel]);
 }
 
 export function useSessionRunStatus(params: {

package/src/components/chat/chat-page-shell.tsx

@@ -0,0 +1,103 @@
+import { useEffect } from 'react';
+import type { Dispatch, MutableRefObject, SetStateAction } from 'react';
+import { ChatSidebar } from '@/components/chat/ChatSidebar';
+import { ChatConversationPanel } from '@/components/chat/ChatConversationPanel';
+import { CronConfig } from '@/components/config/CronConfig';
+import { MarketplacePage } from '@/components/marketplace/MarketplacePage';
+
+export type MainPanelView = 'chat' | 'cron' | 'skills';
+
+export type ChatPageProps = {
+  view: MainPanelView;
+};
+
+type UseChatSessionSyncParams = {
+  view: MainPanelView;
+  routeSessionKey: string | null;
+  selectedSessionKey: string | null;
+  selectedAgentId: string;
+  setSelectedSessionKey: Dispatch<SetStateAction<string | null>>;
+  setSelectedAgentId: Dispatch<SetStateAction<string>>;
+  selectedSessionKeyRef: MutableRefObject<string | null>;
+  resetStreamState: () => void;
+  resolveAgentIdFromSessionKey: (sessionKey: string) => string | null;
+};
+
+export function useChatSessionSync(params: UseChatSessionSyncParams): void {
+  const {
+    view,
+    routeSessionKey,
+    selectedSessionKey,
+    selectedAgentId,
+    setSelectedSessionKey,
+    setSelectedAgentId,
+    selectedSessionKeyRef,
+    resetStreamState,
+    resolveAgentIdFromSessionKey
+  } = params;
+
+  useEffect(() => {
+    if (view !== 'chat') {
+      return;
+    }
+    if (routeSessionKey) {
+      if (selectedSessionKey !== routeSessionKey) {
+        setSelectedSessionKey(routeSessionKey);
+      }
+      return;
+    }
+    if (selectedSessionKey !== null) {
+      setSelectedSessionKey(null);
+      resetStreamState();
+    }
+  }, [resetStreamState, routeSessionKey, selectedSessionKey, setSelectedSessionKey, view]);
+
+  useEffect(() => {
+    const inferred = selectedSessionKey ? resolveAgentIdFromSessionKey(selectedSessionKey) : null;
+    if (!inferred) {
+      return;
+    }
+    if (selectedAgentId !== inferred) {
+      setSelectedAgentId(inferred);
+    }
+  }, [resolveAgentIdFromSessionKey, selectedAgentId, selectedSessionKey, setSelectedAgentId]);
+
+  useEffect(() => {
+    selectedSessionKeyRef.current = selectedSessionKey;
+  }, [selectedSessionKey, selectedSessionKeyRef]);
+}
+
+type ChatPageLayoutProps = {
+  view: MainPanelView;
+  confirmDialog: JSX.Element;
+};
+
+export function ChatPageLayout({ view, confirmDialog }: ChatPageLayoutProps) {
+  return (
+    <div className="h-full flex">
+      <ChatSidebar />
+
+      {view === 'chat' ? (
+        <ChatConversationPanel />
+      ) : (
+        <section className="flex-1 min-h-0 overflow-hidden bg-gradient-to-b from-gray-50/60 to-white">
+          {view === 'cron' ? (
+            <div className="h-full overflow-auto custom-scrollbar">
+              <div className="mx-auto w-full max-w-[min(1120px,100%)] px-6 py-5">
+                <CronConfig />
+              </div>
+            </div>
+          ) : (
+            <div className="h-full overflow-hidden">
+              <div className="mx-auto flex h-full min-h-0 w-full max-w-[min(1120px,100%)] flex-col px-6 py-5">
+                <MarketplacePage forcedType="skills" />
+              </div>
+            </div>
+          )}
+        </section>
+      )}
+
+      {confirmDialog}
+    </div>
+  );
+}

package/src/components/chat/chat-session-preference-sync.test.ts

@@ -0,0 +1,62 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { updateSession } from '@/api/config';
+import { ChatSessionPreferenceSync } from '@/components/chat/chat-session-preference-sync';
+import { useChatInputStore } from '@/components/chat/stores/chat-input.store';
+import { useChatSessionListStore } from '@/components/chat/stores/chat-session-list.store';
+
+vi.mock('@/api/config', () => ({
+  updateSession: vi.fn(async () => ({
+    key: 'session-1',
+    totalMessages: 0,
+    totalEvents: 0,
+    sessionType: 'native',
+    sessionTypeMutable: false,
+    metadata: {},
+    messages: [],
+    events: []
+  }))
+}));
+
+describe('ChatSessionPreferenceSync', () => {
+  afterEach(() => {
+    useChatInputStore.setState((state) => ({
+      snapshot: {
+        ...state.snapshot,
+        selectedModel: '',
+        selectedThinkingLevel: null
+      }
+    }));
+    useChatSessionListStore.setState((state) => ({
+      snapshot: {
+        ...state.snapshot,
+        selectedSessionKey: null
+      }
+    }));
+    vi.clearAllMocks();
+  });
+
+  it('persists the selected model and thinking to the current session metadata', async () => {
+    useChatInputStore.setState((state) => ({
+      snapshot: {
+        ...state.snapshot,
+        selectedModel: 'openai/gpt-5',
+        selectedThinkingLevel: 'high'
+      }
+    }));
+    useChatSessionListStore.setState((state) => ({
+      snapshot: {
+        ...state.snapshot,
+        selectedSessionKey: 'session-1'
+      }
+    }));
+
+    const sync = new ChatSessionPreferenceSync(updateSession);
+    sync.syncSelectedSessionPreferences();
+    await vi.waitFor(() => {
+      expect(updateSession).toHaveBeenCalledWith('session-1', {
+        preferredModel: 'openai/gpt-5',
+        preferredThinking: 'high'
+      });
+    });
+  });
+});