@nextclaw/ui 0.11.22 → 0.12.0

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

@@ -20,6 +20,7 @@ describe('adaptNcpSessionSummary', () => {
   it('maps session metadata into shared session entry fields', () => {
     const adapted = adaptNcpSessionSummary(
       createSummary({
+        agentId: 'engineer',
         metadata: {
           label: 'NCP Planning Thread',
           model: 'openai/gpt-5',
@@ -32,6 +33,7 @@ describe('adaptNcpSessionSummary', () => {
 
     expect(adapted).toMatchObject({
       key: 'ncp-session-1',
+      agentId: 'engineer',
       label: 'NCP Planning Thread',
       preferredModel: 'openai/gpt-5',
       preferredThinking: 'medium',
@@ -39,9 +41,30 @@ describe('adaptNcpSessionSummary', () => {
       projectName: 'project-alpha',
       sessionType: 'native',
       sessionTypeMutable: false,
+      isChildSession: false,
       messageCount: 3
     });
   });
+
+  it('marks child sessions from parent_session_id metadata and keeps the request link', () => {
+    const adapted = adaptNcpSessionSummary(
+      createSummary({
+        metadata: {
+          label: 'Verifier',
+          session_type: 'native',
+          parent_session_id: 'parent-session-1',
+          spawned_by_request_id: 'request-1',
+        },
+      }),
+    );
+
+    expect(adapted).toMatchObject({
+      key: 'ncp-session-1',
+      isChildSession: true,
+      parentSessionId: 'parent-session-1',
+      spawnedByRequestId: 'request-1',
+    });
+  });
 });
 
 describe('adaptNcpMessageToUiMessage', () => {

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

@@ -88,6 +88,30 @@ function readNcpSessionType(summary: NcpSessionSummaryView): string {
   return readOptionalString(metadata.session_type) ?? readOptionalString(metadata.sessionType) ?? 'native';
 }
 
+function readNcpParentSessionId(summary: NcpSessionSummaryView): string | null {
+  const metadata = readMetadata(summary);
+  if (!metadata) {
+    return null;
+  }
+  return readOptionalString(metadata.parent_session_id) ?? readOptionalString(metadata.parentSessionId);
+}
+
+function readNcpSpawnedByRequestId(summary: NcpSessionSummaryView): string | null {
+  const metadata = readMetadata(summary);
+  if (!metadata) {
+    return null;
+  }
+  return readOptionalString(metadata.spawned_by_request_id) ?? readOptionalString(metadata.spawnedByRequestId);
+}
+
+function readPromotedChildSession(summary: NcpSessionSummaryView): boolean {
+  const metadata = readMetadata(summary);
+  if (!metadata) {
+    return false;
+  }
+  return metadata.child_session_promoted === true;
+}
+
 function parseSessionContext(sessionKey: string): { channel?: string; type?: string } {
   if (sessionKey === 'heartbeat') {
     return { type: 'heartbeat' };
@@ -222,10 +246,14 @@ export function adaptNcpSessionSummary(summary: NcpSessionSummaryView): SessionE
   const projectRoot = readNcpSessionProjectRoot(summary);
   const projectName = getSessionProjectName(projectRoot);
   const context = parseSessionContext(summary.sessionId);
+  const parentSessionId = readNcpParentSessionId(summary);
+  const spawnedByRequestId = readNcpSpawnedByRequestId(summary);
+  const isPromotedChildSession = readPromotedChildSession(summary);
   return {
     key: summary.sessionId,
     createdAt: summary.updatedAt,
     updatedAt: summary.updatedAt,
+    ...(typeof summary.agentId === 'string' && summary.agentId.trim().length > 0 ? { agentId: summary.agentId.trim() } : {}),
     ...(label ? { label } : {}),
     ...context,
     ...(preferredModel ? { preferredModel } : {}),
@@ -234,6 +262,10 @@ export function adaptNcpSessionSummary(summary: NcpSessionSummaryView): SessionE
     ...(projectName ? { projectName } : {}),
     sessionType: readNcpSessionType(summary),
     sessionTypeMutable: false,
+    isChildSession: Boolean(parentSessionId),
+    ...(isPromotedChildSession ? { isPromotedChildSession } : {}),
+    ...(parentSessionId ? { parentSessionId } : {}),
+    ...(spawnedByRequestId ? { spawnedByRequestId } : {}),
     messageCount: summary.messageCount
   };
 }

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

@@ -0,0 +1,128 @@
+import { useEffect, useMemo, type MutableRefObject } from 'react';
+import type {
+  AgentProfileView,
+  NcpSessionSummaryView,
+  SessionEntryView,
+  SessionSkillEntryView
+} from '@/api/types';
+import { sessionDisplayName } from '@/components/chat/chat-session-display';
+import { adaptNcpSessionSummary } from '@/components/chat/ncp/ncp-session-adapter';
+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 { resolveSessionTypeLabel } from '@/components/chat/useChatSessionTypeState';
+export function useNcpChatDerivedState(params: {
+  selectedSession: SessionEntryView | null;
+  selectedAgentId: string;
+  availableAgents: AgentProfileView[];
+  parentSessionId: string | null;
+  sessionSummaries: NcpSessionSummaryView[];
+  selectedSessionType: string;
+  sessionTypeOptions: Array<{ value: string; label: string }>;
+}) {
+  const currentSessionDisplayName = params.selectedSession
+    ? sessionDisplayName(params.selectedSession)
+    : undefined;
+  const currentAgentId = params.selectedSession?.agentId ?? params.selectedAgentId;
+  const currentAgent =
+    params.availableAgents.find((agent) => agent.id === currentAgentId) ?? null;
+  const parentSession = useMemo(() => {
+    if (!params.parentSessionId) {
+      return null;
+    }
+    const parentSummary =
+      params.sessionSummaries.find(
+        (summary) => summary.sessionId === params.parentSessionId,
+      ) ?? null;
+    return parentSummary ? adaptNcpSessionSummary(parentSummary) : null;
+  }, [params.parentSessionId, params.sessionSummaries]);
+  const currentSessionTypeLabel =
+    params.sessionTypeOptions.find((option) => option.value === params.selectedSessionType)
+      ?.label ?? resolveSessionTypeLabel(params.selectedSessionType);
+
+  return {
+    currentSessionDisplayName,
+    currentAgentId,
+    currentAgent,
+    parentSession,
+    currentSessionTypeLabel
+  };
+}
+
+export function useNcpChatSnapshotSync(params: {
+  presenter: NcpChatPresenter;
+  isProviderStateResolved: boolean;
+  defaultSessionType: string;
+  canStopCurrentRun: boolean;
+  stopDisabledReason: string | null;
+  lastSendError: string | null;
+  isSending: boolean;
+  modelOptions: ChatModelOption[];
+  sessionTypeOptions: Array<{ value: string; label: string }>;
+  selectedSessionType: string;
+  canEditSessionType: boolean;
+  sessionTypeUnavailable: boolean;
+  skillRecords: SessionSkillEntryView[];
+  isSkillsLoading: boolean;
+  sessionTypeUnavailableMessage: string | null;
+  currentSessionTypeLabel: string;
+  sessionKey: string;
+  currentAgentId: string;
+  currentAgent: AgentProfileView | null;
+  availableAgents: AgentProfileView[];
+  currentSessionDisplayName?: string;
+  effectiveSessionProjectRoot: string | null;
+  effectiveSessionProjectName: string | null;
+  selectedSession: SessionEntryView | null;
+  threadRef: MutableRefObject<HTMLDivElement | null>;
+  agent: Pick<UseHydratedNcpAgentResult, 'isHydrating' | 'visibleMessages'>;
+  isAwaitingAssistantOutput: boolean;
+  parentSession: SessionEntryView | null;
+}) {
+  useEffect(() => {
+    params.presenter.chatInputManager.syncSnapshot({
+      isProviderStateResolved: params.isProviderStateResolved,
+      defaultSessionType: params.defaultSessionType,
+      canStopGeneration: params.canStopCurrentRun,
+      stopDisabledReason: params.stopDisabledReason,
+      stopSupported: true,
+      stopReason: undefined,
+      sendError: params.lastSendError,
+      isSending: params.isSending,
+      modelOptions: params.modelOptions,
+      sessionTypeOptions: params.sessionTypeOptions,
+      selectedSessionType: params.selectedSessionType,
+      canEditSessionType: params.canEditSessionType,
+      sessionTypeUnavailable: params.sessionTypeUnavailable,
+      skillRecords: params.skillRecords,
+      isSkillsLoading: params.isSkillsLoading,
+    });
+    params.presenter.chatThreadManager.syncSnapshot({
+      isProviderStateResolved: params.isProviderStateResolved,
+      modelOptions: params.modelOptions,
+      sessionTypeUnavailable: params.sessionTypeUnavailable,
+      sessionTypeUnavailableMessage: params.sessionTypeUnavailableMessage,
+      sessionTypeLabel: params.currentSessionTypeLabel,
+      sessionKey: params.sessionKey,
+      agentId: params.currentAgentId,
+      agentDisplayName: params.currentAgent?.displayName ?? null,
+      agentAvatarUrl: params.currentAgent?.avatarUrl ?? null,
+      availableAgents: params.availableAgents,
+      sessionDisplayName: params.currentSessionDisplayName,
+      sessionProjectRoot: params.effectiveSessionProjectRoot,
+      sessionProjectName: params.effectiveSessionProjectName,
+      canDeleteSession: Boolean(params.selectedSession),
+      threadRef: params.threadRef,
+      isHistoryLoading: params.agent.isHydrating,
+      messages: params.agent.visibleMessages,
+      isSending: params.isSending,
+      isAwaitingAssistantOutput: params.isAwaitingAssistantOutput,
+      parentSessionKey: params.parentSession?.key ?? null,
+      parentSessionLabel: params.parentSession
+        ? sessionDisplayName(params.parentSession)
+        : null,
+    });
+  }, [
+    params
+  ]);
+}

package/src/components/chat/ncp/session-conversation/use-ncp-child-session-tabs-view.ts

@@ -0,0 +1,52 @@
+import { useMemo } from 'react';
+import type { SessionEntryView } from '@/api/types';
+import { sessionDisplayName } from '@/components/chat/chat-session-display';
+import { adaptNcpSessionSummaries } from '@/components/chat/ncp/ncp-session-adapter';
+import type { ChatChildSessionTab } from '@/components/chat/stores/chat-thread.store';
+import { useNcpSessions } from '@/hooks/useConfig';
+
+export type ResolvedChildSessionTab = {
+  sessionKey: string;
+  parentSessionKey: string | null;
+  title: string;
+  agentId: string | null;
+};
+
+function resolveChildSessionTitle(
+  tab: ChatChildSessionTab,
+  session: SessionEntryView | null,
+): string {
+  if (tab.label?.trim()) {
+    return tab.label.trim();
+  }
+  if (session) {
+    return sessionDisplayName(session);
+  }
+  return tab.sessionKey;
+}
+
+export function useNcpChildSessionTabsView(
+  tabs: readonly ChatChildSessionTab[],
+): ResolvedChildSessionTab[] {
+  const sessionsQuery = useNcpSessions({ limit: 200 });
+
+  const sessionByKey = useMemo(() => {
+    const sessions = adaptNcpSessionSummaries(sessionsQuery.data?.sessions ?? []);
+    return new Map(sessions.map((session) => [session.key, session]));
+  }, [sessionsQuery.data?.sessions]);
+
+  return useMemo(
+    () =>
+      tabs.map((tab) => {
+        const session = sessionByKey.get(tab.sessionKey) ?? null;
+        const agentId = tab.agentId?.trim() || session?.agentId || null;
+        return {
+          sessionKey: tab.sessionKey,
+          parentSessionKey: tab.parentSessionKey,
+          title: resolveChildSessionTitle(tab, session),
+          agentId,
+        };
+      }),
+    [sessionByKey, tabs],
+  );
+}

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

@@ -0,0 +1,101 @@
+import { renderHook } from "@testing-library/react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { fetchNcpSessionConversationSeed, useNcpSessionConversation } from "./use-ncp-session-conversation";
+
+const mocks = vi.hoisted(() => ({
+  fetchNcpSessionMessages: vi.fn(),
+  hydratedCalls: [] as Array<{ client: unknown }>,
+  useHydratedNcpAgent: vi.fn(() => ({
+    snapshot: {
+      messages: [],
+      streamingMessage: null,
+      activeRun: null,
+      error: null,
+    },
+    visibleMessages: [],
+    activeRunId: null,
+    isRunning: false,
+    isSending: false,
+    send: vi.fn(),
+    abort: vi.fn(),
+    streamRun: vi.fn(),
+    isHydrating: false,
+    hydrateError: null,
+  })),
+  clientInstances: [] as unknown[],
+}));
+
+vi.mock("@/api/ncp-session", () => ({
+  fetchNcpSessionMessages: mocks.fetchNcpSessionMessages,
+}));
+
+vi.mock("@nextclaw/ncp-react", () => ({
+  useHydratedNcpAgent: vi.fn((params: { client: unknown }) => {
+    mocks.hydratedCalls.push(params);
+    return mocks.useHydratedNcpAgent();
+  }),
+}));
+
+vi.mock("@nextclaw/ncp-http-agent-client", () => ({
+  NcpHttpAgentClientEndpoint: vi.fn().mockImplementation(function MockClient(this: object) {
+    mocks.clientInstances.push(this);
+  }),
+}));
+
+describe("useNcpSessionConversation", () => {
+  beforeEach(() => {
+    mocks.fetchNcpSessionMessages.mockReset();
+    mocks.useHydratedNcpAgent.mockClear();
+    mocks.hydratedCalls.length = 0;
+    mocks.clientInstances.length = 0;
+  });
+
+  it("hydrates seed from the shared session messages endpoint payload", async () => {
+    mocks.fetchNcpSessionMessages.mockResolvedValue({
+      sessionId: "session-1",
+      status: "running",
+      total: 1,
+      messages: [{ id: "msg-1" }],
+    });
+
+    const result = await fetchNcpSessionConversationSeed(
+      "session-1",
+      new AbortController().signal,
+      300,
+    );
+
+    expect(mocks.fetchNcpSessionMessages).toHaveBeenCalledWith("session-1", 300);
+    expect(result).toEqual({
+      messages: [{ id: "msg-1" }],
+      status: "running",
+    });
+  });
+
+  it("treats a missing session as an empty idle draft seed", async () => {
+    mocks.fetchNcpSessionMessages.mockRejectedValue(
+      new Error("ncp session not found: draft-session"),
+    );
+
+    const result = await fetchNcpSessionConversationSeed(
+      "draft-session",
+      new AbortController().signal,
+    );
+
+    expect(result).toEqual({
+      messages: [],
+      status: "idle",
+    });
+  });
+
+  it("creates an isolated endpoint instance per viewer", () => {
+    renderHook(() => useNcpSessionConversation("session-a"));
+    renderHook(() => useNcpSessionConversation("session-b"));
+
+    expect(mocks.useHydratedNcpAgent).toHaveBeenCalledTimes(2);
+    expect(mocks.clientInstances).toHaveLength(2);
+    expect(mocks.hydratedCalls).toHaveLength(2);
+    expect(mocks.clientInstances[0]).not.toBe(mocks.clientInstances[1]);
+    expect(mocks.hydratedCalls[0]?.client).toBe(mocks.clientInstances[0]);
+    expect(mocks.hydratedCalls[1]?.client).toBe(mocks.clientInstances[1]);
+  });
+});

package/src/components/chat/ncp/session-conversation/use-ncp-session-conversation.ts

@@ -0,0 +1,72 @@
+import { useCallback, useState } from "react";
+import { NcpHttpAgentClientEndpoint } from "@nextclaw/ncp-http-agent-client";
+import { useHydratedNcpAgent, type NcpConversationSeed } from "@nextclaw/ncp-react";
+import { API_BASE } from "@/api/api-base";
+import { fetchNcpSessionMessages } from "@/api/ncp-session";
+import { createNcpAppClientFetch } from "@/components/chat/ncp/ncp-app-client-fetch";
+
+const DEFAULT_MESSAGE_LIMIT = 300;
+
+type UseNcpSessionConversationOptions = {
+  messageLimit?: number;
+};
+
+function isMissingNcpSessionError(error: unknown): boolean {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return error.message.includes("ncp session not found:");
+}
+
+export function createNcpSessionConversationClient(): NcpHttpAgentClientEndpoint {
+  return new NcpHttpAgentClientEndpoint({
+    baseUrl: API_BASE,
+    basePath: "/api/ncp/agent",
+    fetchImpl: createNcpAppClientFetch(),
+  });
+}
+
+export async function fetchNcpSessionConversationSeed(
+  sessionId: string,
+  signal: AbortSignal,
+  messageLimit = DEFAULT_MESSAGE_LIMIT,
+): Promise<NcpConversationSeed> {
+  signal.throwIfAborted();
+
+  try {
+    const response = await fetchNcpSessionMessages(sessionId, messageLimit);
+    signal.throwIfAborted();
+    return {
+      messages: response.messages,
+      status: response.status ?? "idle",
+    };
+  } catch (error) {
+    signal.throwIfAborted();
+    if (!isMissingNcpSessionError(error)) {
+      throw error;
+    }
+    return {
+      messages: [],
+      status: "idle",
+    };
+  }
+}
+
+export function useNcpSessionConversation(
+  sessionId: string,
+  options: UseNcpSessionConversationOptions = {},
+) {
+  const [client] = useState(() => createNcpSessionConversationClient());
+  const messageLimit = options.messageLimit ?? DEFAULT_MESSAGE_LIMIT;
+  const loadSeed = useCallback(
+    (targetSessionId: string, signal: AbortSignal) =>
+      fetchNcpSessionConversationSeed(targetSessionId, signal, messageLimit),
+    [messageLimit],
+  );
+
+  return useHydratedNcpAgent({
+    sessionId,
+    client,
+    loadSeed,
+  });
+}

package/src/components/chat/ncp/use-ncp-session-list-view.ts

@@ -15,13 +15,22 @@ function filterSessionsByQuery(sessions: readonly SessionEntryView[], query: str
   return sessions.filter((session) => sessionMatchesQuery(session, query));
 }
 
+function shouldShowSessionInSidebar(session: SessionEntryView): boolean {
+  if (!session.isChildSession) {
+    return true;
+  }
+  return session.isPromotedChildSession === true;
+}
+
 export function useNcpSessionListView(params: { limit?: number } = {}) {
   const query = useChatSessionListStore((state) => state.snapshot.query);
   const sessionsQuery = useNcpSessions({ limit: params.limit ?? 200 });
 
   const items = useMemo<NcpSessionListItemView[]>(() => {
     const summaries = sessionsQuery.data?.sessions ?? [];
-    const sessions = adaptNcpSessionSummaries(summaries);
+    const sessions = adaptNcpSessionSummaries(summaries).filter(
+      shouldShowSessionInSidebar,
+    );
     const filteredSessions = filterSessionsByQuery(sessions, query);
     const summaryBySessionId = new Map(summaries.map((summary) => [summary.sessionId, summary]));
 

package/src/components/chat/presenter/chat-presenter-context.tsx

@@ -1,4 +1,4 @@
-import type { ChatComposerNode } from '@nextclaw/agent-chat-ui';
+import type { ChatComposerNode, ChatToolActionViewModel } from '@nextclaw/agent-chat-ui';
 import type { NcpDraftAttachment } from '@nextclaw/ncp-react';
 import { createContext, useContext } from 'react';
 import type { ReactNode } from 'react';
@@ -37,6 +37,10 @@ export type ChatThreadManagerLike = {
   deleteSession: () => void;
   createSession: () => void;
   goToProviders: () => void;
+  openSessionFromToolAction: (action: ChatToolActionViewModel) => void;
+  selectChildSessionDetail: (sessionKey: string) => void;
+  closeChildSessionDetail: () => void;
+  goToParentSession: () => void;
 };
 
 export type ChatPresenterLike = {

package/src/components/chat/stores/chat-thread.store.ts

@@ -2,6 +2,14 @@ import { create } from 'zustand';
 import type { MutableRefObject } from 'react';
 import type { NcpMessage } from '@nextclaw/ncp';
 import type { ChatModelOption } from '@/components/chat/chat-input.types';
+import type { AgentProfileView } from '@/api/types';
+
+export type ChatChildSessionTab = {
+  sessionKey: string;
+  parentSessionKey: string | null;
+  label?: string | null;
+  agentId?: string | null;
+};
 
 export type ChatThreadSnapshot = {
   isProviderStateResolved: boolean;
@@ -10,6 +18,10 @@ export type ChatThreadSnapshot = {
   sessionTypeUnavailableMessage?: string | null;
   sessionTypeLabel?: string | null;
   sessionKey: string | null;
+  agentId?: string | null;
+  agentDisplayName?: string | null;
+  agentAvatarUrl?: string | null;
+  availableAgents?: AgentProfileView[];
   sessionDisplayName?: string;
   sessionProjectRoot?: string | null;
   sessionProjectName?: string | null;
@@ -20,6 +32,10 @@ export type ChatThreadSnapshot = {
   messages: readonly NcpMessage[];
   isSending: boolean;
   isAwaitingAssistantOutput: boolean;
+  parentSessionKey?: string | null;
+  parentSessionLabel?: string | null;
+  childSessionTabs: ChatChildSessionTab[];
+  activeChildSessionKey?: string | null;
 };
 
 type ChatThreadStore = {
@@ -34,6 +50,10 @@ const initialSnapshot: ChatThreadSnapshot = {
   sessionTypeUnavailableMessage: null,
   sessionTypeLabel: null,
   sessionKey: null,
+  agentId: null,
+  agentDisplayName: null,
+  agentAvatarUrl: null,
+  availableAgents: [],
   sessionDisplayName: undefined,
   sessionProjectRoot: null,
   sessionProjectName: null,
@@ -43,7 +63,11 @@ const initialSnapshot: ChatThreadSnapshot = {
   isHistoryLoading: false,
   messages: [],
   isSending: false,
-  isAwaitingAssistantOutput: false
+  isAwaitingAssistantOutput: false,
+  parentSessionKey: null,
+  parentSessionLabel: null,
+  childSessionTabs: [],
+  activeChildSessionKey: null,
 };
 
 export const useChatThreadStore = create<ChatThreadStore>((set) => ({

package/src/components/chat/useHydratedNcpAgent.test.tsx

@@ -1,18 +1,19 @@
-import { renderHook, waitFor } from '@testing-library/react';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { useHydratedNcpAgent } from '../../../../ncp-packages/nextclaw-ncp-react/src/hooks/use-hydrated-ncp-agent.ts';
+import { renderHook, waitFor } from "@testing-library/react";
+import type { NcpAgentClientEndpoint } from "@nextclaw/ncp";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { useHydratedNcpAgent } from "../../../../ncp-packages/nextclaw-ncp-react/src/hooks/use-hydrated-ncp-agent.ts";
 
 const mocks = vi.hoisted(() => ({
   manager: {
     reset: vi.fn(),
-    hydrate: vi.fn()
+    hydrate: vi.fn(),
   },
   runtime: {
     snapshot: {
       messages: [],
       streamingMessage: null,
       activeRun: null,
-      error: null
+      error: null,
     },
     visibleMessages: [],
     activeRunId: null,
@@ -20,16 +21,19 @@ const mocks = vi.hoisted(() => ({
     isSending: false,
     send: vi.fn(),
     abort: vi.fn(),
-    streamRun: vi.fn()
-  }
+    streamRun: vi.fn(),
+  },
 }));
 
-vi.mock('../../../../ncp-packages/nextclaw-ncp-react/src/hooks/use-ncp-agent-runtime.js', () => ({
-  useScopedAgentManager: () => mocks.manager,
-  useNcpAgentRuntime: () => mocks.runtime
-}));
+vi.mock(
+  "../../../../ncp-packages/nextclaw-ncp-react/src/hooks/use-ncp-agent-runtime.js",
+  () => ({
+    useScopedAgentManager: () => mocks.manager,
+    useNcpAgentRuntime: () => mocks.runtime,
+  }),
+);
 
-describe('useHydratedNcpAgent', () => {
+describe("useHydratedNcpAgent", () => {
   beforeEach(() => {
     mocks.manager.reset.mockReset();
     mocks.manager.hydrate.mockReset();
@@ -38,40 +42,43 @@ describe('useHydratedNcpAgent', () => {
     mocks.runtime.streamRun.mockReset();
   });
 
-  it('treats a newly selected session as hydrating immediately on rerender', async () => {
+  it("treats a newly selected session as hydrating immediately on rerender", async () => {
     const client = {
       stop: vi.fn().mockResolvedValue(undefined),
-      stream: vi.fn().mockResolvedValue(undefined)
-    } as never;
+      stream: vi.fn().mockResolvedValue(undefined),
+    } satisfies Pick<NcpAgentClientEndpoint, "stop" | "stream">;
     const loadSeed = vi
       .fn()
-      .mockResolvedValueOnce({ messages: [], status: 'idle' })
-      .mockResolvedValueOnce({ messages: [], status: 'idle' });
+      .mockResolvedValueOnce({ messages: [], status: "idle" })
+      .mockResolvedValueOnce({ messages: [], status: "idle" });
 
     const { result, rerender } = renderHook(
       ({ sessionId }: { sessionId: string }) =>
         useHydratedNcpAgent({
           sessionId,
-          client,
-          loadSeed
+          client: client as never,
+          loadSeed,
         }),
       {
         initialProps: {
-          sessionId: 'session-a'
-        }
-      }
+          sessionId: "session-a",
+        },
+      },
     );
 
     await waitFor(() => {
       expect(result.current.isHydrating).toBe(false);
     });
+    expect(client.stream).toHaveBeenCalledWith({ sessionId: "session-a" });
 
-    rerender({ sessionId: 'session-b' });
+    rerender({ sessionId: "session-b" });
 
     expect(result.current.isHydrating).toBe(true);
 
     await waitFor(() => {
       expect(result.current.isHydrating).toBe(false);
     });
+    expect(client.stream).toHaveBeenCalledWith({ sessionId: "session-b" });
+    expect(client.stream).toHaveBeenCalledTimes(2);
   });
 });