@nextclaw/ui 0.13.13 → 0.14.1-beta.0

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

@@ -0,0 +1,126 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { ChatUiManager } from '@/features/chat/managers/chat-ui.manager';
+import type { PanelAppEntryView } from '@/shared/lib/api';
+import type * as SharedApi from '@/shared/lib/api';
+
+const { listPanelAppsMock } = vi.hoisted(() => ({
+  listPanelAppsMock: vi.fn(),
+}));
+
+vi.mock('@/shared/lib/api', async (importOriginal) => {
+  const actual = await importOriginal<typeof SharedApi>();
+  return {
+    ...actual,
+    nextclawClient: {
+      panelApps: {
+        listPanelApps: listPanelAppsMock,
+      },
+    },
+  };
+});
+
+function createDocBrowserManager() {
+  return {
+    open: vi.fn(),
+    openTarget: vi.fn(),
+  };
+}
+
+function createPanelAppEntry(overrides: Partial<PanelAppEntryView> = {}): PanelAppEntryView {
+  return {
+    appId: 'reader',
+    clientDeclared: false,
+    clientGranted: false,
+    contentPath: '/api/panel-apps/encoded-reader/content',
+    createdAt: '2026-06-09T00:00:00.000Z',
+    favorite: false,
+    fileName: 'reader.panel',
+    id: 'encoded-reader',
+    kind: 'folder',
+    openCount: 0,
+    sizeBytes: 1024,
+    title: 'Reader',
+    updatedAt: '2026-06-09T00:00:00.000Z',
+    ...overrides,
+  };
+}
+
+describe('ChatUiManager content display', () => {
+  beforeEach(() => {
+    listPanelAppsMock.mockReset();
+    listPanelAppsMock.mockResolvedValue({ entries: [] });
+  });
+
+  it('shows URL content through DocBrowser', async () => {
+    const docBrowserManager = createDocBrowserManager();
+    const manager = new ChatUiManager(
+      docBrowserManager as unknown as ConstructorParameters<typeof ChatUiManager>[0],
+    );
+
+    await manager.showContent({
+      target: {
+        type: 'url',
+        payload: {
+          url: 'https://example.com/read',
+        },
+      },
+      title: 'Example URL',
+    });
+
+    expect(docBrowserManager.open).toHaveBeenCalledWith('https://example.com/read', {
+      title: 'Example URL',
+    });
+  });
+
+  it('opens a listed panel app as a managed DocBrowser target', async () => {
+    listPanelAppsMock.mockResolvedValue({
+      entries: [createPanelAppEntry()],
+    });
+    const docBrowserManager = createDocBrowserManager();
+    const manager = new ChatUiManager(
+      docBrowserManager as unknown as ConstructorParameters<typeof ChatUiManager>[0],
+    );
+
+    await manager.showContent({
+      target: {
+        type: 'panel_app',
+        payload: {
+          appId: 'reader',
+        },
+      },
+      title: 'Reader',
+    });
+
+    expect(docBrowserManager.openTarget).toHaveBeenCalledWith({
+      dedupeKey: 'panel-app:encoded-reader',
+      historyPolicy: 'managed',
+      kind: 'panel-app',
+      resourceUri: 'nextclaw://panel-app/encoded-reader',
+      title: 'Reader',
+      url: '/api/panel-apps/encoded-reader/content',
+    }, {
+      title: 'Reader',
+    });
+  });
+
+  it('falls back to the panel app resource URI when no listed entry matches', async () => {
+    const docBrowserManager = createDocBrowserManager();
+    const manager = new ChatUiManager(
+      docBrowserManager as unknown as ConstructorParameters<typeof ChatUiManager>[0],
+    );
+
+    await manager.showContent({
+      target: {
+        type: 'panel_app',
+        payload: {
+          appId: 'encoded-reader',
+        },
+      },
+      title: 'Reader',
+    });
+
+    expect(docBrowserManager.open).toHaveBeenCalledWith('nextclaw://panel-app/encoded-reader', {
+      title: 'Reader',
+    });
+  });
+});

package/src/features/chat/managers/{recent-selection.manager.test.ts → __tests__/recent-selection.manager.test.ts}

@@ -1,22 +1,16 @@
-import { RecentSelectionManager } from './recent-selection.manager';
+import { RecentSelectionManager } from '@/features/chat/managers/recent-selection.manager';
+import { useRecentSelectionStore } from '@/features/chat/stores/recent-selection.store';
 
 describe('RecentSelectionManager', () => {
   const storageKey = 'test.recent-selection-manager';
-  let storageState: Record<string, string>;
-  let storage: Pick<Storage, 'getItem' | 'setItem'>;
 
   beforeEach(() => {
-    storageState = {};
-    storage = {
-      getItem: (key) => storageState[key] ?? null,
-      setItem: (key, value) => {
-        storageState[key] = value;
-      }
-    };
+    window.localStorage.clear();
+    useRecentSelectionStore.setState({ entriesByKey: {} });
   });
 
   it('stores recent values in LRU order and respects the size limit', () => {
-    const manager = new RecentSelectionManager({ storageKey, limit: 3, storage });
+    const manager = new RecentSelectionManager({ storageKey, limit: 3 });
 
     manager.remember('openai/gpt-5');
     manager.remember('anthropic/claude-sonnet-4');
@@ -31,7 +25,7 @@ describe('RecentSelectionManager', () => {
   });
 
   it('filters recent values by the currently available list and threshold', () => {
-    const manager = new RecentSelectionManager({ storageKey, limit: 4, storage });
+    const manager = new RecentSelectionManager({ storageKey, limit: 4 });
     manager.remember('openai/gpt-5');
     manager.remember('anthropic/claude-sonnet-4');
     manager.remember('missing/model');
@@ -60,9 +54,38 @@ describe('RecentSelectionManager', () => {
   });
 
   it('returns an empty list when storage content is malformed', () => {
-    storageState[storageKey] = '{broken-json';
-    const manager = new RecentSelectionManager({ storageKey, limit: 3, storage });
+    window.localStorage.setItem(storageKey, '{broken-json');
+    const manager = new RecentSelectionManager({ storageKey, limit: 3 });
 
     expect(manager.read()).toEqual([]);
   });
+
+  it('does not mutate an empty store while reading recent values', () => {
+    const manager = new RecentSelectionManager({ storageKey, limit: 3 });
+
+    expect(manager.read()).toEqual([]);
+    expect(useRecentSelectionStore.getState().entriesByKey).toEqual({});
+  });
+
+  it('keeps namespaced recent values separate from the global list', () => {
+    const manager = new RecentSelectionManager({ storageKey, limit: 3 });
+
+    manager.remember('openai/gpt-5');
+    manager.remember('anthropic/claude-sonnet-4', { namespace: 'codex' });
+    manager.remember('minimax/MiniMax-M2.7', { namespace: 'hermes' });
+    manager.remember('openai/gpt-5.1', { namespace: 'codex' });
+
+    expect(manager.read()).toEqual(['openai/gpt-5']);
+    expect(manager.read({ namespace: 'codex' })).toEqual([
+      'openai/gpt-5.1',
+      'anthropic/claude-sonnet-4'
+    ]);
+    expect(
+      manager.resolveVisible({
+        namespace: 'hermes',
+        availableValues: ['minimax/MiniMax-M2.7', 'openai/gpt-5'],
+        minAvailableCount: 0
+      })
+    ).toEqual(['minimax/MiniMax-M2.7']);
+  });
 });

package/src/features/chat/managers/chat-draft-intent.manager.ts

@@ -0,0 +1,46 @@
+export type ChatDraftIntent = {
+  id: number;
+  prompt: string;
+};
+
+type ChatDraftIntentListener = (intent: ChatDraftIntent) => void;
+
+export class ChatDraftIntentManager {
+  private nextId = 0;
+  private pendingIntent: ChatDraftIntent | null = null;
+  private readonly listeners = new Set<ChatDraftIntentListener>();
+
+  requestDraft = (prompt: string) => {
+    const normalizedPrompt = prompt.trim();
+    if (!normalizedPrompt) {
+      return;
+    }
+    const intent: ChatDraftIntent = {
+      id: this.nextId + 1,
+      prompt: normalizedPrompt,
+    };
+    this.nextId = intent.id;
+    this.pendingIntent = intent;
+    this.listeners.forEach((listener) => listener(intent));
+  };
+
+  consumePending = (): ChatDraftIntent | null => {
+    const intent = this.pendingIntent;
+    this.pendingIntent = null;
+    return intent;
+  };
+
+  markConsumed = (intentId: number) => {
+    if (this.pendingIntent?.id !== intentId) {
+      return;
+    }
+    this.pendingIntent = null;
+  };
+
+  subscribe = (listener: ChatDraftIntentListener) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+}

package/src/features/chat/managers/{ncp-chat-input.manager.ts → chat-input.manager.ts}

@@ -1,4 +1,5 @@
 import type { ChatComposerNode } from '@nextclaw/agent-chat-ui';
+import { isRuntimeDefaultModelValue } from '@nextclaw/shared';
 import type { NcpDraftAttachment } from '@nextclaw/ncp-react';
 import type { SetStateAction } from 'react';
 import type { ThinkingLevel } from '@/shared/lib/api';
@@ -12,24 +13,28 @@ import {
   pruneComposerAttachments,
   syncComposerAttachments,
   syncComposerSkills
-} from '@/features/chat/utils/chat-composer-state.utils';
+} from '@/features/chat/features/input/utils/chat-composer-state.utils';
 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';
 import type { ChatInputSnapshot } from '@/features/chat/stores/chat-input.store';
-import type { ChatStreamActionsManager } from '@/features/chat/managers/chat-stream-actions.manager';
-import type { ChatUiManager } from '@/features/chat/managers/chat-ui.manager';
+import type { ChatRunManager } from '@/features/chat/managers/chat-run.manager';
 import type { ChatSessionListManager } from '@/features/chat/managers/chat-session-list.manager';
 import { ChatSessionPreferenceSync } from '@/features/chat/managers/chat-session-preference-sync.manager';
-import { isNcpChatSendDisabled } from '@/features/chat/utils/ncp-chat-input-availability.utils';
-import { isNcpChatRuntimeBlocked } from '@/features/chat/utils/ncp-chat-runtime-availability.utils';
+import { isNcpChatSendDisabled } from '@/features/chat/features/input/utils/ncp-chat-input-availability.utils';
+import { isNcpChatRuntimeBlocked } from '@/features/chat/features/runtime/utils/ncp-chat-runtime-availability.utils';
 import { chatRecentModelsManager } from '@/features/chat/managers/chat-recent-models.manager';
 import { chatRecentSkillsManager } from '@/features/chat/managers/chat-recent-skills.manager';
 import type { ChatModelOption } from '@/features/chat/types/chat-input.types';
-import { normalizeSessionType } from '@/features/chat/hooks/use-chat-session-type-state';
+import { normalizeSessionType } from '@/features/chat/features/session-type/utils/chat-session-type.utils';
 import { systemStatusManager } from '@/features/system-status';
+import { shouldClearPendingProjectRootOverride } from '@/features/chat/features/session/utils/chat-run-metadata.utils';
 
-export class NcpChatInputManager {
+function resolveModelForSend(value: string): string | undefined {
+  return value || undefined;
+}
+
+export class ChatInputManager {
   private readonly sessionPreferenceSync = new ChatSessionPreferenceSync(updateNcpSession);
 
   private buildAttachmentSignature = (attachment: NcpDraftAttachment): string =>
@@ -43,21 +48,10 @@ export class NcpChatInputManager {
     ].join(':');
 
   constructor(
-    private uiManager: ChatUiManager,
-    private streamActionsManager: ChatStreamActionsManager,
+    private chatRunManager: ChatRunManager,
     private sessionListManager: ChatSessionListManager
   ) {}
 
-  private hasSnapshotChanges = (patch: Partial<ChatInputSnapshot>): boolean => {
-    const current = useChatInputStore.getState().snapshot;
-    for (const [key, value] of Object.entries(patch) as Array<[keyof ChatInputSnapshot, ChatInputSnapshot[keyof ChatInputSnapshot]]>) {
-      if (!Object.is(current[key], value)) {
-        return true;
-      }
-    }
-    return false;
-  };
-
   private resolveUpdateValue = <T>(prev: T, next: SetStateAction<T>): T => {
     if (typeof next === 'function') {
       return (next as (value: T) => T)(prev);
@@ -68,6 +62,16 @@ export class NcpChatInputManager {
   private isSameStringArray = (left: string[], right: string[]): boolean =>
     left.length === right.length && left.every((value, index) => value === right[index]);
 
+  private hasSnapshotChanges = (patch: Partial<ChatInputSnapshot>): boolean => {
+    const current = useChatInputStore.getState().snapshot;
+    for (const [key, value] of Object.entries(patch) as Array<[keyof ChatInputSnapshot, ChatInputSnapshot[keyof ChatInputSnapshot]]>) {
+      if (!Object.is(current[key], value)) {
+        return true;
+      }
+    }
+    return false;
+  };
+
   private isRuntimeBlockedForSend = (): boolean =>
     isNcpChatRuntimeBlocked(systemStatusManager.getStatusView());
 
@@ -109,20 +113,78 @@ export class NcpChatInputManager {
   };
 
   syncSnapshot = (patch: Partial<ChatInputSnapshot>) => {
-    if (!this.hasSnapshotChanges(patch)) {
+    const current = useChatInputStore.getState().snapshot;
+    let resolvedPatch = patch;
+    if (
+      patch.defaultSessionType &&
+      current.selectedSessionType === undefined &&
+      patch.selectedSessionType === undefined
+    ) {
+      resolvedPatch = Object.assign({}, patch, {
+        selectedSessionType: patch.defaultSessionType,
+      });
+    }
+    if (!this.hasSnapshotChanges(resolvedPatch)) {
       return;
     }
-    useChatInputStore.getState().setSnapshot(patch);
+    useChatInputStore.getState().setSnapshot(resolvedPatch);
     if (
-      Object.prototype.hasOwnProperty.call(patch, 'modelOptions') ||
-      Object.prototype.hasOwnProperty.call(patch, 'selectedModel') ||
-      Object.prototype.hasOwnProperty.call(patch, 'selectedThinkingLevel')
+      Object.prototype.hasOwnProperty.call(resolvedPatch, 'modelOptions') ||
+      Object.prototype.hasOwnProperty.call(resolvedPatch, 'selectedModel') ||
+      Object.prototype.hasOwnProperty.call(resolvedPatch, 'selectedThinkingLevel')
     ) {
       const { selectedModel } = useChatInputStore.getState().snapshot;
       this.reconcileThinkingForModel(selectedModel);
     }
   };
 
+  resolveProjectRootForSend = (params: {
+    sessionKey: string | null | undefined;
+    selectedSessionProjectRoot: string | null | undefined;
+  }): string | null => {
+    const { pendingProjectRoot, pendingProjectRootSessionKey } =
+      useChatInputStore.getState().snapshot;
+    if (
+      pendingProjectRoot !== null &&
+      (!params.sessionKey || params.sessionKey === pendingProjectRootSessionKey)
+    ) {
+      return pendingProjectRoot;
+    }
+    return params.selectedSessionProjectRoot ?? null;
+  };
+
+  clearPendingProjectRootOverrideForSession = (params: {
+    sessionKey: string | null | undefined;
+    selectedSessionProjectRoot: string | null | undefined;
+  }) => {
+    const { pendingProjectRoot, pendingProjectRootSessionKey } =
+      useChatInputStore.getState().snapshot;
+    if (
+      !shouldClearPendingProjectRootOverride({
+        pendingProjectRoot,
+        pendingProjectRootSessionKey,
+        sessionKey: params.sessionKey,
+        selectedSessionProjectRoot: params.selectedSessionProjectRoot,
+      })
+    ) {
+      return;
+    }
+    useChatInputStore.getState().setSnapshot({
+      pendingProjectRoot: null,
+      pendingProjectRootSessionKey: null,
+    });
+  };
+
+  clearPendingProjectRootOverrideForCurrentThread = () => {
+    const { sessionKey, sessionProjectRoot } = useChatThreadStore.getState().snapshot;
+    this.clearPendingProjectRootOverrideForSession({
+      sessionKey,
+      selectedSessionProjectRoot: sessionProjectRoot,
+    });
+  };
+
+  syncSessionPreferences = this.sessionPreferenceSync.syncInputSelection;
+
   setDraft = (next: SetStateAction<string>) => {
     const prev = useChatInputStore.getState().snapshot.draft;
     const value = this.resolveUpdateValue(prev, next);
@@ -189,7 +251,10 @@ export class NcpChatInputManager {
     if (value === prev) {
       return;
     }
-    useChatInputStore.getState().setSnapshot({ pendingSessionType: value });
+    useChatInputStore.getState().setSnapshot({
+      pendingSessionType: value,
+      selectedSessionType: value,
+    });
   };
 
   send = async () => {
@@ -220,28 +285,31 @@ export class NcpChatInputManager {
       this.sessionListManager.ensureDraftSession(inputSnapshot.selectedSessionType);
     }
     this.setComposerNodes(createInitialChatComposerNodes());
-    await this.streamActionsManager.sendMessage({
-      message,
-      ...(sessionKey ? { sessionKey } : {}),
-      agentId: sessionSnapshot.selectedAgentId,
-      sessionType: inputSnapshot.selectedSessionType,
-      model: inputSnapshot.selectedModel || undefined,
-      thinkingLevel: inputSnapshot.selectedThinkingLevel ?? undefined,
-      stopSupported: true,
-      requestedSkills,
-      attachments,
-      parts,
-      restoreDraftOnError: true,
-      composerNodes
-    });
+    try {
+      await this.chatRunManager.sendMessage({
+        message,
+        sessionKey: sessionKey ?? undefined,
+        agentId: sessionSnapshot.selectedAgentId,
+        sessionType: inputSnapshot.selectedSessionType,
+        model: resolveModelForSend(inputSnapshot.selectedModel),
+        thinkingLevel: inputSnapshot.selectedThinkingLevel ?? undefined,
+        projectRoot: this.resolveProjectRootForSend({
+          sessionKey,
+          selectedSessionProjectRoot: threadSnapshot.sessionProjectRoot,
+        }),
+        requestedSkills,
+        attachments,
+        parts,
+        composerNodes,
+      });
+    } catch (error) {
+      this.restoreComposerState(composerNodes, attachments);
+      throw error;
+    }
   };
 
   stop = async () => {
-    await this.streamActionsManager.stopCurrentRun();
-  };
-
-  goToProviders = () => {
-    this.uiManager.goToProviders();
+    await this.chatRunManager.stopCurrentRun();
   };
 
   setSelectedModel = (next: SetStateAction<string>) => {
@@ -280,7 +348,12 @@ export class NcpChatInputManager {
 
   selectModel = (value: string) => {
     this.setSelectedModel(value);
-    chatRecentModelsManager.remember(value);
+    chatRecentModelsManager.remember(value, {
+      namespace: useChatInputStore.getState().snapshot.selectedSessionType,
+    });
+    if (!isRuntimeDefaultModelValue(value)) {
+      chatRecentModelsManager.remember(value);
+    }
     this.sessionPreferenceSync.syncSelectedSessionPreferences();
   };
 

package/src/features/chat/managers/chat-query.manager.ts

@@ -0,0 +1,48 @@
+import type { ChatQuerySnapshot } from '@/features/chat/stores/ncp-chat-query.store';
+import { useChatQueryStore } from '@/features/chat/stores/ncp-chat-query.store';
+
+function toQuerySnapshotComparable(snapshot: ChatQuerySnapshot) {
+  const toQueryComparable = (query: unknown) => {
+    if (!query || typeof query !== 'object') {
+      return query;
+    }
+    const record = query as Record<string, unknown>;
+    const error = record.error instanceof Error
+      ? { name: record.error.name, message: record.error.message }
+      : record.error;
+    return {
+      data: record.data,
+      error,
+      status: record.status,
+      fetchStatus: record.fetchStatus,
+      isLoading: record.isLoading,
+      isFetching: record.isFetching,
+      isFetched: record.isFetched,
+      isSuccess: record.isSuccess,
+    };
+  };
+  return {
+    configQuery: toQueryComparable(snapshot.configQuery),
+    providersQuery: toQueryComparable(snapshot.providersQuery),
+    providerTemplatesQuery: toQueryComparable(snapshot.providerTemplatesQuery),
+    sessionsQuery: toQueryComparable(snapshot.sessionsQuery),
+    sessionTypesQuery: toQueryComparable(snapshot.sessionTypesQuery),
+    sessionSkillsSessionId: snapshot.sessionSkillsSessionId,
+    sessionSkillsQuery: toQueryComparable(snapshot.sessionSkillsQuery),
+  };
+}
+
+function hasQuerySnapshotChange(current: ChatQuerySnapshot, patch: Partial<ChatQuerySnapshot>): boolean {
+  return JSON.stringify(toQuerySnapshotComparable(current)) !==
+    JSON.stringify(toQuerySnapshotComparable({ ...current, ...patch }));
+}
+
+export class ChatQueryManager {
+  syncSnapshot = (value: Partial<ChatQuerySnapshot>) => {
+    const store = useChatQueryStore.getState();
+    if (!hasQuerySnapshotChange(store.snapshot, value)) {
+      return;
+    }
+    store.setSnapshot(value);
+  };
+}

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

@@ -0,0 +1,110 @@
+import { buildNcpRequestEnvelope } from '@nextclaw/ncp-react';
+import { useChatInputStore } from '@/features/chat/stores/chat-input.store';
+import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
+import type { ChatUiManager } from '@/features/chat/managers/chat-ui.manager';
+import type {
+  ChatRunRuntime,
+  ChatRunSnapshot,
+  SendMessageParams,
+} from '@/features/chat/types/chat-run.types';
+import { buildChatRunMetadata } from '@/features/chat/features/session/utils/chat-run-metadata.utils';
+
+export class ChatRunManager {
+  private activeRuntime: ChatRunRuntime | null = null;
+
+  constructor(private uiManager: ChatUiManager) {}
+
+  setActiveRuntime = (runtime: ChatRunRuntime | null) => {
+    this.activeRuntime = runtime;
+  };
+
+  sendMessage = async (payload: SendMessageParams) => {
+    const runtime = this.activeRuntime;
+    if (!runtime || runtime.sessionKey !== (payload.sessionKey ?? null)) {
+      return;
+    }
+    const metadata = buildChatRunMetadata({
+      agentId: payload.agentId,
+      model: payload.model,
+      thinkingLevel: payload.thinkingLevel,
+      sessionType: payload.sessionType,
+      projectRoot: payload.projectRoot,
+      requestedSkills: payload.requestedSkills,
+      composerNodes: payload.composerNodes,
+    });
+    const envelope = buildNcpRequestEnvelope({
+      sessionId: payload.sessionKey,
+      text: payload.message,
+      attachments: payload.attachments,
+      parts: payload.parts,
+      metadata,
+    });
+    if (!envelope) {
+      return;
+    }
+    const handle = await runtime.sendEnvelope(envelope);
+    if (!payload.sessionKey && handle?.sessionId) {
+      this.materializeRootSessionRoute(handle.sessionId);
+    }
+  };
+
+  stopCurrentRun = async () => {
+    await this.activeRuntime?.abortCurrentRun();
+  };
+
+  resumeRun = async (run: { sessionKey: string }) => {
+    if (this.activeRuntime?.sessionKey !== run.sessionKey) {
+      return;
+    }
+    await this.activeRuntime.resumeCurrentSessionRun();
+  };
+
+  applyRunSnapshot = (snapshot: ChatRunSnapshot) => {
+    const isSending = snapshot.isSending || snapshot.isRunning;
+    const sessionKey =
+      snapshot.routeSessionKey ?? snapshot.materializedSessionKey ?? null;
+    useChatInputStore.getState().setSnapshot({
+      canStopGeneration: snapshot.isRunning,
+      stopDisabledReason: snapshot.isRunning ? null : '__preparing__',
+      stopSupported: true,
+      stopReason: undefined,
+      sendError: snapshot.sendErrorMessage,
+      isSending,
+    });
+    useChatThreadStore.getState().setSnapshot({
+      sessionKey,
+      isHistoryLoading: snapshot.isHydrating,
+      messages: snapshot.visibleMessages,
+      isSending,
+      isAwaitingAssistantOutput: snapshot.isRunning,
+      contextWindow: snapshot.contextWindow,
+    });
+    if (!snapshot.routeSessionKey && snapshot.materializedSessionKey) {
+      this.materializeRootSessionRoute(snapshot.materializedSessionKey);
+    }
+  };
+
+  clearRunState = () => {
+    useChatInputStore.getState().setSnapshot({
+      canStopGeneration: false,
+      stopDisabledReason: '__preparing__',
+      sendError: null,
+      isSending: false,
+    });
+    useChatThreadStore.getState().setSnapshot({
+      isHistoryLoading: false,
+      messages: [],
+      isSending: false,
+      isAwaitingAssistantOutput: false,
+      contextWindow: null,
+    });
+  };
+
+  private materializeRootSessionRoute = (sessionKey: string) => {
+    const normalizedSessionKey = sessionKey.trim();
+    if (!normalizedSessionKey || !this.uiManager.isAtChatRoot()) {
+      return;
+    }
+    this.uiManager.goToSession(normalizedSessionKey, { replace: true });
+  };
+}