@nextclaw/ui 0.12.8 → 0.12.9

package/src/components/chat/ncp/ncp-chat-thread.manager.ts

@@ -1,14 +1,17 @@
 import { appQueryClient } from '@/app-query-client';
 import { deleteNcpSessionSummaryInQueryClient } from '@/api/ncp-session-query-cache';
 import { deleteNcpSession as deleteNcpSessionApi } from '@/api/ncp-session';
-import type { ChatToolActionViewModel } from '@nextclaw/agent-chat-ui';
+import type {
+  ChatFileOpenActionViewModel,
+  ChatToolActionViewModel,
+} from '@nextclaw/agent-chat-ui';
 import type { ChatSessionListManager } from '@/components/chat/managers/chat-session-list.manager';
 import type { ChatStreamActionsManager } from '@/components/chat/managers/chat-stream-actions.manager';
 import type { ChatUiManager } from '@/components/chat/managers/chat-ui.manager';
 import { useChatSessionListStore } from '@/components/chat/stores/chat-session-list.store';
 import type {
-  ChatChildSessionTab,
   ChatThreadSnapshot,
+  ChatWorkspaceFileTab,
 } from '@/components/chat/stores/chat-thread.store';
 import { useChatThreadStore } from '@/components/chat/stores/chat-thread.store';
 import { t } from '@/lib/i18n';
@@ -37,6 +40,98 @@ export class NcpChatThreadManager {
     useChatThreadStore.getState().setSnapshot(patch);
   };
 
+  private clearDeletedSessionState = (sessionKey: string) => {
+    if (useChatSessionListStore.getState().snapshot.selectedSessionKey === sessionKey) {
+      this.sessionListManager.setSelectedSessionKey(null);
+    }
+    useChatThreadStore.getState().setSnapshot({
+      sessionKey: null,
+      sessionTypeLabel: null,
+      agentId: null,
+      agentDisplayName: null,
+      agentAvatarUrl: null,
+      sessionDisplayName: undefined,
+      sessionProjectRoot: null,
+      sessionProjectName: null,
+      canDeleteSession: false,
+      isHistoryLoading: false,
+      messages: [],
+      isSending: false,
+      isAwaitingAssistantOutput: false,
+      parentSessionKey: null,
+      parentSessionLabel: null,
+      workspacePanelParentKey: null,
+      childSessionTabs: [],
+      activeChildSessionKey: null,
+      workspaceFileTabs: [],
+      activeWorkspaceFileKey: null,
+    });
+  };
+
+  private resolveWorkspaceParentSessionKey = (): string | null => {
+    const threadSessionKey = useChatThreadStore.getState().snapshot.sessionKey?.trim();
+    if (threadSessionKey) {
+      return threadSessionKey;
+    }
+    return useChatSessionListStore.getState().snapshot.selectedSessionKey ?? null;
+  };
+
+  private buildWorkspaceFileTab = (
+    action: ChatFileOpenActionViewModel,
+    parentSessionKey: string | null,
+  ): ChatWorkspaceFileTab | null => {
+    const normalizedPath = action.path.trim();
+    if (!normalizedPath) {
+      return null;
+    }
+    const normalizedParentSessionKey = parentSessionKey?.trim() || null;
+    const key =
+      `${normalizedParentSessionKey ?? 'draft'}::${action.viewMode}::${normalizedPath}`;
+    return {
+      key,
+      parentSessionKey: normalizedParentSessionKey,
+      path: normalizedPath,
+      label: action.label?.trim() || null,
+      viewMode: action.viewMode,
+      line: action.line ?? null,
+      column: action.column ?? null,
+      rawText: action.rawText ?? null,
+      beforeText: action.beforeText ?? null,
+      afterText: action.afterText ?? null,
+      patchText: action.patchText ?? null,
+      oldStartLine: action.oldStartLine ?? null,
+      newStartLine: action.newStartLine ?? null,
+      fullLines: action.fullLines,
+    };
+  };
+
+  private upsertWorkspaceFileTab = (nextTab: ChatWorkspaceFileTab): ChatWorkspaceFileTab[] => {
+    const { workspaceFileTabs } = useChatThreadStore.getState().snapshot;
+    const existingIndex = workspaceFileTabs.findIndex((tab) => tab.key === nextTab.key);
+    if (existingIndex === -1) {
+      return [nextTab, ...workspaceFileTabs];
+    }
+    const nextTabs = [...workspaceFileTabs];
+    nextTabs.splice(existingIndex, 1);
+    nextTabs.unshift({
+      ...workspaceFileTabs[existingIndex],
+      ...nextTab,
+    });
+    return nextTabs;
+  };
+
+  private ensureWorkspaceParentRoute = (parentSessionKey: string | null) => {
+    if (!parentSessionKey) {
+      return;
+    }
+    const {
+      snapshot: { selectedSessionKey },
+    } = useChatSessionListStore.getState();
+    if (selectedSessionKey !== parentSessionKey) {
+      this.uiManager.goToSession(parentSessionKey);
+    }
+  };
+
   deleteSession = () => {
     void this.deleteCurrentSession();
   };
@@ -49,21 +144,36 @@ export class NcpChatThreadManager {
     this.uiManager.goToProviders();
   };
 
-  private upsertChildSessionTab = (tab: ChatChildSessionTab) => {
-    const { snapshot } = useChatThreadStore.getState();
-    const existingIndex = snapshot.childSessionTabs.findIndex(
-      (item) => item.sessionKey === tab.sessionKey,
-    );
-    const nextTabs =
-      existingIndex >= 0
-        ? snapshot.childSessionTabs.map((item, index) =>
-            index === existingIndex ? { ...item, ...tab } : item,
-          )
-        : [...snapshot.childSessionTabs, tab];
+  openChildSessionPanel = (params: {
+    parentSessionKey: string;
+    activeChildSessionKey?: string | null;
+  }) => {
+    const parentSessionKey = params.parentSessionKey.trim();
+    if (!parentSessionKey) {
+      return;
+    }
+    const activeChildSessionKey = params.activeChildSessionKey?.trim() || null;
+    useChatThreadStore.getState().setSnapshot({
+      workspacePanelParentKey: parentSessionKey,
+      activeChildSessionKey,
+      activeWorkspaceFileKey: null,
+    });
+    this.ensureWorkspaceParentRoute(parentSessionKey);
+  };
+
+  openFilePreview = (action: ChatFileOpenActionViewModel) => {
+    const parentSessionKey = this.resolveWorkspaceParentSessionKey();
+    const nextTab = this.buildWorkspaceFileTab(action, parentSessionKey);
+    if (!nextTab) {
+      return;
+    }
     useChatThreadStore.getState().setSnapshot({
-      childSessionTabs: nextTabs,
-      activeChildSessionKey: tab.sessionKey,
+      workspacePanelParentKey: parentSessionKey,
+      workspaceFileTabs: this.upsertWorkspaceFileTab(nextTab),
+      activeWorkspaceFileKey: nextTab.key,
+      activeChildSessionKey: null,
     });
+    this.ensureWorkspaceParentRoute(parentSessionKey);
   };
 
   openSessionFromToolAction = (action: ChatToolActionViewModel) => {
@@ -75,14 +185,19 @@ export class NcpChatThreadManager {
         action.parentSessionId?.trim() ||
         useChatSessionListStore.getState().snapshot.selectedSessionKey ||
         null;
-      this.upsertChildSessionTab({
-        sessionKey: action.sessionId,
-        parentSessionKey,
-        label: action.label?.trim() || null,
-        agentId: action.agentId?.trim() || null,
-      });
-      return;
+      if (parentSessionKey) {
+        this.openChildSessionPanel({
+          parentSessionKey,
+          activeChildSessionKey: action.sessionId,
+        });
+        return;
+      }
     }
+    useChatThreadStore.getState().setSnapshot({
+      workspacePanelParentKey: null,
+      activeChildSessionKey: null,
+      activeWorkspaceFileKey: null,
+    });
     this.uiManager.goToSession(action.sessionId);
   };
 
@@ -97,34 +212,56 @@ export class NcpChatThreadManager {
     }
     useChatThreadStore.getState().setSnapshot({
       activeChildSessionKey: normalizedSessionKey,
+      activeWorkspaceFileKey: null,
     });
   };
 
-  closeChildSessionDetail = () => {
-    const {
-      sessionKey,
-      childSessionTabs,
-      activeChildSessionKey,
-    } = useChatThreadStore.getState().snapshot;
-    if (!sessionKey) {
-      useChatThreadStore.getState().setSnapshot({
-        childSessionTabs: [],
-        activeChildSessionKey: null,
-      });
+  selectWorkspaceFile = (fileKey: string) => {
+    const normalizedFileKey = fileKey.trim();
+    if (!normalizedFileKey) {
       return;
     }
-    const nextTabs = childSessionTabs.filter(
-      (tab) => tab.parentSessionKey !== sessionKey,
+    const { workspaceFileTabs } = useChatThreadStore.getState().snapshot;
+    if (!workspaceFileTabs.some((tab) => tab.key === normalizedFileKey)) {
+      return;
+    }
+    useChatThreadStore.getState().setSnapshot({
+      activeWorkspaceFileKey: normalizedFileKey,
+      activeChildSessionKey: null,
+    });
+  };
+
+  closeWorkspaceFile = (fileKey: string) => {
+    const normalizedFileKey = fileKey.trim();
+    if (!normalizedFileKey) {
+      return;
+    }
+    const { snapshot } = useChatThreadStore.getState();
+    const { activeWorkspaceFileKey, workspaceFileTabs } = snapshot;
+    const nextTabs = workspaceFileTabs.filter(
+      (tab) => tab.key !== normalizedFileKey,
     );
-    const nextActiveKey = nextTabs.some((tab) => tab.sessionKey === activeChildSessionKey)
-      ? activeChildSessionKey
-      : null;
+    const nextPatch: Partial<ChatThreadSnapshot> = {
+      workspaceFileTabs: nextTabs,
+    };
+    if (activeWorkspaceFileKey === normalizedFileKey) {
+      nextPatch.activeWorkspaceFileKey = null;
+    }
+    useChatThreadStore.getState().setSnapshot(nextPatch);
+  };
+
+  closeWorkspacePanel = () => {
     useChatThreadStore.getState().setSnapshot({
-      childSessionTabs: nextTabs,
-      activeChildSessionKey: nextActiveKey,
+      workspacePanelParentKey: null,
+      activeChildSessionKey: null,
+      activeWorkspaceFileKey: null,
     });
   };
 
+  closeChildSessionDetail = () => {
+    this.closeWorkspacePanel();
+  };
+
   goToParentSession = () => {
     const {
       parentSessionKey,
@@ -139,7 +276,7 @@ export class NcpChatThreadManager {
     if (!resolvedParentSessionKey) {
       return;
     }
-    this.closeChildSessionDetail();
+    this.closeWorkspacePanel();
     this.uiManager.goToSession(resolvedParentSessionKey);
   };
 
@@ -171,6 +308,7 @@ export class NcpChatThreadManager {
       deleteNcpSessionSummaryInQueryClient(appQueryClient, selectedSessionKey);
       appQueryClient.removeQueries({ queryKey: ['ncp-session-messages', selectedSessionKey] });
       this.streamActionsManager.resetStreamState();
+      this.clearDeletedSessionState(selectedSessionKey);
       this.uiManager.goToChatRoot({ replace: true });
     } finally {
       useChatThreadStore.getState().setSnapshot({ isDeletePending: false });

package/src/components/chat/ncp/ncp-session-adapter.test.ts

@@ -71,7 +71,7 @@ describe('adaptNcpSessionSummary', () => {
   });
 });
 
-describe('adaptNcpMessageToUiMessage', () => {
+describe('adaptNcpMessageToUiMessage file rendering', () => {
   it('preserves mixed text and image part order for message rendering', () => {
     const adapted = adaptNcpMessageToUiMessage({
       id: 'ncp-message-1',
@@ -111,6 +111,40 @@ describe('adaptNcpMessageToUiMessage', () => {
     ]);
   });
 
+  it('maps assetUri file parts into asset content urls for rendering', () => {
+    const adapted = adaptNcpMessageToUiMessage({
+      id: 'ncp-message-asset-1',
+      sessionId: 'ncp-session-1',
+      role: 'assistant',
+      status: 'final',
+      timestamp: '2026-04-16T00:00:00.000Z',
+      parts: [
+        {
+          type: 'file',
+          name: 'diagram.png',
+          mimeType: 'image/png',
+          assetUri: 'asset://store/2026/04/16/asset_123',
+          sizeBytes: 42,
+        },
+      ],
+    });
+
+    expect(adapted.parts).toHaveLength(1);
+    expect(adapted.parts[0]).toMatchObject({
+      type: 'file',
+      name: 'diagram.png',
+      mimeType: 'image/png',
+      data: '',
+      sizeBytes: 42,
+    });
+    expect((adapted.parts[0] as { url?: string }).url).toMatch(
+      /\/api\/ncp\/assets\/content\?uri=asset%3A%2F%2Fstore%2F2026%2F04%2F16%2Fasset_123$/,
+    );
+  });
+
+});
+
+describe('adaptNcpMessageToUiMessage tool rendering', () => {
   it('keeps streamed native file tool args renderable as a preview before the tool result arrives', () => {
     const uiMessage = adaptNcpMessageToUiMessage({
       id: 'ncp-message-tool-1',

package/src/components/chat/ncp/ncp-session-adapter.ts

@@ -1,6 +1,7 @@
 import { ToolInvocationStatus, type UIMessage } from '@nextclaw/agent-chat';
 import type { NcpMessagePart } from '@nextclaw/ncp';
 import type { NcpMessageView, NcpSessionSummaryView, SessionEntryView, ThinkingLevel } from '@/api/types';
+import { API_BASE } from '@/api/api-base';
 import {
   getSessionProjectName,
   normalizeSessionProjectRootValue,
@@ -19,6 +20,11 @@ function stringifyUnknown(value: unknown): string {
   }
 }
 
+function buildNcpAssetContentUrl(assetUri: string): string {
+  const query = new URLSearchParams({ uri: assetUri });
+  return `${API_BASE}/api/ncp/assets/content?${query.toString()}`;
+}
+
 function readOptionalString(value: unknown): string | null {
   if (typeof value !== 'string') {
     return null;
@@ -207,6 +213,17 @@ function toUiParts(parts: NcpMessagePart[]): UIMessage['parts'] {
       });
       continue;
     }
+    if (part.type === 'file' && part.assetUri) {
+      uiParts.push({
+        type: 'file',
+        ...(part.name ? { name: part.name } : {}),
+        mimeType: part.mimeType ?? 'application/octet-stream',
+        data: '',
+        url: buildNcpAssetContentUrl(part.assetUri),
+        ...(typeof part.sizeBytes === 'number' ? { sizeBytes: part.sizeBytes } : {})
+      });
+      continue;
+    }
     if (part.type === 'step-start') {
       uiParts.push({ type: 'step-start' });
       continue;

package/src/components/chat/ncp/page/ncp-chat-derived-state.ts

@@ -10,8 +10,30 @@ import { adaptNcpSessionSummary } from '@/components/chat/ncp/ncp-session-adapte
 import type { NcpChatPresenter } from '@/components/chat/ncp/ncp-chat.presenter';
 import type { UseHydratedNcpAgentResult } from '@nextclaw/ncp-react';
 import type { ChatModelOption } from '@/components/chat/chat-input.types';
+import type { ChatChildSessionTab } from '@/components/chat/stores/chat-thread.store';
 import { resolveSessionTypeLabel } from '@/components/chat/useChatSessionTypeState';
+
+function buildChildSessionTabs(params: {
+  parentSessionKey: string | null;
+  sessionSummaries: NcpSessionSummaryView[];
+}): ChatChildSessionTab[] {
+  if (!params.parentSessionKey) {
+    return [];
+  }
+  return params.sessionSummaries
+    .map(adaptNcpSessionSummary)
+    .filter((session) => session.parentSessionId === params.parentSessionKey)
+    .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))
+    .map((session) => ({
+      sessionKey: session.key,
+      parentSessionKey: session.parentSessionId ?? null,
+      label: session.label ?? null,
+      agentId: session.agentId ?? null,
+    }));
+}
+
 export function useNcpChatDerivedState(params: {
+  sessionKey: string | null;
   selectedSession: SessionEntryView | null;
   selectedAgentId: string;
   availableAgents: AgentProfileView[];
@@ -20,32 +42,51 @@ export function useNcpChatDerivedState(params: {
   selectedSessionType: string;
   sessionTypeOptions: Array<{ value: string; label: string }>;
 }) {
-  const currentSessionDisplayName = params.selectedSession
-    ? sessionDisplayName(params.selectedSession)
+  const {
+    availableAgents,
+    parentSessionId,
+    selectedAgentId,
+    selectedSession,
+    selectedSessionType,
+    sessionKey,
+    sessionSummaries,
+    sessionTypeOptions,
+  } = params;
+  const currentSessionDisplayName = selectedSession
+    ? sessionDisplayName(selectedSession)
     : undefined;
-  const currentAgentId = params.selectedSession?.agentId ?? params.selectedAgentId;
+  const currentAgentId = selectedSession?.agentId ?? selectedAgentId;
   const currentAgent =
-    params.availableAgents.find((agent) => agent.id === currentAgentId) ?? null;
+    availableAgents.find((agent) => agent.id === currentAgentId) ?? null;
   const parentSession = useMemo(() => {
-    if (!params.parentSessionId) {
+    if (!parentSessionId) {
       return null;
     }
     const parentSummary =
-      params.sessionSummaries.find(
-        (summary) => summary.sessionId === params.parentSessionId,
+      sessionSummaries.find(
+        (summary) => summary.sessionId === parentSessionId,
       ) ?? null;
     return parentSummary ? adaptNcpSessionSummary(parentSummary) : null;
-  }, [params.parentSessionId, params.sessionSummaries]);
+  }, [parentSessionId, sessionSummaries]);
   const currentSessionTypeLabel =
-    params.sessionTypeOptions.find((option) => option.value === params.selectedSessionType)
-      ?.label ?? resolveSessionTypeLabel(params.selectedSessionType);
+    sessionTypeOptions.find((option) => option.value === selectedSessionType)
+      ?.label ?? resolveSessionTypeLabel(selectedSessionType);
+  const currentChildSessionTabs = useMemo(
+    () =>
+      buildChildSessionTabs({
+        parentSessionKey: sessionKey,
+        sessionSummaries,
+      }),
+    [sessionKey, sessionSummaries],
+  );
 
   return {
     currentSessionDisplayName,
     currentAgentId,
     currentAgent,
     parentSession,
-    currentSessionTypeLabel
+    currentSessionTypeLabel,
+    currentChildSessionTabs,
   };
 }
 
@@ -78,6 +119,7 @@ export function useNcpChatSnapshotSync(params: {
   agent: Pick<UseHydratedNcpAgentResult, 'isHydrating' | 'visibleMessages'>;
   isAwaitingAssistantOutput: boolean;
   parentSession: SessionEntryView | null;
+  childSessionTabs: ChatChildSessionTab[];
 }) {
   useEffect(() => {
     params.presenter.chatInputManager.syncSnapshot({
@@ -121,6 +163,7 @@ export function useNcpChatSnapshotSync(params: {
       parentSessionLabel: params.parentSession
         ? sessionDisplayName(params.parentSession)
         : null,
+      childSessionTabs: params.childSessionTabs,
     });
   }, [
     params

package/src/components/chat/ncp/tests/ncp-chat-thread.manager.test.ts

@@ -0,0 +1,189 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { appQueryClient } from '@/app-query-client';
+import { NcpChatThreadManager } from '@/components/chat/ncp/ncp-chat-thread.manager';
+import { useChatSessionListStore } from '@/components/chat/stores/chat-session-list.store';
+import { useChatThreadStore } from '@/components/chat/stores/chat-thread.store';
+
+const { deleteNcpSessionMock, deleteSummaryMock } = vi.hoisted(() => ({
+  deleteNcpSessionMock: vi.fn(async () => ({ deleted: true, sessionId: 'parent-session-1' })),
+  deleteSummaryMock: vi.fn(),
+}));
+
+vi.mock('@/api/ncp-session', () => ({
+  deleteNcpSession: deleteNcpSessionMock,
+}));
+
+vi.mock('@/api/ncp-session-query-cache', () => ({
+  deleteNcpSessionSummaryInQueryClient: deleteSummaryMock,
+}));
+
+describe('NcpChatThreadManager', () => {
+  beforeEach(() => {
+    useChatSessionListStore.setState({
+      optimisticReadAtBySessionKey: {},
+      snapshot: {
+        ...useChatSessionListStore.getState().snapshot,
+        selectedSessionKey: 'parent-session-1',
+      },
+    });
+    useChatThreadStore.setState({
+      snapshot: {
+        ...useChatThreadStore.getState().snapshot,
+        sessionKey: 'parent-session-1',
+        workspacePanelParentKey: null,
+        childSessionTabs: [
+          {
+            sessionKey: 'child-session-1',
+            parentSessionKey: 'parent-session-1',
+            label: 'Child Session 1',
+            agentId: 'reviewer',
+          },
+        ],
+        activeChildSessionKey: null,
+      },
+    });
+  });
+
+  it('opens the child-session panel for the requested parent session and keeps focus on the chosen child', () => {
+    const uiManager = {
+      goToSession: vi.fn(),
+      goToChatRoot: vi.fn(),
+      goToProviders: vi.fn(),
+      confirm: vi.fn(),
+    } as unknown as ConstructorParameters<typeof NcpChatThreadManager>[0];
+
+    const manager = new NcpChatThreadManager(
+      uiManager,
+      {} as ConstructorParameters<typeof NcpChatThreadManager>[1],
+      {} as ConstructorParameters<typeof NcpChatThreadManager>[2],
+    );
+
+    manager.openChildSessionPanel({
+      parentSessionKey: 'parent-session-1',
+      activeChildSessionKey: 'child-session-1',
+    });
+
+    expect(useChatThreadStore.getState().snapshot.workspacePanelParentKey).toBe('parent-session-1');
+    expect(useChatThreadStore.getState().snapshot.activeChildSessionKey).toBe('child-session-1');
+    expect(uiManager.goToSession).not.toHaveBeenCalled();
+  });
+
+  it('routes to the parent session before opening the child-session panel when needed', () => {
+    useChatSessionListStore.setState({
+      snapshot: {
+        ...useChatSessionListStore.getState().snapshot,
+        selectedSessionKey: 'another-session',
+      },
+    });
+    const uiManager = {
+      goToSession: vi.fn(),
+      goToChatRoot: vi.fn(),
+      goToProviders: vi.fn(),
+      confirm: vi.fn(),
+    } as unknown as ConstructorParameters<typeof NcpChatThreadManager>[0];
+
+    const manager = new NcpChatThreadManager(
+      uiManager,
+      {} as ConstructorParameters<typeof NcpChatThreadManager>[1],
+      {} as ConstructorParameters<typeof NcpChatThreadManager>[2],
+    );
+
+    manager.openChildSessionPanel({
+      parentSessionKey: 'parent-session-1',
+      activeChildSessionKey: 'child-session-1',
+    });
+
+    expect(uiManager.goToSession).toHaveBeenCalledWith('parent-session-1');
+  });
+
+  it('keeps preview and diff for the same file as separate workspace tabs', () => {
+    const uiManager = {
+      goToSession: vi.fn(),
+      goToChatRoot: vi.fn(),
+      goToProviders: vi.fn(),
+      confirm: vi.fn(),
+    } as unknown as ConstructorParameters<typeof NcpChatThreadManager>[0];
+
+    const manager = new NcpChatThreadManager(
+      uiManager,
+      {} as ConstructorParameters<typeof NcpChatThreadManager>[1],
+      {} as ConstructorParameters<typeof NcpChatThreadManager>[2],
+    );
+
+    manager.openFilePreview({
+      path: 'README.md',
+      label: 'README.md',
+      viewMode: 'preview',
+    });
+    manager.openFilePreview({
+      path: 'README.md',
+      label: 'README.md',
+      viewMode: 'diff',
+      beforeText: 'old\n',
+      afterText: 'new\n',
+    });
+
+    expect(useChatThreadStore.getState().snapshot.workspaceFileTabs).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          key: 'parent-session-1::preview::README.md',
+          path: 'README.md',
+          viewMode: 'preview',
+        }),
+        expect.objectContaining({
+          key: 'parent-session-1::diff::README.md',
+          path: 'README.md',
+          viewMode: 'diff',
+        }),
+      ]),
+    );
+  });
+
+  it('clears the selected thread state after deleting the current session', async () => {
+    const removeQueries = vi.spyOn(appQueryClient, 'removeQueries').mockImplementation(async () => undefined);
+    const uiManager = {
+      goToSession: vi.fn(),
+      goToChatRoot: vi.fn(),
+      goToProviders: vi.fn(),
+      confirm: vi.fn(async () => true),
+    } as unknown as ConstructorParameters<typeof NcpChatThreadManager>[0];
+    const sessionListManager = {
+      setSelectedSessionKey: vi.fn((value: string | null) => {
+        useChatSessionListStore.getState().setSnapshot({
+          selectedSessionKey: value,
+        });
+      }),
+    } as unknown as ConstructorParameters<typeof NcpChatThreadManager>[1];
+    const streamActionsManager = {
+      resetStreamState: vi.fn(),
+    } as unknown as ConstructorParameters<typeof NcpChatThreadManager>[2];
+    const manager = new NcpChatThreadManager(
+      uiManager,
+      sessionListManager,
+      streamActionsManager,
+    );
+
+    await (manager as unknown as { deleteCurrentSession: () => Promise<void> }).deleteCurrentSession();
+
+    expect(sessionListManager.setSelectedSessionKey).toHaveBeenCalledWith(null);
+    expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBeNull();
+    expect(useChatThreadStore.getState().snapshot).toMatchObject({
+      sessionKey: null,
+      canDeleteSession: false,
+      messages: [],
+      workspacePanelParentKey: null,
+      childSessionTabs: [],
+      activeChildSessionKey: null,
+      workspaceFileTabs: [],
+      activeWorkspaceFileKey: null,
+    });
+    expect(streamActionsManager.resetStreamState).toHaveBeenCalledTimes(1);
+    expect(deleteSummaryMock).toHaveBeenCalledWith(appQueryClient, 'parent-session-1');
+    expect(removeQueries).toHaveBeenCalledWith({
+      queryKey: ['ncp-session-messages', 'parent-session-1'],
+    });
+    expect(uiManager.goToChatRoot).toHaveBeenCalledWith({ replace: true });
+
+    removeQueries.mockRestore();
+  });
+});