@nextclaw/ui 0.12.4 → 0.12.5

package/src/components/chat/chat-child-session-panel.tsx

@@ -1,13 +1,18 @@
-import { ArrowLeft, Loader2, X } from 'lucide-react';
-import { ChatMessageListContainer } from '@/components/chat/containers/chat-message-list.container';
-import { useNcpChildSessionTabsView } from '@/components/chat/ncp/session-conversation/use-ncp-child-session-tabs-view';
-import { useNcpSessionConversation } from '@/components/chat/ncp/session-conversation/use-ncp-session-conversation';
-import type { ChatChildSessionTab } from '@/components/chat/stores/chat-thread.store';
-import { AgentIdentityAvatar } from '@/components/common/agent-identity';
-import { Tabs, TabsList, TabsTrigger } from '@/components/ui/tabs';
-import { t } from '@/lib/i18n';
-import { cn } from '@/lib/utils';
-import type { ChatToolActionViewModel } from '@nextclaw/agent-chat-ui';
+import { useRef } from "react";
+import { ArrowLeft, Loader2, X } from "lucide-react";
+import { useStickyBottomScroll } from "@nextclaw/agent-chat-ui";
+import { ChatMessageListContainer } from "@/components/chat/containers/chat-message-list.container";
+import {
+  useNcpChildSessionTabsView,
+  type ResolvedChildSessionTab,
+} from "@/components/chat/ncp/session-conversation/use-ncp-child-session-tabs-view";
+import { useNcpSessionConversation } from "@/components/chat/ncp/session-conversation/use-ncp-session-conversation";
+import type { ChatChildSessionTab } from "@/components/chat/stores/chat-thread.store";
+import { AgentIdentityAvatar } from "@/components/common/agent-identity";
+import { Tabs, TabsList, TabsTrigger } from "@/components/ui/tabs";
+import { t } from "@/lib/i18n";
+import { cn } from "@/lib/utils";
+import type { ChatToolActionViewModel } from "@nextclaw/agent-chat-ui";
 
 type ChatChildSessionPanelProps = {
   tabs: readonly ChatChildSessionTab[];
@@ -27,39 +32,84 @@ function ChildSessionPanelConversation({
 }) {
   const agent = useNcpSessionConversation(sessionKey);
   const messages = agent.visibleMessages;
+  const scrollRef = useRef<HTMLDivElement>(null);
+  const { onScroll } = useStickyBottomScroll({
+    scrollRef,
+    resetKey: sessionKey,
+    isLoading: agent.isHydrating,
+    hasContent: messages.length > 0,
+    contentVersion: messages[messages.length - 1] ?? null,
+    stickyThresholdPx: 20,
+  });
 
-  if (agent.isHydrating) {
-    return (
-      <div className="flex h-full items-center justify-center text-sm text-gray-500">
-        <Loader2 className="mr-2 h-4 w-4 animate-spin" />
-        {t('chatChildSessionLoading')}
-      </div>
-    );
-  }
+  return (
+    <div
+      ref={scrollRef}
+      onScroll={onScroll}
+      className="h-full overflow-y-auto custom-scrollbar"
+    >
+      {agent.isHydrating ? (
+        <div className="flex h-full items-center justify-center text-sm text-gray-500">
+          <Loader2 className="mr-2 h-4 w-4 animate-spin" />
+          {t("chatChildSessionLoading")}
+        </div>
+      ) : agent.hydrateError ? (
+        <div className="px-4 py-5 text-sm text-rose-600">
+          {agent.hydrateError.message}
+        </div>
+      ) : messages.length === 0 && !agent.isRunning ? (
+        <div className="px-4 py-5 text-sm text-gray-500">
+          {t("chatChildSessionEmpty")}
+        </div>
+      ) : (
+        <div className="px-4 py-5">
+          <ChatMessageListContainer
+            messages={messages}
+            isSending={agent.isRunning}
+            onToolAction={onToolAction}
+          />
+        </div>
+      )}
+    </div>
+  );
+}
 
-  if (agent.hydrateError) {
-    return (
-      <div className="px-4 py-5 text-sm text-rose-600">
-        {agent.hydrateError.message}
-      </div>
-    );
-  }
+function ChildSessionPanelMetaChip({ value }: { value: string }) {
+  return (
+    <span className="inline-flex max-w-full items-center rounded-full border border-gray-200/80 bg-gray-50/90 px-2.5 py-1 text-[11px] font-medium text-gray-600">
+      <span className="truncate">{value}</span>
+    </span>
+  );
+}
 
-  if (messages.length === 0 && !agent.isRunning) {
-    return (
-      <div className="px-4 py-5 text-sm text-gray-500">
-        {t('chatChildSessionEmpty')}
-      </div>
-    );
+function ChildSessionPanelMetaStrip({ tab }: { tab: ResolvedChildSessionTab }) {
+  const metaItems = [
+    tab.sessionTypeLabel,
+    tab.preferredModel,
+    tab.projectName,
+  ].filter((value): value is string => Boolean(value?.trim()));
+
+  if (metaItems.length === 0 && !tab.projectRoot) {
+    return null;
   }
 
   return (
-    <div className="px-4 py-5">
-      <ChatMessageListContainer
-        messages={messages}
-        isSending={agent.isRunning}
-        onToolAction={onToolAction}
-      />
+    <div className="mt-3 space-y-2">
+      {metaItems.length > 0 ? (
+        <div className="flex flex-wrap gap-1.5">
+          {metaItems.map((item) => (
+            <ChildSessionPanelMetaChip key={item} value={item} />
+          ))}
+        </div>
+      ) : null}
+      {tab.projectRoot ? (
+        <div
+          title={tab.projectRoot}
+          className="truncate rounded-xl border border-gray-200/70 bg-gray-50/80 px-2.5 py-2 font-mono text-[11px] text-gray-500"
+        >
+          {tab.projectRoot}
+        </div>
+      ) : null}
     </div>
   );
 }
@@ -77,7 +127,9 @@ export function ChatChildSessionPanel({
     resolvedTabs.find((tab) => tab.sessionKey === activeSessionKey) ??
     resolvedTabs[0] ??
     null;
-  const hasParentSession = resolvedTabs.some((tab) => Boolean(tab.parentSessionKey));
+  const hasParentSession = resolvedTabs.some((tab) =>
+    Boolean(tab.parentSessionKey),
+  );
   const shouldShowTabs = resolvedTabs.length > 1;
 
   if (!activeTab) {
@@ -93,18 +145,18 @@ export function ChatChildSessionPanel({
               type="button"
               onClick={onBackToParent}
               className={cn(
-                'inline-flex items-center gap-1 text-xs font-medium text-gray-600 transition-colors hover:text-gray-900',
-                !hasParentSession && 'pointer-events-none opacity-0',
+                "inline-flex items-center gap-1 text-xs font-medium text-gray-600 transition-colors hover:text-gray-900",
+                !hasParentSession && "pointer-events-none opacity-0",
               )}
             >
               <ArrowLeft className="h-3.5 w-3.5" />
-              <span>{t('chatBackToParent')}</span>
+              <span>{t("chatBackToParent")}</span>
             </button>
             <button
               type="button"
               onClick={onClose}
               className="rounded-full border border-gray-200/80 p-1.5 text-gray-500 transition-colors hover:bg-gray-100 hover:text-gray-900"
-              aria-label={t('chatChildSessionClosePanel')}
+              aria-label={t("chatChildSessionClosePanel")}
             >
               <X className="h-4 w-4" />
             </button>
@@ -138,20 +190,26 @@ export function ChatChildSessionPanel({
                           className="h-4 w-4 shrink-0"
                         />
                       ) : null}
-                      <span className="max-w-[132px] truncate">{tab.title}</span>
+                      <span className="max-w-[132px] truncate">
+                        {tab.title}
+                      </span>
                     </TabsTrigger>
                   ))}
                 </TabsList>
               </Tabs>
             </div>
           ) : null}
+          <ChildSessionPanelMetaStrip tab={activeTab} />
         </div>
 
-        <div className="flex-1 min-h-0 overflow-y-auto custom-scrollbar">
+        <div className="flex-1 min-h-0">
           {resolvedTabs.map((tab) => (
             <div
               key={tab.sessionKey}
-              className={cn(tab.sessionKey === activeSessionKey ? 'block' : 'hidden')}
+              className={cn(
+                "h-full",
+                tab.sessionKey === activeSessionKey ? "block" : "hidden",
+              )}
             >
               <ChildSessionPanelConversation
                 sessionKey={tab.sessionKey}

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

@@ -6,7 +6,9 @@ import {
   resolveSelectedModelValue,
   resolveSelectedThinkingLevelValue
 } from '@/components/chat/chat-session-preference-governance';
-import { shouldRefreshDraftSessionId } from '@/components/chat/ncp/NcpChatPage';
+import {
+  shouldClearPendingProjectRootOverride
+} from '@/components/chat/ncp/NcpChatPage';
 
 const modelOptions = [
   {
@@ -155,33 +157,28 @@ describe('resolveSelectedModelValue', () => {
   });
 });
 
-describe('shouldRefreshDraftSessionId', () => {
-  it('does not replace the initial draft session id on first mount', () => {
+describe('shouldClearPendingProjectRootOverride', () => {
+  it('does not clear an unrelated session project override', () => {
     expect(
-      shouldRefreshDraftSessionId({
-        previousSelectedSessionKey: undefined,
-        nextSelectedSessionKey: null
+      shouldClearPendingProjectRootOverride({
+        pendingProjectRoot: '/tmp/project-alpha',
+        pendingProjectRootSessionKey: 'draft-project-alpha',
+        sessionKey: 'session-existing',
+        selectedSessionProjectRoot: '/tmp/project-alpha'
       })
     ).toBe(false);
   });
 
-  it('replaces the draft session id after leaving an existing session', () => {
+  it('clears the override only after the bound session reflects the same project root', () => {
     expect(
-      shouldRefreshDraftSessionId({
-        previousSelectedSessionKey: 'session-1',
-        nextSelectedSessionKey: null
+      shouldClearPendingProjectRootOverride({
+        pendingProjectRoot: '/tmp/project-alpha',
+        pendingProjectRootSessionKey: 'draft-after-refresh',
+        sessionKey: 'draft-after-refresh',
+        selectedSessionProjectRoot: '/tmp/project-alpha'
       })
     ).toBe(true);
   });
-
-  it('does not replace the draft session id while staying on the same session', () => {
-    expect(
-      shouldRefreshDraftSessionId({
-        previousSelectedSessionKey: 'session-1',
-        nextSelectedSessionKey: 'session-1'
-      })
-    ).toBe(false);
-  });
 });
 
 describe('resolveRecentSessionPreferredModel', () => {

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

@@ -3,6 +3,7 @@ import { updateNcpSession } from '@/api/ncp-session';
 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';
+import { useChatThreadStore } from '@/components/chat/stores/chat-thread.store';
 
 vi.mock('@/api/ncp-session', () => ({
   updateNcpSession: vi.fn(async () => ({
@@ -29,6 +30,12 @@ describe('ChatSessionPreferenceSync', () => {
         selectedSessionKey: null
       }
     }));
+    useChatThreadStore.setState((state) => ({
+      snapshot: {
+        ...state.snapshot,
+        canDeleteSession: false
+      }
+    }));
     vi.clearAllMocks();
   });
 
@@ -46,6 +53,12 @@ describe('ChatSessionPreferenceSync', () => {
         selectedSessionKey: 'session-1'
       }
     }));
+    useChatThreadStore.setState((state) => ({
+      snapshot: {
+        ...state.snapshot,
+        canDeleteSession: true
+      }
+    }));
 
     const sync = new ChatSessionPreferenceSync(updateNcpSession);
     sync.syncSelectedSessionPreferences();

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

@@ -1,6 +1,7 @@
 import type { SessionPatchUpdate, ThinkingLevel } from '@/api/types';
 import { useChatInputStore } from '@/components/chat/stores/chat-input.store';
 import { useChatSessionListStore } from '@/components/chat/stores/chat-session-list.store';
+import { useChatThreadStore } from '@/components/chat/stores/chat-thread.store';
 
 type QueuedSessionPreferenceSync = {
   sessionKey: string;
@@ -30,8 +31,9 @@ export class ChatSessionPreferenceSync {
   syncSelectedSessionPreferences = (): void => {
     const inputSnapshot = useChatInputStore.getState().snapshot;
     const sessionSnapshot = useChatSessionListStore.getState().snapshot;
+    const threadSnapshot = useChatThreadStore.getState().snapshot;
     const sessionKey = sessionSnapshot.selectedSessionKey;
-    if (!sessionKey) {
+    if (!sessionKey || !threadSnapshot.canDeleteSession) {
       return;
     }
 
@@ -44,15 +46,15 @@ export class ChatSessionPreferenceSync {
     });
   };
 
-  private enqueue(next: QueuedSessionPreferenceSync): void {
+  private enqueue = (next: QueuedSessionPreferenceSync): void => {
     this.queued = next;
     if (this.inFlight) {
       return;
     }
     this.startFlush();
-  }
+  };
 
-  private startFlush(): void {
+  private startFlush = (): void => {
     this.inFlight = this.flush()
       .catch((error) => {
         console.error(`Failed to sync chat session preferences: ${String(error)}`);
@@ -63,13 +65,13 @@ export class ChatSessionPreferenceSync {
           this.startFlush();
         }
       });
-  }
+  };
 
-  private async flush(): Promise<void> {
+  private flush = async (): Promise<void> => {
     while (this.queued) {
       const current = this.queued;
       this.queued = null;
       await this.updateSession(current.sessionKey, current.patch);
     }
-  }
+  };
 }

package/src/components/chat/hooks/use-chat-session-project.test.tsx

@@ -71,7 +71,7 @@ describe('useChatSessionProject', () => {
     expect(toast.success).toHaveBeenCalledTimes(1);
   });
 
-  it('persists to the server and mirrors the updated project override locally for an existing session', async () => {
+  it('persists to the server without reusing the draft override state for an existing session', async () => {
     const { result } = renderHook(() => useChatSessionProject());
 
     await act(async () => {
@@ -88,12 +88,12 @@ describe('useChatSessionProject', () => {
       successMessage: 'Project directory updated',
     });
     expect(useChatInputStore.getState().snapshot).toMatchObject({
-      pendingProjectRoot: '/tmp/project-beta',
-      pendingProjectRootSessionKey: 'session-1',
+      pendingProjectRoot: null,
+      pendingProjectRootSessionKey: null,
     });
   });
 
-  it('persists clearing to the server and keeps the cleared override until session state catches up', async () => {
+  it('persists clearing to the server without keeping a session-scoped local override', async () => {
     const { result } = renderHook(() => useChatSessionProject());
 
     await act(async () => {
@@ -111,7 +111,7 @@ describe('useChatSessionProject', () => {
     });
     expect(useChatInputStore.getState().snapshot).toMatchObject({
       pendingProjectRoot: null,
-      pendingProjectRootSessionKey: 'session-1',
+      pendingProjectRootSessionKey: null,
     });
   });
 });

package/src/components/chat/hooks/use-chat-session-project.ts

@@ -31,10 +31,5 @@ export function useChatSessionProject() {
       patch: { projectRoot: params.projectRoot },
       successMessage,
     });
-
-    useChatInputStore.getState().setSnapshot({
-      pendingProjectRoot: params.projectRoot,
-      pendingProjectRootSessionKey: params.sessionKey,
-    });
   };
 }

package/src/components/chat/hooks/use-chat-session-update.test.tsx

@@ -0,0 +1,75 @@
+import { act, renderHook } from '@testing-library/react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import type { ReactNode } from 'react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { toast } from 'sonner';
+import { useChatSessionUpdate } from '@/components/chat/hooks/use-chat-session-update';
+
+const mocks = vi.hoisted(() => ({
+  updateNcpSession: vi.fn(),
+  upsertNcpSessionSummaryInQueryClient: vi.fn(),
+}));
+
+vi.mock('sonner', () => ({
+  toast: {
+    success: vi.fn(),
+    error: vi.fn(),
+  },
+}));
+
+vi.mock('@/api/ncp-session', () => ({
+  updateNcpSession: (...args: unknown[]) => mocks.updateNcpSession(...args),
+}));
+
+vi.mock('@/api/ncp-session-query-cache', () => ({
+  upsertNcpSessionSummaryInQueryClient: (...args: unknown[]) =>
+    mocks.upsertNcpSessionSummaryInQueryClient(...args),
+}));
+
+function createWrapper(queryClient: QueryClient) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>;
+  };
+}
+
+describe('useChatSessionUpdate', () => {
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('updates the session summary and invalidates the matching session skills queries', async () => {
+    const queryClient = new QueryClient();
+    const invalidateQueriesSpy = vi.spyOn(queryClient, 'invalidateQueries');
+    const updatedSession = {
+      sessionId: 'session-1',
+      updatedAt: '2026-04-09T00:00:00.000Z',
+      status: 'idle',
+      metadata: { project_root: '/tmp/project-alpha' },
+    };
+    mocks.updateNcpSession.mockResolvedValue(updatedSession);
+
+    const { result } = renderHook(() => useChatSessionUpdate(), {
+      wrapper: createWrapper(queryClient),
+    });
+
+    await act(async () => {
+      await result.current({
+        sessionKey: 'session-1',
+        patch: { projectRoot: '/tmp/project-alpha' },
+        successMessage: 'Project directory updated',
+      });
+    });
+
+    expect(mocks.updateNcpSession).toHaveBeenCalledWith('session-1', {
+      projectRoot: '/tmp/project-alpha',
+    });
+    expect(mocks.upsertNcpSessionSummaryInQueryClient).toHaveBeenCalledWith(
+      queryClient,
+      updatedSession,
+    );
+    expect(invalidateQueriesSpy).toHaveBeenCalledWith({
+      queryKey: ['ncp-session-skills', 'session-1'],
+    });
+    expect(toast.success).toHaveBeenCalledWith('Project directory updated');
+  });
+});

package/src/components/chat/hooks/use-chat-session-update.ts

@@ -15,10 +15,12 @@ export function useChatSessionUpdate() {
   const queryClient = useQueryClient();
 
   return async (params: UpdateChatSessionParams): Promise<void> => {
+    const { sessionKey, patch, successMessage } = params;
     try {
-      const updated = await updateNcpSession(params.sessionKey, params.patch);
+      const updated = await updateNcpSession(sessionKey, patch);
       upsertNcpSessionSummaryInQueryClient(queryClient, updated);
-      toast.success(params.successMessage ?? t('configSavedApplied'));
+      await queryClient.invalidateQueries({ queryKey: ['ncp-session-skills', sessionKey] });
+      toast.success(successMessage ?? t('configSavedApplied'));
     } catch (error) {
       toast.error(
         t('configSaveFailed') + ': ' + (error instanceof Error ? error.message : String(error)),

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

@@ -18,6 +18,7 @@ describe('ChatSessionListManager', () => {
       snapshot: {
         ...useChatSessionListStore.getState().snapshot,
         selectedSessionKey: 'session-1',
+        draftSessionKey: 'draft-root-1',
         listMode: 'time-first'
       }
     });
@@ -25,7 +26,7 @@ describe('ChatSessionListManager', () => {
 
   it('applies the requested session type when creating a session', () => {
     const uiManager = {
-      goToChatRoot: vi.fn()
+      goToSession: vi.fn()
     } as unknown as ConstructorParameters<typeof ChatSessionListManager>[0];
     const streamActionsManager = {
       resetStreamState: vi.fn()
@@ -35,8 +36,9 @@ describe('ChatSessionListManager', () => {
     manager.createSession('codex');
 
     expect(streamActionsManager.resetStreamState).toHaveBeenCalledTimes(1);
-    expect(uiManager.goToChatRoot).toHaveBeenCalledTimes(1);
-    expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBeNull();
+    expect(uiManager.goToSession).toHaveBeenCalledWith('draft-root-1');
+    expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBe('session-1');
+    expect(useChatSessionListStore.getState().snapshot.draftSessionKey).not.toBe('draft-root-1');
     expect(useChatInputStore.getState().snapshot.pendingSessionType).toBe('codex');
     expect(useChatInputStore.getState().snapshot.pendingProjectRoot).toBeNull();
     expect(useChatInputStore.getState().snapshot.pendingProjectRootSessionKey).toBeNull();
@@ -44,7 +46,7 @@ describe('ChatSessionListManager', () => {
 
   it('hydrates the draft project root when creating a session inside a project group', () => {
     const uiManager = {
-      goToChatRoot: vi.fn()
+      goToSession: vi.fn()
     } as unknown as ConstructorParameters<typeof ChatSessionListManager>[0];
     const streamActionsManager = {
       resetStreamState: vi.fn()
@@ -54,7 +56,45 @@ describe('ChatSessionListManager', () => {
     manager.createSession('native', '/tmp/project-alpha');
 
     expect(useChatInputStore.getState().snapshot.pendingProjectRoot).toBe('/tmp/project-alpha');
-    expect(useChatInputStore.getState().snapshot.pendingProjectRootSessionKey).toBeNull();
+    expect(useChatInputStore.getState().snapshot.pendingProjectRootSessionKey).toBe('draft-root-1');
+  });
+
+  it('promotes the current root draft when send flow needs a concrete session key', () => {
+    useChatSessionListStore.setState({
+      snapshot: {
+        ...useChatSessionListStore.getState().snapshot,
+        selectedSessionKey: null,
+        draftSessionKey: 'draft-root-2'
+      }
+    });
+    const uiManager = {
+      goToSession: vi.fn()
+    } as unknown as ConstructorParameters<typeof ChatSessionListManager>[0];
+    const streamActionsManager = {
+      resetStreamState: vi.fn()
+    } as unknown as ConstructorParameters<typeof ChatSessionListManager>[1];
+
+    const manager = new ChatSessionListManager(uiManager, streamActionsManager);
+    const sessionKey = manager.ensureDraftSession('native');
+
+    expect(sessionKey).toBe('draft-root-2');
+    expect(uiManager.goToSession).toHaveBeenCalledWith('draft-root-2');
+    expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBeNull();
+  });
+
+  it('does not eagerly replace the old selected session before the route finishes switching', () => {
+    const uiManager = {
+      goToSession: vi.fn()
+    } as unknown as ConstructorParameters<typeof ChatSessionListManager>[0];
+    const streamActionsManager = {
+      resetStreamState: vi.fn()
+    } as unknown as ConstructorParameters<typeof ChatSessionListManager>[1];
+
+    const manager = new ChatSessionListManager(uiManager, streamActionsManager);
+    manager.createSession('native', '/tmp/project-alpha');
+
+    expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBe('session-1');
+    expect(useChatInputStore.getState().snapshot.pendingProjectRootSessionKey).toBe('draft-root-1');
   });
 
   it('delegates existing-session selection to routing without eagerly mutating the selected session state', () => {

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

@@ -4,6 +4,7 @@ import type { ChatUiManager } from '@/components/chat/managers/chat-ui.manager';
 import type { SetStateAction } from 'react';
 import type { ChatStreamActionsManager } from '@/components/chat/managers/chat-stream-actions.manager';
 import { normalizeSessionProjectRootValue } from '@/lib/session-project/session-project.utils';
+import { createNcpSessionId } from '@/components/chat/ncp/ncp-session-adapter';
 
 export class ChatSessionListManager {
   constructor(
@@ -45,8 +46,9 @@ export class ChatSessionListManager {
     useChatSessionListStore.getState().setSnapshot({ listMode: value });
   };
 
-  createSession = (sessionType?: string, projectRoot?: string | null) => {
+  createSession = (sessionType?: string, projectRoot?: string | null): string => {
     const { snapshot } = useChatInputStore.getState();
+    const { snapshot: sessionListSnapshot } = useChatSessionListStore.getState();
     const { defaultSessionType: configuredDefaultSessionType } = snapshot;
     const defaultSessionType = configuredDefaultSessionType || 'native';
     const nextSessionType =
@@ -54,14 +56,26 @@ export class ChatSessionListManager {
         ? sessionType.trim()
         : defaultSessionType;
     const normalizedProjectRoot = normalizeSessionProjectRootValue(projectRoot);
+    const nextSessionKey = sessionListSnapshot.draftSessionKey;
     this.streamActionsManager.resetStreamState();
-    useChatSessionListStore.getState().setSnapshot({ selectedSessionKey: null });
+    useChatSessionListStore.getState().setSnapshot({
+      draftSessionKey: createNcpSessionId()
+    });
     useChatInputStore.getState().setSnapshot({
       pendingSessionType: nextSessionType,
       pendingProjectRoot: normalizedProjectRoot,
-      pendingProjectRootSessionKey: null
+      pendingProjectRootSessionKey: normalizedProjectRoot ? nextSessionKey : null
     });
-    this.uiManager.goToChatRoot();
+    this.uiManager.goToSession(nextSessionKey);
+    return nextSessionKey;
+  };
+
+  ensureDraftSession = (sessionType?: string): string => {
+    const { snapshot } = useChatSessionListStore.getState();
+    if (snapshot.selectedSessionKey) {
+      return snapshot.selectedSessionKey;
+    }
+    return this.createSession(sessionType);
   };
 
   selectSession = (sessionKey: string) => {