fix(session): skip caching failed project root lookups

A missing directory or a failed git lookup is not a stable root.
Caching it pins the session key to the fallback for the process.

Author: TheGreatAxios

src/session/project-key.test.ts

@@ -98,6 +98,41 @@ exec ${shQuote(realGit)} "$@"
   }
 });
 
+test("projectRootFor resolves a directory created after a missing lookup", async () => {
+  initTemporaryGitRepo(root);
+  await commitReadme(root);
+
+  const parent = realpathSync(root);
+  const child = join(parent, "child");
+  expect(projectRootFor(child)).toBe(child);
+  await mkdir(child);
+  expect(projectRootFor(child)).toBe(parent);
+});
+
+test("projectRootFor retries a nested dir after git was unavailable", async () => {
+  initTemporaryGitRepo(root);
+  await commitReadme(root);
+
+  const nested = join(root, "nested");
+  await mkdir(nested);
+  const parent = realpathSync(root);
+  const emptyBin = join(root, "empty-bin");
+  await mkdir(emptyBin);
+
+  const previousPath = process.env.PATH;
+  process.env.PATH = emptyBin;
+  try {
+    expect(projectRootFor(nested)).toBe(realpathSync(nested));
+  } finally {
+    if (previousPath === undefined) {
+      delete process.env.PATH;
+    } else {
+      process.env.PATH = previousPath;
+    }
+  }
+  expect(projectRootFor(nested)).toBe(parent);
+});
+
 test("linked worktrees have distinct project roots and keys from main and each other", async () => {
   initTemporaryGitRepo(root);
   await commitReadme(root);

src/session/project-key.ts

@@ -29,9 +29,9 @@ function slugSegment(name: string): string {
   return slug.length > 0 ? slug : "project";
 }
 
-// Repeated boot lookups of one cwd must not each spawn git. Keyed by the
-// resolved directory when it exists so equivalent spellings share one entry.
-// Missing paths keep the original string, because that string is the result.
+// Repeated boot lookups of one cwd must not each spawn git. Only a successful
+// toplevel is stored: a missing directory or a failed git lookup must be tried
+// again, or the session key stays on the fallback for the process lifetime.
 const projectRootByResolvedCwd = new Map<string, string>();
 
 function resolvedCwd(cwd: string): string {
@@ -42,7 +42,7 @@ function resolvedCwd(cwd: string): string {
   }
 }
 
-function projectRootUncached(cwd: string): string {
+function gitToplevel(cwd: string): string | undefined {
   try {
     const toplevelRaw = execFileSync(
       "git",
@@ -53,16 +53,15 @@ function projectRootUncached(cwd: string): string {
         stdio: ["ignore", "pipe", "ignore"],
       },
     ).trim();
-    if (toplevelRaw.length > 0) {
-      const toplevelAbs = isAbsolute(toplevelRaw)
-        ? toplevelRaw
-        : resolve(cwd, toplevelRaw);
-      return realpathOr(toplevelAbs);
-    }
+    if (toplevelRaw.length === 0) return undefined;
+    const toplevelAbs = isAbsolute(toplevelRaw)
+      ? toplevelRaw
+      : resolve(cwd, toplevelRaw);
+    return realpathOr(toplevelAbs);
   } catch {
     // Not a git checkout (or git unavailable) — use the workspace path.
+    return undefined;
   }
-  return realpathOr(cwd);
 }
 
 /**
@@ -75,9 +74,12 @@ export function projectRootFor(cwd: string): string {
   const key = resolvedCwd(cwd);
   const cached = projectRootByResolvedCwd.get(key);
   if (cached !== undefined) return cached;
-  const root = projectRootUncached(cwd);
-  projectRootByResolvedCwd.set(key, root);
-  return root;
+  const toplevel = gitToplevel(cwd);
+  if (toplevel !== undefined) {
+    projectRootByResolvedCwd.set(key, toplevel);
+    return toplevel;
+  }
+  return realpathOr(cwd);
 }
 
 export function projectKeyFor(cwd: string): string {