@nextclaw/ui 0.12.22 → 0.12.24

package/src/features/chat/hooks/use-ncp-agent-runtime.test.tsx

@@ -1,90 +1,179 @@
-import { act, renderHook } from "@testing-library/react";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { NcpEventType, type NcpEndpointEvent } from "@nextclaw/ncp";
+import { act, renderHook, waitFor } from "@testing-library/react";
+import {
+  type NcpAgentClientEndpoint,
+  type NcpAgentSendEnvelope,
+  type NcpEndpointEvent,
+  type NcpEndpointManifest,
+  type NcpEndpointSubscriber,
+  NcpEventType,
+} from "@nextclaw/ncp";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { DefaultNcpAgentConversationStateManager } from "../../../../../ncp-packages/nextclaw-ncp-toolkit/src/agent/agent-conversation-state-manager.ts";
 import { useNcpAgentRuntime } from "../../../../../ncp-packages/nextclaw-ncp-react/src/hooks/use-ncp-agent-runtime.ts";
 
-function createEvent(type: NcpEventType, delta: string): NcpEndpointEvent {
-  return {
-    type,
-    payload: {
-      sessionId: "session-1",
-      messageId: "assistant-1",
-      toolCallId: "tool-1",
-      delta,
-    },
-  } as NcpEndpointEvent;
+const now = "2026-05-14T00:00:00.000Z";
+
+class DeferredSendClient implements NcpAgentClientEndpoint {
+  readonly manifest: NcpEndpointManifest = {
+    endpointKind: "agent",
+    endpointId: "deferred-send-client",
+    version: "0.1.0",
+    supportsStreaming: true,
+    supportsAbort: true,
+    supportsProactiveMessages: false,
+    supportsLiveSessionStream: true,
+    supportedPartTypes: ["text"],
+    expectedLatency: "seconds",
+  };
+
+  readonly stop = vi.fn(async () => {});
+  readonly start = vi.fn(async () => {});
+  readonly stream = vi.fn(async () => {});
+  readonly abort = vi.fn(async () => {});
+  private listeners = new Set<NcpEndpointSubscriber>();
+  private releaseCompletion: (() => void) | null = null;
+  private completionGate = new Promise<void>((resolve) => {
+    this.releaseCompletion = resolve;
+  });
+
+  emit = async (event: NcpEndpointEvent): Promise<void> => {
+    this.publish(event);
+  };
+
+  subscribe = (listener: NcpEndpointSubscriber): (() => void) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+
+  send = vi.fn(async (_envelope: NcpAgentSendEnvelope): Promise<void> => {
+    this.publish({
+      type: NcpEventType.MessageSent,
+      payload: {
+        sessionId: "session-created",
+        message: {
+          id: "user-1",
+          sessionId: "session-created",
+          role: "user",
+          status: "final",
+          parts: [{ type: "text", text: "hello" }],
+          timestamp: now,
+        },
+      },
+    });
+    this.publish({
+      type: NcpEventType.RunStarted,
+      payload: {
+        sessionId: "session-created",
+        messageId: "assistant-1",
+        runId: "run-1",
+      },
+    });
+    await this.completionGate;
+    this.publish({
+      type: NcpEventType.MessageTextStart,
+      payload: {
+        sessionId: "session-created",
+        messageId: "assistant-1",
+      },
+    });
+    this.publish({
+      type: NcpEventType.MessageTextDelta,
+      payload: {
+        sessionId: "session-created",
+        messageId: "assistant-1",
+        delta: "done",
+      },
+    });
+    this.publish({
+      type: NcpEventType.MessageTextEnd,
+      payload: {
+        sessionId: "session-created",
+        messageId: "assistant-1",
+      },
+    });
+    this.publish({
+      type: NcpEventType.MessageCompleted,
+      payload: {
+        sessionId: "session-created",
+        message: {
+          id: "assistant-1",
+          sessionId: "session-created",
+          role: "assistant",
+          status: "final",
+          parts: [{ type: "text", text: "done" }],
+          timestamp: now,
+        },
+      },
+    });
+    this.publish({
+      type: NcpEventType.RunFinished,
+      payload: {
+        sessionId: "session-created",
+        runId: "run-1",
+      },
+    });
+  });
+
+  release = (): void => {
+    this.releaseCompletion?.();
+  };
+
+  private publish = (event: NcpEndpointEvent): void => {
+    for (const listener of this.listeners) {
+      listener(event);
+    }
+  };
 }
 
 describe("useNcpAgentRuntime", () => {
   beforeEach(() => {
-    vi.useFakeTimers();
+    vi.clearAllMocks();
   });
 
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("batches streamed endpoint events before dispatching them to the manager", async () => {
-    let subscriber: ((event: NcpEndpointEvent) => void) | null = null;
-    const snapshot = {
-      messages: [],
-      streamingMessage: null,
-      error: null,
-      activeRun: null,
-    };
-    const client = {
-      subscribe: vi.fn((callback: (event: NcpEndpointEvent) => void) => {
-        subscriber = callback;
-        return () => {
-          subscriber = null;
-        };
-      }),
-      stop: vi.fn().mockResolvedValue(undefined),
-      send: vi.fn().mockResolvedValue(undefined),
-      abort: vi.fn().mockResolvedValue(undefined),
-      stream: vi.fn().mockResolvedValue(undefined),
-    };
-    const manager = {
-      getSnapshot: vi.fn(() => snapshot),
-      subscribe: vi.fn(() => () => {}),
-      dispatch: vi.fn().mockResolvedValue(undefined),
-      dispatchBatch: vi.fn().mockResolvedValue(undefined),
+  it("keeps the active send stream alive when a new root chat materializes a session id", async () => {
+    const client = new DeferredSendClient();
+    const manager = new DefaultNcpAgentConversationStateManager();
+    const envelope: NcpAgentSendEnvelope = {
+      message: {
+        id: "user-1",
+        role: "user",
+        status: "final",
+        parts: [{ type: "text", text: "hello" }],
+        timestamp: now,
+      },
     };
-
-    renderHook(() =>
-      useNcpAgentRuntime({
-        sessionId: "session-1",
-        client: client as never,
-        manager: manager as never,
-      }),
+    const { result, rerender } = renderHook(
+      ({ sessionId }: { sessionId?: string }) =>
+        useNcpAgentRuntime({ sessionId, client, manager: manager as never }),
+      { initialProps: { sessionId: undefined as string | undefined } },
     );
 
-    expect(subscriber).not.toBeNull();
-
+    let sendPromise: Promise<void>;
     act(() => {
-      subscriber?.(createEvent(NcpEventType.MessageToolCallArgsDelta, '{"path":"src/app.ts",'));
-      subscriber?.(
-        createEvent(
-          NcpEventType.MessageToolCallArgsDelta,
-          '"content":"console.log(1);"}',
-        ),
-      );
+      sendPromise = result.current.send(envelope);
+    });
+
+    await waitFor(() => {
+      expect(result.current.snapshot.activeRun?.sessionId).toBe("session-created");
     });
 
-    expect(manager.dispatchBatch).not.toHaveBeenCalled();
+    rerender({ sessionId: "session-created" });
+
+    expect(client.stop).not.toHaveBeenCalled();
 
     await act(async () => {
-      vi.advanceTimersByTime(16);
-      await Promise.resolve();
+      client.release();
+      await sendPromise;
     });
 
-    expect(manager.dispatchBatch).toHaveBeenCalledTimes(1);
-    expect(manager.dispatchBatch).toHaveBeenCalledWith([
-      createEvent(NcpEventType.MessageToolCallArgsDelta, '{"path":"src/app.ts",'),
-      createEvent(
-        NcpEventType.MessageToolCallArgsDelta,
-        '"content":"console.log(1);"}',
-      ),
+    await waitFor(() => {
+      expect(result.current.snapshot.activeRun).toBeNull();
+    });
+    expect(result.current.visibleMessages.map((message) => message.id)).toEqual([
+      "user-1",
+      "assistant-1",
     ]);
   });
 });

package/src/features/chat/hooks/use-ncp-chat-derived-state.ts

@@ -113,7 +113,7 @@ export function useNcpChatSnapshotSync(params: {
   sessionTypeUnavailableMessage: string | null;
   currentSessionTypeLabel: string;
   currentSessionTypeIcon: ChatSessionTypeOption['icon'];
-  sessionKey: string;
+  sessionKey: string | null | undefined;
   currentAgentId: string;
   currentAgent: AgentProfileView | null;
   availableAgents: AgentProfileView[];
@@ -152,7 +152,7 @@ export function useNcpChatSnapshotSync(params: {
       sessionTypeUnavailableMessage: params.sessionTypeUnavailableMessage,
       sessionTypeLabel: params.currentSessionTypeLabel,
       sessionTypeIcon: params.currentSessionTypeIcon,
-      sessionKey: params.sessionKey,
+      sessionKey: params.sessionKey ?? null,
       agentId: params.currentAgentId,
       agentDisplayName: params.currentAgent?.displayName ?? null,
       agentAvatarUrl: params.currentAgent?.avatarUrl ?? null,

package/src/features/chat/hooks/use-ncp-chat-page-data.ts

@@ -23,7 +23,7 @@ export type { ChatModelOption } from '@/features/chat/types/chat-input.types';
 
 type UseNcpChatPageDataParams = {
   query: string;
-  sessionKey: string;
+  sessionKey: string | null;
   projectRootOverride?: string | null;
   currentSelectedModel: string;
   pendingSessionType: string;
@@ -76,7 +76,7 @@ function useNcpChatModelOptions(params: {
 
 function useRecentSessionPreferences(params: {
   sessions: SessionEntryView[];
-  sessionKey: string;
+  sessionKey: string | null;
   sessionType: string;
 }) {
   const { sessions, sessionKey, sessionType } = params;
@@ -84,7 +84,7 @@ function useRecentSessionPreferences(params: {
     () =>
       resolveRecentSessionPreferredValue<string>({
         sessions,
-        selectedSessionKey: sessionKey,
+        selectedSessionKey: sessionKey ?? '',
         sessionType,
         readPreference: (session) => session.preferredModel?.trim() || undefined
       }),
@@ -94,7 +94,7 @@ function useRecentSessionPreferences(params: {
     () =>
       resolveRecentSessionPreferredValue<ThinkingLevel>({
         sessions,
-        selectedSessionKey: sessionKey,
+        selectedSessionKey: sessionKey ?? '',
         sessionType,
         readPreference: (session) => session.preferredThinking ?? undefined
       }),
@@ -158,7 +158,7 @@ export function useNcpChatPageData(params: UseNcpChatPageDataParams) {
   const sessionsQuery = useNcpSessions({ limit: 200 });
   const sessionTypesQuery = useNcpChatSessionTypes();
   const sessionSkillsQuery = useNcpSessionSkills({
-    sessionId: sessionKey,
+    sessionId: sessionKey ?? null,
     ...(Object.prototype.hasOwnProperty.call(params, 'projectRootOverride')
       ? { projectRoot: projectRootOverride ?? null }
       : {})
@@ -219,7 +219,7 @@ export function useNcpChatPageData(params: UseNcpChatPageDataParams) {
 
   useSyncSelectedModel({
     modelOptions: filteredModelOptions,
-    selectedSessionKey: sessionKey,
+    selectedSessionKey: sessionKey ?? '',
     selectedSessionExists: Boolean(selectedSession),
     selectedSessionPreferredModel: selectedSession?.preferredModel,
     fallbackPreferredModel: sessionTypeState.selectedSessionTypeOption?.recommendedModel ?? recentSessionPreferredModel,
@@ -228,7 +228,7 @@ export function useNcpChatPageData(params: UseNcpChatPageDataParams) {
   });
   useSyncSelectedThinking({
     supportedThinkingLevels,
-    selectedSessionKey: sessionKey,
+    selectedSessionKey: sessionKey ?? '',
     selectedSessionExists: Boolean(selectedSession),
     selectedSessionPreferredThinking: selectedSession?.preferredThinking ?? null,
     fallbackPreferredThinking: recentSessionPreferredThinking ?? null,

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

@@ -146,6 +146,16 @@ describe("useNcpSessionConversation", () => {
     expect(mocks.hydratedCalls[1]?.client).toBe(mocks.clientInstances[1]);
   });
 
+  it("passes an empty session through without requesting a draft history seed", () => {
+    renderHook(() => useNcpSessionConversation(undefined));
+
+    expect(mocks.useHydratedNcpAgent).toHaveBeenCalledTimes(1);
+    expect(mocks.hydratedCalls[0]).toMatchObject({
+      sessionId: undefined,
+    });
+    expect(mocks.fetchNcpSessionMessages).not.toHaveBeenCalled();
+  });
+
   it("exposes the hydrated session context window without changing the generic ncp agent seed", async () => {
     const contextWindow = {
       usedContextTokens: 42,

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

@@ -93,7 +93,7 @@ function useSyncReadyRetryVersion(
 }
 
 export function useNcpSessionConversation(
-  sessionId: string,
+  sessionId: string | undefined,
   options: UseNcpSessionConversationOptions = {},
 ) {
   const [client] = useState(() => createNcpSessionConversationClient());
@@ -126,6 +126,7 @@ export function useNcpSessionConversation(
   const currentAgentError =
     agent.hydrateError?.message ?? agent.snapshot.error?.message ?? null;
   const readyRetrySignature =
+    sessionId &&
     systemStatus.phase === "ready" &&
     isNcpAgentStartupUnavailableErrorMessage(currentAgentError)
       ? `${sessionId}:${systemStatus.lastReadyAt ?? 0}`

package/src/features/chat/hooks/use-selected-session-context-window-indicator.ts

@@ -6,15 +6,13 @@ import { buildChatContextWindowIndicator } from '@/features/chat/utils/chat-cont
 
 export function useSelectedSessionContextWindowIndicator(): ChatContextWindowIndicator | null {
   const selectedSessionKey = useChatSessionListStore((state) => state.snapshot.selectedSessionKey);
-  const draftSessionKey = useChatSessionListStore((state) => state.snapshot.draftSessionKey);
   const liveSessionKey = useChatThreadStore((state) => state.snapshot.sessionKey);
   const liveContextWindow = useChatThreadStore((state) => state.snapshot.contextWindow);
-  const currentSessionKey = selectedSessionKey ?? draftSessionKey;
 
   return useMemo(() => {
-    if (liveSessionKey === currentSessionKey && liveContextWindow) {
+    if (selectedSessionKey && liveSessionKey === selectedSessionKey && liveContextWindow) {
       return buildChatContextWindowIndicator(liveContextWindow);
     }
     return null;
-  }, [currentSessionKey, liveContextWindow, liveSessionKey]);
+  }, [liveContextWindow, liveSessionKey, selectedSessionKey]);
 }

package/src/features/chat/managers/chat-session-list.manager.test.ts

@@ -1,4 +1,5 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type * as SharedApi from '@/shared/lib/api';
 import { ChatSessionListManager } from '@/features/chat/managers/chat-session-list.manager';
 import { useChatInputStore } from '@/features/chat/stores/chat-input.store';
 import { useChatSessionListStore } from '@/features/chat/stores/chat-session-list.store';
@@ -9,7 +10,7 @@ const mocks = vi.hoisted(() => ({
 }));
 
 vi.mock('@/shared/lib/api', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('@/shared/lib/api')>();
+  const actual = await importOriginal<typeof SharedApi>();
   return {
     ...actual,
     updateNcpSession: mocks.updateNcpSession,
@@ -59,13 +60,13 @@ describe('ChatSessionListManager', () => {
     } as unknown as ConstructorParameters<typeof ChatSessionListManager>[1];
 
     const manager = new ChatSessionListManager(uiManager, streamActionsManager);
-    const sessionKey = manager.createSession('codex');
+    manager.createSession('codex');
 
     expect(streamActionsManager.resetStreamState).toHaveBeenCalledTimes(1);
     expect(uiManager.goToChatRoot).toHaveBeenCalledTimes(1);
     expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBeNull();
-    expect(useChatSessionListStore.getState().snapshot.draftSessionKey).toBe(sessionKey);
-    expect(useChatSessionListStore.getState().snapshot.draftSessionKey).not.toBe('draft-root-1');
+    expect(useChatSessionListStore.getState().snapshot.draftSessionKey).toBeNull();
+    expect(useChatThreadStore.getState().snapshot.sessionKey).toBeNull();
     expect(useChatInputStore.getState().snapshot.pendingSessionType).toBe('codex');
     expect(useChatInputStore.getState().snapshot.pendingProjectRoot).toBeNull();
     expect(useChatInputStore.getState().snapshot.pendingProjectRootSessionKey).toBeNull();
@@ -82,14 +83,14 @@ describe('ChatSessionListManager', () => {
     } as unknown as ConstructorParameters<typeof ChatSessionListManager>[1];
 
     const manager = new ChatSessionListManager(uiManager, streamActionsManager);
-    const sessionKey = manager.startAgentDraftChat('researcher', 'codex');
+    manager.startAgentDraftChat('researcher', 'codex');
 
     expect(streamActionsManager.resetStreamState).toHaveBeenCalledTimes(1);
     expect(uiManager.goToChatRoot).toHaveBeenCalledTimes(1);
     expect(useChatSessionListStore.getState().snapshot.selectedAgentId).toBe('researcher');
     expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBeNull();
-    expect(useChatSessionListStore.getState().snapshot.draftSessionKey).toBe(sessionKey);
-    expect(useChatThreadStore.getState().snapshot.sessionKey).toBe(sessionKey);
+    expect(useChatSessionListStore.getState().snapshot.draftSessionKey).toBeNull();
+    expect(useChatThreadStore.getState().snapshot.sessionKey).toBeNull();
     expect(useChatInputStore.getState().snapshot.pendingSessionType).toBe('codex');
     expect(useChatInputStore.getState().snapshot.pendingProjectRoot).toBeNull();
     expect(useChatInputStore.getState().snapshot.pendingProjectRootSessionKey).toBeNull();
@@ -106,13 +107,13 @@ describe('ChatSessionListManager', () => {
     } as unknown as ConstructorParameters<typeof ChatSessionListManager>[1];
 
     const manager = new ChatSessionListManager(uiManager, streamActionsManager);
-    const sessionKey = manager.createSession('native', '/tmp/project-alpha');
+    manager.createSession('native', '/tmp/project-alpha');
 
     expect(useChatInputStore.getState().snapshot.pendingProjectRoot).toBe('/tmp/project-alpha');
-    expect(useChatInputStore.getState().snapshot.pendingProjectRootSessionKey).toBe(sessionKey);
+    expect(useChatInputStore.getState().snapshot.pendingProjectRootSessionKey).toBeNull();
   });
 
-  it('reuses the current root draft when send flow needs a concrete session key', () => {
+  it('keeps the root draft key empty when send flow has no concrete session yet', () => {
     useChatSessionListStore.setState({
       snapshot: {
         ...useChatSessionListStore.getState().snapshot,
@@ -132,7 +133,7 @@ describe('ChatSessionListManager', () => {
     const manager = new ChatSessionListManager(uiManager, streamActionsManager);
     const sessionKey = manager.ensureDraftSession('native');
 
-    expect(sessionKey).toBe('draft-root-2');
+    expect(sessionKey).toBeNull();
     expect(uiManager.goToChatRoot).not.toHaveBeenCalled();
     expect(uiManager.goToSession).not.toHaveBeenCalled();
     expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBeNull();
@@ -149,10 +150,10 @@ describe('ChatSessionListManager', () => {
     } as unknown as ConstructorParameters<typeof ChatSessionListManager>[1];
 
     const manager = new ChatSessionListManager(uiManager, streamActionsManager);
-    const sessionKey = manager.createSession('native', '/tmp/project-alpha');
+    manager.createSession('native', '/tmp/project-alpha');
 
     expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBeNull();
-    expect(useChatInputStore.getState().snapshot.pendingProjectRootSessionKey).toBe(sessionKey);
+    expect(useChatInputStore.getState().snapshot.pendingProjectRootSessionKey).toBeNull();
   });
 
   it('delegates existing-session selection to routing without eagerly mutating the selected session state', () => {
@@ -224,7 +225,7 @@ describe('ChatSessionListManager', () => {
     expect(mocks.updateNcpSession).not.toHaveBeenCalled();
   });
 
-  it('promotes the active root draft to a concrete session route after the draft has been sent successfully', () => {
+  it('routes to the backend-materialized root session after the first send starts', () => {
     useChatSessionListStore.setState({
       snapshot: {
         ...useChatSessionListStore.getState().snapshot,
@@ -243,8 +244,10 @@ describe('ChatSessionListManager', () => {
     const manager = new ChatSessionListManager(uiManager, streamActionsManager);
 
     manager.ensureDraftSession('native');
-    manager.promoteRootDraftSessionRoute('draft-root-2');
+    manager.materializeRootSessionRoute('ncp-materialized-session');
 
-    expect(uiManager.goToSession).toHaveBeenCalledWith('draft-root-2', { replace: true });
+    expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBe('ncp-materialized-session');
+    expect(useChatThreadStore.getState().snapshot.sessionKey).toBe('ncp-materialized-session');
+    expect(uiManager.goToSession).toHaveBeenCalledWith('ncp-materialized-session', { replace: true });
   });
 });

package/src/features/chat/managers/chat-session-list.manager.ts

@@ -5,7 +5,6 @@ import type { ChatUiManager } from '@/features/chat/managers/chat-ui.manager';
 import type { SetStateAction } from 'react';
 import type { ChatStreamActionsManager } from '@/features/chat/managers/chat-stream-actions.manager';
 import { normalizeSessionProjectRootValue } from '@/shared/lib/session-project';
-import { createNcpSessionId } from '@/features/chat/utils/ncp-session-adapter.utils';
 import { updateNcpSession } from '@/shared/lib/api';
 export class ChatSessionListManager {
   constructor(
@@ -13,9 +12,9 @@ export class ChatSessionListManager {
     private streamActionsManager: ChatStreamActionsManager
   ) {}
 
-  private syncDraftThreadState = (sessionKey: string) => {
+  private syncDraftThreadState = () => {
     useChatThreadStore.getState().setSnapshot({
-      sessionKey,
+      sessionKey: null,
       sessionDisplayName: undefined,
       canDeleteSession: false,
       isHistoryLoading: false,
@@ -97,7 +96,7 @@ export class ChatSessionListManager {
     void updateNcpSession(normalizedSessionKey, { uiReadAt: normalizedReadAt }).catch(() => undefined);
   };
 
-  createSession = (sessionType?: string, projectRoot?: string | null): string => {
+  createSession = (sessionType?: string, projectRoot?: string | null): void => {
     const { snapshot } = useChatInputStore.getState();
     const { defaultSessionType: configuredDefaultSessionType } = snapshot;
     const defaultSessionType = configuredDefaultSessionType || 'native';
@@ -106,30 +105,27 @@ export class ChatSessionListManager {
         ? sessionType.trim()
         : defaultSessionType;
     const normalizedProjectRoot = normalizeSessionProjectRootValue(projectRoot);
-    const nextSessionKey = createNcpSessionId();
     this.streamActionsManager.resetStreamState();
     useChatSessionListStore.getState().setSnapshot({
       selectedSessionKey: null,
-      draftSessionKey: nextSessionKey
+      draftSessionKey: null
     });
-    this.syncDraftThreadState(nextSessionKey);
+    this.syncDraftThreadState();
     useChatInputStore.getState().setSnapshot({
       pendingSessionType: nextSessionType,
       pendingProjectRoot: normalizedProjectRoot,
-      pendingProjectRootSessionKey: normalizedProjectRoot ? nextSessionKey : null
+      pendingProjectRootSessionKey: null
     });
     this.uiManager.goToChatRoot();
-    return nextSessionKey;
   };
 
-  startAgentDraftChat = (agentId: string, sessionType: string): string => {
+  startAgentDraftChat = (agentId: string, sessionType: string): void => {
     const normalizedAgentId = agentId.trim() || 'main';
-    const nextSessionKey = this.createSession(sessionType);
+    this.createSession(sessionType);
     this.setSelectedAgentId(normalizedAgentId);
-    return nextSessionKey;
   };
 
-  ensureDraftSession = (sessionType?: string): string => {
+  ensureDraftSession = (sessionType?: string): string | null => {
     const { snapshot } = useChatSessionListStore.getState();
     if (snapshot.selectedSessionKey) {
       return snapshot.selectedSessionKey;
@@ -138,28 +134,28 @@ export class ChatSessionListManager {
       typeof sessionType === 'string' && sessionType.trim().length > 0
         ? sessionType.trim()
         : null;
-    this.syncDraftThreadState(snapshot.draftSessionKey);
+    this.syncDraftThreadState();
     if (normalizedSessionType) {
       useChatInputStore.getState().setSnapshot({ pendingSessionType: normalizedSessionType });
     }
-    return snapshot.draftSessionKey;
+    return null;
   };
 
-  promoteRootDraftSessionRoute = (sessionKey: string) => {
+  materializeRootSessionRoute = (sessionKey: string) => {
     const normalizedSessionKey = sessionKey.trim();
     if (!normalizedSessionKey) {
       return;
     }
-    const { snapshot } = useChatSessionListStore.getState();
-    const { sessionKey: currentThreadSessionKey } = useChatThreadStore.getState().snapshot;
-    if (
-      snapshot.selectedSessionKey !== null ||
-      snapshot.draftSessionKey !== normalizedSessionKey ||
-      currentThreadSessionKey !== normalizedSessionKey ||
-      !this.uiManager.isAtChatRoot()
-    ) {
+    if (!this.uiManager.isAtChatRoot()) {
       return;
     }
+    useChatSessionListStore.getState().setSnapshot({
+      selectedSessionKey: normalizedSessionKey,
+      draftSessionKey: null,
+    });
+    useChatThreadStore.getState().setSnapshot({
+      sessionKey: normalizedSessionKey,
+    });
     this.uiManager.goToSession(normalizedSessionKey, { replace: true });
   };