@@ -761,7 +761,9 @@ function toWorkLogEntry(
     case "file_change":
       return {
         ...common,
-        changedFiles: item.changes?.map((change) => change.path) ?? [item.fileName],
+        changedFiles: item.changes?.length
+          ? item.changes.map((change) => change.path)
+          : [item.fileName],
         toolTitle: title ?? "File change",
         toolData: item,
       };
 
@@ -151,6 +151,10 @@ describe("handoff budget", () => {
       })?.text,
       "File change: src/a.ts, src/b.ts, src/new.ts",
     );
+    assert.equal(
+      historicalMessage({ ...base, type: "file_change", fileName: "src/a.ts", changes: [] })?.text,
+      "File change: src/a.ts",
+    );
     assert.isNull(
       historicalMessage({
         ...base,
 
@@ -215,7 +215,7 @@ function summarizeDeltaItem(item: OrchestrationV2TurnItem): string | null {
     case "command_execution":
       return `- Command: ${compactText(item.input)}`;
     case "file_change":
-      return `- File change: ${compactText(item.changes?.map((change) => change.path).join(", ") ?? item.fileName)}`;
+      return `- File change: ${compactText(item.changes?.length ? item.changes.map((change) => change.path).join(", ") : item.fileName)}`;
     case "checkpoint":
       return `- Checkpoint: ${item.files.length} files`;
     case "handoff":
 
@@ -688,17 +688,28 @@ it.layer(layerTest, { excludeTestServices: true })("WorkspaceEntries", (it) => {
         yield* git(cwd, ["commit", "-m", "init"], env);
         yield* git(cwd, ["worktree", "add", "-b", "x", ".worktrees/x"]);
         yield* writeTextFile(cwd, ".worktrees/x/src/foo.py", "print(1)");
+        const expected = [".worktrees/x/src/foo.py"];
+        // Windows file names cannot contain a newline.
+        if ((yield* HostProcess.Platform) !== "win32") {
+          yield* git(cwd, ["worktree", "add", "--detach", ".worktrees/line\nname"]);
+          yield* writeTextFile(cwd, ".worktrees/line\nname/src/foo.py", "print(2)");
+          expected.unshift(".worktrees/line\nname/src/foo.py");
+        }
 
         const exact = yield* searchWorkspaceEntries({
           cwd,
           query: "src/foo.py",
           limit: 25,
           kind: "file",
         });
-        expect(exact.entries).toEqual([{ path: ".worktrees/x/src/foo.py", kind: "file" }]);
+        expect(exact.entries.toSorted((a, b) => (a.path < b.path ? -1 : 1))).toEqual(
+          expected.map((path) => ({ path, kind: "file" })),
+        );
 
         const partial = yield* searchWorkspaceEntries({ cwd, query: "src/fo", limit: 25 });
-        expect(partial.entries.map((entry) => entry.path)).not.toContain(".worktrees/x/src/foo.py");
+        for (const path of expected) {
+          expect(partial.entries.map((entry) => entry.path)).not.toContain(path);
+        }
       }),
     );
   });
 
@@ -307,23 +307,30 @@ export const make = Effect.gen(function* () {
     ) {
       return [];
     }
-    const listed = yield* vcsProcess
-      .run({
-        operation: "WorkspaceEntries.listWorktrees",
-        command: "git",
-        args: ["worktree", "list", "--porcelain"],
-        cwd,
-        allowNonZeroExit: true,
-        timeoutMs: 5_000,
-      })
-      .pipe(Effect.orElseSucceed(() => undefined));
-    if (!listed || listed.exitCode !== 0) return [];
+    const listWorktrees = (args: ReadonlyArray<string>) =>
+      vcsProcess
+        .run({
+          operation: "WorkspaceEntries.listWorktrees",
+          command: "git",
+          args: ["worktree", "list", "--porcelain", ...args],
+          cwd,
+          allowNonZeroExit: true,
+          timeoutMs: 5_000,
+        })
+        .pipe(
+          Effect.map((result) => (result.exitCode === 0 ? result.stdout : undefined)),
+          Effect.orElseSucceed(() => undefined),
+        );
+    // Only NUL framing keeps a newline in a worktree path. Pre-2.36 Git rejects `-z`.
+    const listed =
+      (yield* listWorktrees(["-z"])) ?? (yield* listWorktrees([]))?.replaceAll("\n", "\0");
+    if (listed === undefined) return [];
     const realCwd = yield* Effect.promise(() => NodeFSP.realpath(cwd).catch(() => cwd));
-    const worktreeRoots = listed.stdout.split(/\n\s*\n/).flatMap((record) => {
-      const lines = record.split("\n");
-      const worktree = lines.find((line) => line.startsWith("worktree "));
+    const worktreeRoots = listed.split("\0\0").flatMap((record) => {
+      const fields = record.split("\0");
+      const worktree = fields.find((field) => field.startsWith("worktree "));
       // A `prunable` record's directory is gone; another checkout may now sit there.
-      if (worktree === undefined || lines.some((line) => line.startsWith("prunable"))) return [];
+      if (worktree === undefined || fields.some((field) => field.startsWith("prunable"))) return [];
       const root = worktree.slice("worktree ".length);
       const relativeRoot = path.relative(realCwd, root);
       return relativeRoot === "" ||
 
@@ -12,6 +12,7 @@ const { listEntries, mocks } = vi.hoisted(() => ({
   listEntries: vi.fn(),
   mocks: {
     reconnect: false,
+    generation: 0,
     reachable: null as unknown as Atom.Writable<boolean>,
     connectedSession: null as unknown as Atom.Writable<number>,
   },
@@ -21,26 +22,39 @@ vi.mock("~/connection/catalog", () => ({
     sessionGenerationAtom: () => Atom.make((get) => get(mocks.connectedSession)),
   },
 }));
-vi.mock("~/state/projects", () => ({
-  projectEnvironment: {
-    listEntries: (request: unknown) =>
-      mocks.reconnect
-        ? Atom.make((get) =>
-            get(mocks.reachable)
-              ? AsyncResult.success({
-                  entries: [{ path: "README.md", kind: "file" }],
-                  truncated: false,
-                })
-              : AsyncResult.failure(Cause.fail(new Error("Environment is reconnecting."))),
-          )
-        : Atom.make(Effect.promise(() => listEntries(request))),
-  },
-}));
+vi.mock("~/state/projects", () => {
+  const queries = new Map<string, ReturnType<typeof makeQuery>>();
+  const makeQuery = (request: unknown) => Atom.make(Effect.promise(() => listEntries(request)));
+  return {
+    projectEnvironment: {
+      listEntries: (request: unknown) =>
+        mocks.reconnect
+          ? Atom.make((get) =>
+              get(mocks.reachable)
+                ? AsyncResult.success({
+                    entries: [{ path: "README.md", kind: "file" }],
+                    truncated: false,
+                  })
+                : AsyncResult.failure(Cause.fail(new Error("Environment is reconnecting."))),
+            )
+          : (() => {
+              const key = JSON.stringify([mocks.generation, request]);
+              let query = queries.get(key);
+              if (!query) {
+                query = makeQuery(request);
+                queries.set(key, query);
+              }
+              return query;
+            })(),
+    },
+  };
+});
 
 import { useDirectoryEntries } from "./useDirectoryEntries";
 
 function setup() {
   mocks.reconnect = false;
+  mocks.generation++;
   mocks.reachable = Atom.make(false);
   mocks.connectedSession = Atom.make(1);
   let view!: ReturnType<typeof useDirectoryEntries>;
@@ -125,6 +139,18 @@ it("rescans mutations during both the initial listing and the follow-up", async
   await state.settle(2, [entry]);
   expect(state.view.entries).toEqual([entry]);
   expect(state.view.isPending).toBe(false);
+
+  const folder = { path: "src", kind: "directory" } as const;
+  const child = { path: "src/new.ts", kind: "file" } as const;
+  await act(async () => {
+    void state.view.load("src");
+  });
+  await state.settle(3, [child]);
+  await act(async () => {
+    void state.view.load("", true);
+  });
+  await state.settle(4, [folder]);
+  expect(state.view.entries).toEqual([folder, child]);
 });
 
 it("shares the follow-up promise and does not resolve callers before the final listing", async () => {
@@ -214,3 +240,38 @@ it("reads a folder that failed while unreachable again once a new session is up"
   });
   await expect.element(screen.getByText("README.md")).toBeInTheDocument();
 });
+
+it("reloads a removed folder when it reappears under the same name", async () => {
+  const state = setup();
+  // The hook probe does not navigate.
+  await using _screen = await render(<state.Probe />, { router: false });
+  const folder = { path: "src", kind: "directory" } as const;
+  await state.settle(0, [folder]);
+  await act(async () => {
+    void state.view.load("src");
+  });
+  await state.settle(1, [{ path: "src/old.ts", kind: "file" }]);
+
+  await act(async () => {
+    state.view.refresh();
+    void state.view.load("src", true);
+  });
+  await state.settle(2, []);
+  expect(state.view.entries).toEqual([]);
+
+  await act(async () => state.view.refresh());
+  await state.settle(4, [folder]);
+  await act(async () => {
+    void state.view.load("src");
+  });
+  const replacementRefresh = state.view.load("src", true);
+  await state.settle(3, [{ path: "src/old.ts", kind: "file" }]);
+  expect(state.view.load("src", true)).toBe(replacementRefresh);
+  expect(state.view.entries).toEqual([folder]);
+  expect(state.view.loadingDirectories.has("src")).toBe(true);
+  await state.settle(5, [{ path: "src/new.ts", kind: "file" }]);
+  await state.settle(6, [{ path: "src/new.ts", kind: "file" }]);
+  await replacementRefresh;
+  expect(state.view.entries).toEqual([folder, { path: "src/new.ts", kind: "file" }]);
+  expect(state.view.isPending).toBe(false);
+});
@@ -15,7 +15,10 @@ export function useDirectoryEntries(environmentId: EnvironmentId, cwd: string) {
   const [loadingDirectories, setLoadingDirectories] = useState<ReadonlySet<string>>(
     () => new Set([""]),
   );
+  // Source of truth for `directories`, so a listing can purge folders it no longer holds.
+  const listings = useRef(new Map<string, readonly ProjectEntry[]>());
   const requests = useRef(new Map<string, Promise<void>>());
+  const detachedRequests = useRef(new Map<string, Promise<void>>());
   const followUpRefreshes = useRef(new Map<string, Promise<void>>());
   const loaded = useRef(new Set<string>());
   const requested = useRef(new Set<string>());
@@ -27,7 +30,10 @@ export function useDirectoryEntries(environmentId: EnvironmentId, cwd: string) {
     loaded.current.add(directoryPath);
     requested.current.add(directoryPath);
     const atom = projectEnvironment.listEntries({ environmentId, input: { cwd, directoryPath } });
+    const detached = detachedRequests.current.get(directoryPath);
     const request = (async () => {
+      // A shared query still waiting would join the removed folder's read.
+      if (detached) await detached;
       if (running.current >= 4) await new Promise<void>((resolve) => waiting.current.push(resolve));
       else running.current++;
       const result = active.current
@@ -43,21 +49,44 @@ export function useDirectoryEntries(environmentId: EnvironmentId, cwd: string) {
       return result;
     })()
       .then((result) => {
-        if (!active.current || !result) return;
+        // A request is dropped from `requests` when its folder disappears, so its read is stale.
+        if (!active.current || !result || requests.current.get(directoryPath) !== request) return;
         if (result._tag === "Success") {
-          setDirectories((previous) =>
-            new Map(previous).set(
-              directoryPath,
-              result.value.entries.filter(
-                (entry) =>
-                  entry.path.slice(0, Math.max(0, entry.path.lastIndexOf("/"))) === directoryPath,
-              ),
-            ),
+          const children = result.value.entries.filter(
+            (entry) =>
+              entry.path.slice(0, Math.max(0, entry.path.lastIndexOf("/"))) === directoryPath,
+          );
+          const next = new Map(listings.current).set(directoryPath, children);
+          const childDirectories = new Set(
+            children.filter((entry) => entry.kind === "directory").map((entry) => entry.path),
           );
+          const prefix = directoryPath === "" ? "" : `${directoryPath}/`;
+          const removed = [...requested.current].filter((path) => {
+            if (path === directoryPath || !path.startsWith(prefix)) return false;
+            const slash = path.indexOf("/", prefix.length);
+            return !childDirectories.has(slash === -1 ? path : path.slice(0, slash));
+          });
+          for (const path of removed) {
+            next.delete(path);
+            loaded.current.delete(path);
+            requested.current.delete(path);
+            const detachedRequest = requests.current.get(path);
+            if (detachedRequest) detachedRequests.current.set(path, detachedRequest);
+            requests.current.delete(path);
+            followUpRefreshes.current.delete(path);
+          }
+          listings.current = next;
+          setDirectories(next);
+          if (removed.length > 0)
+            setLoadingDirectories((previous) => {
+              const remaining = new Set(previous);
+              for (const path of removed) remaining.delete(path);
+              return remaining;
+            });
           setErrors((previous) => {
-            const next = new Map(previous);
-            next.delete(directoryPath);
-            return next;
+            const remaining = new Map(previous);
+            for (const path of [directoryPath, ...removed]) remaining.delete(path);
+            return remaining;
           });
         } else {
           loaded.current.delete(directoryPath);
@@ -71,10 +100,13 @@ export function useDirectoryEntries(environmentId: EnvironmentId, cwd: string) {
         }
       })
       .finally(() => {
-        requests.current.delete(directoryPath);
+        if (detachedRequests.current.get(directoryPath) === request)
+          detachedRequests.current.delete(directoryPath);
+        const current = requests.current.get(directoryPath) === request;
+        if (current) requests.current.delete(directoryPath);
         if (!active.current) return;
         setPending((count) => count - 1);
-        if (!refresh)
+        if (!refresh && current)
           setLoadingDirectories((previous) => {
             const next = new Set(previous);
             next.delete(directoryPath);
@@ -92,8 +124,10 @@ export function useDirectoryEntries(environmentId: EnvironmentId, cwd: string) {
       let followUp = followUpRefreshes.current.get(directoryPath);
       if (!followUp) {
         followUp = existing.then(() => {
+          if (followUpRefreshes.current.get(directoryPath) !== followUp) return;
           followUpRefreshes.current.delete(directoryPath);
-          if (active.current) return loadDirectory(directoryPath, true);
+          if (active.current && requested.current.has(directoryPath))
+            return loadDirectory(directoryPath, true);
         });
         followUpRefreshes.current.set(directoryPath, followUp);
       }
 
@@ -4,7 +4,7 @@ import {
   type WorktreeSubmodules,
   managedRuntimeModeDenial,
 } from "@t3tools/contracts";
-import { createModelSelection } from "@t3tools/shared/model";
+import { createModelSelection, pickModelSelection } from "@t3tools/shared/model";
 import { resolveProjectSettings } from "@t3tools/shared/projectSettings";
 import { useNavigate } from "@tanstack/react-router";
 
@@ -172,7 +172,7 @@ export function ProjectDefaultsSettings({ category }: { category: ProjectSetting
                   });
               }}
               onInstanceModelChange={(instanceId, model) =>
-                setModel(createModelSelection(instanceId, model))
+                setModel(pickModelSelection(mixedModel ? null : selection, instanceId, model))
               }
             />
             {!mixedModel && !presentation.providerNote && !effortDisabledReason && activeEntry ? (
@@ -288,7 +288,13 @@ export function ProjectDefaultsSettings({ category }: { category: ProjectSetting
                   });
                   return;
                 }
-                updateSettings({ fallbackModelSelection: createModelSelection(instanceId, model) });
+                updateSettings({
+                  fallbackModelSelection: pickModelSelection(
+                    mixedFallback ? null : settings.fallbackModelSelection,
+                    instanceId,
+                    model,
+                  ),
+                });
               }}
             />
             {settings.fallbackModelSelection !== null && fallbackEntry && !mixedFallback ? (
 
@@ -27,7 +27,7 @@ import {
   ToolCallVisibility,
 } from "@t3tools/contracts/settings";
 import { desktopUpdateChannelOf } from "@t3tools/shared/cliRelease";
-import { createModelSelection } from "@t3tools/shared/model";
+import { createModelSelection, pickModelSelection } from "@t3tools/shared/model";
 import { resolvePastedPath } from "@t3tools/shared/path";
 import * as Equal from "effect/Equal";
 import * as Schema from "effect/Schema";
@@ -2046,7 +2046,11 @@ export function ThreadsSettingsPanel() {
                       textGenerationModelSelection: resolveAppModelSelectionState(
                         {
                           ...settings,
-                          textGenerationModelSelection: createModelSelection(instanceId, model),
+                          textGenerationModelSelection: pickModelSelection(
+                            textGenerationModelSelection,
+                            instanceId,
+                            model,
+                          ),
                         },
                         textGenerationProviders,
                       ),