@nextclaw/ui 0.13.12 → 0.13.13

package/src/features/chat/components/conversation/chat-conversation-panel.test.tsx

@@ -16,6 +16,8 @@ const mocks = vi.hoisted(() => ({
   goToChatRoot: vi.fn(),
   goToSession: vi.fn(),
   openSessionCronPanel: vi.fn(),
+  goBackWorkspacePanel: vi.fn(),
+  goForwardWorkspacePanel: vi.fn(),
   deleteCronJob: vi.fn(),
   cronJobs: [] as CronJobView[],
   setSelectedAgentId: vi.fn(),
@@ -119,6 +121,8 @@ vi.mock("@/features/chat/components/providers/chat-presenter.provider", () => ({
       selectWorkspaceFile: vi.fn(),
       closeWorkspaceFile: vi.fn(),
       closeWorkspacePanel: vi.fn(),
+      goBackWorkspacePanel: mocks.goBackWorkspacePanel,
+      goForwardWorkspacePanel: mocks.goForwardWorkspacePanel,
       goToParentSession: vi.fn(),
     },
     chatSessionListManager: {
@@ -200,8 +204,25 @@ function resetChatConversationPanelTestState() {
   mocks.goToChatRoot.mockReset();
   mocks.goToSession.mockReset();
   mocks.openSessionCronPanel.mockReset();
+  mocks.goBackWorkspacePanel.mockReset();
+  mocks.goForwardWorkspacePanel.mockReset();
   mocks.deleteCronJob.mockReset();
   mocks.cronJobs = [];
+  mocks.resolvedChildTabs = [
+    {
+      sessionKey: "child-session-1",
+      parentSessionKey: "parent-session-1",
+      title: "北京天气",
+      agentId: "weather",
+      updatedAt: "2026-04-10T09:00:00.000Z",
+      lastMessageAt: "2026-04-10T09:00:00.000Z",
+      readAt: "2026-04-10T09:00:00.000Z",
+      sessionTypeLabel: "Codex",
+      preferredModel: "openai/gpt-5.3-codex",
+      projectName: "project-alpha",
+      projectRoot: "/Users/demo/project-alpha",
+    },
+  ];
   mocks.setSelectedAgentId.mockReset();
   mocks.setPendingSessionType.mockReset();
   mocks.stickyBottomScroll.mockClear();
@@ -247,6 +268,8 @@ function resetChatConversationPanelTestState() {
       activeChildSessionKey: null,
       workspaceFileTabs: [],
       activeWorkspaceFileKey: null,
+      workspaceNavigationHistory: [],
+      workspaceNavigationHistoryIndex: 0,
     },
   });
   useChatSessionListStore.setState({
@@ -406,6 +429,11 @@ describe("ChatConversationPanel", () => {
       messageCount: "1",
       sending: "true",
     });
+    expect(
+      screen
+        .getByTestId("chat-message-list")
+        .closest('[data-chat-scroll-container="true"]'),
+    ).toBeTruthy();
     expect(
       screen.queryByText("No messages yet. Send one to start."),
     ).toBeNull();
@@ -520,6 +548,8 @@ describe("ChatConversationPanel", () => {
 });
 
 describe("ChatSessionWorkspacePanel", () => {
+  beforeEach(resetChatConversationPanelTestState);
+
   it("renders child session tabs and active child metadata in the workspace sidebar", () => {
     mocks.resolvedChildTabs = [
       {
@@ -661,6 +691,45 @@ describe("ChatSessionWorkspacePanel", () => {
     ).toContain("workspace-horizontal-scrollbar");
   });
 
+  it("uses workspace-local backward and forward history actions in the tab bar", async () => {
+    const user = userEvent.setup();
+
+    render(
+      <ChatSessionWorkspacePanel
+        sessionKey="parent-session-1"
+        childSessionTabs={[]}
+        activeChildSessionKey={null}
+        workspaceFileTabs={[
+          {
+            key: "parent-session-1::preview::README.md",
+            parentSessionKey: "parent-session-1",
+            path: "README.md",
+            label: "README.md",
+            viewMode: "preview",
+          },
+        ]}
+        activeWorkspaceFileKey="parent-session-1::preview::README.md"
+        workspaceNavigationHistory={[
+          { kind: "child-session", key: "child-session-1" },
+          { kind: "file", key: "parent-session-1::preview::README.md" },
+          { kind: "cron" },
+        ]}
+        workspaceNavigationHistoryIndex={1}
+        sessionProjectRoot="/Users/demo/project-alpha"
+        sessionWorkingDir="/Users/demo/project-alpha"
+      />,
+    );
+
+    await user.click(screen.getByRole("button", { name: "Back in workspace" }));
+    await user.click(
+      screen.getByRole("button", { name: "Forward in workspace" }),
+    );
+
+    expect(mocks.goBackWorkspacePanel).toHaveBeenCalledTimes(1);
+    expect(mocks.goForwardWorkspacePanel).toHaveBeenCalledTimes(1);
+    expect(screen.queryByRole("button", { name: "Back to parent" })).toBeNull();
+  });
+
   it("renders session cron jobs in the workspace sidebar and deletes with a neutral confirmation", async () => {
     const user = userEvent.setup();
     const job: CronJobView = {

package/src/features/chat/components/conversation/chat-conversation-panel.tsx

@@ -194,6 +194,7 @@ function ChatConversationContent() {
     <div
       ref={threadRef}
       onScroll={onScroll}
+      data-chat-scroll-container="true"
       className="flex-1 min-h-0 overflow-y-auto custom-scrollbar"
     >
       {showWelcome ? (
@@ -363,6 +364,8 @@ function ChatSessionWorkspacePanelContainer({
       activeChildSessionKey={snapshot.activeChildSessionKey ?? null}
       workspaceFileTabs={workspaceFileTabs}
       activeWorkspaceFileKey={snapshot.activeWorkspaceFileKey ?? null}
+      workspaceNavigationHistory={snapshot.workspaceNavigationHistory}
+      workspaceNavigationHistoryIndex={snapshot.workspaceNavigationHistoryIndex}
       activePanelKind={snapshot.activeWorkspacePanelKind ?? null}
       sessionCronJobs={sessionCronJobs}
       sessionProjectRoot={snapshot.sessionProjectRoot ?? null}

package/src/features/chat/components/providers/chat-presenter.provider.tsx

@@ -42,6 +42,8 @@ export type ChatThreadManagerLike = {
   selectWorkspaceFile: (fileKey: string) => void;
   closeWorkspaceFile: (fileKey: string) => void;
   closeWorkspacePanel: () => void;
+  goBackWorkspacePanel: () => void;
+  goForwardWorkspacePanel: () => void;
   goToParentSession: () => void;
 };
 

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

@@ -57,6 +57,10 @@ describe('ChatSessionListManager', () => {
         activeWorkspacePanelKind: 'child-session',
         activeChildSessionKey: 'child-session-1',
         activeWorkspaceFileKey: null,
+        workspaceNavigationHistory: [
+          { kind: 'child-session', key: 'child-session-1' },
+        ],
+        workspaceNavigationHistoryIndex: 0,
       },
     });
   });

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

@@ -30,6 +30,8 @@ export class ChatSessionListManager {
       childSessionTabs: [],
       activeChildSessionKey: null,
       activeWorkspaceFileKey: null,
+      workspaceNavigationHistory: [],
+      workspaceNavigationHistoryIndex: 0,
     });
   };
 

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

@@ -19,33 +19,37 @@ vi.mock('@/shared/lib/api', async (importOriginal) => {
   };
 });
 
-describe('NcpChatThreadManager', () => {
-  beforeEach(() => {
-    useChatSessionListStore.setState({
-      optimisticReadAtBySessionKey: {},
-      snapshot: {
-        ...useChatSessionListStore.getState().snapshot,
-        selectedSessionKey: 'parent-session-1',
-      },
-    });
-    useChatThreadStore.setState({
-      snapshot: {
-        ...useChatThreadStore.getState().snapshot,
-        sessionKey: 'parent-session-1',
-        workspacePanelParentKey: null,
-        childSessionTabs: [
-          {
-            sessionKey: 'child-session-1',
-            parentSessionKey: 'parent-session-1',
-            label: 'Child Session 1',
-            agentId: 'reviewer',
-          },
-        ],
-        activeChildSessionKey: null,
-      },
-    });
+beforeEach(() => {
+  useChatSessionListStore.setState({
+    optimisticReadAtBySessionKey: {},
+    snapshot: {
+      ...useChatSessionListStore.getState().snapshot,
+      selectedSessionKey: 'parent-session-1',
+    },
   });
+  useChatThreadStore.setState({
+    snapshot: {
+      ...useChatThreadStore.getState().snapshot,
+      sessionKey: 'parent-session-1',
+      workspacePanelParentKey: null,
+      childSessionTabs: [
+        {
+          sessionKey: 'child-session-1',
+          parentSessionKey: 'parent-session-1',
+          label: 'Child Session 1',
+          agentId: 'reviewer',
+        },
+      ],
+      activeChildSessionKey: null,
+      workspaceFileTabs: [],
+      activeWorkspaceFileKey: null,
+      workspaceNavigationHistory: [],
+      workspaceNavigationHistoryIndex: 0,
+    },
+  });
+});
 
+describe('NcpChatThreadManager', () => {
   it('opens the child-session panel for the requested parent session and keeps focus on the chosen child', () => {
     const uiManager = {
       goToSession: vi.fn(),
@@ -190,7 +194,129 @@ describe('NcpChatThreadManager', () => {
       ]),
     );
   });
+});
+
+describe('NcpChatThreadManager workspace navigation', () => {
+  it('navigates backward and forward through workspace selections', () => {
+    const uiManager = {
+      goToSession: vi.fn(),
+      goToChatRoot: vi.fn(),
+      goToProviders: vi.fn(),
+      confirm: vi.fn(),
+    } as unknown as ConstructorParameters<typeof NcpChatThreadManager>[0];
+    const manager = new NcpChatThreadManager(
+      uiManager,
+      {} as ConstructorParameters<typeof NcpChatThreadManager>[1],
+      {} as ConstructorParameters<typeof NcpChatThreadManager>[2],
+    );
+
+    manager.openChildSessionPanel({
+      parentSessionKey: 'parent-session-1',
+      activeChildSessionKey: 'child-session-1',
+    });
+    manager.openFilePreview({
+      path: 'README.md',
+      label: 'README.md',
+      viewMode: 'preview',
+    });
+    manager.openSessionCronPanel('parent-session-1');
+
+    expect(useChatThreadStore.getState().snapshot.workspaceNavigationHistory).toEqual([
+      { kind: 'child-session', key: 'child-session-1' },
+      { kind: 'file', key: 'parent-session-1::preview::README.md' },
+      { kind: 'cron' },
+    ]);
+
+    manager.goBackWorkspacePanel();
+    expect(useChatThreadStore.getState().snapshot).toMatchObject({
+      activeWorkspacePanelKind: 'file',
+      activeWorkspaceFileKey: 'parent-session-1::preview::README.md',
+      workspaceNavigationHistoryIndex: 1,
+    });
+
+    manager.goBackWorkspacePanel();
+    expect(useChatThreadStore.getState().snapshot).toMatchObject({
+      activeWorkspacePanelKind: 'child-session',
+      activeChildSessionKey: 'child-session-1',
+      workspaceNavigationHistoryIndex: 0,
+    });
+
+    manager.goForwardWorkspacePanel();
+    expect(useChatThreadStore.getState().snapshot).toMatchObject({
+      activeWorkspacePanelKind: 'file',
+      activeWorkspaceFileKey: 'parent-session-1::preview::README.md',
+      workspaceNavigationHistoryIndex: 1,
+    });
+  });
+
+  it('truncates workspace forward history after selecting a new entry', () => {
+    useChatThreadStore.getState().setSnapshot({
+      childSessionTabs: [
+        ...useChatThreadStore.getState().snapshot.childSessionTabs,
+        {
+          sessionKey: 'child-session-2',
+          parentSessionKey: 'parent-session-1',
+          label: 'Child Session 2',
+          agentId: 'writer',
+        },
+      ],
+    });
+    const manager = new NcpChatThreadManager(
+      { goToSession: vi.fn() } as unknown as ConstructorParameters<typeof NcpChatThreadManager>[0],
+      {} as ConstructorParameters<typeof NcpChatThreadManager>[1],
+      {} as ConstructorParameters<typeof NcpChatThreadManager>[2],
+    );
+
+    manager.openChildSessionPanel({
+      parentSessionKey: 'parent-session-1',
+      activeChildSessionKey: 'child-session-1',
+    });
+    manager.openFilePreview({
+      path: 'README.md',
+      label: 'README.md',
+      viewMode: 'preview',
+    });
+    manager.goBackWorkspacePanel();
+    manager.selectChildSessionDetail('child-session-2');
+
+    expect(useChatThreadStore.getState().snapshot.workspaceNavigationHistory).toEqual([
+      { kind: 'child-session', key: 'child-session-1' },
+      { kind: 'child-session', key: 'child-session-2' },
+    ]);
+    expect(useChatThreadStore.getState().snapshot.workspaceNavigationHistoryIndex).toBe(1);
+  });
+
+  it('removes a closed active file from workspace history and restores the previous entry', () => {
+    const manager = new NcpChatThreadManager(
+      { goToSession: vi.fn() } as unknown as ConstructorParameters<typeof NcpChatThreadManager>[0],
+      {} as ConstructorParameters<typeof NcpChatThreadManager>[1],
+      {} as ConstructorParameters<typeof NcpChatThreadManager>[2],
+    );
+
+    manager.openChildSessionPanel({
+      parentSessionKey: 'parent-session-1',
+      activeChildSessionKey: 'child-session-1',
+    });
+    manager.openFilePreview({
+      path: 'README.md',
+      label: 'README.md',
+      viewMode: 'preview',
+    });
+    manager.closeWorkspaceFile('parent-session-1::preview::README.md');
+
+    expect(useChatThreadStore.getState().snapshot).toMatchObject({
+      activeWorkspacePanelKind: 'child-session',
+      activeChildSessionKey: 'child-session-1',
+      activeWorkspaceFileKey: null,
+      workspaceNavigationHistory: [
+        { kind: 'child-session', key: 'child-session-1' },
+      ],
+      workspaceNavigationHistoryIndex: 0,
+    });
+  });
+});
 
+describe('NcpChatThreadManager deletion', () => {
   it('clears the selected thread state after deleting the current session', async () => {
     const removeQueries = vi.spyOn(appQueryClient, 'removeQueries').mockImplementation(async () => undefined);
     const uiManager = {
@@ -228,6 +354,8 @@ describe('NcpChatThreadManager', () => {
       activeChildSessionKey: null,
       workspaceFileTabs: [],
       activeWorkspaceFileKey: null,
+      workspaceNavigationHistory: [],
+      workspaceNavigationHistoryIndex: 0,
     });
     expect(streamActionsManager.resetStreamState).toHaveBeenCalledTimes(1);
     expect(deleteSummaryMock).toHaveBeenCalledWith(appQueryClient, 'parent-session-1');

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

@@ -11,11 +11,30 @@ import type { ChatUiManager } from '@/features/chat/managers/chat-ui.manager';
 import { useChatSessionListStore } from '@/features/chat/stores/chat-session-list.store';
 import type {
   ChatThreadSnapshot,
+  ChatWorkspaceNavigationEntry,
   ChatWorkspaceFileTab,
 } from '@/features/chat/stores/chat-thread.store';
 import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
 import { viewportLayoutManager } from '@/app/managers/viewport-layout.manager';
 import { t } from '@/shared/lib/i18n';
+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;
+}
 
 export class NcpChatThreadManager {
   constructor(
@@ -67,6 +86,8 @@ export class NcpChatThreadManager {
       activeChildSessionKey: null,
       workspaceFileTabs: [],
       activeWorkspaceFileKey: null,
+      workspaceNavigationHistory: [],
+      workspaceNavigationHistoryIndex: 0,
     });
   };
 
@@ -134,6 +155,57 @@ export class NcpChatThreadManager {
     }
   };
 
+  private createWorkspaceSelectionPatch = (
+    entry: ChatWorkspaceNavigationEntry,
+    snapshot: ChatThreadSnapshot,
+  ): Partial<ChatThreadSnapshot> | null => {
+    if (entry.kind === 'cron') {
+      return {
+        activeWorkspacePanelKind: 'cron',
+        activeChildSessionKey: null,
+        activeWorkspaceFileKey: null,
+      };
+    }
+    if (entry.kind === 'file') {
+      if (!snapshot.workspaceFileTabs.some((tab) => tab.key === entry.key)) {
+        return null;
+      }
+      return {
+        activeWorkspacePanelKind: 'file',
+        activeChildSessionKey: null,
+        activeWorkspaceFileKey: entry.key,
+      };
+    }
+    if (!entry.key) {
+      return null;
+    }
+    return {
+      activeWorkspacePanelKind: 'child-session',
+      activeChildSessionKey: entry.key,
+      activeWorkspaceFileKey: null,
+    };
+  };
+
+  private setWorkspaceSelection = (
+    patch: Partial<ChatThreadSnapshot>,
+    entry: ChatWorkspaceNavigationEntry,
+  ) => {
+    const { snapshot } = useChatThreadStore.getState();
+    const history = pushNavigationHistoryEntry(
+      {
+        entries: snapshot.workspaceNavigationHistory,
+        index: snapshot.workspaceNavigationHistoryIndex,
+      },
+      entry,
+      areWorkspaceNavigationEntriesEqual,
+    );
+    useChatThreadStore.getState().setSnapshot({
+      ...patch,
+      workspaceNavigationHistory: [...history.entries],
+      workspaceNavigationHistoryIndex: history.index,
+    });
+  };
+
   deleteSession = () => {
     void this.deleteCurrentSession();
   };
@@ -155,12 +227,20 @@ export class NcpChatThreadManager {
       return;
     }
     const activeChildSessionKey = params.activeChildSessionKey?.trim() || null;
-    useChatThreadStore.getState().setSnapshot({
+    const patch: Partial<ChatThreadSnapshot> = {
       workspacePanelParentKey: parentSessionKey,
       activeWorkspacePanelKind: 'child-session',
       activeChildSessionKey,
       activeWorkspaceFileKey: null,
-    });
+    };
+    if (activeChildSessionKey) {
+      this.setWorkspaceSelection(patch, {
+        kind: 'child-session',
+        key: activeChildSessionKey,
+      });
+    } else {
+      useChatThreadStore.getState().setSnapshot(patch);
+    }
     this.ensureWorkspaceParentRoute(parentSessionKey);
   };
 
@@ -170,12 +250,15 @@ export class NcpChatThreadManager {
     if (!nextTab) {
       return;
     }
-    useChatThreadStore.getState().setSnapshot({
+    this.setWorkspaceSelection({
       workspacePanelParentKey: parentSessionKey,
       activeWorkspacePanelKind: 'file',
       workspaceFileTabs: this.upsertWorkspaceFileTab(nextTab),
       activeWorkspaceFileKey: nextTab.key,
       activeChildSessionKey: null,
+    }, {
+      kind: 'file',
+      key: nextTab.key,
     });
     this.ensureWorkspaceParentRoute(parentSessionKey);
   };
@@ -202,6 +285,8 @@ export class NcpChatThreadManager {
       activeWorkspacePanelKind: null,
       activeChildSessionKey: null,
       activeWorkspaceFileKey: null,
+      workspaceNavigationHistory: [],
+      workspaceNavigationHistoryIndex: 0,
     });
     this.uiManager.goToSession(action.sessionId);
   };
@@ -215,10 +300,13 @@ export class NcpChatThreadManager {
     if (!childSessionTabs.some((tab) => tab.sessionKey === normalizedSessionKey)) {
       return;
     }
-    useChatThreadStore.getState().setSnapshot({
+    this.setWorkspaceSelection({
       activeChildSessionKey: normalizedSessionKey,
       activeWorkspaceFileKey: null,
       activeWorkspacePanelKind: 'child-session',
+    }, {
+      kind: 'child-session',
+      key: normalizedSessionKey,
     });
   };
 
@@ -231,10 +319,13 @@ export class NcpChatThreadManager {
     if (!workspaceFileTabs.some((tab) => tab.key === normalizedFileKey)) {
       return;
     }
-    useChatThreadStore.getState().setSnapshot({
+    this.setWorkspaceSelection({
       activeWorkspaceFileKey: normalizedFileKey,
       activeChildSessionKey: null,
       activeWorkspacePanelKind: 'file',
+    }, {
+      kind: 'file',
+      key: normalizedFileKey,
     });
   };
 
@@ -248,11 +339,31 @@ export class NcpChatThreadManager {
     const nextTabs = workspaceFileTabs.filter(
       (tab) => tab.key !== normalizedFileKey,
     );
+    const history = filterNavigationHistoryEntries(
+      {
+        entries: snapshot.workspaceNavigationHistory,
+        index: snapshot.workspaceNavigationHistoryIndex,
+      },
+      (entry) => entry.kind !== 'file' || entry.key !== normalizedFileKey,
+    );
     const nextPatch: Partial<ChatThreadSnapshot> = {
       workspaceFileTabs: nextTabs,
+      workspaceNavigationHistory: [...history.entries],
+      workspaceNavigationHistoryIndex: history.index,
     };
     if (activeWorkspaceFileKey === normalizedFileKey) {
-      nextPatch.activeWorkspaceFileKey = null;
+      const nextSnapshot = {
+        ...snapshot,
+        workspaceFileTabs: nextTabs,
+      };
+      const restoreEntry = history.entries[history.index];
+      const restorePatch = restoreEntry
+        ? this.createWorkspaceSelectionPatch(restoreEntry, nextSnapshot)
+        : null;
+      Object.assign(nextPatch, restorePatch ?? {
+        activeWorkspacePanelKind: null,
+        activeWorkspaceFileKey: null,
+      });
     }
     useChatThreadStore.getState().setSnapshot(nextPatch);
   };
@@ -263,6 +374,8 @@ export class NcpChatThreadManager {
       activeWorkspacePanelKind: null,
       activeChildSessionKey: null,
       activeWorkspaceFileKey: null,
+      workspaceNavigationHistory: [],
+      workspaceNavigationHistoryIndex: 0,
     });
   };
 
@@ -271,15 +384,48 @@ export class NcpChatThreadManager {
     if (!parentSessionKey) {
       return;
     }
-    useChatThreadStore.getState().setSnapshot({
+    this.setWorkspaceSelection({
       workspacePanelParentKey: parentSessionKey,
       activeWorkspacePanelKind: 'cron',
       activeChildSessionKey: null,
       activeWorkspaceFileKey: null,
+    }, {
+      kind: 'cron',
     });
     this.ensureWorkspaceParentRoute(parentSessionKey);
   };
 
+  goBackWorkspacePanel = () => {
+    this.restoreWorkspaceNavigationStep('back');
+  };
+
+  goForwardWorkspacePanel = () => {
+    this.restoreWorkspaceNavigationStep('forward');
+  };
+
+  private restoreWorkspaceNavigationStep = (direction: 'back' | 'forward') => {
+    const { snapshot } = useChatThreadStore.getState();
+    const step = stepNavigationHistory(
+      {
+        entries: snapshot.workspaceNavigationHistory,
+        index: snapshot.workspaceNavigationHistoryIndex,
+      },
+      direction,
+    );
+    if (!step) {
+      return;
+    }
+    const selectionPatch = this.createWorkspaceSelectionPatch(step.entry, snapshot);
+    if (!selectionPatch) {
+      return;
+    }
+    useChatThreadStore.getState().setSnapshot({
+      ...selectionPatch,
+      workspaceNavigationHistory: [...step.history.entries],
+      workspaceNavigationHistoryIndex: step.history.index,
+    });
+  };
+
   closeChildSessionDetail = () => {
     this.closeWorkspacePanel();
   };