@nextclaw/ui 0.12.6 → 0.12.8

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

@@ -129,15 +129,15 @@ export function ChatChildSessionPanel({
 }: ChatChildSessionPanelProps) {
   const presenter = usePresenter();
   const resolvedTabs = useNcpChildSessionTabsView(tabs);
-  const readUpdatedAtBySessionKey = useChatSessionListStore(
-    (state) => state.readUpdatedAtBySessionKey,
+  const optimisticReadAtBySessionKey = useChatSessionListStore(
+    (state) => state.optimisticReadAtBySessionKey,
   );
   const activeTab =
     resolvedTabs.find((tab) => tab.sessionKey === activeSessionKey) ??
     resolvedTabs[0] ??
     null;
   const activeTabSessionKey = activeTab?.sessionKey ?? null;
-  const activeTabUpdatedAt = activeTab?.updatedAt?.trim() ?? null;
+  const activeTabReadAt = activeTab?.lastMessageAt?.trim() ?? null;
   const hasParentSession = resolvedTabs.some((tab) =>
     Boolean(tab.parentSessionKey),
   );
@@ -145,16 +145,17 @@ export function ChatChildSessionPanel({
 
   useEffect(() => {
     const syncActiveTabReadState = () => {
-      if (!activeTabSessionKey || !activeTabUpdatedAt) {
+      if (!activeTabSessionKey || !activeTabReadAt) {
         return;
       }
       presenter.chatSessionListManager.markSessionRead(
         activeTabSessionKey,
-        activeTabUpdatedAt,
+        activeTabReadAt,
+        activeTab?.readAt ?? null,
       );
     };
     syncActiveTabReadState();
-  }, [activeTabSessionKey, activeTabUpdatedAt, presenter]);
+  }, [activeTab?.readAt, activeTabReadAt, activeTabSessionKey, presenter]);
 
   if (!activeTab) {
     return null;
@@ -203,10 +204,17 @@ export function ChatChildSessionPanel({
               <Tabs value={activeSessionKey} onValueChange={onSelectSession}>
                 <TabsList className="h-auto min-w-max justify-start gap-1.5 rounded-none bg-transparent p-0 text-gray-500">
                   {resolvedTabs.map((tab) => {
+                    const optimisticReadAt = optimisticReadAtBySessionKey[tab.sessionKey];
+                    const effectiveReadAt =
+                      optimisticReadAt && tab.readAt
+                        ? (optimisticReadAt.localeCompare(tab.readAt) > 0
+                            ? optimisticReadAt
+                            : tab.readAt)
+                        : optimisticReadAt ?? tab.readAt;
                     const showUnreadDot = shouldShowUnreadSessionIndicator({
                       active: tab.sessionKey === activeSessionKey,
-                      updatedAt: tab.updatedAt,
-                      readUpdatedAt: readUpdatedAtBySessionKey[tab.sessionKey],
+                      lastMessageAt: tab.lastMessageAt,
+                      readAt: effectiveReadAt,
                       runStatus: tab.runStatus,
                     });
                     return (

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

@@ -8,7 +8,7 @@ import {
 } from '@/components/chat/chat-session-preference-governance';
 import {
   shouldClearPendingProjectRootOverride
-} from '@/components/chat/ncp/NcpChatPage';
+} from '@/components/chat/ncp/ncp-chat-page';
 
 const modelOptions = [
   {

package/src/components/chat/{ChatPage.tsx → chat-page.tsx}

@@ -1,5 +1,5 @@
 import type { ChatPageProps } from '@/components/chat/chat-page-shell';
-import { NcpChatPage } from '@/components/chat/ncp/NcpChatPage';
+import { NcpChatPage } from '@/components/chat/ncp/ncp-chat-page';
 
 export function ChatPage({ view }: ChatPageProps) {
   return <NcpChatPage view={view} />;

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

@@ -3,8 +3,18 @@ import { ChatSessionListManager } from '@/components/chat/managers/chat-session-
 import { useChatInputStore } from '@/components/chat/stores/chat-input.store';
 import { useChatSessionListStore } from '@/components/chat/stores/chat-session-list.store';
 
+const mocks = vi.hoisted(() => ({
+  updateNcpSession: vi.fn(),
+}));
+
+vi.mock('@/api/ncp-session', () => ({
+  updateNcpSession: mocks.updateNcpSession,
+}));
+
 describe('ChatSessionListManager', () => {
   beforeEach(() => {
+    mocks.updateNcpSession.mockReset();
+    mocks.updateNcpSession.mockResolvedValue({});
     useChatInputStore.setState({
       snapshot: {
         ...useChatInputStore.getState().snapshot,
@@ -15,8 +25,7 @@ describe('ChatSessionListManager', () => {
       }
     });
     useChatSessionListStore.setState({
-      readUpdatedAtBySessionKey: {},
-      hasHydratedReadWatermarks: false,
+      optimisticReadAtBySessionKey: {},
       snapshot: {
         ...useChatSessionListStore.getState().snapshot,
         selectedSessionKey: 'session-1',
@@ -28,18 +37,21 @@ describe('ChatSessionListManager', () => {
 
   it('applies the requested session type when creating a session', () => {
     const uiManager = {
-      goToSession: vi.fn()
+      goToChatRoot: vi.fn(),
+      goToSession: vi.fn(),
+      isAtChatRoot: vi.fn(() => true),
     } 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('codex');
+    const sessionKey = manager.createSession('codex');
 
     expect(streamActionsManager.resetStreamState).toHaveBeenCalledTimes(1);
-    expect(uiManager.goToSession).toHaveBeenCalledWith('draft-root-1');
-    expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBe('session-1');
+    expect(uiManager.goToChatRoot).toHaveBeenCalledTimes(1);
+    expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBeNull();
+    expect(useChatSessionListStore.getState().snapshot.draftSessionKey).toBe(sessionKey);
     expect(useChatSessionListStore.getState().snapshot.draftSessionKey).not.toBe('draft-root-1');
     expect(useChatInputStore.getState().snapshot.pendingSessionType).toBe('codex');
     expect(useChatInputStore.getState().snapshot.pendingProjectRoot).toBeNull();
@@ -48,20 +60,22 @@ describe('ChatSessionListManager', () => {
 
   it('hydrates the draft project root when creating a session inside a project group', () => {
     const uiManager = {
-      goToSession: vi.fn()
+      goToChatRoot: vi.fn(),
+      goToSession: vi.fn(),
+      isAtChatRoot: vi.fn(() => true),
     } 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');
+    const sessionKey = manager.createSession('native', '/tmp/project-alpha');
 
     expect(useChatInputStore.getState().snapshot.pendingProjectRoot).toBe('/tmp/project-alpha');
-    expect(useChatInputStore.getState().snapshot.pendingProjectRootSessionKey).toBe('draft-root-1');
+    expect(useChatInputStore.getState().snapshot.pendingProjectRootSessionKey).toBe(sessionKey);
   });
 
-  it('promotes the current root draft when send flow needs a concrete session key', () => {
+  it('reuses the current root draft when send flow needs a concrete session key', () => {
     useChatSessionListStore.setState({
       snapshot: {
         ...useChatSessionListStore.getState().snapshot,
@@ -70,7 +84,9 @@ describe('ChatSessionListManager', () => {
       }
     });
     const uiManager = {
-      goToSession: vi.fn()
+      goToChatRoot: vi.fn(),
+      goToSession: vi.fn(),
+      isAtChatRoot: vi.fn(() => true),
     } as unknown as ConstructorParameters<typeof ChatSessionListManager>[0];
     const streamActionsManager = {
       resetStreamState: vi.fn()
@@ -80,28 +96,33 @@ describe('ChatSessionListManager', () => {
     const sessionKey = manager.ensureDraftSession('native');
 
     expect(sessionKey).toBe('draft-root-2');
-    expect(uiManager.goToSession).toHaveBeenCalledWith('draft-root-2');
+    expect(uiManager.goToChatRoot).not.toHaveBeenCalled();
+    expect(uiManager.goToSession).not.toHaveBeenCalled();
     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()
+      goToChatRoot: vi.fn(),
+      goToSession: vi.fn(),
+      isAtChatRoot: vi.fn(() => true),
     } 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');
+    const sessionKey = manager.createSession('native', '/tmp/project-alpha');
 
-    expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBe('session-1');
-    expect(useChatInputStore.getState().snapshot.pendingProjectRootSessionKey).toBe('draft-root-1');
+    expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBeNull();
+    expect(useChatInputStore.getState().snapshot.pendingProjectRootSessionKey).toBe(sessionKey);
   });
 
   it('delegates existing-session selection to routing without eagerly mutating the selected session state', () => {
     const uiManager = {
-      goToSession: vi.fn()
+      goToChatRoot: vi.fn(),
+      goToSession: vi.fn(),
+      isAtChatRoot: vi.fn(() => true),
     } as unknown as ConstructorParameters<typeof ChatSessionListManager>[0];
     const streamActionsManager = {
       resetStreamState: vi.fn()
@@ -115,7 +136,9 @@ describe('ChatSessionListManager', () => {
   });
 
   it('updates the sidebar list mode without touching other session list state', () => {
-    const uiManager = {} as ConstructorParameters<typeof ChatSessionListManager>[0];
+    const uiManager = {
+      isAtChatRoot: vi.fn(() => true),
+    } as unknown as ConstructorParameters<typeof ChatSessionListManager>[0];
     const streamActionsManager = {} as ConstructorParameters<typeof ChatSessionListManager>[1];
 
     const manager = new ChatSessionListManager(uiManager, streamActionsManager);
@@ -127,33 +150,61 @@ describe('ChatSessionListManager', () => {
 
   it('marks a session as read through the session list owner boundary', () => {
     const manager = new ChatSessionListManager(
-      {} as ConstructorParameters<typeof ChatSessionListManager>[0],
+      {
+        isAtChatRoot: vi.fn(() => true),
+      } as unknown as ConstructorParameters<typeof ChatSessionListManager>[0],
       {} as ConstructorParameters<typeof ChatSessionListManager>[1]
     );
 
     manager.markSessionRead('session-2', '2026-04-10T10:00:00.000Z');
 
-    expect(useChatSessionListStore.getState().readUpdatedAtBySessionKey['session-2']).toBe(
+    expect(useChatSessionListStore.getState().optimisticReadAtBySessionKey['session-2']).toBe(
       '2026-04-10T10:00:00.000Z'
     );
+    expect(mocks.updateNcpSession).toHaveBeenCalledWith('session-2', {
+      uiReadAt: '2026-04-10T10:00:00.000Z'
+    });
   });
 
-  it('hydrates the initial unread baseline through the session list owner boundary', () => {
+  it('skips persisting read state when the backend already has the same watermark', () => {
     const manager = new ChatSessionListManager(
-      {} as ConstructorParameters<typeof ChatSessionListManager>[0],
+      {
+        isAtChatRoot: vi.fn(() => true),
+      } as unknown as ConstructorParameters<typeof ChatSessionListManager>[0],
       {} as ConstructorParameters<typeof ChatSessionListManager>[1]
     );
 
-    manager.hydrateReadWatermarks([
-      {
-        sessionKey: 'session-2',
-        updatedAt: '2026-04-10T10:00:00.000Z'
-      }
-    ]);
-
-    expect(useChatSessionListStore.getState().readUpdatedAtBySessionKey['session-2']).toBe(
+    manager.markSessionRead(
+      'session-2',
+      '2026-04-10T10:00:00.000Z',
       '2026-04-10T10:00:00.000Z'
     );
-    expect(useChatSessionListStore.getState().hasHydratedReadWatermarks).toBe(true);
+
+    expect(useChatSessionListStore.getState().optimisticReadAtBySessionKey['session-2']).toBeUndefined();
+    expect(mocks.updateNcpSession).not.toHaveBeenCalled();
+  });
+
+  it('promotes the active root draft to a concrete session route after the draft has been sent successfully', () => {
+    useChatSessionListStore.setState({
+      snapshot: {
+        ...useChatSessionListStore.getState().snapshot,
+        selectedSessionKey: null,
+        draftSessionKey: 'draft-root-2',
+      }
+    });
+    const uiManager = {
+      goToChatRoot: vi.fn(),
+      goToSession: vi.fn(),
+      isAtChatRoot: vi.fn(() => true),
+    } 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.ensureDraftSession('native');
+    manager.promoteRootDraftSessionRoute('draft-root-2');
+
+    expect(uiManager.goToSession).toHaveBeenCalledWith('draft-root-2', { replace: true });
   });
 });

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

@@ -1,10 +1,12 @@
 import { useChatSessionListStore } from '@/components/chat/stores/chat-session-list.store';
 import { useChatInputStore } from '@/components/chat/stores/chat-input.store';
+import { useChatThreadStore } from '@/components/chat/stores/chat-thread.store';
 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';
+import { updateNcpSession } from '@/api/ncp-session';
 
 export class ChatSessionListManager {
   constructor(
@@ -12,6 +14,22 @@ export class ChatSessionListManager {
     private streamActionsManager: ChatStreamActionsManager
   ) {}
 
+  private syncDraftThreadState = (sessionKey: string) => {
+    useChatThreadStore.getState().setSnapshot({
+      sessionKey,
+      sessionDisplayName: undefined,
+      canDeleteSession: false,
+      isHistoryLoading: false,
+      messages: [],
+      isSending: false,
+      isAwaitingAssistantOutput: false,
+      parentSessionKey: null,
+      parentSessionLabel: null,
+      childSessionTabs: [],
+      activeChildSessionKey: null,
+    });
+  };
+
   private resolveUpdateValue = <T>(prev: T, next: SetStateAction<T>): T => {
     if (typeof next === 'function') {
       return (next as (value: T) => T)(prev);
@@ -19,6 +37,22 @@ export class ChatSessionListManager {
     return next;
   };
 
+  private shouldPersistReadAt = (
+    sessionKey: string,
+    readAt: string,
+    currentReadAt?: string | null,
+  ): boolean => {
+    const optimisticReadAt = useChatSessionListStore.getState().optimisticReadAtBySessionKey[sessionKey];
+    const effectiveCurrentReadAt =
+      optimisticReadAt && currentReadAt
+        ? (optimisticReadAt.localeCompare(currentReadAt) > 0 ? optimisticReadAt : currentReadAt)
+        : optimisticReadAt ?? currentReadAt ?? undefined;
+    if (!effectiveCurrentReadAt) {
+      return true;
+    }
+    return readAt.localeCompare(effectiveCurrentReadAt) > 0;
+  };
+
   setSelectedAgentId = (next: SetStateAction<string>) => {
     const prev = useChatSessionListStore.getState().snapshot.selectedAgentId;
     const value = this.resolveUpdateValue(prev, next);
@@ -46,22 +80,25 @@ export class ChatSessionListManager {
     useChatSessionListStore.getState().setSnapshot({ listMode: value });
   };
 
-  markSessionRead = (sessionKey: string | null | undefined, updatedAt: string | null | undefined) => {
-    if (!sessionKey) {
+  markSessionRead = (
+    sessionKey: string | null | undefined,
+    readAt: string | null | undefined,
+    currentReadAt?: string | null,
+  ) => {
+    const normalizedSessionKey = sessionKey?.trim();
+    const normalizedReadAt = readAt?.trim();
+    if (!normalizedSessionKey || !normalizedReadAt) {
       return;
     }
-    useChatSessionListStore.getState().markSessionRead(sessionKey, updatedAt);
-  };
-
-  hydrateReadWatermarks = (
-    entries: readonly { sessionKey: string; updatedAt: string | null | undefined }[],
-  ) => {
-    useChatSessionListStore.getState().hydrateReadWatermarks(entries);
+    if (!this.shouldPersistReadAt(normalizedSessionKey, normalizedReadAt, currentReadAt)) {
+      return;
+    }
+    useChatSessionListStore.getState().markSessionRead(normalizedSessionKey, normalizedReadAt);
+    void updateNcpSession(normalizedSessionKey, { uiReadAt: normalizedReadAt }).catch(() => undefined);
   };
 
   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 =
@@ -69,17 +106,19 @@ export class ChatSessionListManager {
         ? sessionType.trim()
         : defaultSessionType;
     const normalizedProjectRoot = normalizeSessionProjectRootValue(projectRoot);
-    const nextSessionKey = sessionListSnapshot.draftSessionKey;
+    const nextSessionKey = createNcpSessionId();
     this.streamActionsManager.resetStreamState();
     useChatSessionListStore.getState().setSnapshot({
-      draftSessionKey: createNcpSessionId()
+      selectedSessionKey: null,
+      draftSessionKey: nextSessionKey
     });
+    this.syncDraftThreadState(nextSessionKey);
     useChatInputStore.getState().setSnapshot({
       pendingSessionType: nextSessionType,
       pendingProjectRoot: normalizedProjectRoot,
       pendingProjectRootSessionKey: normalizedProjectRoot ? nextSessionKey : null
     });
-    this.uiManager.goToSession(nextSessionKey);
+    this.uiManager.goToChatRoot();
     return nextSessionKey;
   };
 
@@ -88,7 +127,33 @@ export class ChatSessionListManager {
     if (snapshot.selectedSessionKey) {
       return snapshot.selectedSessionKey;
     }
-    return this.createSession(sessionType);
+    const normalizedSessionType =
+      typeof sessionType === 'string' && sessionType.trim().length > 0
+        ? sessionType.trim()
+        : null;
+    this.syncDraftThreadState(snapshot.draftSessionKey);
+    if (normalizedSessionType) {
+      useChatInputStore.getState().setSnapshot({ pendingSessionType: normalizedSessionType });
+    }
+    return snapshot.draftSessionKey;
+  };
+
+  promoteRootDraftSessionRoute = (sessionKey: string) => {
+    const normalizedSessionKey = sessionKey.trim();
+    if (!normalizedSessionKey) {
+      return;
+    }
+    const { snapshot } = useChatSessionListStore.getState();
+    const { sessionKey: currentThreadSessionKey } = useChatThreadStore.getState().snapshot;
+    if (
+      snapshot.selectedSessionKey !== null ||
+      snapshot.draftSessionKey !== normalizedSessionKey ||
+      currentThreadSessionKey !== normalizedSessionKey ||
+      !this.uiManager.isAtChatRoot()
+    ) {
+      return;
+    }
+    this.uiManager.goToSession(normalizedSessionKey, { replace: true });
   };
 
   selectSession = (sessionKey: string) => {

package/src/components/chat/managers/chat-ui.manager.ts

@@ -59,6 +59,8 @@ export class ChatUiManager {
     this.navigateTo('/chat', options);
   };
 
+  isAtChatRoot = () => this.state.pathname === '/chat';
+
   goToSession = (sessionKey: string, options?: NavigateOptions) => {
     this.navigateTo(buildSessionPath(sessionKey), options);
   };

package/src/components/chat/ncp/README.md

@@ -1,3 +1,3 @@
 ## 子树边界豁免
 
-- 原因：`chat/ncp/` 目录是 NCP 聊天运行时的装配子树，需要并列保留页面数据、派生状态、输入/线程 manager、session adapter 与测试文件。本次新增派生状态模块是为了拆短 `NcpChatPage.tsx`，属于职责下沉，而不是继续把复杂度堆回页面壳。
+- 原因：`chat/ncp/` 目录是 NCP 聊天运行时的装配子树，需要并列保留页面数据、派生状态、输入/线程 manager、session adapter 与测试文件。本次新增派生状态模块是为了拆短 `ncp-chat-page.tsx`，属于职责下沉，而不是继续把复杂度堆回页面壳。

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

@@ -15,6 +15,7 @@ import {
 } from '@/components/chat/chat-composer-state';
 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';
 import type { ChatInputSnapshot } from '@/components/chat/stores/chat-input.store';
 import type { ChatStreamActionsManager } from '@/components/chat/managers/chat-stream-actions.manager';
 import type { ChatUiManager } from '@/components/chat/managers/chat-ui.manager';
@@ -170,6 +171,7 @@ export class NcpChatInputManager {
   send = async () => {
     const inputSnapshot = useChatInputStore.getState().snapshot;
     const sessionSnapshot = useChatSessionListStore.getState().snapshot;
+    const threadSnapshot = useChatThreadStore.getState().snapshot;
     const message = inputSnapshot.draft.trim();
     const attachments = inputSnapshot.attachments;
     const parts = deriveNcpMessagePartsFromComposer(inputSnapshot.composerNodes, attachments);
@@ -180,7 +182,10 @@ export class NcpChatInputManager {
       return;
     }
     const { selectedSkills: requestedSkills, composerNodes } = inputSnapshot;
-    const sessionKey = sessionSnapshot.selectedSessionKey ?? this.sessionListManager.ensureDraftSession(inputSnapshot.selectedSessionType);
+    const sessionKey =
+      threadSnapshot.sessionKey ??
+      sessionSnapshot.selectedSessionKey ??
+      this.sessionListManager.ensureDraftSession(inputSnapshot.selectedSessionType);
     this.setComposerNodes(createInitialChatComposerNodes());
     await this.streamActionsManager.sendMessage({
       message,
@@ -196,6 +201,7 @@ export class NcpChatInputManager {
       restoreDraftOnError: true,
       composerNodes
     });
+    this.sessionListManager.promoteRootDraftSessionRoute(sessionKey);
   };
 
   stop = async () => {

package/src/components/chat/ncp/ncp-chat-page-data.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { buildNcpSendMetadata } from '@/components/chat/ncp/NcpChatPage';
+import { buildNcpSendMetadata } from '@/components/chat/ncp/ncp-chat-page';
 import { filterModelOptionsBySessionType } from '@/components/chat/ncp/ncp-chat-page-data';
 import type { ChatModelOption } from '@/components/chat/chat-input.types';
 

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,

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

@@ -80,6 +80,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) {
@@ -249,6 +257,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 +268,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/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)