@nextclaw/ui 0.12.10 → 0.12.12

package/src/{components/chat/ncp/ncp-chat-page-data.ts → features/chat/hooks/use-ncp-chat-page-data.ts}

@@ -1,24 +1,26 @@
 import { useMemo } from 'react';
 import type { Dispatch, SetStateAction } from 'react';
-import type { SessionEntryView, ThinkingLevel } from '@/api/types';
-import type { ChatModelOption } from '@/components/chat/chat-input.types';
-import { sessionMatchesQuery } from '@/components/chat/chat-session-display';
-import { adaptNcpSessionSummaries } from '@/components/chat/ncp/ncp-session-adapter';
-import { useChatSessionTypeState } from '@/components/chat/useChatSessionTypeState';
+import type { SessionEntryView, ThinkingLevel } from '@/shared/lib/api';
+import type { ChatModelOption } from '@/features/chat/types/chat-input.types';
+import { sessionMatchesQuery } from '@/features/chat/utils/chat-session-display.utils';
+import { adaptNcpSessionSummaries } from '@/features/chat/utils/ncp-session-adapter.utils';
+import { useChatSessionTypeState } from '@/features/chat/hooks/use-chat-session-type-state';
 import {
   resolveRecentSessionPreferredThinking,
   resolveRecentSessionPreferredModel,
   useSyncSelectedModel,
   useSyncSelectedThinking
-} from '@/components/chat/chat-session-preference-governance';
+} from '@/features/chat/utils/chat-session-preference-governance.utils';
 import {
   useConfig,
   useConfigMeta,
   useNcpSessionSkills,
   useNcpSessions
-} from '@/hooks/useConfig';
-import { useNcpChatSessionTypes } from '@/hooks/use-ncp-chat-session-types';
-import { buildProviderModelCatalog, composeProviderModel, resolveModelThinkingCapability } from '@/lib/provider-models';
+} from '@/shared/hooks/use-config';
+import { useNcpChatSessionTypes } from './use-ncp-chat-session-types';
+import { buildProviderModelCatalog, composeProviderModel, resolveModelThinkingCapability } from '@/shared/lib/provider-models';
+
+export type { ChatModelOption } from '@/features/chat/types/chat-input.types';
 
 type UseNcpChatPageDataParams = {
   query: string;
@@ -35,37 +37,15 @@ function filterSessionsByQuery(sessions: SessionEntryView[], query: string): Ses
   return sessions.filter((session) => sessionMatchesQuery(session, query));
 }
 
-export function filterModelOptionsBySessionType(params: {
-  modelOptions: ChatModelOption[];
-  supportedModels?: string[];
-}): ChatModelOption[] {
-  if (!params.supportedModels || params.supportedModels.length === 0) {
-    return params.modelOptions;
-  }
-  const supportedModelSet = new Set(params.supportedModels);
-  const filtered = params.modelOptions.filter((option) => supportedModelSet.has(option.value));
-  return filtered.length > 0 ? filtered : params.modelOptions;
-}
-
-export function useNcpChatPageData(params: UseNcpChatPageDataParams) {
-  const configQuery = useConfig();
-  const configMetaQuery = useConfigMeta();
-  const sessionsQuery = useNcpSessions({ limit: 200 });
-  const sessionTypesQuery = useNcpChatSessionTypes();
-  const sessionSkillsQuery = useNcpSessionSkills({
-    sessionId: params.sessionKey,
-    ...(Object.prototype.hasOwnProperty.call(params, 'projectRootOverride')
-      ? { projectRoot: params.projectRootOverride ?? null }
-      : {})
-  });
-  const isProviderStateResolved =
-    (configQuery.isFetched || configQuery.isSuccess) &&
-    (configMetaQuery.isFetched || configMetaQuery.isSuccess);
-
-  const modelOptions = useMemo<ChatModelOption[]>(() => {
+function useNcpChatModelOptions(params: {
+  config: ReturnType<typeof useConfig>['data'];
+  meta: ReturnType<typeof useConfigMeta>['data'];
+}) {
+  const { config, meta } = params;
+  return useMemo<ChatModelOption[]>(() => {
     const providers = buildProviderModelCatalog({
-      meta: configMetaQuery.data,
-      config: configQuery.data,
+      meta,
+      config,
       onlyConfigured: true
     });
     const seen = new Set<string>();
@@ -92,7 +72,103 @@ export function useNcpChatPageData(params: UseNcpChatPageDataParams) {
       }
       return left.modelLabel.localeCompare(right.modelLabel);
     });
-  }, [configMetaQuery.data, configQuery.data]);
+  }, [config, meta]);
+}
+
+function useRecentSessionPreferences(params: {
+  sessions: SessionEntryView[];
+  sessionKey: string;
+  sessionType: string;
+}) {
+  const { sessions, sessionKey, sessionType } = params;
+  const recentSessionPreferredModel = useMemo(
+    () =>
+      resolveRecentSessionPreferredModel({
+        sessions,
+        selectedSessionKey: sessionKey,
+        sessionType
+      }),
+    [sessionKey, sessionType, sessions]
+  );
+  const recentSessionPreferredThinking = useMemo(
+    () =>
+      resolveRecentSessionPreferredThinking({
+        sessions,
+        selectedSessionKey: sessionKey,
+        sessionType
+      }),
+    [sessionKey, sessionType, sessions]
+  );
+  return {
+    recentSessionPreferredModel,
+    recentSessionPreferredThinking
+  };
+}
+
+function useCurrentModelThinkingState(params: {
+  currentSelectedModel: string;
+  modelOptions: ChatModelOption[];
+}) {
+  const { currentSelectedModel, modelOptions } = params;
+  const currentModelOption = useMemo(
+    () => modelOptions.find((option) => option.value === currentSelectedModel),
+    [currentSelectedModel, modelOptions]
+  );
+  const supportedThinkingLevels = useMemo(
+    () => (currentModelOption?.thinkingCapability?.supported as ThinkingLevel[] | undefined) ?? [],
+    [currentModelOption?.thinkingCapability?.supported]
+  );
+  const defaultThinkingLevel = useMemo(
+    () => (currentModelOption?.thinkingCapability?.default as ThinkingLevel | null | undefined) ?? null,
+    [currentModelOption?.thinkingCapability?.default]
+  );
+  return {
+    supportedThinkingLevels,
+    defaultThinkingLevel
+  };
+}
+
+export function filterModelOptionsBySessionType(params: {
+  modelOptions: ChatModelOption[];
+  supportedModels?: string[];
+}): ChatModelOption[] {
+  const { modelOptions, supportedModels } = params;
+  if (!supportedModels || supportedModels.length === 0) {
+    return modelOptions;
+  }
+  const supportedModelSet = new Set(supportedModels);
+  const filtered = modelOptions.filter((option) => supportedModelSet.has(option.value));
+  return filtered.length > 0 ? filtered : modelOptions;
+}
+
+export function useNcpChatPageData(params: UseNcpChatPageDataParams) {
+  const {
+    currentSelectedModel,
+    pendingSessionType,
+    projectRootOverride,
+    query,
+    sessionKey,
+    setPendingSessionType,
+    setSelectedModel,
+    setSelectedThinkingLevel,
+  } = params;
+  const configQuery = useConfig();
+  const configMetaQuery = useConfigMeta();
+  const sessionsQuery = useNcpSessions({ limit: 200 });
+  const sessionTypesQuery = useNcpChatSessionTypes();
+  const sessionSkillsQuery = useNcpSessionSkills({
+    sessionId: sessionKey,
+    ...(Object.prototype.hasOwnProperty.call(params, 'projectRootOverride')
+      ? { projectRoot: projectRootOverride ?? null }
+      : {})
+  });
+  const isProviderStateResolved =
+    (configQuery.isFetched || configQuery.isSuccess) &&
+    (configMetaQuery.isFetched || configMetaQuery.isSuccess);
+  const modelOptions = useNcpChatModelOptions({
+    config: configQuery.data,
+    meta: configMetaQuery.data
+  });
 
   const sessionSummaries = useMemo(
     () => sessionsQuery.data?.sessions ?? [],
@@ -103,12 +179,12 @@ export function useNcpChatPageData(params: UseNcpChatPageDataParams) {
     [sessionSummaries]
   );
   const sessions = useMemo(
-    () => filterSessionsByQuery(allSessions, params.query),
-    [allSessions, params.query]
+    () => filterSessionsByQuery(allSessions, query),
+    [allSessions, query]
   );
   const selectedSession = useMemo(
-    () => allSessions.find((session) => session.key === params.sessionKey) ?? null,
-    [allSessions, params.sessionKey]
+    () => allSessions.find((session) => session.key === sessionKey) ?? null,
+    [allSessions, sessionKey]
   );
   const skillRecords = useMemo(
     () => sessionSkillsQuery.data?.records ?? [],
@@ -116,8 +192,8 @@ export function useNcpChatPageData(params: UseNcpChatPageDataParams) {
   );
   const sessionTypeState = useChatSessionTypeState({
     selectedSession,
-    pendingSessionType: params.pendingSessionType,
-    setPendingSessionType: params.setPendingSessionType,
+    pendingSessionType,
+    setPendingSessionType,
     sessionTypesData: sessionTypesQuery.data
   });
   const filteredModelOptions = useMemo(
@@ -128,54 +204,35 @@ export function useNcpChatPageData(params: UseNcpChatPageDataParams) {
       }),
     [modelOptions, sessionTypeState.selectedSessionTypeOption?.supportedModels]
   );
-  const recentSessionPreferredModel = useMemo(
-    () =>
-      resolveRecentSessionPreferredModel({
-        sessions: allSessions,
-        selectedSessionKey: params.sessionKey,
-        sessionType: sessionTypeState.selectedSessionType
-      }),
-    [allSessions, params.sessionKey, sessionTypeState.selectedSessionType]
-  );
-  const currentModelOption = useMemo(
-    () => filteredModelOptions.find((option) => option.value === params.currentSelectedModel),
-    [filteredModelOptions, params.currentSelectedModel]
-  );
-  const supportedThinkingLevels = useMemo(
-    () => (currentModelOption?.thinkingCapability?.supported as ThinkingLevel[] | undefined) ?? [],
-    [currentModelOption?.thinkingCapability?.supported]
-  );
-  const defaultThinkingLevel = useMemo(
-    () => (currentModelOption?.thinkingCapability?.default as ThinkingLevel | null | undefined) ?? null,
-    [currentModelOption?.thinkingCapability?.default]
-  );
-  const recentSessionPreferredThinking = useMemo(
-    () =>
-      resolveRecentSessionPreferredThinking({
-        sessions: allSessions,
-        selectedSessionKey: params.sessionKey,
-        sessionType: sessionTypeState.selectedSessionType
-      }),
-    [allSessions, params.sessionKey, sessionTypeState.selectedSessionType]
-  );
+  const { recentSessionPreferredModel, recentSessionPreferredThinking } =
+    useRecentSessionPreferences({
+      sessions: allSessions,
+      sessionKey,
+      sessionType: sessionTypeState.selectedSessionType
+    });
+  const { supportedThinkingLevels, defaultThinkingLevel } =
+    useCurrentModelThinkingState({
+      currentSelectedModel,
+      modelOptions: filteredModelOptions
+    });
 
   useSyncSelectedModel({
     modelOptions: filteredModelOptions,
-    selectedSessionKey: params.sessionKey,
+    selectedSessionKey: sessionKey,
     selectedSessionExists: Boolean(selectedSession),
     selectedSessionPreferredModel: selectedSession?.preferredModel,
     fallbackPreferredModel: sessionTypeState.selectedSessionTypeOption?.recommendedModel ?? recentSessionPreferredModel,
     defaultModel: sessionTypeState.selectedSessionTypeOption?.recommendedModel ?? configQuery.data?.agents.defaults.model,
-    setSelectedModel: params.setSelectedModel
+    setSelectedModel
   });
   useSyncSelectedThinking({
     supportedThinkingLevels,
-    selectedSessionKey: params.sessionKey,
+    selectedSessionKey: sessionKey,
     selectedSessionExists: Boolean(selectedSession),
     selectedSessionPreferredThinking: selectedSession?.preferredThinking ?? null,
     fallbackPreferredThinking: recentSessionPreferredThinking ?? null,
     defaultThinkingLevel,
-    setSelectedThinkingLevel: params.setSelectedThinkingLevel
+    setSelectedThinkingLevel
   });
 
   return {

package/src/{hooks → features/chat/hooks}/use-ncp-chat-session-types.ts

@@ -1,5 +1,5 @@
 import { useQuery } from '@tanstack/react-query';
-import { fetchNcpChatSessionTypes } from '@/api/config';
+import { fetchNcpChatSessionTypes } from '@/shared/lib/api';
 
 export function useNcpChatSessionTypes() {
   return useQuery({

package/src/{components/chat/ncp/session-conversation → features/chat/hooks}/use-ncp-child-session-tabs-view.ts

@@ -1,11 +1,11 @@
 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 { resolveSessionTypeLabel } from "@/components/chat/useChatSessionTypeState";
-import type { ChatChildSessionTab } from "@/components/chat/stores/chat-thread.store";
-import { useNcpSessions } from "@/hooks/useConfig";
-import type { SessionRunStatus } from "@/lib/session-run-status";
+import type { SessionEntryView } from "@/shared/lib/api";
+import { sessionDisplayName } from "@/features/chat/utils/chat-session-display.utils";
+import { adaptNcpSessionSummaries } from "@/features/chat/utils/ncp-session-adapter.utils";
+import { resolveSessionTypeLabel } from "@/features/chat/hooks/use-chat-session-type-state";
+import type { ChatChildSessionTab } from "@/features/chat/stores/chat-thread.store";
+import { useNcpSessions } from "@/shared/hooks/use-config";
+import type { SessionRunStatus } from "@/features/chat/types/session-run-status.types";
 
 export type ResolvedChildSessionTab = {
   sessionKey: string;

package/src/{components/chat/ncp/session-conversation → features/chat/hooks}/use-ncp-session-conversation.test.tsx

@@ -1,16 +1,20 @@
-import { renderHook } from "@testing-library/react";
+import { act, renderHook, waitFor } 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 }>,
+  hydratedCalls: [] as Array<{ client: unknown; loadSeed: unknown }>,
+  runtimeAvailability: {
+    phase: "cold-starting" as "cold-starting" | "ready",
+    lastReadyAt: null as number | null,
+  },
   useHydratedNcpAgent: vi.fn(() => ({
     snapshot: {
       messages: [],
       streamingMessage: null,
       activeRun: null,
-      error: null,
+      error: null as Error | null,
     },
     visibleMessages: [],
     activeRunId: null,
@@ -25,12 +29,16 @@ const mocks = vi.hoisted(() => ({
   clientInstances: [] as unknown[],
 }));
 
-vi.mock("@/api/ncp-session", () => ({
-  fetchNcpSessionMessages: mocks.fetchNcpSessionMessages,
-}));
+vi.mock("@/shared/lib/api", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@/shared/lib/api")>();
+  return {
+    ...actual,
+    fetchNcpSessionMessages: mocks.fetchNcpSessionMessages,
+  };
+});
 
 vi.mock("@nextclaw/ncp-react", () => ({
-  useHydratedNcpAgent: vi.fn((params: { client: unknown }) => {
+  useHydratedNcpAgent: vi.fn((params: { client: unknown; loadSeed: unknown }) => {
     mocks.hydratedCalls.push(params);
     return mocks.useHydratedNcpAgent();
   }),
@@ -42,12 +50,18 @@ vi.mock("@nextclaw/ncp-http-agent-client", () => ({
   }),
 }));
 
+vi.mock("@/features/system-status", () => ({
+  useChatRuntimeAvailability: vi.fn(() => mocks.runtimeAvailability),
+}));
+
 describe("useNcpSessionConversation", () => {
   beforeEach(() => {
     mocks.fetchNcpSessionMessages.mockReset();
     mocks.useHydratedNcpAgent.mockClear();
     mocks.hydratedCalls.length = 0;
     mocks.clientInstances.length = 0;
+    mocks.runtimeAvailability.phase = "cold-starting";
+    mocks.runtimeAvailability.lastReadyAt = null;
   });
 
   it("hydrates seed from the shared session messages endpoint payload", async () => {
@@ -98,4 +112,38 @@ describe("useNcpSessionConversation", () => {
     expect(mocks.hydratedCalls[0]?.client).toBe(mocks.clientInstances[0]);
     expect(mocks.hydratedCalls[1]?.client).toBe(mocks.clientInstances[1]);
   });
+
+  it("retries hydration once the runtime becomes ready after a startup placeholder error", async () => {
+    mocks.useHydratedNcpAgent.mockImplementation(() => ({
+      snapshot: {
+        messages: [],
+        streamingMessage: null,
+        activeRun: null,
+        error: new Error("ncp agent unavailable during startup") as Error | null,
+      },
+      visibleMessages: [],
+      activeRunId: null,
+      isRunning: false,
+      isSending: false,
+      send: vi.fn(),
+      abort: vi.fn(),
+      streamRun: vi.fn(),
+      isHydrating: false,
+      hydrateError: null,
+    }));
+
+    const { rerender } = renderHook(() => useNcpSessionConversation("session-a"));
+    const initialLoadSeed = mocks.hydratedCalls[0]?.loadSeed;
+
+    act(() => {
+      mocks.runtimeAvailability.phase = "ready";
+      mocks.runtimeAvailability.lastReadyAt = 123;
+    });
+    rerender();
+
+    await waitFor(() => {
+      expect(mocks.hydratedCalls.length).toBeGreaterThan(2);
+    });
+    expect(mocks.hydratedCalls[mocks.hydratedCalls.length - 1]?.loadSeed).not.toBe(initialLoadSeed);
+  });
 });

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

@@ -0,0 +1,121 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { NcpHttpAgentClientEndpoint } from "@nextclaw/ncp-http-agent-client";
+import { useHydratedNcpAgent, type NcpConversationSeed } from "@nextclaw/ncp-react";
+import { API_BASE, fetchNcpSessionMessages } from "@/shared/lib/api";
+import { createNcpAppClientFetch } from "@/features/chat/utils/ncp-app-client-fetch.utils";
+import { useChatRuntimeAvailability } from "@/features/system-status";
+
+const DEFAULT_MESSAGE_LIMIT = 300;
+const NCP_AGENT_UNAVAILABLE_DURING_STARTUP = "ncp agent unavailable during startup";
+
+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 isNcpAgentStartupUnavailableErrorMessage(
+  message: string | null | undefined,
+): boolean {
+  return (
+    message?.trim().toLowerCase().includes(NCP_AGENT_UNAVAILABLE_DURING_STARTUP) ??
+    false
+  );
+}
+
+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",
+    };
+  }
+}
+
+function useSyncReadyRetryVersion(
+  readyRetrySignature: string | null,
+  bumpRetryVersion: () => void,
+): void {
+  const retriedReadySignatureRef = useRef<string | null>(null);
+  const syncReadyRetryVersion = useCallback(
+    (nextSignature: string | null) => {
+      if (!nextSignature) {
+        retriedReadySignatureRef.current = null;
+        return;
+      }
+      if (retriedReadySignatureRef.current === nextSignature) {
+        return;
+      }
+      retriedReadySignatureRef.current = nextSignature;
+      bumpRetryVersion();
+    },
+    [bumpRetryVersion],
+  );
+
+  useEffect(() => {
+    syncReadyRetryVersion(readyRetrySignature);
+  }, [readyRetrySignature, syncReadyRetryVersion]);
+}
+
+export function useNcpSessionConversation(
+  sessionId: string,
+  options: UseNcpSessionConversationOptions = {},
+) {
+  const [client] = useState(() => createNcpSessionConversationClient());
+  const runtimeAvailability = useChatRuntimeAvailability();
+  const [hydrationRetryVersion, setHydrationRetryVersion] = useState(0);
+  const messageLimit = options.messageLimit ?? DEFAULT_MESSAGE_LIMIT;
+  const loadSeed = useCallback(
+    (targetSessionId: string, signal: AbortSignal) => {
+      void hydrationRetryVersion;
+      return fetchNcpSessionConversationSeed(targetSessionId, signal, messageLimit);
+    },
+    [hydrationRetryVersion, messageLimit],
+  );
+  const agent = useHydratedNcpAgent({
+    sessionId,
+    client,
+    loadSeed,
+  });
+  const currentAgentError =
+    agent.hydrateError?.message ?? agent.snapshot.error?.message ?? null;
+  const readyRetrySignature =
+    runtimeAvailability.phase === "ready" &&
+    isNcpAgentStartupUnavailableErrorMessage(currentAgentError)
+      ? `${sessionId}:${runtimeAvailability.lastReadyAt ?? 0}`
+      : null;
+  useSyncReadyRetryVersion(readyRetrySignature, () => {
+    setHydrationRetryVersion((current) => current + 1);
+  });
+  return agent;
+}

package/src/{components/chat/ncp → features/chat/hooks}/use-ncp-session-list-view.ts

@@ -1,10 +1,10 @@
 import { useMemo } from 'react';
-import type { SessionEntryView } from '@/api/types';
-import { adaptNcpSessionSummaries } from '@/components/chat/ncp/ncp-session-adapter';
-import { sessionMatchesQuery } from '@/components/chat/chat-session-display';
-import { useChatSessionListStore } from '@/components/chat/stores/chat-session-list.store';
-import { useNcpSessions } from '@/hooks/useConfig';
-import type { SessionRunStatus } from '@/lib/session-run-status';
+import type { SessionEntryView } from '@/shared/lib/api';
+import { sessionMatchesQuery } from '@/features/chat/utils/chat-session-display.utils';
+import { adaptNcpSessionSummaries } from '@/features/chat/utils/ncp-session-adapter.utils';
+import { useChatSessionListStore } from '@/features/chat/stores/chat-session-list.store';
+import { useNcpSessions } from '@/shared/hooks/use-config';
+import type { SessionRunStatus } from '@/features/chat/types/session-run-status.types';
 
 export type NcpSessionListItemView = {
   session: SessionEntryView;

package/src/features/chat/index.ts

@@ -0,0 +1,6 @@
+export * from "./components/chat-sidebar-list-mode-switch"; export * from "./components/chat-sidebar-project-groups"; export * from "./components/chat-sidebar-session-item"; export * from "./components/chat-welcome";
+export * from "./components/conversation/chat-conversation-panel"; export * from "./components/layout/chat-sidebar";
+export * from "./components/chat-session-type-option-item"; export * from "./components/chat-session-workspace-file-preview"; export * from "./components/chat-session-workspace-panel"; export * from "./components/chat-session-workspace-panel-nav";
+export * from "./hooks/use-chat-session-type-state"; export * from "./hooks/use-ncp-chat-session-types"; export * from "./hooks/use-ncp-session-list-view";
+export * from "./managers/chat-recent-models.manager"; export * from "./managers/chat-recent-skills.manager"; export * from "./managers/chat-session-preference-sync.manager"; export * from "./managers/ncp-chat-input.manager"; export * from "./managers/ncp-chat-presenter.manager"; export * from "./managers/ncp-chat-thread.manager"; export * from "./stores/chat-input.store"; export * from "./stores/chat-session-list.store"; export * from "./stores/chat-thread.store";
+export * from "./types/chat-input.types"; export * from "./utils/chat-composer-state.utils"; export * from "./utils/chat-inline-token.utils"; export * from "./utils/chat-session-display.utils"; export * from "./utils/chat-session-preference-governance.utils"; export * from "./utils/chat-session-route.utils"; export * from "./utils/ncp-session-adapter.utils";

package/src/{components/chat → features/chat/managers}/chat-recent-models.manager.ts

@@ -1,4 +1,4 @@
-import { RecentSelectionManager } from '@/lib/recent-selection.manager';
+import { RecentSelectionManager } from './recent-selection.manager';
 
 export const chatRecentModelsManager = new RecentSelectionManager({
   storageKey: 'nextclaw.chat.recent-models',

package/src/{components/chat → features/chat/managers}/chat-recent-skills.manager.ts

@@ -1,4 +1,4 @@
-import { RecentSelectionManager } from '@/lib/recent-selection.manager';
+import { RecentSelectionManager } from './recent-selection.manager';
 
 export const chatRecentSkillsManager = new RecentSelectionManager({
   storageKey: 'nextclaw.chat.recent-skills',

package/src/{components → features}/chat/managers/chat-session-list.manager.test.ts

@@ -1,16 +1,20 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { ChatSessionListManager } from '@/components/chat/managers/chat-session-list.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';
+import { ChatSessionListManager } from '@/features/chat/managers/chat-session-list.manager';
+import { useChatInputStore } from '@/features/chat/stores/chat-input.store';
+import { useChatSessionListStore } from '@/features/chat/stores/chat-session-list.store';
+import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
 
 const mocks = vi.hoisted(() => ({
   updateNcpSession: vi.fn(),
 }));
 
-vi.mock('@/api/ncp-session', () => ({
-  updateNcpSession: mocks.updateNcpSession,
-}));
+vi.mock('@/shared/lib/api', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@/shared/lib/api')>();
+  return {
+    ...actual,
+    updateNcpSession: mocks.updateNcpSession,
+  };
+});
 
 describe('ChatSessionListManager', () => {
   beforeEach(() => {

package/src/{components → features}/chat/managers/chat-session-list.manager.ts

@@ -1,13 +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 { useChatSessionListStore } from '@/features/chat/stores/chat-session-list.store';
+import { useChatInputStore } from '@/features/chat/stores/chat-input.store';
+import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
+import type { ChatUiManager } from '@/features/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';
-
+import type { ChatStreamActionsManager } from '@/features/chat/managers/chat-stream-actions.manager';
+import { normalizeSessionProjectRootValue } from '@/shared/lib/session-project';
+import { createNcpSessionId } from '@/features/chat/utils/ncp-session-adapter.utils';
+import { updateNcpSession } from '@/shared/lib/api';
 export class ChatSessionListManager {
   constructor(
     private uiManager: ChatUiManager,
@@ -38,7 +37,6 @@ export class ChatSessionListManager {
     }
     return next;
   };
-
   private shouldPersistReadAt = (
     sessionKey: string,
     readAt: string,