@nextclaw/ui 0.14.1 → 0.14.2

package/src/features/chat/managers/chat-session-list.manager.ts

@@ -1,12 +1,11 @@
 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 { ChatRunManager } from '@/features/chat/managers/chat-run.manager';
 import { normalizeSessionProjectRootValue } from '@/shared/lib/session-project';
 import { updateNcpSession } from '@/shared/lib/api';
 import { CHAT_DRAFT_SESSION_PATH } from '@/features/chat/features/session/utils/chat-session-route.utils';
+import { DEFAULT_SESSION_TYPE, normalizeSessionType } from '@/features/chat/features/session-type/utils/chat-session-type.utils';
 
 type WorkspaceChildReadState = {
   sessionKey: string | null | undefined;
@@ -15,21 +14,13 @@ type WorkspaceChildReadState = {
   runStatus?: string | null;
 };
 export class ChatSessionListManager {
-  constructor(
-    private uiManager: ChatUiManager,
-    private chatRunManager: ChatRunManager
-  ) {}
+  constructor(private uiManager: ChatUiManager) {}
 
-  private syncDraftThreadState = (hasSubmittedDraftMessage = false) => {
+  private syncDraftThreadState = () => {
     useChatThreadStore.getState().setSnapshot({
       sessionKey: null,
       sessionDisplayName: undefined,
       canDeleteSession: false,
-      isHistoryLoading: false,
-      messages: [],
-      isSending: false,
-      isAwaitingAssistantOutput: false,
-      hasSubmittedDraftMessage,
       parentSessionKey: null,
       parentSessionLabel: null,
       workspacePanelParentKey: null,
@@ -107,7 +98,6 @@ export class ChatSessionListManager {
     }
     if (selectedSessionKey !== null) {
       this.setSelectedSessionKey(null);
-      this.chatRunManager.clearRunState();
     }
   };
 
@@ -142,26 +132,21 @@ export class ChatSessionListManager {
   };
 
   createSession = (sessionType?: string, projectRoot?: string | null): void => {
-    const { snapshot } = useChatInputStore.getState();
-    const { defaultSessionType: configuredDefaultSessionType } = snapshot;
-    const defaultSessionType = configuredDefaultSessionType || 'native';
-    const nextSessionType =
-      typeof sessionType === 'string' && sessionType.trim().length > 0
-        ? sessionType.trim()
-        : defaultSessionType;
+    const nextSessionType = normalizeSessionType(sessionType ?? DEFAULT_SESSION_TYPE);
     const normalizedProjectRoot = normalizeSessionProjectRootValue(projectRoot);
-    this.chatRunManager.clearRunState();
     useChatSessionListStore.getState().setSnapshot({
       selectedSessionKey: null,
     });
     this.syncDraftThreadState();
-    useChatInputStore.getState().setSnapshot({
-      pendingSessionType: nextSessionType,
-      selectedSessionType: nextSessionType,
-      pendingProjectRoot: normalizedProjectRoot,
-      pendingProjectRootSessionKey: null
+    this.uiManager.navigateTo(CHAT_DRAFT_SESSION_PATH, {
+      replace: this.uiManager.isAtChatRoot(),
+      state: {
+        chatDraft: {
+          sessionType: nextSessionType,
+          projectRoot: normalizedProjectRoot,
+        },
+      },
     });
-    this.uiManager.navigateTo(CHAT_DRAFT_SESSION_PATH);
   };
 
   startAgentDraftChat = (agentId: string, sessionType: string): void => {
@@ -170,22 +155,6 @@ export class ChatSessionListManager {
     this.setSelectedAgentId(normalizedAgentId);
   };
 
-  ensureDraftSession = (sessionType?: string): string | null => {
-    const { snapshot } = useChatSessionListStore.getState();
-    if (snapshot.selectedSessionKey) {
-      return snapshot.selectedSessionKey;
-    }
-    const normalizedSessionType =
-      typeof sessionType === 'string' && sessionType.trim().length > 0
-        ? sessionType.trim()
-        : null;
-    this.syncDraftThreadState(true);
-    if (normalizedSessionType) {
-      useChatInputStore.getState().setSnapshot({ pendingSessionType: normalizedSessionType });
-    }
-    return null;
-  };
-
   selectSession = (sessionKey: string) => {
     this.uiManager.goToSession(sessionKey);
   };

package/src/features/chat/managers/chat-thread.manager.ts

@@ -10,37 +10,33 @@ import type {
 } from '@nextclaw/agent-chat-ui';
 import type { UiShowContentEventPayload } from '@nextclaw/shared';
 import type { ChatSessionListManager } from '@/features/chat/managers/chat-session-list.manager';
-import type { ChatRunManager } from '@/features/chat/managers/chat-run.manager';
 import type { ChatUiManager } from '@/features/chat/managers/chat-ui.manager';
 import { useChatSessionListStore } from '@/features/chat/stores/chat-session-list.store';
 import type {
+  ChatChildSessionTab,
   ChatThreadSnapshot,
   ChatWorkspaceNavigationEntry,
   ChatWorkspaceFileTab,
 } from '@/features/chat/stores/chat-thread.store';
 import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
 import { t } from '@/shared/lib/i18n';
+import {
+  areWorkspaceNavigationEntriesEqual,
+  createSideChatDraft,
+  materializeSideChatDraftSnapshot,
+  upsertChildSessionTab,
+} from '@/features/chat/features/workspace/utils/chat-thread-workspace-session.utils';
 import {
   filterNavigationHistoryEntries,
   pushNavigationHistoryEntry,
   stepNavigationHistory,
 } from '@/shared/lib/navigation-history';
 
-function areWorkspaceNavigationEntriesEqual(
-  current: ChatWorkspaceNavigationEntry,
-  next: ChatWorkspaceNavigationEntry,
-): boolean {
-  if (current.kind !== next.kind) {
-    return false;
-  }
-  if (current.kind === 'cron') {
-    return true;
-  }
-  return next.kind !== 'cron' && current.key === next.key;
-}
-
 type WorkspaceChildReadState = Parameters<ChatSessionListManager['markVisibleWorkspaceChildRead']>[0];
-export type ChatVisibleWorkspaceSelection = { kind: 'child-session'; tab: WorkspaceChildReadState } | { kind: 'file' | 'cron' } | null;
+export type ChatVisibleWorkspaceSelection =
+  | { kind: 'child-session'; tab: WorkspaceChildReadState }
+  | { kind: 'file' | 'side-chat-draft' | 'cron' }
+  | null;
 
 export class ChatThreadManager {
   private readonly handledUiShowContentEventIds = new Set<string>();
@@ -48,7 +44,6 @@ export class ChatThreadManager {
   constructor(
     private uiManager: ChatUiManager,
     private sessionListManager: ChatSessionListManager,
-    private chatRunManager: ChatRunManager,
   ) {}
 
   private hasSnapshotChanges = (patch: Partial<ChatThreadSnapshot>): boolean => {
@@ -80,16 +75,13 @@ export class ChatThreadManager {
       sessionProjectRoot: null,
       sessionProjectName: null,
       canDeleteSession: false,
-      isHistoryLoading: false,
-      messages: [],
-      isSending: false,
-      isAwaitingAssistantOutput: false,
       parentSessionKey: null,
       parentSessionLabel: null,
       workspacePanelParentKey: null,
       activeWorkspacePanelKind: null,
       childSessionTabs: [],
       activeChildSessionKey: null,
+      activeSideChatDraft: null,
       workspaceFileTabs: [],
       activeWorkspaceFileKey: null,
       workspaceNavigationHistory: [],
@@ -98,6 +90,10 @@ export class ChatThreadManager {
   };
 
   private resolveWorkspaceParentSessionKey = (): string | null => {
+    const selectedSessionKey = useChatSessionListStore.getState().snapshot.selectedSessionKey?.trim();
+    if (selectedSessionKey) {
+      return selectedSessionKey;
+    }
     const threadSessionKey = useChatThreadStore.getState().snapshot.sessionKey?.trim();
     if (threadSessionKey) {
       return threadSessionKey;
@@ -169,6 +165,7 @@ export class ChatThreadManager {
       return {
         activeWorkspacePanelKind: 'cron',
         activeChildSessionKey: null,
+        activeSideChatDraft: null,
         activeWorkspaceFileKey: null,
       };
     }
@@ -179,15 +176,29 @@ export class ChatThreadManager {
       return {
         activeWorkspacePanelKind: 'file',
         activeChildSessionKey: null,
+        activeSideChatDraft: null,
         activeWorkspaceFileKey: entry.key,
       };
     }
+    if (entry.kind === 'side-chat-draft') {
+      const { activeSideChatDraft } = snapshot;
+      if (activeSideChatDraft?.draftKey !== entry.key) {
+        return null;
+      }
+      return {
+        activeWorkspacePanelKind: 'side-chat-draft',
+        activeChildSessionKey: null,
+        activeSideChatDraft,
+        activeWorkspaceFileKey: null,
+      };
+    }
     if (!entry.key) {
       return null;
     }
     return {
       activeWorkspacePanelKind: 'child-session',
       activeChildSessionKey: entry.key,
+      activeSideChatDraft: null,
       activeWorkspaceFileKey: null,
     };
   };
@@ -215,18 +226,36 @@ export class ChatThreadManager {
   openChildSessionPanel = (params: {
     parentSessionKey: string;
     activeChildSessionKey?: string | null;
+    childSessionTab?: Pick<ChatChildSessionTab, 'label' | 'agentId'> | null;
   }) => {
-    const parentSessionKey = params.parentSessionKey.trim();
+    const {
+      activeChildSessionKey: rawActiveChildSessionKey,
+      childSessionTab,
+      parentSessionKey: rawParentSessionKey,
+    } = params;
+    const parentSessionKey = rawParentSessionKey.trim();
     if (!parentSessionKey) {
       return;
     }
-    const activeChildSessionKey = params.activeChildSessionKey?.trim() || null;
+    const activeChildSessionKey = rawActiveChildSessionKey?.trim() || null;
     const patch: Partial<ChatThreadSnapshot> = {
       workspacePanelParentKey: parentSessionKey,
       activeWorkspacePanelKind: 'child-session',
       activeChildSessionKey,
+      activeSideChatDraft: null,
       activeWorkspaceFileKey: null,
     };
+    if (activeChildSessionKey && childSessionTab) {
+      patch.childSessionTabs = upsertChildSessionTab(
+        useChatThreadStore.getState().snapshot.childSessionTabs,
+        {
+          sessionKey: activeChildSessionKey,
+          parentSessionKey,
+          label: childSessionTab.label?.trim() || null,
+          agentId: childSessionTab.agentId?.trim() || null,
+        },
+      );
+    }
     if (activeChildSessionKey) {
       this.setWorkspaceSelection(patch, {
         kind: 'child-session',
@@ -238,6 +267,43 @@ export class ChatThreadManager {
     this.ensureWorkspaceParentRoute(parentSessionKey);
   };
 
+  openSideChatDraft = (parentSessionKey?: string | null) => {
+    const resolvedParentSessionKey =
+      parentSessionKey?.trim() || this.resolveWorkspaceParentSessionKey()?.trim();
+    if (!resolvedParentSessionKey) {
+      return;
+    }
+    const activeSideChatDraft = createSideChatDraft(resolvedParentSessionKey);
+    this.setWorkspaceSelection({
+      workspacePanelParentKey: resolvedParentSessionKey,
+      activeWorkspacePanelKind: 'side-chat-draft',
+      activeChildSessionKey: null,
+      activeSideChatDraft,
+      activeWorkspaceFileKey: null,
+    }, {
+      kind: 'side-chat-draft',
+      key: activeSideChatDraft.draftKey,
+    });
+    this.ensureWorkspaceParentRoute(resolvedParentSessionKey);
+  };
+
+  materializeSideChatDraft = (params: {
+    draftKey: string;
+    sessionKey: string;
+    label?: string | null;
+    agentId?: string | null;
+  }) => {
+    const materialized = materializeSideChatDraftSnapshot({
+      snapshot: useChatThreadStore.getState().snapshot,
+      ...params,
+    });
+    if (!materialized) {
+      return;
+    }
+    useChatThreadStore.getState().setSnapshot(materialized.patch);
+    this.ensureWorkspaceParentRoute(materialized.parentSessionKey);
+  };
+
   openFilePreview = (action: ChatFileOpenActionViewModel) => {
     const parentSessionKey = this.resolveWorkspaceParentSessionKey();
     const nextTab = this.buildWorkspaceFileTab(action, parentSessionKey);
@@ -250,6 +316,7 @@ export class ChatThreadManager {
       workspaceFileTabs: this.upsertWorkspaceFileTab(nextTab),
       activeWorkspaceFileKey: nextTab.key,
       activeChildSessionKey: null,
+      activeSideChatDraft: null,
     }, {
       kind: 'file',
       key: nextTab.key,
@@ -261,6 +328,10 @@ export class ChatThreadManager {
     if (action.kind !== 'open-session') {
       return;
     }
+    const sessionId = action.sessionId.trim();
+    if (!sessionId) {
+      return;
+    }
     if (action.sessionKind === 'child' && !this.uiManager.isCompactViewport()) {
       const parentSessionKey =
         action.parentSessionId?.trim() ||
@@ -269,13 +340,17 @@ export class ChatThreadManager {
       if (parentSessionKey) {
         this.openChildSessionPanel({
           parentSessionKey,
-          activeChildSessionKey: action.sessionId,
+          activeChildSessionKey: sessionId,
+          childSessionTab: {
+            label: action.label,
+            agentId: action.agentId,
+          },
         });
         return;
       }
     }
     this.closeWorkspacePanel();
-    this.uiManager.goToSession(action.sessionId);
+    this.uiManager.goToSession(sessionId);
   };
 
   handleToolAction = async (action: ChatToolActionViewModel): Promise<void> => {
@@ -331,14 +406,11 @@ export class ChatThreadManager {
     if (!normalizedSessionKey) {
       return;
     }
-    const { childSessionTabs } = useChatThreadStore.getState().snapshot;
-    if (!childSessionTabs.some((tab) => tab.sessionKey === normalizedSessionKey)) {
-      return;
-    }
     this.setWorkspaceSelection({
       activeChildSessionKey: normalizedSessionKey,
       activeWorkspaceFileKey: null,
       activeWorkspacePanelKind: 'child-session',
+      activeSideChatDraft: null,
     }, {
       kind: 'child-session',
       key: normalizedSessionKey,
@@ -358,6 +430,7 @@ export class ChatThreadManager {
       activeWorkspaceFileKey: normalizedFileKey,
       activeChildSessionKey: null,
       activeWorkspacePanelKind: 'file',
+      activeSideChatDraft: null,
     }, {
       kind: 'file',
       key: normalizedFileKey,
@@ -397,6 +470,7 @@ export class ChatThreadManager {
         : null;
       Object.assign(nextPatch, restorePatch ?? {
         activeWorkspacePanelKind: null,
+        activeSideChatDraft: null,
         activeWorkspaceFileKey: null,
       });
     }
@@ -408,6 +482,7 @@ export class ChatThreadManager {
       workspacePanelParentKey: null,
       activeWorkspacePanelKind: null,
       activeChildSessionKey: null,
+      activeSideChatDraft: null,
       activeWorkspaceFileKey: null,
       workspaceNavigationHistory: [],
       workspaceNavigationHistoryIndex: 0,
@@ -423,6 +498,7 @@ export class ChatThreadManager {
       workspacePanelParentKey: parentSessionKey,
       activeWorkspacePanelKind: 'cron',
       activeChildSessionKey: null,
+      activeSideChatDraft: null,
       activeWorkspaceFileKey: null,
     }, {
       kind: 'cron',
@@ -461,13 +537,10 @@ export class ChatThreadManager {
     });
   };
 
-  closeChildSessionDetail = () => {
-    this.closeWorkspacePanel();
-  };
-
   goToParentSession = () => {
     const {
       parentSessionKey,
+      activeSideChatDraft,
       childSessionTabs,
       activeChildSessionKey,
     } = useChatThreadStore.getState().snapshot;
@@ -475,7 +548,9 @@ export class ChatThreadManager {
       childSessionTabs.find((tab) => tab.sessionKey === activeChildSessionKey)
         ?.parentSessionKey ?? null;
     const resolvedParentSessionKey =
-      parentSessionKey ?? activeChildParentSessionKey;
+      parentSessionKey ??
+      activeSideChatDraft?.parentSessionKey ??
+      activeChildParentSessionKey;
     if (!resolvedParentSessionKey) {
       return;
     }
@@ -503,7 +578,6 @@ export class ChatThreadManager {
       await deleteNcpSessionApi(selectedSessionKey);
       deleteNcpSessionSummaryInQueryClient(appQueryClient, selectedSessionKey);
       appQueryClient.removeQueries({ queryKey: ['ncp-session-messages', selectedSessionKey] });
-      this.chatRunManager.clearRunState();
       this.clearDeletedSessionState(selectedSessionKey);
       this.uiManager.goToChatRoot({ replace: true });
     } finally {

package/src/features/chat/pages/__tests__/ncp-chat-page.test.ts

@@ -1,5 +1,9 @@
 import { describe, expect, it } from 'vitest';
-import { RUNTIME_DEFAULT_MODEL_VALUE } from '@nextclaw/shared';
+import { createChatComposerTokenNode } from '@nextclaw/agent-chat-ui';
+import {
+  CHAT_SESSION_MATERIALIZATION_METADATA_KEY,
+  RUNTIME_DEFAULT_MODEL_VALUE,
+} from '@nextclaw/shared';
 import type { SessionEntryView, ThinkingLevel } from '@/shared/lib/api';
 import type { ChatModelOption } from '@/features/chat/types/chat-input.types';
 import {
@@ -185,6 +189,49 @@ describe('buildChatRunMetadata', () => {
       requested_skill_refs: ['project:/tmp/project-alpha/.agents/skills/review'],
     });
   });
+
+  it('serializes panel app references as text without run metadata', () => {
+    expect(
+      buildChatRunMetadata({
+        composerNodes: [
+          createChatComposerTokenNode({
+            tokenKind: 'panel_app',
+            tokenKey: 'task-board',
+            label: 'Task Board',
+          }),
+        ],
+      }),
+    ).not.toHaveProperty('referenced_panel_apps');
+    expect(
+      buildChatRunMetadata({
+        composerNodes: [
+          createChatComposerTokenNode({
+            tokenKind: 'panel_app',
+            tokenKey: 'task-board',
+            label: 'Task Board',
+          }),
+        ],
+      }),
+    ).not.toHaveProperty('ui_inline_tokens');
+  });
+
+  it('serializes child session materialization metadata for side chat drafts', () => {
+    expect(
+      buildChatRunMetadata({
+        sessionMaterialization: {
+          kind: 'child',
+          parentSessionId: 'parent-session-1',
+          inheritContext: true,
+        },
+      }),
+    ).toMatchObject({
+      [CHAT_SESSION_MATERIALIZATION_METADATA_KEY]: {
+        kind: 'child',
+        parentSessionId: 'parent-session-1',
+        inheritContext: true,
+      },
+    });
+  });
 });
 
 function createSession(overrides: Partial<SessionEntryView> & Pick<SessionEntryView, 'key'>): SessionEntryView {

package/src/features/chat/pages/__tests__/ncp-chat-page.test.tsx

@@ -0,0 +1,72 @@
+import { render, screen } from '@testing-library/react';
+import { MemoryRouter } from 'react-router-dom';
+import { describe, expect, it, vi } from 'vitest';
+
+import { AppPresenterProvider } from '@/app/components/app-presenter-provider';
+import { NcpChatPage } from '@/features/chat/pages/ncp-chat-page';
+
+const mocks = vi.hoisted(() => ({
+  confirm: vi.fn(),
+  consumePending: vi.fn(() => null),
+  markConsumed: vi.fn(),
+  subscribe: vi.fn(() => vi.fn()),
+  useChatSessionSync: vi.fn(),
+}));
+
+vi.mock('@/app/presenters/app.presenter', () => ({
+  getAppPresenter: () => ({
+    docBrowserManager: {},
+    chatDraftIntentManager: {
+      consumePending: mocks.consumePending,
+      markConsumed: mocks.markConsumed,
+      subscribe: mocks.subscribe,
+    },
+  }),
+}));
+
+vi.mock('@/shared/hooks/use-confirm-dialog', () => ({
+  useConfirmDialog: () => ({
+    confirm: mocks.confirm,
+    ConfirmDialog: () => <div data-testid="confirm-dialog" />,
+  }),
+}));
+
+vi.mock('@/features/chat/components/layout/chat-page-shell', () => ({
+  ChatPageLayout: () => <div data-testid="chat-page-layout" />,
+  useChatSessionSync: (params: {
+    syncRouteSessionSelection: (value: {
+      isChatView: boolean;
+      routeSessionKey: string | null;
+    }) => void;
+  }) => {
+    mocks.useChatSessionSync(params);
+    const { syncRouteSessionSelection } = params;
+    syncRouteSessionSelection({
+      isChatView: true,
+      routeSessionKey: null,
+    });
+  },
+}));
+
+vi.mock('@/features/chat/features/ncp/hooks/use-ncp-chat-query-store-sync', () => ({
+  useChatQueryStoreSync: () => undefined,
+}));
+
+vi.mock('@/features/chat/features/ncp/hooks/use-ui-show-content-event', () => ({
+  useUiShowContentEvent: () => undefined,
+}));
+
+describe('NcpChatPage render boundary', () => {
+  it('creates its chat presenter from the global app presenter provider', () => {
+    render(
+      <MemoryRouter initialEntries={['/chat']}>
+        <AppPresenterProvider>
+          <NcpChatPage view="chat" />
+        </AppPresenterProvider>
+      </MemoryRouter>,
+    );
+
+    expect(screen.getByTestId('chat-page-layout')).toBeTruthy();
+    expect(mocks.useChatSessionSync).toHaveBeenCalledOnce();
+  });
+});