@nextclaw/ui 0.12.23 → 0.12.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/ui",
-  "version": "0.12.23",
+  "version": "0.12.24",
   "private": false,
   "type": "module",
   "license": "MIT",
@@ -28,14 +28,14 @@
     "tailwind-merge": "^2.5.4",
     "zod": "^3.23.8",
     "zustand": "^5.0.2",
-    "@nextclaw/agent-chat": "0.1.13",
-    "@nextclaw/client-sdk": "0.1.3",
-    "@nextclaw/agent-chat-ui": "0.3.15",
-    "@nextclaw/shared": "0.1.2",
-    "@nextclaw/ncp-react": "0.4.28",
-    "@nextclaw/ncp-http-agent-client": "0.3.20",
-    "@nextclaw/ncp": "0.5.8",
-    "@nextclaw/server": "0.12.15"
+    "@nextclaw/agent-chat": "0.1.14",
+    "@nextclaw/agent-chat-ui": "0.3.16",
+    "@nextclaw/client-sdk": "0.1.4",
+    "@nextclaw/ncp": "0.5.9",
+    "@nextclaw/ncp-http-agent-client": "0.3.21",
+    "@nextclaw/ncp-react": "0.4.29",
+    "@nextclaw/server": "0.12.16",
+    "@nextclaw/shared": "0.1.3"
   },
   "devDependencies": {
     "@testing-library/react": "^16.3.0",

package/src/features/chat/components/chat-sidebar-session-item.tsx

@@ -165,7 +165,7 @@ function ChatSidebarSessionDisplayView({
               className="ml-auto h-2 w-2 shrink-0 rounded-full bg-primary"
             />
           ) : (
-            <span className="ml-auto shrink-0">{formatDateShort(session.updatedAt)}</span>
+            <span className="ml-auto shrink-0">{formatDateShort(session.lastMessageAt ?? session.createdAt)}</span>
           )}
         </div>
       </button>

package/src/features/chat/components/conversation/chat-conversation-panel.tsx

@@ -273,8 +273,8 @@ export function ChatConversationPanel({
       resolveDraftAgent(snapshot.agentId ?? "main"),
       defaultSessionType,
     );
-    const sessionKey = presenter.chatSessionListManager.createSession(sessionType);
-    if (layoutMode === "mobile") presenter.chatUiManager.goToSession(sessionKey);
+    presenter.chatSessionListManager.createSession(sessionType);
+    if (layoutMode === "mobile") presenter.chatUiManager.goToChatRoot();
   };
   const selectDraftAgent = (agentId: string) => {
     presenter.chatSessionListManager.setSelectedAgentId(agentId);

package/src/features/chat/components/layout/chat-sidebar.test.tsx

@@ -341,6 +341,80 @@ describe('ChatSidebar create and list basics', () => {
   });
 });
 
+describe('ChatSidebar activity ordering', () => {
+  beforeEach(resetSidebarTestState);
+
+  it('orders sessions by last message time and ignores metadata updatedAt changes', () => {
+    mocks.sessionItems = [
+      createSessionItem({
+        key: 'session:message-newer',
+        createdAt: '2026-03-19T08:00:00.000Z',
+        updatedAt: '2026-03-19T09:00:00.000Z',
+        lastMessageAt: '2026-03-19T09:00:00.000Z',
+        label: 'Message Newer',
+        sessionType: 'native',
+        sessionTypeMutable: false,
+        messageCount: 1
+      }),
+      createSessionItem({
+        key: 'session:metadata-newer',
+        createdAt: '2026-03-19T07:00:00.000Z',
+        updatedAt: '2026-03-19T12:00:00.000Z',
+        lastMessageAt: '2026-03-19T08:00:00.000Z',
+        label: 'Metadata Newer',
+        sessionType: 'native',
+        sessionTypeMutable: false,
+        messageCount: 1
+      })
+    ];
+
+    render(
+      <MemoryRouter>
+        <ChatSidebar />
+      </MemoryRouter>
+    );
+
+    const messageNewer = screen.getByText('Message Newer');
+    const metadataNewer = screen.getByText('Metadata Newer');
+
+    expect(messageNewer.compareDocumentPosition(metadataNewer) & Node.DOCUMENT_POSITION_FOLLOWING).toBeTruthy();
+  });
+
+  it('uses createdAt for sorting sessions without messages', () => {
+    mocks.sessionItems = [
+      createSessionItem({
+        key: 'session:created-older',
+        createdAt: '2026-03-19T08:00:00.000Z',
+        updatedAt: '2026-03-19T12:00:00.000Z',
+        label: 'Created Older',
+        sessionType: 'native',
+        sessionTypeMutable: false,
+        messageCount: 0
+      }),
+      createSessionItem({
+        key: 'session:created-newer',
+        createdAt: '2026-03-19T09:00:00.000Z',
+        updatedAt: '2026-03-19T10:00:00.000Z',
+        label: 'Created Newer',
+        sessionType: 'native',
+        sessionTypeMutable: false,
+        messageCount: 0
+      })
+    ];
+
+    render(
+      <MemoryRouter>
+        <ChatSidebar />
+      </MemoryRouter>
+    );
+
+    const createdNewer = screen.getByText('Created Newer');
+    const createdOlder = screen.getByText('Created Older');
+
+    expect(createdNewer.compareDocumentPosition(createdOlder) & Node.DOCUMENT_POSITION_FOLLOWING).toBeTruthy();
+  });
+});
+
 describe('ChatSidebar project-first mode', () => {
   beforeEach(resetSidebarTestState);
 

package/src/features/chat/components/layout/chat-sidebar.tsx

@@ -40,12 +40,12 @@ type DateGroup = {
   items: NcpSessionListItemView[];
 };
 
-function getSessionUpdatedAtTimestamp(item: NcpSessionListItemView): number {
-  return new Date(item.session.updatedAt).getTime();
+function getSessionActivityAtTimestamp(item: NcpSessionListItemView): number {
+  return new Date(item.session.lastMessageAt ?? item.session.createdAt).getTime();
 }
 
-function sortSessionItemsByUpdatedAtDesc(items: NcpSessionListItemView[]): NcpSessionListItemView[] {
-  return [...items].sort((left, right) => getSessionUpdatedAtTimestamp(right) - getSessionUpdatedAtTimestamp(left));
+function sortSessionItemsByActivityAtDesc(items: NcpSessionListItemView[]): NcpSessionListItemView[] {
+  return [...items].sort((left, right) => getSessionActivityAtTimestamp(right) - getSessionActivityAtTimestamp(left));
 }
 
 function groupSessionsByDate(items: NcpSessionListItemView[]): DateGroup[] {
@@ -60,8 +60,7 @@ function groupSessionsByDate(items: NcpSessionListItemView[]): DateGroup[] {
   const older: NcpSessionListItemView[] = [];
 
   for (const item of items) {
-    const { session } = item;
-    const ts = new Date(session.updatedAt).getTime();
+    const ts = getSessionActivityAtTimestamp(item);
     if (ts >= todayStart) {
       today.push(item);
     } else if (ts >= yesterdayStart) {
@@ -90,7 +89,7 @@ function groupSessionsByProject(items: NcpSessionListItemView[]): ChatSidebarPro
       continue;
     }
     const existingGroup = grouped.get(projectRoot);
-    const updatedAt = getSessionUpdatedAtTimestamp(item);
+    const updatedAt = getSessionActivityAtTimestamp(item);
     if (existingGroup) {
       existingGroup.items.push(item);
       existingGroup.latestUpdatedAt = Math.max(existingGroup.latestUpdatedAt, updatedAt);
@@ -107,11 +106,28 @@ function groupSessionsByProject(items: NcpSessionListItemView[]): ChatSidebarPro
   return [...grouped.values()]
     .map((group) => ({
       ...group,
-      items: sortSessionItemsByUpdatedAtDesc(group.items)
+      items: sortSessionItemsByActivityAtDesc(group.items)
     }))
     .sort((left, right) => right.latestUpdatedAt - left.latestUpdatedAt);
 }
 
+function groupChildSessionsByParentKey(items: NcpSessionListItemView[]): Map<string, NcpSessionListItemView[]> {
+  const grouped = new Map<string, NcpSessionListItemView[]>();
+  for (const item of items) {
+    const parentSessionKey = item.session.parentSessionId?.trim();
+    if (!parentSessionKey) {
+      continue;
+    }
+    const bucket = grouped.get(parentSessionKey) ?? [];
+    bucket.push(item);
+    grouped.set(parentSessionKey, bucket);
+  }
+  for (const bucket of grouped.values()) {
+    bucket.sort((left, right) => getSessionActivityAtTimestamp(right) - getSessionActivityAtTimestamp(left));
+  }
+  return grouped;
+}
+
 function sessionTitle(session: SessionEntryView): string {
   if (session.label && session.label.trim()) {
     return session.label.trim();
@@ -183,23 +199,8 @@ export function ChatSidebar({
     () => new Map((agentsQuery.data?.agents ?? []).map((agent) => [agent.id, agent])),
     [agentsQuery.data?.agents]
   );
-  const sortedItems = useMemo(() => sortSessionItemsByUpdatedAtDesc(items), [items]);
-  const childSessionsByParentKey = useMemo(() => {
-    const grouped = new Map<string, NcpSessionListItemView[]>();
-    for (const item of items) {
-      const parentSessionKey = item.session.parentSessionId?.trim();
-      if (!parentSessionKey) {
-        continue;
-      }
-      const bucket = grouped.get(parentSessionKey) ?? [];
-      bucket.push(item);
-      grouped.set(parentSessionKey, bucket);
-    }
-    for (const bucket of grouped.values()) {
-      bucket.sort((left, right) => getSessionUpdatedAtTimestamp(right) - getSessionUpdatedAtTimestamp(left));
-    }
-    return grouped;
-  }, [items]);
+  const sortedItems = useMemo(() => sortSessionItemsByActivityAtDesc(items), [items]);
+  const childSessionsByParentKey = useMemo(() => groupChildSessionsByParentKey(items), [items]);
   const groups = useMemo(() => groupSessionsByDate(sortedItems), [sortedItems]);
   const projectGroups = useMemo(() => groupSessionsByProject(sortedItems), [sortedItems]);
   const defaultSessionType = inputSnapshot.defaultSessionType || 'native';
@@ -248,10 +249,8 @@ export function ChatSidebar({
     />
   );
   const createSessionAndOpenIfNeeded = (sessionType: string, projectRoot?: string | null) => {
-    const sessionKey = typeof projectRoot === "string"
-      ? presenter.chatSessionListManager.createSession(sessionType, projectRoot)
-      : presenter.chatSessionListManager.createSession(sessionType);
-    if (isMobileVariant) presenter.chatUiManager.goToSession(sessionKey);
+    presenter.chatSessionListManager.createSession(sessionType, typeof projectRoot === "string" ? projectRoot : undefined);
+    if (isMobileVariant) presenter.chatUiManager.goToChatRoot();
   };
 
   return (

package/src/features/chat/hooks/use-hydrated-ncp-agent.test.tsx

@@ -7,6 +7,11 @@ const mocks = vi.hoisted(() => ({
   manager: {
     reset: vi.fn(),
     hydrate: vi.fn(),
+    getSnapshot: vi.fn(() => ({
+      messages: [],
+      streamingMessage: null,
+      activeRun: null,
+    })),
   },
   runtime: {
     snapshot: {
@@ -37,6 +42,7 @@ describe("useHydratedNcpAgent", () => {
   beforeEach(() => {
     mocks.manager.reset.mockReset();
     mocks.manager.hydrate.mockReset();
+    mocks.manager.getSnapshot.mockClear();
     mocks.runtime.send.mockReset();
     mocks.runtime.abort.mockReset();
     mocks.runtime.streamRun.mockReset();

package/src/features/chat/hooks/use-ncp-agent-runtime.test.tsx

@@ -1,90 +1,179 @@
-import { act, renderHook } from "@testing-library/react";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { NcpEventType, type NcpEndpointEvent } from "@nextclaw/ncp";
+import { act, renderHook, waitFor } from "@testing-library/react";
+import {
+  type NcpAgentClientEndpoint,
+  type NcpAgentSendEnvelope,
+  type NcpEndpointEvent,
+  type NcpEndpointManifest,
+  type NcpEndpointSubscriber,
+  NcpEventType,
+} from "@nextclaw/ncp";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { DefaultNcpAgentConversationStateManager } from "../../../../../ncp-packages/nextclaw-ncp-toolkit/src/agent/agent-conversation-state-manager.ts";
 import { useNcpAgentRuntime } from "../../../../../ncp-packages/nextclaw-ncp-react/src/hooks/use-ncp-agent-runtime.ts";
 
-function createEvent(type: NcpEventType, delta: string): NcpEndpointEvent {
-  return {
-    type,
-    payload: {
-      sessionId: "session-1",
-      messageId: "assistant-1",
-      toolCallId: "tool-1",
-      delta,
-    },
-  } as NcpEndpointEvent;
+const now = "2026-05-14T00:00:00.000Z";
+
+class DeferredSendClient implements NcpAgentClientEndpoint {
+  readonly manifest: NcpEndpointManifest = {
+    endpointKind: "agent",
+    endpointId: "deferred-send-client",
+    version: "0.1.0",
+    supportsStreaming: true,
+    supportsAbort: true,
+    supportsProactiveMessages: false,
+    supportsLiveSessionStream: true,
+    supportedPartTypes: ["text"],
+    expectedLatency: "seconds",
+  };
+
+  readonly stop = vi.fn(async () => {});
+  readonly start = vi.fn(async () => {});
+  readonly stream = vi.fn(async () => {});
+  readonly abort = vi.fn(async () => {});
+  private listeners = new Set<NcpEndpointSubscriber>();
+  private releaseCompletion: (() => void) | null = null;
+  private completionGate = new Promise<void>((resolve) => {
+    this.releaseCompletion = resolve;
+  });
+
+  emit = async (event: NcpEndpointEvent): Promise<void> => {
+    this.publish(event);
+  };
+
+  subscribe = (listener: NcpEndpointSubscriber): (() => void) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+
+  send = vi.fn(async (_envelope: NcpAgentSendEnvelope): Promise<void> => {
+    this.publish({
+      type: NcpEventType.MessageSent,
+      payload: {
+        sessionId: "session-created",
+        message: {
+          id: "user-1",
+          sessionId: "session-created",
+          role: "user",
+          status: "final",
+          parts: [{ type: "text", text: "hello" }],
+          timestamp: now,
+        },
+      },
+    });
+    this.publish({
+      type: NcpEventType.RunStarted,
+      payload: {
+        sessionId: "session-created",
+        messageId: "assistant-1",
+        runId: "run-1",
+      },
+    });
+    await this.completionGate;
+    this.publish({
+      type: NcpEventType.MessageTextStart,
+      payload: {
+        sessionId: "session-created",
+        messageId: "assistant-1",
+      },
+    });
+    this.publish({
+      type: NcpEventType.MessageTextDelta,
+      payload: {
+        sessionId: "session-created",
+        messageId: "assistant-1",
+        delta: "done",
+      },
+    });
+    this.publish({
+      type: NcpEventType.MessageTextEnd,
+      payload: {
+        sessionId: "session-created",
+        messageId: "assistant-1",
+      },
+    });
+    this.publish({
+      type: NcpEventType.MessageCompleted,
+      payload: {
+        sessionId: "session-created",
+        message: {
+          id: "assistant-1",
+          sessionId: "session-created",
+          role: "assistant",
+          status: "final",
+          parts: [{ type: "text", text: "done" }],
+          timestamp: now,
+        },
+      },
+    });
+    this.publish({
+      type: NcpEventType.RunFinished,
+      payload: {
+        sessionId: "session-created",
+        runId: "run-1",
+      },
+    });
+  });
+
+  release = (): void => {
+    this.releaseCompletion?.();
+  };
+
+  private publish = (event: NcpEndpointEvent): void => {
+    for (const listener of this.listeners) {
+      listener(event);
+    }
+  };
 }
 
 describe("useNcpAgentRuntime", () => {
   beforeEach(() => {
-    vi.useFakeTimers();
+    vi.clearAllMocks();
   });
 
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("batches streamed endpoint events before dispatching them to the manager", async () => {
-    let subscriber: ((event: NcpEndpointEvent) => void) | null = null;
-    const snapshot = {
-      messages: [],
-      streamingMessage: null,
-      error: null,
-      activeRun: null,
-    };
-    const client = {
-      subscribe: vi.fn((callback: (event: NcpEndpointEvent) => void) => {
-        subscriber = callback;
-        return () => {
-          subscriber = null;
-        };
-      }),
-      stop: vi.fn().mockResolvedValue(undefined),
-      send: vi.fn().mockResolvedValue(undefined),
-      abort: vi.fn().mockResolvedValue(undefined),
-      stream: vi.fn().mockResolvedValue(undefined),
-    };
-    const manager = {
-      getSnapshot: vi.fn(() => snapshot),
-      subscribe: vi.fn(() => () => {}),
-      dispatch: vi.fn().mockResolvedValue(undefined),
-      dispatchBatch: vi.fn().mockResolvedValue(undefined),
+  it("keeps the active send stream alive when a new root chat materializes a session id", async () => {
+    const client = new DeferredSendClient();
+    const manager = new DefaultNcpAgentConversationStateManager();
+    const envelope: NcpAgentSendEnvelope = {
+      message: {
+        id: "user-1",
+        role: "user",
+        status: "final",
+        parts: [{ type: "text", text: "hello" }],
+        timestamp: now,
+      },
     };
-
-    renderHook(() =>
-      useNcpAgentRuntime({
-        sessionId: "session-1",
-        client: client as never,
-        manager: manager as never,
-      }),
+    const { result, rerender } = renderHook(
+      ({ sessionId }: { sessionId?: string }) =>
+        useNcpAgentRuntime({ sessionId, client, manager: manager as never }),
+      { initialProps: { sessionId: undefined as string | undefined } },
     );
 
-    expect(subscriber).not.toBeNull();
-
+    let sendPromise: Promise<void>;
     act(() => {
-      subscriber?.(createEvent(NcpEventType.MessageToolCallArgsDelta, '{"path":"src/app.ts",'));
-      subscriber?.(
-        createEvent(
-          NcpEventType.MessageToolCallArgsDelta,
-          '"content":"console.log(1);"}',
-        ),
-      );
+      sendPromise = result.current.send(envelope);
+    });
+
+    await waitFor(() => {
+      expect(result.current.snapshot.activeRun?.sessionId).toBe("session-created");
     });
 
-    expect(manager.dispatchBatch).not.toHaveBeenCalled();
+    rerender({ sessionId: "session-created" });
+
+    expect(client.stop).not.toHaveBeenCalled();
 
     await act(async () => {
-      vi.advanceTimersByTime(16);
-      await Promise.resolve();
+      client.release();
+      await sendPromise;
     });
 
-    expect(manager.dispatchBatch).toHaveBeenCalledTimes(1);
-    expect(manager.dispatchBatch).toHaveBeenCalledWith([
-      createEvent(NcpEventType.MessageToolCallArgsDelta, '{"path":"src/app.ts",'),
-      createEvent(
-        NcpEventType.MessageToolCallArgsDelta,
-        '"content":"console.log(1);"}',
-      ),
+    await waitFor(() => {
+      expect(result.current.snapshot.activeRun).toBeNull();
+    });
+    expect(result.current.visibleMessages.map((message) => message.id)).toEqual([
+      "user-1",
+      "assistant-1",
     ]);
   });
 });

package/src/features/chat/hooks/use-ncp-chat-derived-state.ts

@@ -113,7 +113,7 @@ export function useNcpChatSnapshotSync(params: {
   sessionTypeUnavailableMessage: string | null;
   currentSessionTypeLabel: string;
   currentSessionTypeIcon: ChatSessionTypeOption['icon'];
-  sessionKey: string;
+  sessionKey: string | null | undefined;
   currentAgentId: string;
   currentAgent: AgentProfileView | null;
   availableAgents: AgentProfileView[];
@@ -152,7 +152,7 @@ export function useNcpChatSnapshotSync(params: {
       sessionTypeUnavailableMessage: params.sessionTypeUnavailableMessage,
       sessionTypeLabel: params.currentSessionTypeLabel,
       sessionTypeIcon: params.currentSessionTypeIcon,
-      sessionKey: params.sessionKey,
+      sessionKey: params.sessionKey ?? null,
       agentId: params.currentAgentId,
       agentDisplayName: params.currentAgent?.displayName ?? null,
       agentAvatarUrl: params.currentAgent?.avatarUrl ?? null,

package/src/features/chat/hooks/use-ncp-chat-page-data.ts

@@ -23,7 +23,7 @@ export type { ChatModelOption } from '@/features/chat/types/chat-input.types';
 
 type UseNcpChatPageDataParams = {
   query: string;
-  sessionKey: string;
+  sessionKey: string | null;
   projectRootOverride?: string | null;
   currentSelectedModel: string;
   pendingSessionType: string;
@@ -76,7 +76,7 @@ function useNcpChatModelOptions(params: {
 
 function useRecentSessionPreferences(params: {
   sessions: SessionEntryView[];
-  sessionKey: string;
+  sessionKey: string | null;
   sessionType: string;
 }) {
   const { sessions, sessionKey, sessionType } = params;
@@ -84,7 +84,7 @@ function useRecentSessionPreferences(params: {
     () =>
       resolveRecentSessionPreferredValue<string>({
         sessions,
-        selectedSessionKey: sessionKey,
+        selectedSessionKey: sessionKey ?? '',
         sessionType,
         readPreference: (session) => session.preferredModel?.trim() || undefined
       }),
@@ -94,7 +94,7 @@ function useRecentSessionPreferences(params: {
     () =>
       resolveRecentSessionPreferredValue<ThinkingLevel>({
         sessions,
-        selectedSessionKey: sessionKey,
+        selectedSessionKey: sessionKey ?? '',
         sessionType,
         readPreference: (session) => session.preferredThinking ?? undefined
       }),
@@ -158,7 +158,7 @@ export function useNcpChatPageData(params: UseNcpChatPageDataParams) {
   const sessionsQuery = useNcpSessions({ limit: 200 });
   const sessionTypesQuery = useNcpChatSessionTypes();
   const sessionSkillsQuery = useNcpSessionSkills({
-    sessionId: sessionKey,
+    sessionId: sessionKey ?? null,
     ...(Object.prototype.hasOwnProperty.call(params, 'projectRootOverride')
       ? { projectRoot: projectRootOverride ?? null }
       : {})
@@ -219,7 +219,7 @@ export function useNcpChatPageData(params: UseNcpChatPageDataParams) {
 
   useSyncSelectedModel({
     modelOptions: filteredModelOptions,
-    selectedSessionKey: sessionKey,
+    selectedSessionKey: sessionKey ?? '',
     selectedSessionExists: Boolean(selectedSession),
     selectedSessionPreferredModel: selectedSession?.preferredModel,
     fallbackPreferredModel: sessionTypeState.selectedSessionTypeOption?.recommendedModel ?? recentSessionPreferredModel,
@@ -228,7 +228,7 @@ export function useNcpChatPageData(params: UseNcpChatPageDataParams) {
   });
   useSyncSelectedThinking({
     supportedThinkingLevels,
-    selectedSessionKey: sessionKey,
+    selectedSessionKey: sessionKey ?? '',
     selectedSessionExists: Boolean(selectedSession),
     selectedSessionPreferredThinking: selectedSession?.preferredThinking ?? null,
     fallbackPreferredThinking: recentSessionPreferredThinking ?? null,

package/src/features/chat/hooks/use-ncp-session-conversation.test.tsx

@@ -146,6 +146,16 @@ describe("useNcpSessionConversation", () => {
     expect(mocks.hydratedCalls[1]?.client).toBe(mocks.clientInstances[1]);
   });
 
+  it("passes an empty session through without requesting a draft history seed", () => {
+    renderHook(() => useNcpSessionConversation(undefined));
+
+    expect(mocks.useHydratedNcpAgent).toHaveBeenCalledTimes(1);
+    expect(mocks.hydratedCalls[0]).toMatchObject({
+      sessionId: undefined,
+    });
+    expect(mocks.fetchNcpSessionMessages).not.toHaveBeenCalled();
+  });
+
   it("exposes the hydrated session context window without changing the generic ncp agent seed", async () => {
     const contextWindow = {
       usedContextTokens: 42,

package/src/features/chat/hooks/use-ncp-session-conversation.ts

@@ -93,7 +93,7 @@ function useSyncReadyRetryVersion(
 }
 
 export function useNcpSessionConversation(
-  sessionId: string,
+  sessionId: string | undefined,
   options: UseNcpSessionConversationOptions = {},
 ) {
   const [client] = useState(() => createNcpSessionConversationClient());
@@ -126,6 +126,7 @@ export function useNcpSessionConversation(
   const currentAgentError =
     agent.hydrateError?.message ?? agent.snapshot.error?.message ?? null;
   const readyRetrySignature =
+    sessionId &&
     systemStatus.phase === "ready" &&
     isNcpAgentStartupUnavailableErrorMessage(currentAgentError)
       ? `${sessionId}:${systemStatus.lastReadyAt ?? 0}`

package/src/features/chat/hooks/use-selected-session-context-window-indicator.ts

@@ -6,15 +6,13 @@ import { buildChatContextWindowIndicator } from '@/features/chat/utils/chat-cont
 
 export function useSelectedSessionContextWindowIndicator(): ChatContextWindowIndicator | null {
   const selectedSessionKey = useChatSessionListStore((state) => state.snapshot.selectedSessionKey);
-  const draftSessionKey = useChatSessionListStore((state) => state.snapshot.draftSessionKey);
   const liveSessionKey = useChatThreadStore((state) => state.snapshot.sessionKey);
   const liveContextWindow = useChatThreadStore((state) => state.snapshot.contextWindow);
-  const currentSessionKey = selectedSessionKey ?? draftSessionKey;
 
   return useMemo(() => {
-    if (liveSessionKey === currentSessionKey && liveContextWindow) {
+    if (selectedSessionKey && liveSessionKey === selectedSessionKey && liveContextWindow) {
       return buildChatContextWindowIndicator(liveContextWindow);
     }
     return null;
-  }, [currentSessionKey, liveContextWindow, liveSessionKey]);
+  }, [liveContextWindow, liveSessionKey, selectedSessionKey]);
 }