@nextclaw/ui 0.19.2 → 0.19.4

package/src/features/chat/features/conversation/hooks/use-session-pending-input-actions.ts

@@ -0,0 +1,135 @@
+import { useCallback, useMemo, useState } from 'react';
+import type {
+  UiNcpSessionPendingInputView,
+  UiNcpSessionQueuedInputView,
+} from '@nextclaw/client-sdk';
+import type { NcpAgentSendEnvelope } from '@nextclaw/ncp';
+
+import { t } from '@/shared/lib/i18n';
+import {
+  buildSessionQueuedInputComposerSnapshot,
+  buildSessionQueuedInputPresentation,
+  type SessionQueuedInputAttachmentPreview,
+} from '@/features/chat/features/conversation/utils/session-queued-input.utils';
+import type { SessionConversationInputSnapshot } from './use-session-conversation-input-state';
+
+type ComposerDraftSnapshot = Pick<
+  SessionConversationInputSnapshot,
+  'text' | 'nodes' | 'selectedSkills' | 'skillRecords' | 'attachments'
+>;
+
+type SessionRunQueue = {
+  readonly inputs: readonly UiNcpSessionQueuedInputView[];
+  readonly removeQueuedInput: (id: string) => Promise<UiNcpSessionQueuedInputView | null>;
+  readonly steerQueuedInput: (id: string) => Promise<UiNcpSessionPendingInputView | null>;
+};
+
+export type SubmittingQueuedInput = {
+  readonly attachments: readonly SessionQueuedInputAttachmentPreview[];
+  readonly id: string;
+  readonly preview: string;
+  readonly sessionId: string;
+  readonly userMessageId: string;
+};
+
+type ProjectedQueuedInput = {
+  readonly attachments: readonly SessionQueuedInputAttachmentPreview[];
+  readonly id: string;
+  readonly isSubmitting?: boolean;
+  readonly preview: string;
+};
+
+function buildSubmittingQueuedInput(
+  envelope: NcpAgentSendEnvelope,
+): SubmittingQueuedInput | null {
+  const sessionId = envelope.sessionId?.trim();
+  if (!sessionId) return null;
+  const input: UiNcpSessionQueuedInputView = {
+    id: `submitting-${envelope.message.id}`,
+    sessionId,
+    enqueuedAt: new Date().toISOString(),
+    message: { ...envelope.message, sessionId },
+    metadata: structuredClone(envelope.metadata ?? {}),
+  };
+  const presentation = buildSessionQueuedInputPresentation(input);
+  return {
+    attachments: presentation.attachments,
+    id: input.id,
+    preview: presentation.preview,
+    sessionId,
+    userMessageId: input.message.id,
+  };
+}
+
+export function useSubmittingQueuedInputProjection(
+  serverInputs: readonly UiNcpSessionQueuedInputView[],
+  sessionKey: string | null,
+) {
+  const [submittingInput, setSubmittingInput] = useState<SubmittingQueuedInput | null>(null);
+  const stageSubmittingInput = useCallback((envelope: NcpAgentSendEnvelope) => {
+    const input = buildSubmittingQueuedInput(envelope);
+    if (input) setSubmittingInput(input);
+    return input;
+  }, []);
+  const clearSubmittingInput = useCallback((input: SubmittingQueuedInput) => {
+    setSubmittingInput((current) =>
+      current?.userMessageId === input.userMessageId ? null : current
+    );
+  }, []);
+  const queuedInputs = useMemo(() => {
+    const projected: ProjectedQueuedInput[] = serverInputs.map((input) => ({
+      ...buildSessionQueuedInputPresentation(input),
+      id: input.id,
+    }));
+    if (
+      submittingInput?.sessionId === sessionKey &&
+      !serverInputs.some((input) => input.message.id === submittingInput.userMessageId)
+    ) {
+      projected.push({
+        attachments: submittingInput.attachments,
+        id: submittingInput.id,
+        isSubmitting: true,
+        preview: submittingInput.preview,
+      });
+    }
+    return projected;
+  }, [serverInputs, sessionKey, submittingInput]);
+  return { clearSubmittingInput, queuedInputs, stageSubmittingInput };
+}
+
+export function useQueuedInputActions(params: {
+  readonly availableSkills: readonly { ref: string; name: string }[];
+  readonly hasComposerContent: boolean;
+  readonly restoreComposer: (snapshot: ComposerDraftSnapshot) => void;
+  readonly runQueue: SessionRunQueue;
+  readonly setSendError: (message: string | null) => void;
+}) {
+  const { availableSkills, hasComposerContent, restoreComposer, runQueue, setSendError } = params;
+  const editQueuedInput = useCallback((id: string) => {
+    if (hasComposerContent) {
+      setSendError(t('chatQueuedEditComposerNotEmpty'));
+      return;
+    }
+    if (!runQueue.inputs.some((item) => item.id === id)) return;
+    void runQueue.removeQueuedInput(id).then((removed) => {
+      if (!removed) return;
+      restoreComposer(buildSessionQueuedInputComposerSnapshot(removed, availableSkills));
+      setSendError(null);
+    }).catch((error) => {
+      setSendError(error instanceof Error ? error.message : String(error));
+    });
+  }, [availableSkills, hasComposerContent, restoreComposer, runQueue, setSendError]);
+  const deleteQueuedInput = useCallback((id: string) => {
+    void runQueue.removeQueuedInput(id).then(() => setSendError(null)).catch((error) => {
+      setSendError(error instanceof Error ? error.message : String(error));
+    });
+  }, [runQueue, setSendError]);
+  const steerQueuedInput = useCallback((id: string) => {
+    void runQueue.steerQueuedInput(id).then((steered) => {
+      if (steered) setSendError(null);
+    }).catch((error) => {
+      setSendError(error instanceof Error ? error.message : String(error));
+    });
+  }, [runQueue, setSendError]);
+  return { deleteQueuedInput, editQueuedInput, steerQueuedInput };
+}

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

@@ -1,6 +1,10 @@
 import { useCallback, useEffect } from 'react';
 import { useQuery, useQueryClient } from '@tanstack/react-query';
-import { eventKeys, type UiNcpSessionQueuedInputView } from '@nextclaw/client-sdk';
+import {
+  eventKeys,
+  type UiNcpSessionPendingInputView,
+  type UiNcpSessionQueuedInputView,
+} from '@nextclaw/client-sdk';
 
 import { nextclawClient } from '@/shared/lib/api';
 
@@ -11,7 +15,7 @@ export function useSessionRunQueue(sessionKey: string | null) {
   const normalizedSessionKey = sessionKey?.trim() || null;
   const query = useQuery({
     queryKey: [SESSION_RUN_QUEUE_QUERY_KEY, normalizedSessionKey],
-    queryFn: () => nextclawClient.sessions.listQueuedInputs(normalizedSessionKey as string),
+    queryFn: () => nextclawClient.sessions.listPendingInputs(normalizedSessionKey as string),
     enabled: Boolean(normalizedSessionKey),
     retry: false,
     staleTime: 5_000,
@@ -49,13 +53,24 @@ export function useSessionRunQueue(sessionKey: string | null) {
       return [];
     }
     const result = await refetch();
-    return result.data?.inputs ?? [];
+    return result.data?.inputs.filter(({ placement }) => placement === 'queued') ?? [];
   }, [normalizedSessionKey, refetch]);
 
+  const steerQueuedInput = useCallback(async (
+    queuedInputId: string,
+  ): Promise<UiNcpSessionPendingInputView | null> => {
+    if (!normalizedSessionKey) return null;
+    return await nextclawClient.sessions.steerQueuedInput(normalizedSessionKey, queuedInputId);
+  }, [normalizedSessionKey]);
+
+  const inputs = data?.inputs ?? [];
+
   return {
-    inputs: data?.inputs ?? [],
+    inputs: inputs.filter(({ placement }) => placement === 'queued'),
+    pendingInputs: inputs,
     isLoading,
     refreshQueuedInputs,
     removeQueuedInput,
+    steerQueuedInput,
   };
 }

package/src/features/chat/features/conversation/utils/__tests__/session-queued-input.utils.test.ts

@@ -3,7 +3,7 @@ import type { UiNcpSessionQueuedInputView } from '@nextclaw/client-sdk';
 
 import {
   buildSessionQueuedInputComposerSnapshot,
-  buildSessionQueuedInputPreview,
+  buildSessionQueuedInputPresentation,
 } from '@/features/chat/features/conversation/utils/session-queued-input.utils';
 
 describe('session queued input utils', () => {
@@ -58,6 +58,56 @@ describe('session queued input utils', () => {
       mimeType: 'text/markdown',
       assetUri: 'asset://spec',
     }]);
-    expect(buildSessionQueuedInputPreview(input)).toBe('please');
+    expect(buildSessionQueuedInputPresentation(input)).toEqual({
+      attachments: [{
+        mimeType: 'text/markdown',
+        name: 'spec.md',
+      }],
+      preview: 'please',
+    });
+  });
+
+  it('keeps image content available to the compact queue presentation', () => {
+    const input: UiNcpSessionQueuedInputView = {
+      id: 'queued-image',
+      sessionId: 'session-1',
+      enqueuedAt: '2026-07-22T10:00:00.000Z',
+      metadata: {},
+      message: {
+        id: 'message-image',
+        sessionId: 'session-1',
+        role: 'user',
+        status: 'final',
+        timestamp: '2026-07-22T10:00:00.000Z',
+        parts: [
+          {
+            type: 'file',
+            name: 'inline.png',
+            mimeType: 'image/png',
+            contentBase64: 'aW1hZ2U=',
+          },
+          {
+            type: 'file',
+            name: 'stored.png',
+            mimeType: 'image/png',
+            assetUri: 'asset://store/stored.png',
+          },
+        ],
+      },
+    };
+
+    const presentation = buildSessionQueuedInputPresentation(input);
+
+    expect(presentation.preview).toBe('');
+    expect(presentation.attachments[0]).toEqual({
+      mimeType: 'image/png',
+      name: 'inline.png',
+      previewUrl: 'data:image/png;base64,aW1hZ2U=',
+    });
+    expect(presentation.attachments[1]).toMatchObject({
+      mimeType: 'image/png',
+      name: 'stored.png',
+      previewUrl: expect.stringContaining('/api/ncp/assets/content?uri=asset%3A%2F%2Fstore%2Fstored.png'),
+    });
   });
 });

package/src/features/chat/features/conversation/utils/session-queued-input.utils.ts

@@ -1,5 +1,7 @@
 import type { UiNcpSessionQueuedInputView } from '@nextclaw/client-sdk';
+import type { NcpMessagePart } from '@nextclaw/ncp';
 
+import { buildNcpAssetContentUrl } from '@/shared/lib/api';
 import {
   readInlineTokensFromMetadata,
 } from '@/features/chat/features/input/utils/chat-inline-token.utils';
@@ -10,6 +12,17 @@ import {
 
 export type SessionQueuedInputComposerSnapshot = SessionMessageComposerSnapshot;
 
+export type SessionQueuedInputAttachmentPreview = {
+  readonly mimeType: string;
+  readonly name: string;
+  readonly previewUrl?: string;
+};
+
+export type SessionQueuedInputPresentation = {
+  readonly attachments: readonly SessionQueuedInputAttachmentPreview[];
+  readonly preview: string;
+};
+
 function readInputMetadata(input: UiNcpSessionQueuedInputView): Record<string, unknown> {
   return {
     ...input.metadata,
@@ -17,7 +30,7 @@ function readInputMetadata(input: UiNcpSessionQueuedInputView): Record<string, u
   };
 }
 
-export function buildSessionQueuedInputPreview(input: UiNcpSessionQueuedInputView): string {
+function buildSessionQueuedInputPreview(input: UiNcpSessionQueuedInputView): string {
   const inlineTokens = readInlineTokensFromMetadata(readInputMetadata(input));
   const text = input.message.parts.flatMap((part) =>
     part.type === 'text' || part.type === 'rich-text' || part.type === 'reasoning'
@@ -28,10 +41,38 @@ export function buildSessionQueuedInputPreview(input: UiNcpSessionQueuedInputVie
     (value, token) => value.split(token.rawText).join(''),
     text,
   ).replace(/\s+/g, ' ').trim();
-  if (plainText) {
-    return plainText;
-  }
-  return input.message.parts.flatMap((part) => part.type === 'file' && part.name ? [part.name] : []).join(', ');
+  return plainText;
+}
+
+function buildImagePreviewUrl(
+  part: Extract<NcpMessagePart, { type: 'file' }>,
+): string | undefined {
+  if (!part.mimeType?.startsWith('image/')) return undefined;
+  const url = part.url?.trim();
+  if (url) return url;
+  const contentBase64 = part.contentBase64?.trim();
+  if (contentBase64) return `data:${part.mimeType};base64,${contentBase64}`;
+  const assetUri = part.assetUri?.trim();
+  return assetUri ? buildNcpAssetContentUrl(assetUri) : undefined;
+}
+
+export function buildSessionQueuedInputPresentation(
+  input: UiNcpSessionQueuedInputView,
+): SessionQueuedInputPresentation {
+  const attachments = input.message.parts.flatMap((part, index) => {
+    if (part.type !== 'file') return [];
+    const mimeType = part.mimeType ?? 'application/octet-stream';
+    const previewUrl = buildImagePreviewUrl(part);
+    return [{
+      mimeType,
+      name: part.name?.trim() || `attachment-${index + 1}`,
+      ...(previewUrl ? { previewUrl } : {}),
+    }];
+  });
+  return {
+    attachments,
+    preview: buildSessionQueuedInputPreview(input),
+  };
 }
 
 export function buildSessionQueuedInputComposerSnapshot(

package/src/features/chat/features/message/utils/chat-message-texts.utils.ts

@@ -160,6 +160,7 @@ export function buildChatMessageTexts(
     previewZoomOutLabel: t("chatPreviewZoomOut"),
     previewResetZoomLabel: t("chatPreviewResetZoom"),
     typingLabel: t("chatTyping"),
+    pendingInputLabel: t("chatSteeringPending"),
     reasoningCharacterCountTemplates: {
       inProgress: t("chatReasoningInProgressCharacterCount"),
       completed: t("chatReasoningCompletedCharacterCount"),

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

@@ -329,6 +329,108 @@ describe("useHydratedNcpAgent", () => {
 });
 
 describe("useHydratedNcpAgent stream reconciliation", () => {
+  it("keeps the rendered message snapshot stable when reconciliation data is unchanged", async () => {
+    let resolveReconcile: ((seed: { messages: readonly NcpMessage[]; status: "idle" }) => void) | null = null;
+    const reconcileSeed = new Promise<{ messages: readonly NcpMessage[]; status: "idle" }>((resolve) => {
+      resolveReconcile = resolve;
+    });
+    const client = {
+      stop: mocks.stop.mockResolvedValue(undefined),
+      stream: mocks.stream.mockImplementation((_payload, observer) => {
+        observer?.onOpen?.();
+        return new Promise<void>(() => {});
+      }),
+      subscribe: vi.fn(() => () => {}),
+    } as unknown as NcpAgentClientEndpoint;
+    const historyMessage: NcpMessage = {
+      id: "message-stable",
+      sessionId: "session-stable",
+      role: "assistant",
+      status: "final",
+      parts: [{ type: "text", text: "Already rendered" }],
+      timestamp: "2026-08-20T00:00:00.000Z",
+    };
+    const loadSeed = vi
+      .fn()
+      .mockResolvedValueOnce({ messages: [historyMessage], status: "idle" })
+      .mockImplementationOnce(() => reconcileSeed);
+    const { result } = renderHook(() =>
+      useHydratedNcpAgent({
+        sessionId: "session-stable",
+        client,
+        loadSeed,
+      }),
+    );
+
+    await waitFor(() => expect(loadSeed).toHaveBeenCalledTimes(2));
+    await waitFor(() => expect(result.current.visibleMessages).toEqual([historyMessage]));
+    const renderedMessages = result.current.visibleMessages;
+
+    await act(async () => {
+      resolveReconcile?.({ messages: [{ ...historyMessage }], status: "idle" });
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+
+    expect(result.current.visibleMessages).toBe(renderedMessages);
+  });
+
+  it("rehydrates when reconciliation changes the content of an existing message", async () => {
+    let resolveReconcile: ((seed: { messages: readonly NcpMessage[]; status: "idle" }) => void) | null = null;
+    const reconcileSeed = new Promise<{ messages: readonly NcpMessage[]; status: "idle" }>((resolve) => {
+      resolveReconcile = resolve;
+    });
+    const client = {
+      stop: mocks.stop.mockResolvedValue(undefined),
+      stream: mocks.stream.mockImplementation((_payload, observer) => {
+        observer?.onOpen?.();
+        return new Promise<void>(() => {});
+      }),
+      subscribe: vi.fn(() => () => {}),
+    } as unknown as NcpAgentClientEndpoint;
+    const historyMessage: NcpMessage = {
+      id: "message-changed",
+      sessionId: "session-changed",
+      role: "assistant",
+      status: "final",
+      parts: [{ type: "text", text: "Before reconciliation" }],
+      timestamp: "2026-08-20T00:00:00.000Z",
+    };
+    const loadSeed = vi
+      .fn()
+      .mockResolvedValueOnce({ messages: [historyMessage], status: "idle" })
+      .mockImplementationOnce(() => reconcileSeed);
+    const { result } = renderHook(() =>
+      useHydratedNcpAgent({
+        sessionId: "session-changed",
+        client,
+        loadSeed,
+      }),
+    );
+
+    await waitFor(() => expect(loadSeed).toHaveBeenCalledTimes(2));
+    await waitFor(() => expect(result.current.visibleMessages).toEqual([historyMessage]));
+    const renderedMessages = result.current.visibleMessages;
+
+    await act(async () => {
+      resolveReconcile?.({
+        messages: [{
+          ...historyMessage,
+          parts: [{ type: "text", text: "After reconciliation" }],
+        }],
+        status: "idle",
+      });
+      await Promise.resolve();
+    });
+
+    await waitFor(() => {
+      expect(result.current.visibleMessages).not.toBe(renderedMessages);
+      expect(result.current.visibleMessages[0]?.parts).toEqual([
+        { type: "text", text: "After reconciliation" },
+      ]);
+    });
+  });
+
   it("reconciles history after the stream opens without overwriting newer live completion", async () => {
     let subscriber: NcpEndpointSubscriber | null = null;
     let resolveReconcile: ((seed: { messages: readonly NcpMessage[]; status: "running" }) => void) | null = null;

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

@@ -102,6 +102,7 @@ function resetConversationMocks(): void {
   mocks.runtimeAvailability.phase = "cold-starting";
   mocks.runtimeAvailability.lastReadyAt = null;
   mocks.visibleMessages.length = 0;
+  delete window.__NEXTCLAW_INITIAL_SESSION_MESSAGES_PREFETCH__;
 }
 
 describe("useNcpSessionConversation", () => {
@@ -138,6 +139,7 @@ describe("useNcpSessionConversation", () => {
     expect(mocks.fetchNcpSessionMessages).toHaveBeenCalledWith("session-1", {
       limit: 300,
       toolPayload: "summary",
+      initialPayload: "compact",
       signal: expect.any(AbortSignal),
     });
     expect(result).toEqual({
@@ -162,6 +164,79 @@ describe("useNcpSessionConversation", () => {
     });
   });
 
+  it("consumes a matching HTML history prefetch without repeating the compact request", async () => {
+    window.__NEXTCLAW_INITIAL_SESSION_MESSAGES_PREFETCH__ = {
+      consumed: false,
+      limit: 20,
+      sessionId: "session-1",
+      promise: Promise.resolve({
+        responseOk: true,
+        payload: {
+          ok: true,
+          data: {
+            sessionId: "session-1",
+            status: "idle",
+            total: 1,
+            pageInfo: { startCursor: "cursor-1", hasPreviousPage: false },
+            messages: [{ id: "message-1" }],
+          },
+        },
+      }),
+    };
+
+    await expect(fetchNcpSessionConversationSeed(
+      "session-1",
+      new AbortController().signal,
+      20,
+    )).resolves.toMatchObject({
+      messages: [{ id: "message-1" }],
+      total: 1,
+    });
+
+    expect(mocks.fetchNcpSessionMessages).not.toHaveBeenCalled();
+    expect(window.__NEXTCLAW_INITIAL_SESSION_MESSAGES_PREFETCH__?.consumed).toBe(true);
+  });
+
+  it("falls back to the canonical request when the HTML history prefetch is invalid", async () => {
+    window.__NEXTCLAW_INITIAL_SESSION_MESSAGES_PREFETCH__ = {
+      consumed: false,
+      limit: 20,
+      sessionId: "session-1",
+      promise: Promise.resolve({ responseOk: true, payload: { ok: true } }),
+    };
+    mocks.fetchNcpSessionMessages.mockResolvedValue({
+      sessionId: "session-1",
+      status: "idle",
+      total: 1,
+      pageInfo: { startCursor: "cursor-1", hasPreviousPage: false },
+      messages: [{ id: "message-1" }],
+    });
+
+    await fetchNcpSessionConversationSeed(
+      "session-1",
+      new AbortController().signal,
+      20,
+    );
+
+    expect(mocks.fetchNcpSessionMessages).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not revive an aborted session through the history prefetch fallback", async () => {
+    window.__NEXTCLAW_INITIAL_SESSION_MESSAGES_PREFETCH__ = {
+      consumed: false,
+      limit: 20,
+      sessionId: "session-1",
+      promise: new Promise(() => undefined),
+    };
+    const controller = new AbortController();
+    const seed = fetchNcpSessionConversationSeed("session-1", controller.signal, 20);
+
+    controller.abort();
+
+    await expect(seed).rejects.toMatchObject({ name: "AbortError" });
+    expect(mocks.fetchNcpSessionMessages).not.toHaveBeenCalled();
+  });
+
   it("treats a missing session as an empty idle draft seed", async () => {
     mocks.fetchNcpSessionMessages.mockRejectedValue(
       new Error("ncp session not found: draft-session"),
@@ -437,7 +512,7 @@ describe("useNcpSessionConversation history and hydration", () => {
     expect(mocks.fetchNcpSessionMessages).toHaveBeenLastCalledWith(
       "session-1",
       {
-        limit: 40,
+        limit: 20,
         cursor: "cursor-2",
         toolPayload: "summary",
         signal: expect.any(AbortSignal),
@@ -455,6 +530,47 @@ describe("useNcpSessionConversation history and hydration", () => {
     expect(result.current.messageTotal).toBe(5);
   });
 
+  it("uses the compact payload only for the first seed and restores the full recent window during reconciliation", async () => {
+    mocks.fetchNcpSessionMessages
+      .mockResolvedValueOnce({
+        sessionId: "session-1",
+        status: "idle",
+        total: 20,
+        pageInfo: { startCursor: "cursor-16", hasPreviousPage: true },
+        messages: Array.from({ length: 5 }, (_, index) => ({ id: `message-${index + 16}` })),
+      })
+      .mockResolvedValueOnce({
+        sessionId: "session-1",
+        status: "idle",
+        total: 20,
+        pageInfo: { startCursor: "cursor-1", hasPreviousPage: false },
+        messages: Array.from({ length: 20 }, (_, index) => ({ id: `message-${index + 1}` })),
+      });
+    renderHook(() => useNcpSessionConversation("session-1"));
+    const loadSeed = mocks.hydratedCalls[0]?.loadSeed as (
+      sessionId: string,
+      signal: AbortSignal,
+    ) => Promise<{ messages: unknown[]; status: string }>;
+
+    await act(async () => {
+      await loadSeed("session-1", new AbortController().signal);
+      await loadSeed("session-1", new AbortController().signal);
+    });
+
+    expect(mocks.fetchNcpSessionMessages).toHaveBeenNthCalledWith(1, "session-1", {
+      limit: 20,
+      toolPayload: "summary",
+      initialPayload: "compact",
+      signal: expect.any(AbortSignal),
+    });
+    expect(mocks.fetchNcpSessionMessages).toHaveBeenNthCalledWith(2, "session-1", {
+      limit: 20,
+      toolPayload: "summary",
+      initialPayload: undefined,
+      signal: expect.any(AbortSignal),
+    });
+  });
+
   it("loads and caches one complete message when deferred tool details are requested", async () => {
     const summaryMessage: NcpMessage = {
       id: "assistant-large",

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

@@ -12,9 +12,9 @@ import type {
 import { API_BASE } from "@/shared/lib/api";
 import { createNcpAppClientFetch } from "@/features/chat/features/runtime/utils/ncp-app-client-fetch.utils";
 import {
-  DEFAULT_NCP_SESSION_MESSAGE_LIMIT,
   useNcpSessionMessageHistory,
 } from "@/features/chat/features/ncp/hooks/use-ncp-session-message-history";
+import { DEFAULT_NCP_SESSION_MESSAGE_LIMIT } from "@/features/chat/features/ncp/hooks/use-ncp-session-seed-loader";
 import { useSystemStatus } from "@/features/system-status";
 import { nextclawClient } from "@/shared/lib/api";
 
@@ -23,7 +23,7 @@ const NCP_AGENT_UNAVAILABLE_DURING_STARTUP =
 const NCP_AGENT_STREAM_OPEN_TIMEOUT_MS = 15_000;
 const NCP_AGENT_STREAM_IDLE_TIMEOUT_MS = 70_000;
 
-export { fetchNcpSessionConversationSeed } from "@/features/chat/features/ncp/hooks/use-ncp-session-message-history";
+export { fetchNcpSessionConversationSeed } from "@/features/chat/features/ncp/hooks/use-ncp-session-seed-loader";
 
 type UseNcpSessionConversationOptions = {
   messageLimit?: number;