@nextclaw/ui 0.15.26 → 0.15.28

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

@@ -1,4 +1,4 @@
-import { useCallback, useMemo } from 'react';
+import { useCallback, useMemo, useState } from 'react';
 import { buildNcpRequestEnvelope } from '@nextclaw/ncp-react';
 import type { UiNcpSessionQueuedInputView } from '@nextclaw/client-sdk';
 import type { NcpAgentSendEnvelope, NcpRunHandle } from '@nextclaw/ncp';
@@ -39,11 +39,13 @@ type SessionConversationAgent = SessionConversationRecoveryAgent & {
 
 export type SessionConversationQueuedInput = {
   readonly id: string;
+  readonly isSubmitting?: boolean;
   readonly preview: string;
 };
 
 type SessionRunQueue = {
   readonly inputs: readonly UiNcpSessionQueuedInputView[];
+  readonly refreshQueuedInputs: () => Promise<readonly UiNcpSessionQueuedInputView[]>;
   readonly removeQueuedInput: (
     queuedInputId: string,
   ) => Promise<UiNcpSessionQueuedInputView | null>;
@@ -85,6 +87,13 @@ type SubmissionDraft = {
   readonly metadata: Record<string, unknown>;
 };
 
+type SubmittingQueuedInput = {
+  readonly id: string;
+  readonly preview: string;
+  readonly sessionId: string;
+  readonly userMessageId: string;
+};
+
 const hasSendableMessagePart = (parts: ReturnType<typeof deriveNcpMessagePartsFromComposer>): boolean =>
   parts.some((part) => part.type !== 'text' || part.text.trim().length > 0);
 
@@ -188,6 +197,97 @@ function buildSubmissionEnvelope(
   });
 }
 
+function buildSubmittingQueuedInput(
+  envelope: NcpAgentSendEnvelope,
+): SubmittingQueuedInput | null {
+  const sessionId = envelope.sessionId?.trim();
+  if (!sessionId) {
+    return null;
+  }
+  const message = {
+    ...envelope.message,
+    sessionId,
+  };
+  const enqueuedAt = new Date().toISOString();
+  const input: UiNcpSessionQueuedInputView = {
+    id: `submitting-${message.id}`,
+    sessionId,
+    enqueuedAt,
+    message,
+    metadata: structuredClone(envelope.metadata ?? {}),
+  };
+  return {
+    id: input.id,
+    preview: buildSessionQueuedInputPreview(input),
+    sessionId,
+    userMessageId: message.id,
+  };
+}
+
+function useSubmittingQueuedInputProjection(
+  serverInputs: readonly UiNcpSessionQueuedInputView[],
+  sessionKey: string | null,
+) {
+  const [submittingInput, setSubmittingInput] =
+    useState<SubmittingQueuedInput | null>(null);
+  const stageSubmittingInput = useCallback((envelope: NcpAgentSendEnvelope) => {
+    const input = buildSubmittingQueuedInput(envelope);
+    if (input) {
+      setSubmittingInput(input);
+    }
+    return input;
+  }, []);
+  const clearSubmittingInput = useCallback((input: SubmittingQueuedInput) => {
+    setSubmittingInput((current) =>
+      current?.userMessageId === input.userMessageId ? null : current
+    );
+  }, []);
+  const queuedInputs = useMemo<SessionConversationQueuedInput[]>(() => {
+    const projected: SessionConversationQueuedInput[] = serverInputs.map((input) => ({
+      id: input.id,
+      preview: buildSessionQueuedInputPreview(input),
+    }));
+    if (
+      submittingInput?.sessionId === sessionKey &&
+      !serverInputs.some((input) => input.message.id === submittingInput.userMessageId)
+    ) {
+      projected.push({
+        id: submittingInput.id,
+        isSubmitting: true,
+        preview: submittingInput.preview,
+      });
+    }
+    return projected;
+  }, [serverInputs, sessionKey, submittingInput]);
+  return { clearSubmittingInput, queuedInputs, stageSubmittingInput };
+}
+
+function useQueuedInputActions(params: {
+  readonly availableSkills: readonly { ref: string; name: string }[];
+  readonly restoreComposer: (snapshot: ComposerDraftSnapshot) => void;
+  readonly runQueue: SessionRunQueue;
+  readonly setSendError: (message: string | null) => void;
+}) {
+  const { availableSkills, restoreComposer, runQueue, setSendError } = params;
+  const editQueuedInput = useCallback((id: string) => {
+    const input = runQueue.inputs.find((item) => item.id === id);
+    if (!input) return;
+    void runQueue.removeQueuedInput(id).then((removed) => {
+      if (!removed) return;
+      restoreComposer(buildSessionQueuedInputComposerSnapshot(removed, availableSkills));
+      setSendError(null);
+    }).catch((error) => {
+      setSendError(error instanceof Error ? error.message : String(error));
+    });
+  }, [availableSkills, restoreComposer, runQueue, setSendError]);
+  const deleteQueuedInput = useCallback((id: string) => {
+    void runQueue.removeQueuedInput(id).then(() => setSendError(null)).catch((error) => {
+      setSendError(error instanceof Error ? error.message : String(error));
+    });
+  }, [runQueue, setSendError]);
+  return { deleteQueuedInput, editQueuedInput };
+}
+
 export function useSessionConversationController(params: UseSessionConversationControllerParams) {
   const {
     agent,
@@ -203,6 +303,17 @@ export function useSessionConversationController(params: UseSessionConversationC
     restoreComposer,
     setSendError,
   } = params;
+  const {
+    clearSubmittingInput,
+    queuedInputs,
+    stageSubmittingInput,
+  } = useSubmittingQueuedInputProjection(runQueue.inputs, sessionKey);
+  const { deleteQueuedInput, editQueuedInput } = useQueuedInputActions({
+    availableSkills: inputQuery.skillRecords,
+    restoreComposer,
+    runQueue,
+    setSendError,
+  });
   const parts = useMemo(
     () => deriveNcpMessagePartsFromComposer([...inputSnapshot.nodes], inputSnapshot.attachments),
     [inputSnapshot.attachments, inputSnapshot.nodes],
@@ -255,10 +366,17 @@ export function useSessionConversationController(params: UseSessionConversationC
     if (!envelope) {
       return;
     }
+    const queuedSubmission = agent.isRunning ? stageSubmittingInput(envelope) : null;
     resetComposer();
     setSendError(null);
     try {
       const handle = await agent.send(envelope);
+      if (queuedSubmission && handle?.runId === null) {
+        await runQueue.refreshQueuedInputs().catch(() => undefined);
+      }
+      if (queuedSubmission) {
+        clearSubmittingInput(queuedSubmission);
+      }
       const materializedSessionKey =
         handle?.sessionId?.trim() ||
         agent.snapshot.activeRun?.sessionId?.trim() ||
@@ -267,12 +385,16 @@ export function useSessionConversationController(params: UseSessionConversationC
         onSessionMaterialized?.(materializedSessionKey);
       }
     } catch (error) {
+      if (queuedSubmission) {
+        clearSubmittingInput(queuedSubmission);
+      }
       restoreComposer(draft.composerSnapshot);
       setSendError(error instanceof Error ? error.message : String(error));
       throw error;
     }
   }, [
     agent,
+    clearSubmittingInput,
     continueRun,
     inputQuery,
     inputSnapshot,
@@ -284,36 +406,11 @@ export function useSessionConversationController(params: UseSessionConversationC
     selectedAgentId,
     sessionKey,
     setSendError,
+    stageSubmittingInput,
     primaryAction,
+    runQueue,
   ]);
 
-  const editQueuedInput = useCallback((id: string) => {
-    const input = runQueue.inputs.find((item) => item.id === id);
-    if (!input) {
-      return;
-    }
-    void runQueue.removeQueuedInput(id).then((removed) => {
-      if (!removed) {
-        return;
-      }
-      restoreComposer(buildSessionQueuedInputComposerSnapshot(
-        removed,
-        inputQuery.skillRecords,
-      ));
-      setSendError(null);
-    }).catch((error) => {
-      setSendError(error instanceof Error ? error.message : String(error));
-    });
-  }, [inputQuery.skillRecords, restoreComposer, runQueue, setSendError]);
-
-  const deleteQueuedInput = useCallback((id: string) => {
-    void runQueue.removeQueuedInput(id).then(() => {
-      setSendError(null);
-    }).catch((error) => {
-      setSendError(error instanceof Error ? error.message : String(error));
-    });
-  }, [runQueue, setSendError]);
-
   const stop = useCallback(async () => {
     await agent.abort();
   }, [agent]);
@@ -327,10 +424,7 @@ export function useSessionConversationController(params: UseSessionConversationC
     editQueuedInput,
     hasSendableDraft,
     isSending,
-    queuedInputs: runQueue.inputs.map((input) => ({
-      id: input.id,
-      preview: buildSessionQueuedInputPreview(input),
-    })),
+    queuedInputs,
     send,
     sendDisabled,
     primaryAction,

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

@@ -16,6 +16,7 @@ export function useSessionRunQueue(sessionKey: string | null) {
     retry: false,
     staleTime: 5_000,
   });
+  const { data, isLoading, refetch } = query;
 
   useEffect(() => {
     if (!normalizedSessionKey) {
@@ -43,9 +44,18 @@ export function useSessionRunQueue(sessionKey: string | null) {
     );
   }, [normalizedSessionKey]);
 
+  const refreshQueuedInputs = useCallback(async (): Promise<readonly UiNcpSessionQueuedInputView[]> => {
+    if (!normalizedSessionKey) {
+      return [];
+    }
+    const result = await refetch();
+    return result.data?.inputs ?? [];
+  }, [normalizedSessionKey, refetch]);
+
   return {
-    inputs: query.data?.inputs ?? [],
-    isLoading: query.isLoading,
+    inputs: data?.inputs ?? [],
+    isLoading,
+    refreshQueuedInputs,
     removeQueuedInput,
   };
 }

package/src/features/chat/features/input/utils/__tests__/chat-inline-token.utils.test.ts

@@ -374,3 +374,34 @@ describe('chat inline token workspace references', () => {
     })).toBeNull();
   });
 });
+
+describe('UI resource inline tokens', () => {
+  it('round-trips the visible token with its selection-time snapshot', () => {
+    const reference = {
+      uri: 'nextclaw://apps?tab=panel-apps',
+      resourceKind: 'apps',
+      title: 'Panel Apps',
+      currentUrl: 'nextclaw://apps?tab=panel-apps',
+      contentParams: { filter: 'installed' },
+    };
+    const tokens = buildInlineTokensFromComposer([
+      createChatComposerTokenNode({
+        tokenKind: 'ui_resource',
+        tokenKey: reference.uri,
+        label: reference.title,
+        data: { reference },
+      }),
+    ]);
+
+    expect(tokens).toEqual([{
+      kind: 'ui_resource',
+      key: reference.uri,
+      label: reference.title,
+      rawText: `@resource:${encodeURIComponent(reference.uri)}`,
+      reference,
+    }]);
+    expect(readInlineTokensFromMetadata({
+      ui_inline_tokens: createInlineTokensMetadata(tokens),
+    })).toEqual(tokens);
+  });
+});

package/src/features/chat/features/input/utils/chat-composer-token-protocol.utils.ts

@@ -2,6 +2,7 @@ import {
   CHAT_CONVERSATION_EXCERPT_TOKEN_KIND,
   CHAT_PROJECT_TOKEN_KIND,
   CHAT_SYSTEM_OBJECT_TOKEN_KIND,
+  CHAT_UI_RESOURCE_TOKEN_KIND,
   CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND,
   CHAT_WORKSPACE_EXCERPT_TOKEN_KIND,
   CHAT_WORKSPACE_FILE_TOKEN_KIND,
@@ -15,6 +16,7 @@ const CHAT_WORKSPACE_DIRECTORY_TOKEN_PREFIX = '@folder:';
 const CHAT_WORKSPACE_EXCERPT_TOKEN_PREFIX = '@excerpt:';
 const CHAT_CONVERSATION_EXCERPT_TOKEN_PREFIX = '@message-excerpt:';
 const CHAT_SYSTEM_OBJECT_TOKEN_PREFIX = '@object:';
+const CHAT_UI_RESOURCE_TOKEN_PREFIX = '@resource:';
 
 export function serializeChatComposerTokenText(params: {
   label?: string;
@@ -46,5 +48,8 @@ export function serializeChatComposerTokenText(params: {
   if (tokenKind === CHAT_SYSTEM_OBJECT_TOKEN_KIND) {
     return `${CHAT_SYSTEM_OBJECT_TOKEN_PREFIX}${encodeURIComponent(tokenKey)}`;
   }
+  if (tokenKind === CHAT_UI_RESOURCE_TOKEN_KIND) {
+    return `${CHAT_UI_RESOURCE_TOKEN_PREFIX}${encodeURIComponent(tokenKey)}`;
+  }
   return null;
 }

package/src/features/chat/features/input/utils/chat-inline-token-composer.utils.ts

@@ -3,11 +3,13 @@ import {
   CHAT_CONVERSATION_EXCERPT_TOKEN_KIND,
   CHAT_PROJECT_TOKEN_KIND,
   CHAT_SYSTEM_OBJECT_TOKEN_KIND,
+  CHAT_UI_RESOURCE_TOKEN_KIND,
   CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND,
   CHAT_WORKSPACE_EXCERPT_TOKEN_KIND,
   CHAT_WORKSPACE_FILE_TOKEN_KIND,
   type ChatInlineTokenMetadata,
   type ChatSkillSource,
+  readChatUiResourceReference,
 } from '@nextclaw/shared';
 
 import { serializeChatComposerTokenText } from './chat-composer-token-protocol.utils';
@@ -83,6 +85,18 @@ function buildStructuredReferenceToken(
       }
       : null;
   }
+  if (node.tokenKind === CHAT_UI_RESOURCE_TOKEN_KIND) {
+    const reference = readChatUiResourceReference(node.data?.reference);
+    return reference?.uri === node.tokenKey
+      ? {
+          kind: CHAT_UI_RESOURCE_TOKEN_KIND,
+          key: node.tokenKey,
+          label: node.label,
+          rawText,
+          reference,
+        }
+      : null;
+  }
   return undefined;
 }
 

package/src/features/chat/features/input/utils/chat-inline-token.utils.ts

@@ -4,6 +4,7 @@ import {
   CHAT_INLINE_TOKENS_SCHEMA_VERSION,
   CHAT_PROJECT_TOKEN_KIND,
   CHAT_SYSTEM_OBJECT_TOKEN_KIND,
+  CHAT_UI_RESOURCE_TOKEN_KIND,
   CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND,
   CHAT_WORKSPACE_EXCERPT_TOKEN_KIND,
   CHAT_WORKSPACE_FILE_TOKEN_KIND,
@@ -11,6 +12,8 @@ import {
   type ChatInlineTokensMetadata,
   type ChatSkillSource,
   type SystemObjectResolvedReference,
+  type ChatUiResourceReference,
+  readChatUiResourceReference,
 } from '@nextclaw/shared';
 import { readConversationExcerptInlineToken } from './chat-conversation-excerpt-token.utils';
 import { readSystemObjectResolvedReference } from './chat-system-object-reference.utils';
@@ -26,6 +29,7 @@ const CHAT_PROJECT_TOKEN_PATTERN = /@project:([^\s]+)/g;
 const CHAT_WORKSPACE_FILE_TOKEN_PATTERN = /@file:([^\s]+)/g;
 const CHAT_WORKSPACE_DIRECTORY_TOKEN_PATTERN = /@folder:([^\s]+)/g;
 const CHAT_SYSTEM_OBJECT_TOKEN_PATTERN = /@object:([^\s]+)/g;
+const CHAT_UI_RESOURCE_TOKEN_PATTERN = /@resource:([^\s]+)/g;
 
 export type ChatInlineTokenSource =
   | {
@@ -68,6 +72,13 @@ export type ChatInlineTokenSource =
       label: string;
       rawText: string;
       reference: SystemObjectResolvedReference;
+    }
+  | {
+      kind: typeof CHAT_UI_RESOURCE_TOKEN_KIND;
+      key: string;
+      label: string;
+      rawText: string;
+      reference: ChatUiResourceReference;
     };
 
 export function resolveWorkspaceReferencePath(params: {
@@ -124,6 +135,7 @@ function appendEncodedKeyTokens(params: {
   kind:
     | typeof CHAT_PROJECT_TOKEN_KIND
     | typeof CHAT_SYSTEM_OBJECT_TOKEN_KIND
+    | typeof CHAT_UI_RESOURCE_TOKEN_KIND
     | typeof CHAT_WORKSPACE_FILE_TOKEN_KIND
     | typeof CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND;
   pattern: RegExp;
@@ -177,6 +189,12 @@ export function buildInlineTokensFromTextProtocol(text: string): ChatInlineToken
     text,
     tokens,
   });
+  appendEncodedKeyTokens({
+    kind: CHAT_UI_RESOURCE_TOKEN_KIND,
+    pattern: CHAT_UI_RESOURCE_TOKEN_PATTERN,
+    text,
+    tokens,
+  });
   appendEncodedKeyTokens({
     kind: CHAT_WORKSPACE_FILE_TOKEN_KIND,
     pattern: CHAT_WORKSPACE_FILE_TOKEN_PATTERN,
@@ -269,6 +287,13 @@ function readInlineTokenEntry(entry: unknown): ChatInlineTokenSource | null {
       ? { kind, key, label, rawText, reference }
       : null;
   }
+  if (kind === CHAT_UI_RESOURCE_TOKEN_KIND) {
+    const key = readOptionalString(entry.key);
+    const reference = readChatUiResourceReference(entry.reference);
+    return key && reference && reference.uri === key
+      ? { kind, key, label, rawText, reference }
+      : null;
+  }
   const key = readOptionalString(entry.key);
   return key ? { kind, key, rawText, label } : null;
 }

package/src/features/chat/features/message/hooks/use-chat-inline-token-actions.ts

@@ -2,10 +2,12 @@ import { useCallback } from "react";
 import type { ChatInlineTokenViewModel } from "@nextclaw/agent-chat-ui";
 import {
   CHAT_PROJECT_TOKEN_KIND,
+  CHAT_UI_RESOURCE_TOKEN_KIND,
   CHAT_WORKSPACE_EXCERPT_TOKEN_KIND,
 } from "@nextclaw/shared";
 import { toast } from "sonner";
 import { usePresenter } from "@/features/chat/components/providers/chat-presenter.provider";
+import { useAppPresenter } from "@/app/components/app-presenter-provider";
 import { resolveWorkspaceReferencePath } from "@/features/chat/features/input/utils/chat-inline-token.utils";
 import { fetchNcpSessionSkills } from "@/shared/lib/api";
 import { t } from "@/shared/lib/i18n";
@@ -21,9 +23,14 @@ export function useChatInlineTokenActions(params: {
 }) {
   const { selectedSession, sessionKey } = params;
   const presenter = usePresenter();
+  const appPresenter = useAppPresenter();
   const projectRoot = selectedSession?.projectRoot ?? selectedSession?.workingDir;
 
   const handleInlineTokenClick = useCallback((token: ChatInlineTokenViewModel) => {
+    if (token.kind === CHAT_UI_RESOURCE_TOKEN_KIND && "key" in token) {
+      appPresenter.docBrowserManager.open(token.key);
+      return;
+    }
     if (token.kind === "panel_app" && "key" in token) {
       void presenter.chatUiManager.showContent({
         target: { type: "panel_app", payload: { appId: token.key } },
@@ -98,7 +105,7 @@ export function useChatInlineTokenActions(params: {
         previewViewer: "rendered",
       });
     }).catch(() => toast.error(t("chatSkillPreviewUnavailable")));
-  }, [presenter, projectRoot, selectedSession?.projectRoot, sessionKey]);
+  }, [appPresenter.docBrowserManager, presenter, projectRoot, selectedSession?.projectRoot, sessionKey]);
 
   const handleAttachmentOpen = useCallback((file: {
     label: string;

package/src/features/chat/features/workspace/components/__tests__/chat-session-workspace-panel-content.test.tsx

@@ -5,6 +5,7 @@ import { ChatSessionWorkspacePanelContent } from '@/features/chat/features/works
 import type { ResolvedChildSessionTab } from '@/features/chat/features/ncp/hooks/use-ncp-child-session-tabs-view';
 import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
 import { CHAT_WORKSPACE_EXPLORER_DEFAULT_WIDTH } from '@/features/chat/features/workspace/utils/chat-workspace-panel-layout.utils';
+import { useWorkspaceProjectTreeStore } from '@/features/chat/features/workspace/stores/workspace-project-tree.store';
 
 const mocks = vi.hoisted(() => ({
   browseEntries: [
@@ -27,7 +28,9 @@ const mocks = vi.hoisted(() => ({
   deleteServerPathEntry: vi.fn(),
   renameServerPathEntry: vi.fn(),
   uploadServerPathFiles: vi.fn(),
+  watchDirectories: vi.fn(),
   refetchBrowse: vi.fn(),
+  refetchQueries: vi.fn(),
   requestDirectoryReference: vi.fn(),
   requestFileReference: vi.fn(),
   openChildSessions: vi.fn(),
@@ -41,6 +44,15 @@ const mocks = vi.hoisted(() => ({
   scrollIntoView: vi.fn(),
 }));
 
+vi.mock('@/shared/hooks/use-server-path-watch', () => ({
+  useServerPathWatch: mocks.watchDirectories,
+}));
+
+vi.mock('@tanstack/react-query', async (importOriginal) => ({
+  ...(await importOriginal()),
+  useQueryClient: () => ({ refetchQueries: mocks.refetchQueries }),
+}));
+
 function firePointerEvent(
   target: Window | Document | Node | Element,
   type: string,
@@ -168,6 +180,8 @@ beforeEach(() => {
     overwritten: false,
   });
   mocks.refetchBrowse.mockResolvedValue(undefined);
+  mocks.refetchQueries.mockResolvedValue(undefined);
+  useWorkspaceProjectTreeStore.setState({ trees: {} });
   useChatThreadStore.getState().setSnapshot({
     workspaceExplorerOpen: false,
     workspaceExplorerWidth: CHAT_WORKSPACE_EXPLORER_DEFAULT_WIDTH,
@@ -475,7 +489,7 @@ it('creates a project folder from the root toolbar and refreshes the tree', asyn
       parentPath: '/Users/peiwang/Projects/nextbot',
       name: 'research',
     });
-    expect(mocks.refetchBrowse).toHaveBeenCalled();
+    expect(mocks.refetchQueries).toHaveBeenCalled();
     expect(document.activeElement).toBe(screen.getByRole('button', { name: 'research' }));
     expect(mocks.scrollIntoView).toHaveBeenCalledTimes(2);
   });
@@ -564,7 +578,7 @@ it('uploads multiple project files from the root actions menu', async () => {
       files: [file],
       overwrite: undefined,
     });
-    expect(mocks.refetchBrowse).toHaveBeenCalled();
+    expect(mocks.refetchQueries).toHaveBeenCalled();
   });
 });
 
@@ -594,13 +608,62 @@ it('requires destructive confirmation before deleting a project file', async ()
       path: '/private/resolved-worktree/package.json',
     });
     expect(mocks.removeWorkspacePath).toHaveBeenCalledWith('/private/resolved-worktree/package.json');
-    expect(mocks.refetchBrowse).toHaveBeenCalled();
+    expect(mocks.refetchQueries).toHaveBeenCalled();
   });
 });
 
-it('preserves project tree expansion and scroll while visiting another workspace tab', async () => {
+it('refreshes the root and every active expanded directory query', async () => {
   const user = userEvent.setup();
-  const projectFilesProps = {
+  render(
+    <ChatSessionWorkspacePanelContent
+      activeSelection={{ kind: 'project-files' }}
+      childSessionTabs={[]}
+      filePreviewRefreshVersion={0}
+      sessionKey="parent-1"
+      sessionCronJobs={[]}
+      sessionProjectRoot="/Users/peiwang/Projects/nextbot"
+      sessionWorkingDir="/Users/peiwang/Projects/nextbot"
+    />,
+  );
+
+  await user.click(screen.getByRole('button', { name: 'src' }));
+  await user.click(screen.getByRole('button', { name: 'Refresh project files' }));
+
+  expect(mocks.refetchQueries).toHaveBeenCalledTimes(1);
+  const request = mocks.refetchQueries.mock.calls[0]?.[0] as {
+    predicate: (query: { queryKey: readonly unknown[] }) => boolean;
+    type: string;
+  };
+  expect(request.type).toBe('active');
+  expect(request.predicate({ queryKey: ['server-path-browse', '/Users/peiwang/Projects/nextbot', '', true] })).toBe(true);
+  expect(request.predicate({ queryKey: ['server-path-browse', '/Users/peiwang/Projects/nextbot/src', '', true] })).toBe(true);
+  expect(request.predicate({ queryKey: ['server-path-browse', '/tmp/another-project', '', true] })).toBe(false);
+});
+
+it('collapses all persisted directories in one action', async () => {
+  const user = userEvent.setup();
+  render(
+    <ChatSessionWorkspacePanelContent
+      activeSelection={{ kind: 'project-files' }}
+      childSessionTabs={[]}
+      filePreviewRefreshVersion={0}
+      sessionKey="parent-1"
+      sessionCronJobs={[]}
+      sessionProjectRoot="/Users/peiwang/Projects/nextbot"
+      sessionWorkingDir="/Users/peiwang/Projects/nextbot"
+    />,
+  );
+
+  const sourceDirectory = screen.getByRole('treeitem', { name: 'Open directory: src' });
+  await user.click(screen.getByRole('button', { name: 'src' }));
+  expect(sourceDirectory.getAttribute('aria-expanded')).toBe('true');
+  await user.click(screen.getByRole('button', { name: 'Collapse all' }));
+  expect(sourceDirectory.getAttribute('aria-expanded')).toBe('false');
+});
+
+it('restores expansion and scroll from project view state after remounting', async () => {
+  const user = userEvent.setup();
+  const props = {
     activeSelection: { kind: 'project-files' as const },
     childSessionTabs: [],
     filePreviewRefreshVersion: 0,
@@ -609,22 +672,16 @@ it('preserves project tree expansion and scroll while visiting another workspace
     sessionProjectRoot: '/Users/peiwang/Projects/nextbot',
     sessionWorkingDir: '/Users/peiwang/Projects/nextbot',
   };
-  const { rerender } = render(<ChatSessionWorkspacePanelContent {...projectFilesProps} />);
-  const tree = screen.getByRole('tree', { name: 'Project files' });
-  const sourceDirectory = screen.getByRole('treeitem', {
-    name: 'Open directory: src',
-  });
+  const first = render(<ChatSessionWorkspacePanelContent {...props} />);
   await user.click(screen.getByRole('button', { name: 'src' }));
-  tree.scrollTop = 128;
-  expect(sourceDirectory.getAttribute('aria-expanded')).toBe('true');
-
-  rerender(<ChatSessionWorkspacePanelContent {...projectFilesProps} activeSelection={{ kind: 'overview' }} />);
-  rerender(<ChatSessionWorkspacePanelContent {...projectFilesProps} />);
-
-  expect(screen.getByRole('tree', { name: 'Project files' })).toBe(tree);
-  expect(sourceDirectory.isConnected).toBe(true);
-  expect(sourceDirectory.getAttribute('aria-expanded')).toBe('true');
-  expect(tree.scrollTop).toBe(128);
+  const firstTree = screen.getByRole('tree', { name: 'Project files' });
+  firstTree.scrollTop = 144;
+  fireEvent.scroll(firstTree);
+  first.unmount();
+
+  render(<ChatSessionWorkspacePanelContent {...props} />);
+  expect(screen.getAllByRole('treeitem', { name: 'Open directory: src' })[0]?.getAttribute('aria-expanded')).toBe('true');
+  expect(screen.getByRole('tree', { name: 'Project files' }).scrollTop).toBe(144);
 });
 
 it('selects and reveals the active file when it is opened outside the Explorer', async () => {