@nextclaw/ui 0.13.13 → 0.14.1-beta.0

package/src/features/chat/managers/__tests__/chat-run-snapshot.manager.test.ts

@@ -0,0 +1,129 @@
+import type { NcpMessage } from '@nextclaw/ncp';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { ChatRunManager } from '@/features/chat/managers/chat-run.manager';
+import { useChatInputStore } from '@/features/chat/stores/chat-input.store';
+import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
+
+function createChatRunManager() {
+  const uiManager = {
+    isAtChatRoot: vi.fn(() => true),
+    goToSession: vi.fn(),
+  };
+  return new ChatRunManager(
+    uiManager as unknown as ConstructorParameters<typeof ChatRunManager>[0],
+  );
+}
+
+describe('ChatRunManager run snapshots', () => {
+  beforeEach(() => {
+    useChatInputStore.setState({
+      snapshot: {
+        ...useChatInputStore.getState().snapshot,
+        canStopGeneration: false,
+        sendError: null,
+        isSending: false,
+      },
+    });
+    useChatThreadStore.setState({
+      snapshot: {
+        ...useChatThreadStore.getState().snapshot,
+        sessionKey: null,
+        isHistoryLoading: false,
+        messages: [],
+        isSending: false,
+        isAwaitingAssistantOutput: false,
+        contextWindow: null,
+      },
+    });
+  });
+
+  it('syncs the run snapshot into chat input and thread state', () => {
+    const manager = createChatRunManager();
+    const message: NcpMessage = {
+      id: 'message-1',
+      sessionId: 'session-1',
+      role: 'assistant',
+      status: 'final',
+      parts: [{ type: 'text', text: 'done' }],
+      timestamp: '2026-06-10T00:00:00.000Z',
+    };
+
+    manager.applyRunSnapshot({
+      routeSessionKey: 'session-1',
+      isHydrating: true,
+      isSending: false,
+      isRunning: true,
+      visibleMessages: [message],
+      contextWindow: {
+        usedContextTokens: 10,
+        totalContextTokens: 100,
+        availableContextTokens: 90,
+        prunedUsedContextTokens: 10,
+        droppedHistoryCount: 0,
+        truncatedToolResultCount: 0,
+        truncatedSystemPrompt: false,
+        truncatedUserMessage: false,
+        compacted: false,
+        compactedUsedContextTokens: 10,
+        compactedMessageCount: 0,
+        updatedAt: '2026-06-10T00:00:00.000Z',
+      },
+      sendErrorMessage: 'failed',
+      materializedSessionKey: null,
+    });
+
+    expect(useChatInputStore.getState().snapshot).toMatchObject({
+      canStopGeneration: true,
+      sendError: 'failed',
+      isSending: true,
+    });
+    expect(useChatThreadStore.getState().snapshot).toMatchObject({
+      sessionKey: 'session-1',
+      isHistoryLoading: true,
+      messages: [message],
+      isSending: true,
+      isAwaitingAssistantOutput: true,
+      contextWindow: {
+        usedContextTokens: 10,
+        totalContextTokens: 100,
+      },
+    });
+  });
+
+  it('resets stale context window state when switching sessions', () => {
+    const manager = createChatRunManager();
+    useChatThreadStore.getState().setSnapshot({
+      sessionKey: 'session-previous',
+      contextWindow: {
+        usedContextTokens: 80,
+        totalContextTokens: 100,
+        availableContextTokens: 20,
+        prunedUsedContextTokens: 80,
+        droppedHistoryCount: 0,
+        truncatedToolResultCount: 0,
+        truncatedSystemPrompt: false,
+        truncatedUserMessage: false,
+        compacted: false,
+        compactedUsedContextTokens: 80,
+        compactedMessageCount: 0,
+        updatedAt: '2026-06-10T00:00:00.000Z',
+      },
+    });
+
+    manager.applyRunSnapshot({
+      routeSessionKey: 'session-next',
+      isHydrating: true,
+      isSending: false,
+      isRunning: false,
+      visibleMessages: [],
+      contextWindow: null,
+      sendErrorMessage: null,
+      materializedSessionKey: null,
+    });
+
+    expect(useChatThreadStore.getState().snapshot).toMatchObject({
+      sessionKey: 'session-next',
+      contextWindow: null,
+    });
+  });
+});

package/src/features/chat/managers/__tests__/chat-run.manager.test.ts

@@ -0,0 +1,236 @@
+import type { NcpMessage } from '@nextclaw/ncp';
+import { RUNTIME_DEFAULT_MODEL_VALUE } from '@nextclaw/shared';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { ChatRunManager } from '@/features/chat/managers/chat-run.manager';
+import { useChatInputStore } from '@/features/chat/stores/chat-input.store';
+import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
+
+function createChatRunManager() {
+  const uiManager = {
+    isAtChatRoot: vi.fn(() => true),
+    goToSession: vi.fn(),
+  };
+  return {
+    manager: new ChatRunManager(
+      uiManager as unknown as ConstructorParameters<typeof ChatRunManager>[0],
+    ),
+    uiManager,
+  };
+}
+
+describe('ChatRunManager', () => {
+  beforeEach(() => {
+    useChatInputStore.setState({
+      snapshot: {
+        ...useChatInputStore.getState().snapshot,
+        canStopGeneration: false,
+        sendError: null,
+        isSending: false,
+      },
+    });
+    useChatThreadStore.setState({
+      snapshot: {
+        ...useChatThreadStore.getState().snapshot,
+        isHistoryLoading: false,
+        messages: [],
+        isSending: false,
+        isAwaitingAssistantOutput: false,
+        contextWindow: null,
+      },
+    });
+  });
+
+  it('sends an envelope through the active runtime and materializes a root session', async () => {
+    const { manager, uiManager } = createChatRunManager();
+    const sendEnvelope = vi.fn(async () => ({
+      sessionId: 'materialized-session',
+      userMessageId: 'user-message-1',
+      assistantMessageId: null,
+      runId: 'run-1',
+    }));
+    manager.setActiveRuntime({
+      sessionKey: null,
+      sendEnvelope,
+      abortCurrentRun: vi.fn(),
+      resumeCurrentSessionRun: vi.fn(),
+    });
+
+    await manager.sendMessage({
+      message: 'hello',
+      agentId: 'engineer',
+      sessionType: 'codex',
+      projectRoot: '/tmp/project-alpha',
+      requestedSkills: ['project:/tmp/project-alpha/.agents/skills/review'],
+    });
+
+    expect(sendEnvelope).toHaveBeenCalledWith(
+      expect.objectContaining({
+        metadata: expect.objectContaining({
+          agentId: 'engineer',
+          session_type: 'codex',
+          projectRoot: '/tmp/project-alpha',
+          requested_skill_refs: ['project:/tmp/project-alpha/.agents/skills/review'],
+        }),
+      }),
+    );
+    expect(uiManager.goToSession).toHaveBeenCalledWith('materialized-session', { replace: true });
+  });
+
+  it('keeps the runtime-default sentinel in request metadata to override stale session model metadata', async () => {
+    const { manager } = createChatRunManager();
+    const sendEnvelope = vi.fn(async () => ({
+      sessionId: 'session-1',
+      userMessageId: 'user-message-1',
+      assistantMessageId: null,
+      runId: 'run-1',
+    }));
+    manager.setActiveRuntime({
+      sessionKey: 'session-1',
+      sendEnvelope,
+      abortCurrentRun: vi.fn(),
+      resumeCurrentSessionRun: vi.fn(),
+    });
+
+    await manager.sendMessage({
+      message: 'hello',
+      sessionKey: 'session-1',
+      agentId: 'main',
+      sessionType: 'codex',
+      model: RUNTIME_DEFAULT_MODEL_VALUE,
+    });
+
+    expect(sendEnvelope).toHaveBeenCalledWith(
+      expect.objectContaining({
+        metadata: expect.objectContaining({
+          model: RUNTIME_DEFAULT_MODEL_VALUE,
+          preferred_model: RUNTIME_DEFAULT_MODEL_VALUE,
+        }),
+      }),
+    );
+  });
+
+  it('does not send through a runtime for another session', async () => {
+    const { manager } = createChatRunManager();
+    const sendEnvelope = vi.fn();
+    manager.setActiveRuntime({
+      sessionKey: 'session-1',
+      sendEnvelope,
+      abortCurrentRun: vi.fn(),
+      resumeCurrentSessionRun: vi.fn(),
+    });
+
+    await manager.sendMessage({
+      message: 'hello',
+      sessionKey: 'session-2',
+      agentId: 'main',
+    });
+
+    expect(sendEnvelope).not.toHaveBeenCalled();
+  });
+
+  it('routes stop and resume commands through the active runtime', async () => {
+    const { manager } = createChatRunManager();
+    const abortCurrentRun = vi.fn(async () => undefined);
+    const resumeCurrentSessionRun = vi.fn(async () => undefined);
+    manager.setActiveRuntime({
+      sessionKey: 'session-1',
+      sendEnvelope: vi.fn(),
+      abortCurrentRun,
+      resumeCurrentSessionRun,
+    });
+
+    await manager.stopCurrentRun();
+    await manager.resumeRun({ sessionKey: 'session-1' });
+    await manager.resumeRun({ sessionKey: 'session-2' });
+
+    expect(abortCurrentRun).toHaveBeenCalledTimes(1);
+    expect(resumeCurrentSessionRun).toHaveBeenCalledTimes(1);
+  });
+
+  it('syncs the run snapshot into chat input and thread state', () => {
+    const { manager } = createChatRunManager();
+    const message: NcpMessage = {
+      id: 'message-1',
+      sessionId: 'session-1',
+      role: 'assistant',
+      status: 'final',
+      parts: [{ type: 'text', text: 'done' }],
+      timestamp: '2026-06-10T00:00:00.000Z',
+    };
+
+    manager.applyRunSnapshot({
+      routeSessionKey: 'session-1',
+      isHydrating: true,
+      isSending: false,
+      isRunning: true,
+      visibleMessages: [message],
+      contextWindow: {
+        usedContextTokens: 10,
+        totalContextTokens: 100,
+        availableContextTokens: 90,
+        prunedUsedContextTokens: 10,
+        droppedHistoryCount: 0,
+        truncatedToolResultCount: 0,
+        truncatedSystemPrompt: false,
+        truncatedUserMessage: false,
+        compacted: false,
+        compactedUsedContextTokens: 10,
+        compactedMessageCount: 0,
+        updatedAt: '2026-06-10T00:00:00.000Z',
+      },
+      sendErrorMessage: 'failed',
+      materializedSessionKey: null,
+    });
+
+    expect(useChatInputStore.getState().snapshot).toMatchObject({
+      canStopGeneration: true,
+      sendError: 'failed',
+      isSending: true,
+    });
+    expect(useChatThreadStore.getState().snapshot).toMatchObject({
+      isHistoryLoading: true,
+      messages: [message],
+      isSending: true,
+      isAwaitingAssistantOutput: true,
+    });
+  });
+
+  it('clears run-owned input and thread state', () => {
+    const { manager } = createChatRunManager();
+    useChatInputStore.getState().setSnapshot({
+      canStopGeneration: true,
+      sendError: 'failed',
+      isSending: true,
+    });
+    useChatThreadStore.getState().setSnapshot({
+      isHistoryLoading: true,
+      messages: [
+        {
+          id: 'message-1',
+          sessionId: 'session-1',
+          role: 'assistant',
+          status: 'final',
+          parts: [{ type: 'text', text: 'done' }],
+          timestamp: '2026-06-10T00:00:00.000Z',
+        },
+      ],
+      isSending: true,
+      isAwaitingAssistantOutput: true,
+    });
+
+    manager.clearRunState();
+
+    expect(useChatInputStore.getState().snapshot).toMatchObject({
+      canStopGeneration: false,
+      sendError: null,
+      isSending: false,
+    });
+    expect(useChatThreadStore.getState().snapshot).toMatchObject({
+      isHistoryLoading: false,
+      messages: [],
+      isSending: false,
+      isAwaitingAssistantOutput: false,
+      contextWindow: null,
+    });
+  });
+});

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

@@ -27,43 +27,45 @@ vi.mock('@/shared/lib/api', async (importOriginal) => {
   };
 });
 
-describe('ChatSessionListManager', () => {
-  beforeEach(() => {
-    window.localStorage.clear();
-    useChatSessionListStore.persist.setOptions({ storage: createLocalStoragePersistStorage() });
-    mocks.updateNcpSession.mockReset();
-    mocks.updateNcpSession.mockResolvedValue({});
-    useChatInputStore.setState({
-      snapshot: {
-        ...useChatInputStore.getState().snapshot,
-        defaultSessionType: 'native',
-        pendingSessionType: 'native',
-        pendingProjectRoot: null,
-        pendingProjectRootSessionKey: null
-      }
-    });
-    useChatSessionListStore.setState({
-      optimisticReadAtBySessionKey: {},
-      snapshot: {
-        ...useChatSessionListStore.getState().snapshot,
-        selectedSessionKey: 'session-1',
-        listMode: 'time-first'
-      }
-    });
-    useChatThreadStore.setState({
-      snapshot: {
-        ...useChatThreadStore.getState().snapshot,
-        workspacePanelParentKey: 'session-1',
-        activeWorkspacePanelKind: 'child-session',
-        activeChildSessionKey: 'child-session-1',
-        activeWorkspaceFileKey: null,
-        workspaceNavigationHistory: [
-          { kind: 'child-session', key: 'child-session-1' },
-        ],
-        workspaceNavigationHistoryIndex: 0,
-      },
-    });
+function resetChatSessionListManagerState() {
+  window.localStorage.clear();
+  useChatSessionListStore.persist.setOptions({ storage: createLocalStoragePersistStorage() });
+  mocks.updateNcpSession.mockReset();
+  mocks.updateNcpSession.mockResolvedValue({});
+  useChatInputStore.setState({
+    snapshot: {
+      ...useChatInputStore.getState().snapshot,
+      defaultSessionType: 'native',
+      pendingSessionType: 'native',
+      pendingProjectRoot: null,
+      pendingProjectRootSessionKey: null
+    }
+  });
+  useChatSessionListStore.setState({
+    optimisticReadAtBySessionKey: {},
+    snapshot: {
+      ...useChatSessionListStore.getState().snapshot,
+      selectedSessionKey: 'session-1',
+      listMode: 'time-first'
+    }
   });
+  useChatThreadStore.setState({
+    snapshot: {
+      ...useChatThreadStore.getState().snapshot,
+      workspacePanelParentKey: 'session-1',
+      activeWorkspacePanelKind: 'child-session',
+      activeChildSessionKey: 'child-session-1',
+      activeWorkspaceFileKey: null,
+      workspaceNavigationHistory: [
+        { kind: 'child-session', key: 'child-session-1' },
+      ],
+      workspaceNavigationHistoryIndex: 0,
+    },
+  });
+}
+
+describe('ChatSessionListManager draft and selection flow', () => {
+  beforeEach(resetChatSessionListManagerState);
 
   it('applies the requested session type when creating a session', () => {
     const uiManager = {
@@ -72,14 +74,14 @@ describe('ChatSessionListManager', () => {
       goToSession: vi.fn(),
       isAtChatRoot: vi.fn(() => true),
     } as unknown as ConstructorParameters<typeof ChatSessionListManager>[0];
-    const streamActionsManager = {
-      resetStreamState: vi.fn()
+    const chatRunManager = {
+      clearRunState: vi.fn()
     } as unknown as ConstructorParameters<typeof ChatSessionListManager>[1];
 
-    const manager = new ChatSessionListManager(uiManager, streamActionsManager);
+    const manager = new ChatSessionListManager(uiManager, chatRunManager);
     manager.createSession('codex');
 
-    expect(streamActionsManager.resetStreamState).toHaveBeenCalledTimes(1);
+    expect(chatRunManager.clearRunState).toHaveBeenCalledTimes(1);
     expect(uiManager.navigateTo).toHaveBeenCalledWith('/chat/draft');
     expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBeNull();
     expect(useChatThreadStore.getState().snapshot.sessionKey).toBeNull();
@@ -96,14 +98,14 @@ describe('ChatSessionListManager', () => {
       goToSession: vi.fn(),
       isAtChatRoot: vi.fn(() => true),
     } as unknown as ConstructorParameters<typeof ChatSessionListManager>[0];
-    const streamActionsManager = {
-      resetStreamState: vi.fn()
+    const chatRunManager = {
+      clearRunState: vi.fn()
     } as unknown as ConstructorParameters<typeof ChatSessionListManager>[1];
 
-    const manager = new ChatSessionListManager(uiManager, streamActionsManager);
+    const manager = new ChatSessionListManager(uiManager, chatRunManager);
     manager.startAgentDraftChat('researcher', 'codex');
 
-    expect(streamActionsManager.resetStreamState).toHaveBeenCalledTimes(1);
+    expect(chatRunManager.clearRunState).toHaveBeenCalledTimes(1);
     expect(uiManager.navigateTo).toHaveBeenCalledWith('/chat/draft');
     expect(useChatSessionListStore.getState().snapshot.selectedAgentId).toBe('researcher');
     expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBeNull();
@@ -121,11 +123,11 @@ describe('ChatSessionListManager', () => {
       goToSession: vi.fn(),
       isAtChatRoot: vi.fn(() => true),
     } as unknown as ConstructorParameters<typeof ChatSessionListManager>[0];
-    const streamActionsManager = {
-      resetStreamState: vi.fn()
+    const chatRunManager = {
+      clearRunState: vi.fn()
     } as unknown as ConstructorParameters<typeof ChatSessionListManager>[1];
 
-    const manager = new ChatSessionListManager(uiManager, streamActionsManager);
+    const manager = new ChatSessionListManager(uiManager, chatRunManager);
     manager.createSession('native', '/tmp/project-alpha');
 
     expect(useChatInputStore.getState().snapshot.pendingProjectRoot).toBe('/tmp/project-alpha');
@@ -145,11 +147,11 @@ describe('ChatSessionListManager', () => {
       goToSession: vi.fn(),
       isAtChatRoot: vi.fn(() => true),
     } as unknown as ConstructorParameters<typeof ChatSessionListManager>[0];
-    const streamActionsManager = {
-      resetStreamState: vi.fn()
+    const chatRunManager = {
+      clearRunState: vi.fn()
     } as unknown as ConstructorParameters<typeof ChatSessionListManager>[1];
 
-    const manager = new ChatSessionListManager(uiManager, streamActionsManager);
+    const manager = new ChatSessionListManager(uiManager, chatRunManager);
     const sessionKey = manager.ensureDraftSession('native');
 
     expect(sessionKey).toBeNull();
@@ -167,11 +169,11 @@ describe('ChatSessionListManager', () => {
       goToSession: vi.fn(),
       isAtChatRoot: vi.fn(() => true),
     } as unknown as ConstructorParameters<typeof ChatSessionListManager>[0];
-    const streamActionsManager = {
-      resetStreamState: vi.fn()
+    const chatRunManager = {
+      clearRunState: vi.fn()
     } as unknown as ConstructorParameters<typeof ChatSessionListManager>[1];
 
-    const manager = new ChatSessionListManager(uiManager, streamActionsManager);
+    const manager = new ChatSessionListManager(uiManager, chatRunManager);
     manager.createSession('native', '/tmp/project-alpha');
 
     expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBeNull();
@@ -185,11 +187,11 @@ describe('ChatSessionListManager', () => {
       goToSession: vi.fn(),
       isAtChatRoot: vi.fn(() => true),
     } as unknown as ConstructorParameters<typeof ChatSessionListManager>[0];
-    const streamActionsManager = {
-      resetStreamState: vi.fn()
+    const chatRunManager = {
+      clearRunState: vi.fn()
     } as unknown as ConstructorParameters<typeof ChatSessionListManager>[1];
 
-    const manager = new ChatSessionListManager(uiManager, streamActionsManager);
+    const manager = new ChatSessionListManager(uiManager, chatRunManager);
     manager.selectSession('session-2');
 
     expect(uiManager.goToSession).toHaveBeenCalledWith('session-2');
@@ -199,12 +201,16 @@ describe('ChatSessionListManager', () => {
     expect(useChatThreadStore.getState().snapshot.activeChildSessionKey).toBe('child-session-1');
     expect(useChatThreadStore.getState().snapshot.activeWorkspaceFileKey).toBeNull();
   });
+});
+
+describe('ChatSessionListManager list preference and read state', () => {
+  beforeEach(resetChatSessionListManagerState);
 
   it('updates the sidebar list mode without touching other session list state', () => {
     const uiManager = {} as ConstructorParameters<typeof ChatSessionListManager>[0];
-    const streamActionsManager = {} as ConstructorParameters<typeof ChatSessionListManager>[1];
+    const chatRunManager = {} as ConstructorParameters<typeof ChatSessionListManager>[1];
 
-    const manager = new ChatSessionListManager(uiManager, streamActionsManager);
+    const manager = new ChatSessionListManager(uiManager, chatRunManager);
     manager.setListMode('project-first');
 
     expect(useChatSessionListStore.getState().snapshot.listMode).toBe('project-first');
@@ -250,30 +256,44 @@ describe('ChatSessionListManager', () => {
     expect(mocks.updateNcpSession).not.toHaveBeenCalled();
   });
 
-  it('routes to the backend-materialized root session without duplicating route-owned selection state', () => {
-    useChatSessionListStore.setState({
-      snapshot: {
-        ...useChatSessionListStore.getState().snapshot,
-        selectedSessionKey: null,
-      }
+  it('marks a visible workspace child session as read through the session list owner', () => {
+    const manager = new ChatSessionListManager(
+      {} as ConstructorParameters<typeof ChatSessionListManager>[0],
+      {} as ConstructorParameters<typeof ChatSessionListManager>[1]
+    );
+
+    manager.markVisibleWorkspaceChildRead({
+      sessionKey: 'child-session-1',
+      lastMessageAt: '2026-04-10T10:00:00.000Z',
+      readAt: null,
+      runStatus: 'completed',
     });
-    const uiManager = {
-      goToChatRoot: vi.fn(),
-      goToSession: vi.fn(),
-      isAtChatRoot: vi.fn(() => true),
-    } as unknown as ConstructorParameters<typeof ChatSessionListManager>[0];
-    const streamActionsManager = {
-      resetStreamState: vi.fn()
-    } as unknown as ConstructorParameters<typeof ChatSessionListManager>[1];
-    const manager = new ChatSessionListManager(uiManager, streamActionsManager);
 
-    manager.ensureDraftSession('native');
-    manager.materializeRootSessionRoute('ncp-materialized-session');
+    expect(useChatSessionListStore.getState().optimisticReadAtBySessionKey['child-session-1']).toBe(
+      '2026-04-10T10:00:00.000Z'
+    );
+    expect(mocks.updateNcpSession).toHaveBeenCalledWith('child-session-1', {
+      uiReadAt: '2026-04-10T10:00:00.000Z'
+    });
+  });
 
-    expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBeNull();
-    expect(useChatThreadStore.getState().snapshot.sessionKey).toBeNull();
-    expect(uiManager.goToSession).toHaveBeenCalledWith('ncp-materialized-session', { replace: true });
+  it('keeps running workspace child sessions unread until they settle', () => {
+    const manager = new ChatSessionListManager(
+      {} as ConstructorParameters<typeof ChatSessionListManager>[0],
+      {} as ConstructorParameters<typeof ChatSessionListManager>[1]
+    );
+
+    manager.markVisibleWorkspaceChildRead({
+      sessionKey: 'child-session-1',
+      lastMessageAt: '2026-04-10T10:00:00.000Z',
+      readAt: null,
+      runStatus: 'running',
+    });
+
+    expect(useChatSessionListStore.getState().optimisticReadAtBySessionKey['child-session-1']).toBeUndefined();
+    expect(mocks.updateNcpSession).not.toHaveBeenCalled();
   });
+
 });
 
 describe('ChatSessionListStore persistence', () => {