@nextclaw/ui 0.15.26 → 0.15.27

package/src/features/chat/features/workspace/components/chat-session-workspace-directory-browser.tsx

@@ -1,4 +1,5 @@
-import { useState, type MouseEventHandler, type ReactNode } from 'react';
+import { useMemo, type ReactNode } from 'react';
+import { useQueryClient } from '@tanstack/react-query';
 import type { ChatFileOpenActionViewModel } from '@nextclaw/agent-chat-ui';
 import { ChevronsUp, Copy, FilePlus2, FolderPlus, LocateFixed, Upload, RefreshCw } from 'lucide-react';
 import { toast } from 'sonner';
@@ -10,6 +11,10 @@ import {
 } from '@/features/chat/features/workspace/components/project-files/workspace-directory-tree';
 import { WorkspaceNewFolderTreeItem } from '@/features/chat/features/workspace/components/project-files/workspace-new-folder-tree-item';
 import { WorkspaceProjectFilesToolbar } from '@/features/chat/features/workspace/components/project-files/workspace-project-files-toolbar';
+import {
+  isWorkspaceProjectBrowseQuery,
+  WorkspaceProjectTree,
+} from '@/features/chat/features/workspace/components/project-files/workspace-project-tree-view';
 import {
   useWorkspaceProjectFilesController,
   type RefreshDirectory,
@@ -18,10 +23,15 @@ import {
 } from '@/features/chat/features/workspace/hooks/use-workspace-file-actions';
 import { ContextMenu, type ContextMenuGroup } from '@/shared/components/ui/context-menu/context-menu';
 import { useConfirmDialog } from '@/shared/hooks/use-confirm-dialog';
+import { useServerPathWatch } from '@/shared/hooks/use-server-path-watch';
 import type { useServerPathBrowse } from '@/shared/hooks/use-server-path-browse';
 import type { ServerPathEntryView } from '@/shared/lib/api';
 import { hostCapabilityManager } from '@/shared/lib/host-capabilities';
 import { t } from '@/shared/lib/i18n';
+import {
+  normalizeWorkspaceProjectTreeRootKey,
+  useWorkspaceProjectTreeStore,
+} from '@/features/chat/features/workspace/stores/workspace-project-tree.store';
 
 type ChatSessionWorkspaceDirectoryBrowserProps = {
   activeRelativePath?: string | null;
@@ -32,6 +42,8 @@ type ChatSessionWorkspaceDirectoryBrowserProps = {
   showRoot?: boolean;
 };
 
+const EMPTY_EXPANDED_PATHS: readonly string[] = [];
+
 function readPathName(path: string): string {
   return path.split(/[\\/]/).filter(Boolean).pop() ?? path;
 }
@@ -39,7 +51,6 @@ function readPathName(path: string): string {
 function WorkspaceDirectoryEntries({
   activeRelativePath,
   busy,
-  collapseVersion,
   createTarget,
   entries,
   fallbackParentTarget,
@@ -60,10 +71,10 @@ function WorkspaceDirectoryEntries({
   revealPath,
   selectedPath,
   showRoot,
+  treeRootKey,
 }: {
   activeRelativePath: string | null;
   busy: boolean;
-  collapseVersion: number;
   createTarget: WorkspaceDirectoryActionTarget | null;
   entries: readonly ServerPathEntryView[];
   fallbackParentTarget: WorkspaceDirectoryActionTarget;
@@ -84,6 +95,7 @@ function WorkspaceDirectoryEntries({
   revealPath: string | null;
   selectedPath: string | null;
   showRoot: boolean;
+  treeRootKey: string | null;
 }) {
   if (entries.length === 0) {
     return <div className="px-4 py-8 text-center text-xs text-gray-400">{t('chatWorkspaceDirectoryEmpty')}</div>;
@@ -94,7 +106,6 @@ function WorkspaceDirectoryEntries({
       key={entry.path}
       browseParentRefresh={refresh}
       busy={busy}
-      collapseVersion={collapseVersion}
       createTarget={createTarget}
       entry={entry}
       level={showRoot ? 1 : 0}
@@ -113,6 +124,7 @@ function WorkspaceDirectoryEntries({
       renderCreateFolder={renderCreateFolder}
       revealPath={revealPath}
       selectedPath={selectedPath}
+      treeRootKey={treeRootKey}
     />
   ));
 }
@@ -207,45 +219,6 @@ function buildRootContextMenuGroups({
   ];
 }
 
-function WorkspaceProjectTree({
-  children,
-  currentPath,
-  onBlankContext,
-  onContextMenu,
-  rootDraft,
-  showRoot,
-}: {
-  children: ReactNode;
-  currentPath: string | null;
-  onBlankContext: () => void;
-  onContextMenu?: MouseEventHandler<HTMLDivElement>;
-  rootDraft: ReactNode;
-  showRoot: boolean;
-}) {
-  return (
-    <div
-      data-testid="workspace-directory-browser"
-      role="tree"
-      tabIndex={-1}
-      aria-label={t('chatWorkspaceProjectFiles')}
-      className="min-h-0 flex-1 overflow-auto py-1 custom-scrollbar"
-      onContextMenu={(event) => {
-        if (!(event.target as HTMLElement).closest('[data-workspace-tree-entry]')) onBlankContext();
-        onContextMenu?.(event);
-      }}
-    >
-      {showRoot && currentPath ? (
-        <>
-          {rootDraft}
-          {children}
-        </>
-      ) : (
-        children
-      )}
-    </div>
-  );
-}
-
 function WorkspaceDirectoryBrowserReady({
   activeRelativePath,
   browseQuery,
@@ -271,6 +244,7 @@ function WorkspaceDirectoryBrowserReady({
   rootPath: string | null;
   showRoot: boolean;
 }) {
+  const queryClient = useQueryClient();
   const {
     cancelCreateFolder,
     clearSelection,
@@ -298,8 +272,15 @@ function WorkspaceDirectoryBrowserReady({
     selectedPath,
   } = controller.state;
   const busy = pendingAction !== null;
-  const [collapseVersion, setCollapseVersion] = useState(0);
-  const rootRefresh = () => browseQuery.refetch();
+  const treeRootKey = normalizeWorkspaceProjectTreeRootKey(rootPath);
+  const collapseAll = useWorkspaceProjectTreeStore((state) => state.collapseAll);
+  const rootRefresh = () =>
+    rootPath
+      ? queryClient.refetchQueries({
+          predicate: (query) => isWorkspaceProjectBrowseQuery(query.queryKey, rootPath),
+          type: 'active',
+        })
+      : browseQuery.refetch();
   const rootTarget: WorkspaceDirectoryActionTarget | null = rootPath
     ? { label: rootLabel, path: rootPath, refresh: rootRefresh }
     : null;
@@ -328,7 +309,6 @@ function WorkspaceDirectoryBrowserReady({
     <WorkspaceDirectoryEntries
       activeRelativePath={activeRelativePath}
       busy={busy}
-      collapseVersion={collapseVersion}
       createTarget={createTarget}
       entries={entries}
       fallbackParentTarget={fallbackParentTarget}
@@ -349,6 +329,7 @@ function WorkspaceDirectoryBrowserReady({
       revealPath={revealPath}
       selectedPath={selectedPath}
       showRoot={false}
+      treeRootKey={treeRootKey || null}
     />
   );
   const tree = (
@@ -364,10 +345,12 @@ function WorkspaceDirectoryBrowserReady({
   const rootMenuGroups = rootTarget
     ? buildRootContextMenuGroups({
         busy,
-        onCollapseAll: () => setCollapseVersion((value) => value + 1),
+        onCollapseAll: () => {
+          if (treeRootKey) collapseAll(treeRootKey);
+        },
         onCreateFile: () => openCreateFile(rootTarget),
         onCreateFolder: () => openCreateFolder(rootTarget),
-        onRefresh: () => void browseQuery.refetch(),
+        onRefresh: () => void rootRefresh(),
         onRevealPath,
         onUpload: () => requestUpload(rootTarget),
         target: rootTarget,
@@ -385,10 +368,12 @@ function WorkspaceDirectoryBrowserReady({
         <WorkspaceProjectFilesToolbar
           disabled={busy}
           rootLabel={rootLabel}
-          onCollapseAll={() => setCollapseVersion((value) => value + 1)}
+          onCollapseAll={() => {
+            if (treeRootKey) collapseAll(treeRootKey);
+          }}
           onNewFile={() => openCreateFile(toolbarTarget)}
           onNewFolder={() => openCreateFolder(toolbarTarget)}
-          onRefresh={() => void browseQuery.refetch()}
+          onRefresh={() => void rootRefresh()}
         />
       ) : null}
       {rootPath ? (
@@ -427,6 +412,27 @@ export function ChatSessionWorkspaceDirectoryBrowser({
   const entries = browseQuery.data?.entries ?? [];
   const errorMessage = readBrowseError(browseQuery);
   const rootPath = showRoot ? (browseQuery.data?.currentPath ?? null) : null;
+  const treeRootKey = normalizeWorkspaceProjectTreeRootKey(rootPath);
+  const expandedPaths = useWorkspaceProjectTreeStore((state) =>
+    treeRootKey ? (state.trees[treeRootKey]?.expandedPaths ?? EMPTY_EXPANDED_PATHS) : EMPTY_EXPANDED_PATHS,
+  );
+  const watchedDirectories = useMemo(() => {
+    if (!rootPath) return [];
+    const separator = rootPath.includes('\\') && !rootPath.includes('/') ? '\\' : '/';
+    const normalizedRoot = rootPath.replace(/[\\/]+$/g, '');
+    const expandedPathSet = new Set(expandedPaths);
+    const visibleExpandedPaths = expandedPaths.filter((relativePath) => {
+      const segments = relativePath.split('/');
+      return segments.slice(0, -1).every((_, index) => expandedPathSet.has(segments.slice(0, index + 1).join('/')));
+    });
+    return [
+      rootPath,
+      ...visibleExpandedPaths.map(
+        (relativePath) => `${normalizedRoot}${separator}${relativePath.replace(/[\\/]+/g, separator)}`,
+      ),
+    ];
+  }, [expandedPaths, rootPath]);
+  useServerPathWatch(watchedDirectories);
   const rootLabel = rootPath ? readPathName(rootPath) : '';
   const controller = useWorkspaceProjectFilesController({
     activeRelativePath,

package/src/features/chat/features/workspace/components/project-files/workspace-directory-tree.tsx

@@ -1,4 +1,4 @@
-import { useEffect, useLayoutEffect, useMemo, useRef, useState, type ReactNode } from 'react';
+import { useCallback, useLayoutEffect, useMemo, useRef, useState, type ReactNode } from 'react';
 import type { ChatFileOpenActionViewModel } from '@nextclaw/agent-chat-ui';
 import {
   ChevronDown,
@@ -26,13 +26,16 @@ import { buildServerPathContentUrl, type ServerPathEntryView } from '@/shared/li
 import { t } from '@/shared/lib/i18n';
 import { cn } from '@/shared/lib/utils';
 import { buildWorkspaceEntryContextMenuGroups } from '@/features/chat/features/workspace/components/project-files/workspace-directory-entry-menu';
+import {
+  normalizeWorkspaceProjectTreeRelativePath,
+  useWorkspaceProjectTreeStore,
+} from '@/features/chat/features/workspace/stores/workspace-project-tree.store';
 
 export { copyWorkspacePath } from '@/features/chat/features/workspace/components/project-files/workspace-directory-entry-menu';
 
 type WorkspaceDirectoryTreeActionProps = {
   activeRelativePath: string | null;
   busy: boolean;
-  collapseVersion: number;
   createTarget: WorkspaceDirectoryActionTarget | null;
   onAddToChat?: (entry: ServerPathEntryView, relativePath: string) => void;
   onCreateFolder?: (target: WorkspaceDirectoryActionTarget) => void;
@@ -45,6 +48,7 @@ type WorkspaceDirectoryTreeActionProps = {
   renderCreateFolder: (level: number) => ReactNode;
   revealPath: string | null;
   selectedPath: string | null;
+  treeRootKey: string | null;
 };
 
 function buildEntryLabel(entry: ServerPathEntryView): string {
@@ -206,11 +210,31 @@ function isWorkspaceTreeEntryExpanded(
   );
 }
 
+function useWorkspaceTreeEntryExpansion(treeRootKey: string | null, relativePath: string | null) {
+  const [locallyExpanded, setLocallyExpanded] = useState(false);
+  const relativePathKey = normalizeWorkspaceProjectTreeRelativePath(relativePath);
+  const persistedExpanded = useWorkspaceProjectTreeStore((state) =>
+    Boolean(treeRootKey && relativePathKey && state.trees[treeRootKey]?.expandedPaths.includes(relativePathKey)),
+  );
+  const setDirectoryExpanded = useWorkspaceProjectTreeStore((state) => state.setDirectoryExpanded);
+  const manuallyExpanded = treeRootKey && relativePathKey ? persistedExpanded : locallyExpanded;
+  const updateExpanded = useCallback(
+    (expanded: boolean) => {
+      if (treeRootKey && relativePathKey) {
+        setDirectoryExpanded(treeRootKey, relativePathKey, expanded);
+        return;
+      }
+      setLocallyExpanded(expanded);
+    },
+    [relativePathKey, setDirectoryExpanded, treeRootKey],
+  );
+  return { manuallyExpanded, updateExpanded };
+}
+
 export function WorkspaceDirectoryTreeEntry({
   activeRelativePath,
   browseParentRefresh,
   busy,
-  collapseVersion,
   createTarget,
   entry,
   level,
@@ -229,6 +253,7 @@ export function WorkspaceDirectoryTreeEntry({
   renderCreateFolder,
   revealPath,
   selectedPath,
+  treeRootKey,
 }: WorkspaceDirectoryTreeActionProps & {
   browseParentRefresh: RefreshDirectory;
   entry: ServerPathEntryView;
@@ -241,7 +266,7 @@ export function WorkspaceDirectoryTreeEntry({
   const rowRef = useRef<HTMLDivElement | null>(null);
   const entryButtonRef = useRef<HTMLButtonElement | null>(null);
   const isDirectory = entry.kind === 'directory';
-  const [manuallyExpanded, setIsExpanded] = useState(false);
+  const { manuallyExpanded, updateExpanded } = useWorkspaceTreeEntryExpansion(treeRootKey, relativePath);
   const isExpanded = isWorkspaceTreeEntryExpanded(
     manuallyExpanded,
     isDirectory,
@@ -254,9 +279,6 @@ export function WorkspaceDirectoryTreeEntry({
     onRename,
     refresh: browseParentRefresh,
   });
-  useEffect(() => {
-    if (collapseVersion > 0) setIsExpanded(false);
-  }, [collapseVersion]);
   const browseQuery = useServerPathBrowse({
     path: entry.path,
     includeFiles: true,
@@ -271,10 +293,10 @@ export function WorkspaceDirectoryTreeEntry({
             label: entry.name,
             path: entry.path,
             refresh: () => refreshDirectory(),
-            expand: () => setIsExpanded(true),
+            expand: () => updateExpanded(true),
           }
         : parentCreateTarget,
-    [entry.name, entry.path, isDirectory, parentCreateTarget, refreshDirectory],
+    [entry.name, entry.path, isDirectory, parentCreateTarget, refreshDirectory, updateExpanded],
   );
   const selection = useMemo<WorkspaceTreeSelection>(
     () => ({ path: entry.path, createTarget: ownCreateTarget }),
@@ -301,7 +323,7 @@ export function WorkspaceDirectoryTreeEntry({
 
   const activateEntry = () => {
     onSelect(selection);
-    if (isDirectory) setIsExpanded(!isExpanded);
+    if (isDirectory) updateExpanded(!isExpanded);
     else onFileOpen({ path: entry.path, label: entry.name, viewMode: 'preview' });
   };
 
@@ -433,7 +455,6 @@ export function WorkspaceDirectoryTreeEntry({
             activeRelativePath={activeRelativePath}
             browseQuery={browseQuery}
             busy={busy}
-            collapseVersion={collapseVersion}
             createTarget={createTarget}
             level={level}
             onAddToChat={onAddToChat}
@@ -451,6 +472,7 @@ export function WorkspaceDirectoryTreeEntry({
             renderCreateFolder={renderCreateFolder}
             revealPath={revealPath}
             selectedPath={selectedPath}
+            treeRootKey={treeRootKey}
           />
         </div>
       ) : null}

package/src/features/chat/features/workspace/components/project-files/workspace-project-tree-view.tsx

@@ -0,0 +1,93 @@
+import { useEffect, useLayoutEffect, useRef, type MouseEventHandler, type ReactNode } from 'react';
+import type { QueryKey } from '@tanstack/react-query';
+import {
+  normalizeWorkspaceProjectTreeRootKey,
+  useWorkspaceProjectTreeStore,
+} from '@/features/chat/features/workspace/stores/workspace-project-tree.store';
+import { t } from '@/shared/lib/i18n';
+
+function normalizeComparablePath(path: string): string {
+  const normalized = path.trim().replace(/\\/g, '/').replace(/\/+$/g, '') || '/';
+  return /^[a-z]:/i.test(normalized) ? normalized.toLowerCase() : normalized;
+}
+
+export function isWorkspaceProjectBrowseQuery(queryKey: QueryKey, rootPath: string): boolean {
+  if (queryKey[0] !== 'server-path-browse' || queryKey[3] !== true || typeof queryKey[1] !== 'string') {
+    return false;
+  }
+  const root = normalizeComparablePath(rootPath);
+  const candidate = normalizeComparablePath(queryKey[1]);
+  return candidate === root || (root === '/' ? candidate.startsWith('/') : candidate.startsWith(`${root}/`));
+}
+
+export function WorkspaceProjectTree({
+  children,
+  currentPath,
+  onBlankContext,
+  onContextMenu,
+  rootDraft,
+  showRoot,
+}: {
+  children: ReactNode;
+  currentPath: string | null;
+  onBlankContext: () => void;
+  onContextMenu?: MouseEventHandler<HTMLDivElement>;
+  rootDraft: ReactNode;
+  showRoot: boolean;
+}) {
+  const treeRef = useRef<HTMLDivElement | null>(null);
+  const pendingScrollTopRef = useRef<number | null>(null);
+  const scrollPersistTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const treeRootKey = normalizeWorkspaceProjectTreeRootKey(currentPath);
+  const savedScrollTop = useWorkspaceProjectTreeStore((state) =>
+    treeRootKey ? (state.trees[treeRootKey]?.scrollTop ?? 0) : 0,
+  );
+  const setScrollTop = useWorkspaceProjectTreeStore((state) => state.setScrollTop);
+
+  useLayoutEffect(() => {
+    if (treeRef.current && treeRootKey) treeRef.current.scrollTop = savedScrollTop;
+  }, [savedScrollTop, treeRootKey]);
+
+  useEffect(
+    () => () => {
+      if (scrollPersistTimerRef.current) clearTimeout(scrollPersistTimerRef.current);
+      if (treeRootKey && pendingScrollTopRef.current !== null) {
+        setScrollTop(treeRootKey, pendingScrollTopRef.current);
+      }
+    },
+    [setScrollTop, treeRootKey],
+  );
+
+  return (
+    <div
+      ref={treeRef}
+      data-testid="workspace-directory-browser"
+      role="tree"
+      tabIndex={-1}
+      aria-label={t('chatWorkspaceProjectFiles')}
+      className="min-h-0 flex-1 overflow-auto py-1 custom-scrollbar"
+      onContextMenu={(event) => {
+        if (!(event.target as HTMLElement).closest('[data-workspace-tree-entry]')) onBlankContext();
+        onContextMenu?.(event);
+      }}
+      onScroll={(event) => {
+        if (!treeRootKey) return;
+        pendingScrollTopRef.current = event.currentTarget.scrollTop;
+        if (scrollPersistTimerRef.current) clearTimeout(scrollPersistTimerRef.current);
+        scrollPersistTimerRef.current = setTimeout(() => {
+          scrollPersistTimerRef.current = null;
+          if (pendingScrollTopRef.current !== null) setScrollTop(treeRootKey, pendingScrollTopRef.current);
+        }, 120);
+      }}
+    >
+      {showRoot && currentPath ? (
+        <>
+          {rootDraft}
+          {children}
+        </>
+      ) : (
+        children
+      )}
+    </div>
+  );
+}

package/src/features/chat/features/workspace/stores/__tests__/workspace-project-tree.store.test.ts

@@ -0,0 +1,38 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { useWorkspaceProjectTreeStore } from '@/features/chat/features/workspace/stores/workspace-project-tree.store';
+
+const ROOT = '/Users/peiwang/Projects/nextbot';
+
+describe('workspace project tree store', () => {
+  beforeEach(() => {
+    window.localStorage.clear();
+    useWorkspaceProjectTreeStore.setState({ trees: {} });
+  });
+
+  it('keeps expansion and scroll view state isolated by project root', () => {
+    const store = useWorkspaceProjectTreeStore.getState();
+    store.setDirectoryExpanded(ROOT, 'src/features', true);
+    store.setScrollTop(ROOT, 128.4);
+    store.setDirectoryExpanded('/tmp/another-project', 'docs', true);
+
+    expect(useWorkspaceProjectTreeStore.getState().trees[ROOT]).toMatchObject({
+      expandedPaths: ['src/features'],
+      scrollTop: 128,
+    });
+    expect(useWorkspaceProjectTreeStore.getState().trees['/tmp/another-project']).toMatchObject({
+      expandedPaths: ['docs'],
+      scrollTop: 0,
+    });
+  });
+
+  it('normalizes paths and collapses only the requested project', () => {
+    const store = useWorkspaceProjectTreeStore.getState();
+    store.setDirectoryExpanded(`${ROOT}/`, '/src\\features/', true);
+    store.setDirectoryExpanded(ROOT, 'src/features', true);
+    store.setDirectoryExpanded('/tmp/another-project', 'docs', true);
+    useWorkspaceProjectTreeStore.getState().collapseAll(ROOT);
+
+    expect(useWorkspaceProjectTreeStore.getState().trees[ROOT]?.expandedPaths).toEqual([]);
+    expect(useWorkspaceProjectTreeStore.getState().trees['/tmp/another-project']?.expandedPaths).toEqual(['docs']);
+  });
+});

package/src/features/chat/features/workspace/stores/workspace-project-tree.store.ts

@@ -0,0 +1,160 @@
+import { create } from 'zustand';
+import { createJSONStorage, persist } from 'zustand/middleware';
+
+const WORKSPACE_PROJECT_TREE_STORAGE_KEY = 'nextclaw.chat.workspace-project-tree.state';
+const WORKSPACE_PROJECT_TREE_STORAGE_VERSION = 1;
+const MAX_PERSISTED_PROJECT_TREES = 12;
+const MAX_PERSISTED_EXPANDED_PATHS = 256;
+const MAX_PERSISTED_SCROLL_TOP = 10_000_000;
+
+export type WorkspaceProjectTreeViewState = {
+  expandedPaths: string[];
+  scrollTop: number;
+  updatedAt: number;
+};
+
+type WorkspaceProjectTreeStore = {
+  trees: Record<string, WorkspaceProjectTreeViewState>;
+  collapseAll: (rootPath: string) => void;
+  setDirectoryExpanded: (rootPath: string, relativePath: string, expanded: boolean) => void;
+  setScrollTop: (rootPath: string, scrollTop: number) => void;
+};
+
+type PersistedWorkspaceProjectTreeStore = Pick<WorkspaceProjectTreeStore, 'trees'>;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === 'object';
+}
+
+export function normalizeWorkspaceProjectTreeRootKey(path: string | null | undefined): string {
+  const normalized = path?.trim().replace(/\\/g, '/').replace(/\/+$/g, '') ?? '';
+  return normalized || (path?.trim() === '/' ? '/' : '');
+}
+
+export function normalizeWorkspaceProjectTreeRelativePath(path: string | null | undefined): string {
+  return path?.trim().replace(/\\/g, '/').replace(/^\/+|\/+$/g, '').replace(/\/{2,}/g, '/') ?? '';
+}
+
+function normalizeScrollTop(value: unknown): number {
+  if (typeof value !== 'number' || !Number.isFinite(value)) return 0;
+  return Math.min(Math.max(0, Math.round(value)), MAX_PERSISTED_SCROLL_TOP);
+}
+
+function normalizeUpdatedAt(value: unknown): number {
+  return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : 0;
+}
+
+function normalizeExpandedPaths(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return Array.from(
+    new Set(
+      value
+        .map((path) => (typeof path === 'string' ? normalizeWorkspaceProjectTreeRelativePath(path) : ''))
+        .filter(Boolean),
+    ),
+  ).slice(0, MAX_PERSISTED_EXPANDED_PATHS);
+}
+
+function normalizePersistedTrees(value: unknown): Record<string, WorkspaceProjectTreeViewState> {
+  if (!isRecord(value)) return {};
+  return Object.entries(value)
+    .map(([rootPath, tree]) => {
+      const rootKey = normalizeWorkspaceProjectTreeRootKey(rootPath);
+      if (!rootKey || !isRecord(tree)) return null;
+      return [
+        rootKey,
+        {
+          expandedPaths: normalizeExpandedPaths(tree.expandedPaths),
+          scrollTop: normalizeScrollTop(tree.scrollTop),
+          updatedAt: normalizeUpdatedAt(tree.updatedAt),
+        },
+      ] as const;
+    })
+    .filter((entry): entry is readonly [string, WorkspaceProjectTreeViewState] => entry !== null)
+    .sort((left, right) => right[1].updatedAt - left[1].updatedAt)
+    .slice(0, MAX_PERSISTED_PROJECT_TREES)
+    .reduce<Record<string, WorkspaceProjectTreeViewState>>((trees, [rootKey, tree]) => {
+      trees[rootKey] = tree;
+      return trees;
+    }, {});
+}
+
+function retainRecentTrees(
+  trees: Record<string, WorkspaceProjectTreeViewState>,
+): Record<string, WorkspaceProjectTreeViewState> {
+  return normalizePersistedTrees(trees);
+}
+
+function createTreeViewState(): WorkspaceProjectTreeViewState {
+  return { expandedPaths: [], scrollTop: 0, updatedAt: Date.now() };
+}
+
+export const useWorkspaceProjectTreeStore = create<WorkspaceProjectTreeStore>()(
+  persist(
+    (set) => ({
+      trees: {},
+      collapseAll: (rootPath) => {
+        const rootKey = normalizeWorkspaceProjectTreeRootKey(rootPath);
+        if (!rootKey) return;
+        set((state) => {
+          const current = state.trees[rootKey];
+          if (!current || current.expandedPaths.length === 0) return state;
+          return {
+            trees: retainRecentTrees({
+              ...state.trees,
+              [rootKey]: { ...current, expandedPaths: [], updatedAt: Date.now() },
+            }),
+          };
+        });
+      },
+      setDirectoryExpanded: (rootPath, relativePath, expanded) => {
+        const rootKey = normalizeWorkspaceProjectTreeRootKey(rootPath);
+        const pathKey = normalizeWorkspaceProjectTreeRelativePath(relativePath);
+        if (!rootKey || !pathKey) return;
+        set((state) => {
+          const current = state.trees[rootKey] ?? createTreeViewState();
+          const expandedPaths = expanded
+            ? Array.from(new Set([...current.expandedPaths, pathKey])).slice(0, MAX_PERSISTED_EXPANDED_PATHS)
+            : current.expandedPaths.filter((path) => path !== pathKey);
+          if (
+            expandedPaths.length === current.expandedPaths.length &&
+            expandedPaths.every((path, index) => path === current.expandedPaths[index])
+          ) {
+            return state;
+          }
+          return {
+            trees: retainRecentTrees({
+              ...state.trees,
+              [rootKey]: { ...current, expandedPaths, updatedAt: Date.now() },
+            }),
+          };
+        });
+      },
+      setScrollTop: (rootPath, scrollTop) => {
+        const rootKey = normalizeWorkspaceProjectTreeRootKey(rootPath);
+        if (!rootKey) return;
+        const normalizedScrollTop = normalizeScrollTop(scrollTop);
+        set((state) => {
+          const current = state.trees[rootKey] ?? createTreeViewState();
+          if (current.scrollTop === normalizedScrollTop) return state;
+          return {
+            trees: retainRecentTrees({
+              ...state.trees,
+              [rootKey]: { ...current, scrollTop: normalizedScrollTop, updatedAt: Date.now() },
+            }),
+          };
+        });
+      },
+    }),
+    {
+      name: WORKSPACE_PROJECT_TREE_STORAGE_KEY,
+      version: WORKSPACE_PROJECT_TREE_STORAGE_VERSION,
+      storage: createJSONStorage(() => window.localStorage),
+      partialize: (state): PersistedWorkspaceProjectTreeStore => ({ trees: state.trees }),
+      merge: (persistedState, currentState) => ({
+        ...currentState,
+        trees: normalizePersistedTrees(isRecord(persistedState) ? persistedState.trees : null),
+      }),
+    },
+  ),
+);

package/src/features/chat/index.ts

@@ -4,6 +4,7 @@ export { ChatPresenterProvider } from "./components/providers/chat-presenter.pro
 export { usePresenter } from "./components/providers/chat-presenter.provider";
 export { ChatPresenter } from "./presenters/chat.presenter";
 export { ChatDraftIntentManager } from "./managers/chat-draft-intent.manager";
+export { ChatComposerIntentManager } from "./managers/chat-composer-intent.manager";
 export { ChatCompletionNotificationManager } from "./managers/chat-completion-notification.manager";
 export { buildSessionPath, CHAT_DRAFT_SESSION_PATH } from "./features/session/utils/chat-session-route.utils";
 export { useChatSessionListStore } from "./stores/chat-session-list.store";

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

@@ -152,4 +152,33 @@ describe('ChatComposerIntentManager', () => {
       }),
     );
   });
+
+  it('publishes an immutable UI resource reference to the targeted composer', () => {
+    const manager = new ChatComposerIntentManager();
+    const listener = vi.fn();
+    manager.subscribe('session-1', listener);
+    const reference = {
+      uri: 'nextclaw://panel-app/task-board',
+      resourceKind: 'panel-app',
+      title: 'Task board',
+      currentUrl: '/api/panel-apps/task-board/content',
+      contentParams: { boardId: 'today' },
+    };
+
+    manager.requestUiResourceReference({
+      targetSessionKey: 'session-1',
+      reference,
+    });
+    reference.contentParams.boardId = 'mutated';
+
+    expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+      kind: 'ui_resource',
+      targetSessionKey: 'session-1',
+      tokenKey: 'nextclaw://panel-app/task-board',
+      label: 'Task board',
+      reference: expect.objectContaining({
+        contentParams: { boardId: 'today' },
+      }),
+    }));
+  });
 });