@nextclaw/ui 0.15.22 → 0.15.23

package/src/features/chat/features/conversation/components/session-conversation-input.tsx

@@ -21,17 +21,12 @@ import {
   useChatInputSurfaceState,
 } from '@/features/chat/features/input/hooks/use-chat-input-surface-state';
 import { useChatModelFavorites } from '@/features/chat/features/input/hooks/use-chat-model-favorites';
-import {
-  deriveChatComposerDraft,
-  deriveSelectedSkillsFromComposer,
-  pruneComposerAttachments,
-  syncComposerSkills,
-} from '@/features/chat/features/input/utils/chat-composer-state.utils';
+import { syncComposerSkills } from '@/features/chat/features/input/utils/chat-composer-state.utils';
 import {
   buildModelStateHint,
-  type ChatModelRecord,
   type ChatSkillRecord,
   type ChatThinkingLevel,
+  toChatModelRecords,
 } from '@/features/chat/features/input/utils/chat-input-bar.utils';
 import {
   hasNcpChatModelOptions,
@@ -49,6 +44,8 @@ import {
 } from '@/features/chat/managers/chat-recent-skills.manager';
 
 import { useSessionConversationInputAttachments } from '@/features/chat/features/conversation/hooks/use-session-conversation-input-attachments';
+import { useChatComposerReferenceIntent } from '@/features/chat/features/conversation/hooks/use-chat-composer-reference-intent';
+import { useSessionConversationComposerNodes } from '@/features/chat/features/conversation/hooks/use-session-conversation-composer-nodes';
 import { useSessionConversationSlashCommands } from '@/features/chat/features/conversation/hooks/use-session-conversation-slash-commands';
 import { ChatConversationTrack } from '@/features/chat/components/conversation/chat-conversation-track';
 import { useChatMessageLayoutStore } from '@/features/chat/stores/chat-message-layout.store';
@@ -66,6 +63,7 @@ import {
   resolveThinkingForConversationModel,
 } from '@/features/chat/features/conversation/utils/session-conversation-input-toolbar.utils';
 import { SessionQueuedInputRows } from './session-queued-input-rows';
+import { toast } from 'sonner';
 
 type SessionConversationInputQuery = ReturnType<typeof useSessionConversationInputQuery>;
 type SkillSource = SessionSkillEntryView['source'];
@@ -76,6 +74,7 @@ export type SessionConversationInputController = {
   readonly editQueuedInput: (id: string) => void;
   readonly isSending: boolean;
   readonly queuedInputs: readonly SessionConversationQueuedInput[];
+  readonly primaryAction: 'continue' | 'send';
   readonly sendDisabled: boolean;
   readonly stopDisabled: boolean;
   readonly send: () => Promise<void> | void;
@@ -99,20 +98,6 @@ function toSkillRecords(
   }));
 }
 
-function toModelRecords(snapshotModels: SessionConversationInputQuery['modelOptions']): ChatModelRecord[] {
-  return snapshotModels.map((model) => ({
-    value: model.value,
-    modelLabel: model.modelLabel,
-    providerLabel: model.providerLabel,
-    thinkingCapability: model.thinkingCapability
-      ? {
-          supported: model.thinkingCapability.supported as ChatThinkingLevel[],
-          default: (model.thinkingCapability.default as ChatThinkingLevel | null | undefined) ?? null,
-        }
-      : null,
-  }));
-}
-
 function useSessionConversationInputLabels(language: string) {
   const { skillGroupLabels, skillScopeLabels } = useMemo(() => {
     void language;
@@ -167,7 +152,7 @@ function useSessionConversationInputCollections(params: {
     () => toSkillRecords(sourceSkillRecords, skillScopeLabels, skillGroupLabels),
     [skillGroupLabels, skillScopeLabels, sourceSkillRecords],
   );
-  const modelRecords = useMemo(() => toModelRecords(modelOptions), [modelOptions]);
+  const modelRecords = useMemo(() => toChatModelRecords(modelOptions), [modelOptions]);
   return {
     skillRecords,
     modelRecords,
@@ -227,6 +212,10 @@ export const SessionConversationInput = memo(function SessionConversationInput(p
     skillGroupLabels: labels.skillGroupLabels,
     skillScopeLabels: labels.skillScopeLabels,
   });
+  const discoveredModelRecords = useMemo(
+    () => toChatModelRecords(inputQuery.discoveredModelOptions),
+    [inputQuery.discoveredModelOptions],
+  );
   const slashCommands = useSessionConversationSlashCommands({
     language,
     onContextCompactingChange,
@@ -296,19 +285,18 @@ export const SessionConversationInput = memo(function SessionConversationInput(p
     }
     void updateNcpSession(inputQuery.selectedSessionKey, patch).catch(() => undefined);
   }, [inputQuery.selectedSession, inputQuery.selectedSessionKey]);
-  const handleNodesChange = useCallback((nodes: SessionConversationInputSnapshot['nodes']) => {
-    const nextNodes = [...nodes];
-    inputActions.update((current) => ({
-      nodes: nextNodes,
-      attachments: pruneComposerAttachments(nextNodes, current.attachments),
-      text: deriveChatComposerDraft(nextNodes),
-      selectedSkills: deriveSelectedSkillsFromComposer(nextNodes),
-      sendError: null,
-    }));
-  }, [inputActions]);
+  const handleNodesChange = useSessionConversationComposerNodes(inputActions);
+
+  useChatComposerReferenceIntent({
+    inputBarRef,
+    intentManager: presenter.chatComposerIntentManager,
+    selectedSessionKey: inputQuery.selectedSessionKey,
+  });
+
   const handleModelChange = useCallback((value: string) => {
     const nextThinkingLevel = resolveThinkingForConversationModel(
-      modelRecords.find((option) => option.value === value),
+      modelRecords.find((option) => option.value === value) ??
+        discoveredModelRecords.find((option) => option.value === value),
       selectedThinkingLevel,
     );
     inputActions.update({
@@ -328,11 +316,22 @@ export const SessionConversationInput = memo(function SessionConversationInput(p
     });
   }, [
     inputActions,
+    discoveredModelRecords,
     inputQuery.sessionTypeState.selectedSessionType,
     modelRecords,
     selectedThinkingLevel,
     syncSessionPreferences,
   ]);
+  const handleDiscoveredModelSelect = useCallback(async (value: string) => {
+    const option = await inputQuery.addDiscoveredModel(value);
+    if (!option) {
+      toast.error(t('chatDiscoveredModelUnavailable'));
+      throw new Error('Discovered provider model is no longer available.');
+    }
+    toast.success(t('chatDiscoveredModelAdded').replace('{model}', option.modelLabel));
+  }, [
+    inputQuery,
+  ]);
   const handleThinkingChange = useCallback((value: ChatThinkingLevel | null) => {
     inputActions.setSelectedThinkingLevel(value);
     syncSessionPreferences({ preferredThinking: value });
@@ -372,10 +371,16 @@ export const SessionConversationInput = memo(function SessionConversationInput(p
     favoriteModelsLabel: labels.favoriteModelsLabel,
     hasModelOptions,
     isModelOptionsLoading,
+    discoveredModelRecords,
     modelRecords,
     modelSearchEmptyLabel: labels.modelSearchEmptyLabel,
     modelSearchPlaceholder: labels.modelSearchPlaceholder,
     onFavoriteModelToggle: setModelFavorite,
+    onDiscoveredModelSelect: handleDiscoveredModelSelect,
+    onDiscoveredModelsDismiss: inputQuery.dismissDiscoveredModels,
+    onModelSelectOpen: () => {
+      void inputQuery.refreshProviderModelCatalog();
+    },
     onModelChange: handleModelChange,
     onThinkingChange: handleThinkingChange,
     recentModelValues,
@@ -403,14 +408,14 @@ export const SessionConversationInput = memo(function SessionConversationInput(p
     <ChatInputBar
       ref={inputBarRef}
       surface={useReadingTrack ? 'embedded' : surface}
-      sendError={inputSnapshot.sendError}
-      sendErrorDetailsLabel={t('chatErrorDetails', language)}
       topSlot={controller.queuedInputs.length > 0
         ? <SessionQueuedInputRows controller={controller} />
         : null}
       composer={{
         nodes: composerNodes,
         placeholder: textareaPlaceholder,
+        excerptCharacterCountTemplate: t('chatWorkspaceExcerptCharacterCount'),
+        removeTokenLabel: t('chatInputRemoveReference'),
         disabled: inputDisabled,
         onNodesChange: handleNodesChange,
         onFilesAdd: handleFilesAdd,
@@ -419,7 +424,6 @@ export const SessionConversationInput = memo(function SessionConversationInput(p
       }}
       inputSurface={inputSurfaceState.panel ?? undefined}
       hint={buildModelStateHint({
-        isModelOptionsLoading,
         isModelOptionsEmpty,
         onGoToProviders: presenter.chatUiManager.goToProviders,
         texts: {
@@ -447,7 +451,12 @@ export const SessionConversationInput = memo(function SessionConversationInput(p
           sendDisabled: controller.sendDisabled,
           stopDisabled: controller.stopDisabled,
           stopHint: t('chatStopUnavailable'),
-          sendButtonLabel: controller.isSending ? t('chatQueueSend') : t('chatSend'),
+          sendButtonLabel: controller.primaryAction === 'continue'
+            ? t('chatContinueRun')
+            : controller.isSending
+              ? t('chatQueueSend')
+              : t('chatSend'),
+          sendIcon: controller.primaryAction,
           stopButtonLabel: t('chatStop'),
           contextWindow,
           onSend: controller.send,

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

@@ -1,7 +1,7 @@
 import { act, renderHook, waitFor } from '@testing-library/react';
 import { describe, expect, it, vi } from 'vitest';
 import type { UiNcpSessionQueuedInputView } from '@nextclaw/client-sdk';
-import type { NcpAgentSendEnvelope, NcpRunHandle } from '@nextclaw/ncp';
+import type { NcpAgentSendEnvelope, NcpMessage, NcpRunHandle } from '@nextclaw/ncp';
 
 import { useSessionConversationController } from '@/features/chat/features/conversation/hooks/use-session-conversation-controller';
 
@@ -54,12 +54,16 @@ function createControllerParams(params: {
 }) {
   const { isRunning, queuedInputs = [], send: requestedSend } = params;
   const send = requestedSend ?? createSendMock();
+  const continueRun = vi.fn(async () => createRunHandle());
+  const editMessage = vi.fn(async () => createRunHandle({ sessionId: 'edited-session' }));
   const removeQueuedInput = vi.fn(async (id: string) =>
     queuedInputs.find((item) => item.id === id) ?? null,
   );
   return {
     agent: {
       abort: vi.fn(),
+      continueRun,
+      editMessage,
       isHydrating: false,
       isRunning,
       isSending: false,
@@ -70,13 +74,18 @@ function createControllerParams(params: {
       visibleMessages: [],
     },
     inputQuery: {
+      addDiscoveredModel: vi.fn(async () => null),
       defaultModel: 'test-model',
       defaultProjectRoot: null,
+      dismissDiscoveredModels: vi.fn(),
+      discoveredModelOptions: [],
       fallbackPreferredModel: undefined,
       fallbackPreferredThinking: undefined,
       isProviderStateResolved: true,
       isSkillsLoading: false,
       modelOptions: [],
+      providersView: null,
+      refreshProviderModelCatalog: vi.fn(),
       selectedSession: null,
       selectedSessionKey: 'session-1',
       sessionTypeState: {
@@ -113,11 +122,43 @@ function createControllerParams(params: {
     sessionKey: 'session-1',
     resetComposer: vi.fn(),
     restoreComposer: vi.fn(),
+    onSessionMaterialized: vi.fn(),
     setSendError: vi.fn(),
   };
 }
 
 describe('useSessionConversationController backend run queue', () => {
+  it('preallocates one stable session identity for the first root message', async () => {
+    const send = vi.fn<TestAgentSend>(async (envelope) => {
+      if (!envelope.sessionId) {
+        throw new Error('Expected a preallocated session id.');
+      }
+      return createRunHandle({
+        sessionId: envelope.sessionId,
+        userMessageId: envelope.message.id,
+      });
+    });
+    const params = createControllerParams({ isRunning: false, send });
+    const draftParams = {
+      ...params,
+      inputQuery: {
+        ...params.inputQuery,
+        selectedSessionKey: null,
+      },
+      sessionKey: null,
+    } as unknown as Parameters<typeof useSessionConversationController>[0];
+    const { result } = renderHook(() => useSessionConversationController(draftParams));
+
+    await act(async () => {
+      await result.current.send();
+    });
+
+    const envelope = send.mock.calls[0]?.[0];
+    expect(envelope?.sessionId).toMatch(/^ncp-/);
+    expect(envelope?.message.sessionId).toBe(envelope?.sessionId);
+    expect(params.onSessionMaterialized).toHaveBeenCalledWith(envelope?.sessionId);
+  });
+
   it('submits immediately while the session is running so the backend can enqueue it', async () => {
     const send = createSendMock(createRunHandle({ runId: null }));
     const params = createControllerParams({ isRunning: true, send });
@@ -137,6 +178,29 @@ describe('useSessionConversationController backend run queue', () => {
     expect(params.resetComposer).toHaveBeenCalledTimes(1);
   });
 
+  it('keeps an existing session bound to its agent instead of the global draft selection', async () => {
+    const send = createSendMock();
+    const params = createControllerParams({ isRunning: false, send });
+    const controllerParams = {
+      ...params,
+      inputQuery: {
+        ...params.inputQuery,
+        selectedSession: { agentId: 'researcher' },
+      },
+      selectedAgentId: 'main',
+    } as unknown as Parameters<typeof useSessionConversationController>[0];
+    const { result } = renderHook(() => useSessionConversationController(controllerParams));
+
+    await act(async () => {
+      await result.current.send();
+    });
+
+    expect(send.mock.calls[0]?.[0].message.metadata).toMatchObject({
+      agentId: 'researcher',
+      agent_id: 'researcher',
+    });
+  });
+
   it('projects the backend queue and returns a removed item to the composer for editing', async () => {
     const queuedInput = createQueuedInput();
     const params = createControllerParams({ isRunning: true, queuedInputs: [queuedInput] });
@@ -170,4 +234,67 @@ describe('useSessionConversationController backend run queue', () => {
     await waitFor(() => expect(params.runQueue.removeQueuedInput).toHaveBeenCalledWith(queuedInput.id));
     expect(params.restoreComposer).not.toHaveBeenCalled();
   });
+
+  it('continues a cancelled session from the primary action when the composer is empty', async () => {
+    const params = createControllerParams({ isRunning: false });
+    params.inputSnapshot.nodes = [];
+    params.inputSnapshot.text = '';
+    const controllerParams = {
+      ...params,
+      inputQuery: {
+        ...params.inputQuery,
+        selectedSession: { activityPreview: { state: 'cancelled' } },
+      },
+    } as unknown as Parameters<typeof useSessionConversationController>[0];
+    const { result } = renderHook(() => useSessionConversationController(controllerParams));
+
+    expect(result.current.primaryAction).toBe('continue');
+    expect(result.current.canContinue).toBe(true);
+    await act(async () => {
+      await result.current.send();
+    });
+
+    expect(params.agent.continueRun).toHaveBeenCalledWith({ sessionId: 'session-1' });
+    expect(params.agent.send).not.toHaveBeenCalled();
+    expect(params.resetComposer).not.toHaveBeenCalled();
+  });
+
+  it('keeps continuation available but restores send as primary when the user types', () => {
+    const params = createControllerParams({ isRunning: false });
+    const controllerParams = {
+      ...params,
+      inputQuery: {
+        ...params.inputQuery,
+        selectedSession: { activityPreview: { state: 'failed' } },
+      },
+    } as unknown as Parameters<typeof useSessionConversationController>[0];
+    const { result } = renderHook(() => useSessionConversationController(controllerParams));
+
+    expect(result.current.canContinue).toBe(true);
+    expect(result.current.primaryAction).toBe('send');
+  });
+
+  it('edits inside the current session without materializing or navigating to another session', async () => {
+    const params = createControllerParams({ isRunning: false });
+    const message = {
+      id: 'edited-user-message',
+      sessionId: 'session-1',
+      role: 'user',
+      status: 'final',
+      timestamp: '2026-08-08T10:00:00.000Z',
+      parts: [{ type: 'text', text: 'updated request' }],
+    } satisfies NcpMessage;
+    const { result } = renderHook(() => useSessionConversationController(params));
+
+    await act(async () => {
+      await result.current.editMessage({ messageId: 'user-message-1', message });
+    });
+
+    expect(params.agent.editMessage).toHaveBeenCalledWith({
+      message,
+      messageId: 'user-message-1',
+      sessionId: 'session-1',
+    });
+    expect(params.onSessionMaterialized).not.toHaveBeenCalled();
+  });
 });

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

@@ -1,7 +1,9 @@
 import { act, renderHook } from '@testing-library/react';
-import { describe, expect, it } from 'vitest';
+import { beforeEach, describe, expect, it } from 'vitest';
 
 import { useSessionConversationInputState } from '@/features/chat/features/conversation/hooks/use-session-conversation-input-state';
+import { useChatComposerDraftStore } from '@/features/chat/stores/chat-composer-draft.store';
+import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
 import type { ChatModelOption } from '@/features/chat/types/chat-input.types';
 
 const MODEL_OPTIONS: ChatModelOption[] = [
@@ -20,6 +22,12 @@ const MODEL_OPTIONS: ChatModelOption[] = [
 ];
 
 describe('useSessionConversationInputState session preferences', () => {
+  beforeEach(() => {
+    window.localStorage.clear();
+    useChatComposerDraftStore.setState({ drafts: {} });
+    useChatThreadStore.getState().setSnapshot({ draftProjectRoot: null });
+  });
+
   it('owns the initial routed prompt before the composer first renders', () => {
     const { result } = renderHook(() => useSessionConversationInputState('  每天整理项目风险  '));
 
@@ -101,4 +109,62 @@ describe('useSessionConversationInputState session preferences', () => {
     });
     expect(result.current.inputSnapshot.selectedModel).toBe('deepseek/deepseek-v4-flash');
   });
+
+  it('shares the selected draft project with the thread workspace owner', () => {
+    const { result } = renderHook(() => useSessionConversationInputState());
+
+    act(() => {
+      result.current.inputActions.setPendingProjectRoot('/tmp/project-alpha');
+    });
+
+    expect(result.current.inputSnapshot.pendingProjectRoot).toBe('/tmp/project-alpha');
+    expect(useChatThreadStore.getState().snapshot.draftProjectRoot).toBe('/tmp/project-alpha');
+  });
+
+  it('keeps composer drafts isolated by session and restores them when switching back', () => {
+    const { result, rerender } = renderHook(
+      ({ sessionKey }: { sessionKey: string | null }) =>
+        useSessionConversationInputState(null, sessionKey),
+      { initialProps: { sessionKey: 'session-a' as string | null } },
+    );
+
+    act(() => {
+      result.current.inputActions.syncComposer({
+        text: '会话 A 草稿',
+        nodes: [],
+        selectedSkills: [],
+        skillRecords: [],
+      });
+    });
+    rerender({ sessionKey: 'session-b' });
+    expect(result.current.inputSnapshot.text).toBe('');
+
+    act(() => {
+      result.current.inputActions.syncComposer({
+        text: '会话 B 草稿',
+        nodes: [],
+        selectedSkills: [],
+        skillRecords: [],
+      });
+    });
+    rerender({ sessionKey: null });
+    expect(result.current.inputSnapshot.text).toBe('');
+
+    act(() => {
+      result.current.inputActions.syncComposer({
+        text: '新会话草稿',
+        nodes: [],
+        selectedSkills: [],
+        skillRecords: [],
+      });
+    });
+    rerender({ sessionKey: 'session-a' });
+    expect(result.current.inputSnapshot.text).toBe('会话 A 草稿');
+
+    rerender({ sessionKey: 'session-b' });
+    expect(result.current.inputSnapshot.text).toBe('会话 B 草稿');
+
+    rerender({ sessionKey: null });
+    expect(result.current.inputSnapshot.text).toBe('新会话草稿');
+  });
 });

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

@@ -39,6 +39,10 @@ describe('useSessionConversationSlashCommands', () => {
     }));
     const command = result.current.find((entry) => entry.key === 'compact-context');
 
+    expect(result.current.map(({ key, icon }) => ({ key, icon }))).toEqual([
+      { key: 'side-chat', icon: 'message-square-plus' },
+      { key: 'compact-context', icon: 'list-collapse' },
+    ]);
     act(() => command?.onSelect());
 
     await waitFor(() => expect(compactNcpSessionContext).toHaveBeenCalledWith('session-1'));

package/src/features/chat/features/conversation/hooks/__tests__/use-session-provider-model-catalog.test.tsx

@@ -0,0 +1,109 @@
+import { act, renderHook } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { useSessionProviderModelCatalog } from '@/features/chat/features/conversation/hooks/use-session-provider-model-catalog';
+
+const mocks = vi.hoisted(() => ({
+  refetch: vi.fn(),
+  updateProvider: vi.fn(),
+}));
+
+vi.mock('@/shared/hooks/use-config', () => ({
+  useProviderModelCatalog: () => ({
+    data: {
+      refreshIntervalMs: 43_200_000,
+      refreshing: false,
+      lastRefreshStartedAt: '2026-08-07T00:00:00.000Z',
+      lastRefreshCompletedAt: '2026-08-07T00:00:01.000Z',
+      providers: {
+        opencode: {
+          providerId: 'opencode',
+          models: ['big-pickle', 'deepseek-v4-flash-free'],
+          source: 'catalog',
+          fetchedAt: '2026-08-07T00:00:00.500Z',
+          lastError: null,
+        },
+      },
+    },
+    refetch: mocks.refetch,
+  }),
+  useUpdateProvider: () => ({ mutateAsync: mocks.updateProvider }),
+}));
+
+const providersView = {
+  providers: {
+    opencode: {
+      providerId: 'opencode',
+      providerType: 'opencode',
+      isBuiltInType: true,
+      isCustom: false,
+      enabled: true,
+      displayName: 'OpenCode Zen Free Trial',
+      apiKeyRequired: false,
+      apiKeySet: false,
+      models: ['big-pickle'],
+    },
+  },
+};
+
+const templatesView = {
+  providerTemplates: [{
+    id: 'opencode',
+    providerType: 'opencode',
+    displayName: 'OpenCode Zen Free Trial',
+    modelPrefix: 'opencode',
+    keywords: [],
+    envKey: 'OPENCODE_API_KEY',
+    apiKeyRequired: false,
+  }],
+};
+
+describe('useSessionProviderModelCatalog', () => {
+  beforeEach(() => {
+    window.localStorage.clear();
+    mocks.refetch.mockReset();
+    mocks.updateProvider.mockReset().mockResolvedValue(providersView.providers.opencode);
+  });
+
+  it('adds exactly the selected discovered model through the existing provider update path', async () => {
+    const { result } = renderHook(() => useSessionProviderModelCatalog({
+      config: null,
+      providersView,
+      templatesView,
+      modelSelectionMode: 'nextclaw',
+    }));
+
+    expect(result.current.discoveredModelOptions.map((option) => option.value)).toEqual([
+      'opencode/deepseek-v4-flash-free',
+    ]);
+    let addedModel: Awaited<ReturnType<typeof result.current.addDiscoveredModel>> = null;
+    await act(async () => {
+      addedModel = await result.current.addDiscoveredModel('opencode/deepseek-v4-flash-free');
+    });
+
+    expect(mocks.updateProvider).toHaveBeenCalledWith({
+      provider: 'opencode',
+      data: { models: ['big-pickle', 'deepseek-v4-flash-free'] },
+      silentSuccess: true,
+    });
+    expect(addedModel).toMatchObject({
+      value: 'opencode/deepseek-v4-flash-free',
+      providerId: 'opencode',
+      providerModel: 'deepseek-v4-flash-free',
+    });
+    expect(result.current.refreshProviderModelCatalog).toBe(mocks.refetch);
+  });
+
+  it('lets the user mark the current discovery batch as seen without adding it', () => {
+    const { result } = renderHook(() => useSessionProviderModelCatalog({
+      config: null,
+      providersView,
+      templatesView,
+      modelSelectionMode: 'nextclaw',
+    }));
+
+    expect(result.current.discoveredModelOptions).toHaveLength(1);
+    act(() => result.current.dismissDiscoveredModels());
+    expect(result.current.discoveredModelOptions).toEqual([]);
+    expect(mocks.updateProvider).not.toHaveBeenCalled();
+  });
+});

package/src/features/chat/features/conversation/hooks/use-chat-composer-reference-intent.ts

@@ -0,0 +1,46 @@
+import { useEffect, type RefObject } from 'react';
+import { type ChatInputBarHandle } from '@nextclaw/agent-chat-ui';
+import { CHAT_WORKSPACE_EXCERPT_TOKEN_KIND } from '@nextclaw/shared';
+
+import type {
+  ChatComposerIntentManager,
+  ChatComposerReferenceIntent,
+} from '@/features/chat/managers/chat-composer-intent.manager';
+
+export function useChatComposerReferenceIntent(params: {
+  inputBarRef: RefObject<ChatInputBarHandle | null>;
+  intentManager: ChatComposerIntentManager;
+  selectedSessionKey: string | null | undefined;
+}): void {
+  const { inputBarRef, intentManager, selectedSessionKey } = params;
+
+  useEffect(() => {
+    const targetSessionKey = selectedSessionKey?.trim() || null;
+    const applyIntent = (intent: ChatComposerReferenceIntent) => {
+      const inputBar = inputBarRef.current;
+      if (!inputBar) {
+        return;
+      }
+      inputBar.insertToken({
+        tokenKind: intent.kind,
+        tokenKey: intent.tokenKey,
+        label: intent.label,
+        data: intent.kind === CHAT_WORKSPACE_EXCERPT_TOKEN_KIND
+          ? {
+              path: intent.path,
+              excerpt: intent.excerpt,
+              startLine: intent.startLine,
+              endLine: intent.endLine,
+            }
+          : undefined,
+      });
+      intentManager.markConsumed(intent.id);
+    };
+    const unsubscribe = intentManager.subscribe(targetSessionKey, applyIntent);
+    const pendingIntent = intentManager.consumePending(targetSessionKey);
+    if (pendingIntent) {
+      applyIntent(pendingIntent);
+    }
+    return unsubscribe;
+  }, [inputBarRef, intentManager, selectedSessionKey]);
+}

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

@@ -0,0 +1,26 @@
+import { useCallback } from 'react';
+
+import type {
+  SessionConversationInputActions,
+  SessionConversationInputSnapshot,
+} from '@/features/chat/features/conversation/hooks/use-session-conversation-input-state';
+import {
+  deriveChatComposerDraft,
+  deriveSelectedSkillsFromComposer,
+  pruneComposerAttachments,
+} from '@/features/chat/features/input/utils/chat-composer-state.utils';
+
+export function useSessionConversationComposerNodes(
+  inputActions: SessionConversationInputActions,
+) {
+  return useCallback((nodes: SessionConversationInputSnapshot['nodes']) => {
+    const nextNodes = [...nodes];
+    inputActions.update((current) => ({
+      nodes: nextNodes,
+      attachments: pruneComposerAttachments(nextNodes, current.attachments),
+      text: deriveChatComposerDraft(nextNodes),
+      selectedSkills: deriveSelectedSkillsFromComposer(nextNodes),
+      sendError: null,
+    }));
+  }, [inputActions]);
+}