@nextclaw/ui 0.12.7 → 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

@@ -21,12 +21,14 @@ describe('adaptNcpSessionSummary', () => {
     const adapted = adaptNcpSessionSummary(
       createSummary({
         agentId: 'engineer',
+        lastMessageAt: '2026-03-18T00:00:00.000Z',
         metadata: {
           label: 'NCP Planning Thread',
           model: 'openai/gpt-5',
           preferred_thinking: 'medium',
           project_root: '/Users/demo/workspace/project-alpha',
-          session_type: 'native'
+          session_type: 'native',
+          ui_last_read_at: '2026-03-17T23:59:00.000Z'
         }
       })
     );
@@ -39,6 +41,8 @@ describe('adaptNcpSessionSummary', () => {
       preferredThinking: 'medium',
       projectRoot: '/Users/demo/workspace/project-alpha',
       projectName: 'project-alpha',
+      lastMessageAt: '2026-03-18T00:00:00.000Z',
+      readAt: '2026-03-17T23:59:00.000Z',
       sessionType: 'native',
       sessionTypeMutable: false,
       isChildSession: false,
@@ -67,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',
@@ -107,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;
@@ -80,6 +86,14 @@ function readNcpSessionProjectRoot(summary: NcpSessionSummaryView): string | nul
   return normalizeSessionProjectRootValue(metadata.project_root ?? metadata.projectRoot);
 }
 
+function readNcpSessionReadAt(summary: NcpSessionSummaryView): string | null {
+  const metadata = readMetadata(summary);
+  if (!metadata) {
+    return null;
+  }
+  return readOptionalString(metadata.ui_last_read_at);
+}
+
 function readNcpSessionType(summary: NcpSessionSummaryView): string {
   const metadata = readMetadata(summary);
   if (!metadata) {
@@ -199,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;
@@ -249,6 +274,8 @@ export function adaptNcpSessionSummary(summary: NcpSessionSummaryView): SessionE
   const preferredModel = readNcpSessionPreferredModel(summary);
   const preferredThinking = readNcpSessionPreferredThinking(summary);
   const projectRoot = readNcpSessionProjectRoot(summary);
+  const readAt = readNcpSessionReadAt(summary);
+  const lastMessageAt = readOptionalString(summary.lastMessageAt);
   const projectName = getSessionProjectName(projectRoot);
   const context = parseSessionContext(summary.sessionId);
   const parentSessionId = readNcpParentSessionId(summary);
@@ -258,6 +285,8 @@ export function adaptNcpSessionSummary(summary: NcpSessionSummaryView): SessionE
     key: summary.sessionId,
     createdAt: summary.updatedAt,
     updatedAt: summary.updatedAt,
+    ...(lastMessageAt ? { lastMessageAt } : {}),
+    ...(readAt ? { readAt } : {}),
     ...(typeof summary.agentId === 'string' && summary.agentId.trim().length > 0 ? { agentId: summary.agentId.trim() } : {}),
     ...(label ? { label } : {}),
     ...context,

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/session-conversation/use-ncp-child-session-tabs-view.ts

@@ -13,6 +13,8 @@ export type ResolvedChildSessionTab = {
   title: string;
   agentId: string | null;
   updatedAt: string | null;
+  lastMessageAt: string | null;
+  readAt: string | null;
   runStatus?: SessionRunStatus;
   sessionTypeLabel: string | null;
   preferredModel: string | null;
@@ -64,6 +66,8 @@ export function useNcpChildSessionTabsView(
           title: resolveChildSessionTitle(tab, session),
           agentId,
           updatedAt: session?.updatedAt ?? null,
+          lastMessageAt: session?.lastMessageAt ?? null,
+          readAt: session?.readAt ?? null,
           runStatus: summary?.status === "running" ? "running" : undefined,
           sessionTypeLabel: session?.sessionType
             ? resolveSessionTypeLabel(session.sessionType)

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

@@ -0,0 +1,99 @@
+import { createChatComposerTextNode } from '@nextclaw/agent-chat-ui';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { NcpChatInputManager } from '@/components/chat/ncp/ncp-chat-input.manager';
+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';
+
+describe('NcpChatInputManager', () => {
+  beforeEach(() => {
+    useChatInputStore.setState({
+      snapshot: {
+        ...useChatInputStore.getState().snapshot,
+        draft: 'hello from current thread',
+        composerNodes: [createChatComposerTextNode('hello from current thread')],
+        attachments: [],
+        selectedSkills: [],
+        selectedSessionType: 'native',
+        selectedModel: '',
+        selectedThinkingLevel: null,
+      },
+    });
+    useChatSessionListStore.setState({
+      optimisticReadAtBySessionKey: {},
+      snapshot: {
+        ...useChatSessionListStore.getState().snapshot,
+        selectedSessionKey: 'stale-selected-session',
+        draftSessionKey: 'draft-root-session',
+        selectedAgentId: 'main',
+      },
+    });
+    useChatThreadStore.setState({
+      snapshot: {
+        ...useChatThreadStore.getState().snapshot,
+        sessionKey: 'current-route-session',
+      },
+    });
+  });
+
+  it('sends through the current thread session when selected session state is stale', async () => {
+    const streamActionsManager = {
+      sendMessage: vi.fn().mockResolvedValue(undefined),
+      stopCurrentRun: vi.fn().mockResolvedValue(undefined),
+    } as unknown as ConstructorParameters<typeof NcpChatInputManager>[1];
+    const sessionListManager = {
+      ensureDraftSession: vi.fn(() => 'draft-session'),
+      promoteRootDraftSessionRoute: vi.fn(),
+    } as unknown as ConstructorParameters<typeof NcpChatInputManager>[2];
+    const manager = new NcpChatInputManager(
+      {} as ConstructorParameters<typeof NcpChatInputManager>[0],
+      streamActionsManager,
+      sessionListManager,
+    );
+
+    await manager.send();
+
+    expect(streamActionsManager.sendMessage).toHaveBeenCalledTimes(1);
+    expect(streamActionsManager.sendMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        sessionKey: 'current-route-session',
+        message: 'hello from current thread',
+      }),
+    );
+    expect(sessionListManager.ensureDraftSession).not.toHaveBeenCalled();
+    expect(sessionListManager.promoteRootDraftSessionRoute).toHaveBeenCalledWith('current-route-session');
+  });
+
+  it('keeps sending through the current root draft session while /chat is still in blank-draft mode', async () => {
+    useChatThreadStore.setState({
+      snapshot: {
+        ...useChatThreadStore.getState().snapshot,
+        sessionKey: 'draft-root-session',
+      },
+    });
+    const streamActionsManager = {
+      sendMessage: vi.fn().mockResolvedValue(undefined),
+      stopCurrentRun: vi.fn().mockResolvedValue(undefined),
+    } as unknown as ConstructorParameters<typeof NcpChatInputManager>[1];
+    const sessionListManager = {
+      ensureDraftSession: vi.fn(() => 'materialized-draft-session'),
+      promoteRootDraftSessionRoute: vi.fn(),
+    } as unknown as ConstructorParameters<typeof NcpChatInputManager>[2];
+    const manager = new NcpChatInputManager(
+      {} as ConstructorParameters<typeof NcpChatInputManager>[0],
+      streamActionsManager,
+      sessionListManager,
+    );
+
+    await manager.send();
+
+    expect(sessionListManager.ensureDraftSession).not.toHaveBeenCalled();
+    expect(streamActionsManager.sendMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        sessionKey: 'draft-root-session',
+        message: 'hello from current thread',
+      }),
+    );
+    expect(sessionListManager.promoteRootDraftSessionRoute).toHaveBeenCalledWith('draft-root-session');
+  });
+});