@nextclaw/ui 0.12.8 → 0.12.10

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

@@ -0,0 +1,77 @@
+import { describe, expect, it } from 'vitest';
+import { adaptChatMessage } from '@/components/chat/adapters/chat-message.adapter';
+import { adaptNcpMessageToUiMessage } from '../ncp-session-adapter';
+
+const texts = {
+  roleLabels: {
+    user: 'User',
+    assistant: 'Assistant',
+    tool: 'Tool',
+    system: 'System',
+    fallback: 'Message',
+  },
+  reasoningLabel: 'Reasoning',
+  toolCallLabel: 'Tool Call',
+  toolResultLabel: 'Tool Result',
+  toolInputLabel: 'Input',
+  toolNoOutputLabel: 'No output',
+  toolOutputLabel: 'Output',
+  toolStatusPreparingLabel: 'Preparing',
+  toolStatusRunningLabel: 'Running',
+  toolStatusCompletedLabel: 'Completed',
+  toolStatusFailedLabel: 'Failed',
+  toolStatusCancelledLabel: 'Cancelled',
+  imageAttachmentLabel: 'Image',
+  fileAttachmentLabel: 'File',
+  unknownPartLabel: 'Unknown',
+};
+
+describe('adaptNcpMessageToUiMessage cancelled tools', () => {
+  it('renders cancelled tool invocations as cancelled cards', () => {
+    const uiMessage = adaptNcpMessageToUiMessage({
+      id: 'ncp-message-tool-cancelled-1',
+      sessionId: 'ncp-session-1',
+      role: 'assistant',
+      status: 'final',
+      timestamp: '2026-04-01T00:00:00.000Z',
+      parts: [
+        {
+          type: 'tool-invocation',
+          toolCallId: 'tool-cancelled-1',
+          toolName: 'write_file',
+          state: 'cancelled',
+          args: JSON.stringify({
+            path: 'src/app.ts',
+            content: 'hello',
+          }),
+        },
+      ],
+    });
+
+    const adapted = adaptChatMessage(
+      {
+        id: uiMessage.id,
+        role: uiMessage.role,
+        meta: {
+          timestamp: uiMessage.meta?.timestamp,
+          status: uiMessage.meta?.status,
+        },
+        parts: uiMessage.parts as never,
+      },
+      {
+        formatTimestamp: (value) => value ?? '',
+        texts,
+      },
+    );
+
+    expect(adapted.parts[0]).toMatchObject({
+      type: 'tool-card',
+      card: {
+        toolName: 'write_file',
+        statusTone: 'cancelled',
+        statusLabel: 'Cancelled',
+        titleLabel: 'Tool Result',
+      },
+    });
+  });
+});

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

@@ -2,6 +2,7 @@ import {
   useEffect,
   useMemo,
   useRef,
+  useState,
 } from "react";
 import {
   buildNcpRequestEnvelope,
@@ -98,11 +99,7 @@ export function shouldClearPendingProjectRootOverride(params: {
 }
 
 export function NcpChatPage({ view }: ChatPageProps) {
-  const presenterRef = useRef<NcpChatPresenter | null>(null);
-  if (!presenterRef.current) {
-    presenterRef.current = new NcpChatPresenter();
-  }
-  const presenter = presenterRef.current;
+  const [presenter] = useState(() => new NcpChatPresenter());
   const query = useChatSessionListStore((state) => state.snapshot.query);
   const selectedSessionKey = useChatSessionListStore(
     (state) => state.snapshot.selectedSessionKey,
@@ -306,8 +303,11 @@ export function NcpChatPage({ view }: ChatPageProps) {
     currentAgentId,
     currentAgent,
     parentSession,
-    currentSessionTypeLabel
+    currentSessionTypeLabel,
+    currentSessionTypeIcon,
+    currentChildSessionTabs,
   } = useNcpChatDerivedState({
+    sessionKey,
     selectedSession,
     selectedAgentId,
     availableAgents,
@@ -341,6 +341,7 @@ export function NcpChatPage({ view }: ChatPageProps) {
     isSkillsLoading: sessionSkillsQuery.isLoading,
     sessionTypeUnavailableMessage,
     currentSessionTypeLabel,
+    currentSessionTypeIcon,
     sessionKey,
     currentAgentId,
     currentAgent,
@@ -352,7 +353,8 @@ export function NcpChatPage({ view }: ChatPageProps) {
     threadRef,
     agent,
     isAwaitingAssistantOutput,
-    parentSession
+    parentSession,
+    childSessionTabs: currentChildSessionTabs,
   });
 
   return (

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',
@@ -282,6 +316,7 @@ describe('adaptNcpMessageToUiMessage', () => {
       },
     });
   });
+
 });
 
 describe('readNcpSessionPreferredThinking', () => {

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;
@@ -145,6 +151,9 @@ function parseSessionContext(sessionKey: string): { channel?: string; type?: str
 }
 
 function mapToolStatus(part: Extract<NcpMessagePart, { type: 'tool-invocation' }>): ToolInvocationStatus {
+  if (part.state === 'cancelled') {
+    return ToolInvocationStatus.CANCELLED;
+  }
   if (part.state === 'result') {
     return ToolInvocationStatus.RESULT;
   }
@@ -207,6 +216,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,42 +10,87 @@ 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 type { ChatSessionTypeOption } from '@/components/chat/useChatSessionTypeState';
 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[];
   parentSessionId: string | null;
   sessionSummaries: NcpSessionSummaryView[];
   selectedSessionType: string;
-  sessionTypeOptions: Array<{ value: string; label: string }>;
+  sessionTypeOptions: ChatSessionTypeOption[];
 }) {
-  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 currentSessionTypeOption =
+    sessionTypeOptions.find((option) => option.value === selectedSessionType) ?? null;
   const currentSessionTypeLabel =
-    params.sessionTypeOptions.find((option) => option.value === params.selectedSessionType)
-      ?.label ?? resolveSessionTypeLabel(params.selectedSessionType);
+    currentSessionTypeOption?.label ?? resolveSessionTypeLabel(selectedSessionType);
+  const currentSessionTypeIcon = currentSessionTypeOption?.icon ?? null;
+  const currentChildSessionTabs = useMemo(
+    () =>
+      buildChildSessionTabs({
+        parentSessionKey: sessionKey,
+        sessionSummaries,
+      }),
+    [sessionKey, sessionSummaries],
+  );
 
   return {
     currentSessionDisplayName,
     currentAgentId,
     currentAgent,
     parentSession,
-    currentSessionTypeLabel
+    currentSessionTypeLabel,
+    currentSessionTypeIcon,
+    currentChildSessionTabs,
   };
 }
 
@@ -58,7 +103,7 @@ export function useNcpChatSnapshotSync(params: {
   lastSendError: string | null;
   isSending: boolean;
   modelOptions: ChatModelOption[];
-  sessionTypeOptions: Array<{ value: string; label: string }>;
+  sessionTypeOptions: ChatSessionTypeOption[];
   selectedSessionType: string;
   canEditSessionType: boolean;
   sessionTypeUnavailable: boolean;
@@ -66,6 +111,7 @@ export function useNcpChatSnapshotSync(params: {
   isSkillsLoading: boolean;
   sessionTypeUnavailableMessage: string | null;
   currentSessionTypeLabel: string;
+  currentSessionTypeIcon: ChatSessionTypeOption['icon'];
   sessionKey: string;
   currentAgentId: string;
   currentAgent: AgentProfileView | null;
@@ -78,6 +124,7 @@ export function useNcpChatSnapshotSync(params: {
   agent: Pick<UseHydratedNcpAgentResult, 'isHydrating' | 'visibleMessages'>;
   isAwaitingAssistantOutput: boolean;
   parentSession: SessionEntryView | null;
+  childSessionTabs: ChatChildSessionTab[];
 }) {
   useEffect(() => {
     params.presenter.chatInputManager.syncSnapshot({
@@ -103,6 +150,7 @@ export function useNcpChatSnapshotSync(params: {
       sessionTypeUnavailable: params.sessionTypeUnavailable,
       sessionTypeUnavailableMessage: params.sessionTypeUnavailableMessage,
       sessionTypeLabel: params.currentSessionTypeLabel,
+      sessionTypeIcon: params.currentSessionTypeIcon,
       sessionKey: params.sessionKey,
       agentId: params.currentAgentId,
       agentDisplayName: params.currentAgent?.displayName ?? null,
@@ -121,6 +169,7 @@ export function useNcpChatSnapshotSync(params: {
       parentSessionLabel: params.parentSession
         ? sessionDisplayName(params.parentSession)
         : null,
+      childSessionTabs: params.childSessionTabs,
     });
   }, [
     params