@@ -30,6 +30,12 @@ import { PIERRE_TREE_UNSAFE_CSS, pierreTreeStyle } from "~/pierre-tree-theme";
 import { joinHostPath } from "./filePath";
 import { createFileTreeDragMentionController } from "./fileTreeDragMention";
 import { areAllDirectoriesExpanded, setAllDirectoriesExpanded } from "./fileTreeExpansion";
+import {
+  fileTreeExpansionStorageKey,
+  readExpandedPaths,
+  syncPersistedExpansion,
+  writeExpandedPaths,
+} from "./fileTreeExpansionStorage";
 import { buildFileTreePathUpdates } from "./fileTreePathReconciliation";
 import { useDirectoryEntries } from "./useDirectoryEntries";
 import { useProjectPathSearch } from "~/state/queries";
@@ -157,6 +163,7 @@ export default function FileBrowserPanel({
     error,
     isPending,
     loadingDirectories,
+    loadedDirectories,
   } = useDirectoryEntries(environmentId, cwd);
   const [query, setQuery] = useState("");
   const [expandAll, setExpandAll] = useState(false);
@@ -330,13 +337,32 @@ export default function FileBrowserPanel({
     search.close();
   };
   const expandedPathsRef = useRef(new Set<string>());
+  // The panel unmounts with its right-panel tab, so the remembered folders live
+  // in storage. The panel is keyed by workspace, so these are read once.
+  const expansionStorageKey = fileTreeExpansionStorageKey(environmentId, cwd);
+  const [persistedExpansion] = useState(() => {
+    const persisted = readExpandedPaths(expansionStorageKey);
+    return { persisted, pendingRestore: new Set(persisted) };
+  });
   useEffect(() => {
     const currentPaths = new Set(directoryPaths);
     for (const path of expandedPathsRef.current) {
       if (!currentPaths.has(path)) expandedPathsRef.current.delete(path);
     }
     const loadExpanded = () => {
       if (model.isSearchOpen()) return;
+      const { persisted, pendingRestore } = persistedExpansion;
+      if (
+        syncPersistedExpansion({
+          model,
+          directoryPaths,
+          loadedDirectories,
+          persisted,
+          pendingRestore,
+        })
+      ) {
+        writeExpandedPaths(expansionStorageKey, persisted);
+      }
       for (const path of directoryPaths) {
         const item = model.getItem(path);
         if (item?.isDirectory() && "isExpanded" in item && item.isExpanded()) {
@@ -352,7 +378,7 @@ export default function FileBrowserPanel({
     };
     loadExpanded();
     return model.subscribe(loadExpanded);
-  }, [directoryPaths, load, model]);
+  }, [directoryPaths, expansionStorageKey, load, loadedDirectories, model, persistedExpansion]);
   useEffect(() => {
     model.setGitStatus(
       entries
 
@@ -9,7 +9,7 @@ type DirectoryHandle = {
   collapse(): void;
 };
 
-function asDirectoryHandle(item: unknown): DirectoryHandle | null {
+export function asDirectoryHandle(item: unknown): DirectoryHandle | null {
   if (
     typeof item !== "object" ||
     item === null ||
 
@@ -0,0 +1,119 @@
+import { EnvironmentId } from "@t3tools/contracts";
+import { describe, expect, it } from "@effect/vitest";
+import * as Schema from "effect/Schema";
+
+import { setLocalStorageItem } from "~/hooks/useLocalStorage";
+
+import {
+  fileTreeExpansionStorageKey,
+  readExpandedPaths,
+  syncPersistedExpansion,
+  writeExpandedPaths,
+} from "./fileTreeExpansionStorage";
+
+/** Rows exist only for listed directories, like the real tree. */
+function makeTree(rows: Record<string, boolean>) {
+  const item = (path: string) => ({
+    isDirectory: () => true,
+    isExpanded: () => rows[path] ?? false,
+    expand: () => {
+      rows[path] = true;
+    },
+    collapse: () => {
+      rows[path] = false;
+    },
+  });
+  return {
+    rows,
+    model: { getItem: (path: string) => (path in rows ? item(path) : null) },
+  };
+}
+
+function sync(args: {
+  tree: ReturnType<typeof makeTree>;
+  loaded: string[];
+  persisted: string[];
+  pending?: string[];
+}) {
+  const persisted = new Set(args.persisted);
+  const pendingRestore = new Set(args.pending ?? args.persisted);
+  const changed = syncPersistedExpansion({
+    model: args.tree.model,
+    directoryPaths: Object.keys(args.tree.rows),
+    loadedDirectories: new Set(args.loaded),
+    persisted,
+    pendingRestore,
+  });
+  return { changed, persisted, pendingRestore };
+}
+
+describe("file tree expansion storage", () => {
+  const key = fileTreeExpansionStorageKey(EnvironmentId.make("env-1"), "/work/app");
+
+  it("round-trips the expanded set and treats missing or malformed storage as empty", () => {
+    expect(readExpandedPaths(key).size).toBe(0);
+    writeExpandedPaths(key, new Set(["apps", "apps/web"]));
+    expect([...readExpandedPaths(key)]).toEqual(["apps", "apps/web"]);
+    writeExpandedPaths(key, new Set());
+    expect(readExpandedPaths(key).size).toBe(0);
+    setLocalStorageItem(key, 5, Schema.Number);
+    expect(readExpandedPaths(key).size).toBe(0);
+  });
+
+  it("keeps the shallowest folders when the set is larger than the bound", () => {
+    const deep = Array.from({ length: 600 }, (_, index) => `a/b/c/${index}`);
+    writeExpandedPaths(key, new Set([...deep, "a", "a/b"]));
+    const stored = readExpandedPaths(key);
+    expect(stored.size).toBe(500);
+    expect(stored.has("a")).toBe(true);
+    expect(stored.has("a/b")).toBe(true);
+  });
+});
+
+describe("syncPersistedExpansion", () => {
+  it("restores a remembered folder once its row appears and keeps the rest pending", () => {
+    // `apps/web` is listed only after `apps` is expanded.
+    const tree = makeTree({ "apps/": false, "docs/": false });
+    const first = sync({ tree, loaded: [""], persisted: ["apps", "apps/web"] });
+    expect(tree.rows["apps/"]).toBe(true);
+    expect([...first.pendingRestore]).toEqual(["apps/web"]);
+    expect([...first.persisted]).toEqual(["apps", "apps/web"]);
+
+    tree.rows["apps/web/"] = false;
+    const second = sync({
+      tree,
+      loaded: ["", "apps"],
+      persisted: [...first.persisted],
+      pending: [...first.pendingRestore],
+    });
+    expect(tree.rows["apps/web/"]).toBe(true);
+    expect(second.pendingRestore.size).toBe(0);
+    expect(second.changed).toBe(false);
+  });
+
+  it("does not forget remembered folders before they have been listed", () => {
+    const tree = makeTree({ "apps/": false });
+    const result = sync({ tree, loaded: [""], persisted: ["apps", "apps/web"] });
+    expect(result.persisted.has("apps/web")).toBe(true);
+    expect(result.changed).toBe(false);
+  });
+
+  it("forgets folders their parent no longer lists, and ones the user collapses", () => {
+    const tree = makeTree({ "apps/": true, "docs/": false });
+    const result = sync({
+      tree,
+      loaded: ["", "apps"],
+      persisted: ["apps", "docs", "apps/gone"],
+      pending: [],
+    });
+    expect([...result.persisted]).toEqual(["apps"]);
+    expect(result.changed).toBe(true);
+  });
+
+  it("remembers folders the user expands", () => {
+    const tree = makeTree({ "apps/": true });
+    const result = sync({ tree, loaded: [""], persisted: [], pending: [] });
+    expect([...result.persisted]).toEqual(["apps"]);
+    expect(result.changed).toBe(true);
+  });
+});
@@ -0,0 +1,93 @@
+import type { EnvironmentId } from "@t3tools/contracts";
+import * as Schema from "effect/Schema";
+
+import {
+  getLocalStorageItem,
+  removeLocalStorageItem,
+  setLocalStorageItem,
+} from "~/hooks/useLocalStorage";
+
+import { asDirectoryHandle, type FileTreeExpansionModel } from "./fileTreeExpansion";
+
+/** Bounds what a huge "expand all" can write; shallow folders win so restore still reaches them. */
+const MAX_PERSISTED_EXPANDED_PATHS = 500;
+
+const ExpandedPathsSchema = Schema.Array(Schema.String);
+
+/** Expansion is workspace-scoped, like the tree itself, not per thread. */
+export function fileTreeExpansionStorageKey(environmentId: EnvironmentId, cwd: string): string {
+  return `t3code.fileTreeExpanded:${environmentId}:${cwd}`;
+}
+
+/** Expanded directory paths without the trailing slash; unreadable storage restores nothing. */
+export function readExpandedPaths(storageKey: string): Set<string> {
+  try {
+    return new Set(getLocalStorageItem(storageKey, ExpandedPathsSchema) ?? []);
+  } catch {
+    return new Set();
+  }
+}
+
+export function writeExpandedPaths(storageKey: string, paths: ReadonlySet<string>): void {
+  try {
+    if (paths.size === 0) {
+      removeLocalStorageItem(storageKey);
+      return;
+    }
+    const depth = (path: string) => path.split("/").length;
+    const bounded = [...paths]
+      .toSorted((a, b) => depth(a) - depth(b))
+      .slice(0, MAX_PERSISTED_EXPANDED_PATHS);
+    setLocalStorageItem(storageKey, bounded, ExpandedPathsSchema);
+  } catch {
+    // Remembering folders is a convenience; a full or blocked storage must not break the tree.
+  }
+}
+
+function parentDirectory(path: string): string {
+  return path.slice(0, Math.max(0, path.lastIndexOf("/")));
+}
+
+/**
+ * Reconciles the remembered folders with the tree rows. `persisted` is the set
+ * to store; `pendingRestore` holds remembered folders whose row has not
+ * appeared yet. Rows only exist once their parent is listed, so expanding each
+ * as it appears restores parent-before-child. A folder is forgotten when it is
+ * collapsed or when its parent was listed and no longer has it. Returns whether
+ * `persisted` changed.
+ */
+export function syncPersistedExpansion(args: {
+  readonly model: FileTreeExpansionModel;
+  /** Tree paths of known directories, with the trailing slash. */
+  readonly directoryPaths: readonly string[];
+  /** Directories whose listing succeeded. */
+  readonly loadedDirectories: ReadonlySet<string>;
+  readonly persisted: Set<string>;
+  readonly pendingRestore: Set<string>;
+}): boolean {
+  const { model, directoryPaths, loadedDirectories, persisted, pendingRestore } = args;
+  const knownDirectories = new Set<string>();
+  let changed = false;
+  for (const treePath of directoryPaths) {
+    const path = treePath.slice(0, -1);
+    knownDirectories.add(path);
+    const item = asDirectoryHandle(model.getItem(treePath));
+    if (item === null) continue;
+    if (pendingRestore.delete(path) && !item.isExpanded()) item.expand();
+    if (item.isExpanded()) {
+      if (!persisted.has(path)) {
+        persisted.add(path);
+        changed = true;
+      }
+    } else if (persisted.delete(path)) {
+      changed = true;
+    }
+  }
+  for (const path of persisted) {
+    if (knownDirectories.has(path) || !loadedDirectories.has(parentDirectory(path))) continue;
+    persisted.delete(path);
+    pendingRestore.delete(path);
+    changed = true;
+  }
+  return changed;
+}
@@ -117,6 +117,8 @@ export function useDirectoryEntries(environmentId: EnvironmentId, cwd: string) {
     ...entries.filter((entry) => entry.kind === "directory").map((entry) => entry.path),
   ]);
 
+  const loadedDirectories = new Set(directories.keys());
+
   const refresh = () => {
     const paths = [...requested.current].filter((path) => reachableDirectories.has(path));
     const workerCount = Math.min(4, paths.length);
@@ -136,6 +138,7 @@ export function useDirectoryEntries(environmentId: EnvironmentId, cwd: string) {
     refresh,
     isPending: pending > 0,
     loadingDirectories,
+    loadedDirectories,
     ready: directories.has(""),
     error: [...errors].find(([path]) => reachableDirectories.has(path))?.[1] ?? null,
   };