fix(search): simplify literal-dir pin detection

Replace the stack-collapse hasLiteralBefore with a terse fold over the
collapsed prefix segments, and trim over-verbose test comments.

Author: TheGreatAxios

src/plugins/search-files-fail-closed.test.ts

@@ -277,8 +277,6 @@ describe("CL-9469 unbounded-root predicate", () => {
       true,
     );
   });
-  // A recursive descent is only a whole-tree walk when nothing literal pins it
-  // down; a leading literal dir keeps it bounded even at the workspace root.
   test("recursive glob with a leading literal dir is bounded", () => {
     for (const pattern of [
       "src/**/*.ts",
@@ -299,9 +297,7 @@ describe("CL-9469 unbounded-root predicate", () => {
       );
     }
   });
-  // F1 soundness hole: `.`/`..` are relative-notation, not literal pins, so a
-  // leading dot segment must not whitelist a root walk (`./**`, `./**/*.ts`)
-  // and `..` must not be readable as an anchored workspace-escape.
+  // A leading `.`/`..` is relative notation, not a literal pin.
   test("leading dot or dotdot is not a literal pin", () => {
     for (const pattern of [
       "./**",
@@ -315,11 +311,7 @@ describe("CL-9469 unbounded-root predicate", () => {
       );
     }
   });
-  // F3 soundness hole: interior `..` collapse must be normalized, not read
-  // verbatim. `a/../**` collapses to `./**` (root-wide walk), `src/../../**`
-  // pops above the workspace root (escape), and `./a/../**` is still root
-  // relative. Only a prefix that collapses to a surviving name-bearing pin
-  // (`src/../packages/**` -> `packages/**`) stays bounded.
+  // Interior `..` collapses first, so the pin must survive the fold.
   test("interior dotdot collapse is normalized, so the pin must survive", () => {
     for (const pattern of [
       "a/../**",

src/plugins/tool-time-budget.ts

@@ -42,44 +42,25 @@ export function isUnboundedSearchGlob(pattern: string): boolean {
   return !hasLiteralBefore(pattern.slice(0, firstRecursive));
 }
 
-// True when the pre-`**` prefix collapses to a real, name-bearing directory
-// that anchors the walk away from the workspace root. The prefix is split on
-// `/` and collapsed left-to-right on a stack: `.` and empty segments are
-// skipped and `..` pops the preceding segment. A segment of only `*` wildcards
-// is pushed as a non-name pin (it occupies a slot but cannot anchor the walk);
-// the first surviving name-bearing segment is the pin. A prefix whose collapse
-// runs the stack empty (the pattern reaches the root, e.g. `a/../**`) or where
-// a `..` pops above the root (`src/../../**` escapes the workspace) leaves no
-// literal pin, so the recursion is a whole-tree walk. A leading separator or
-// dot-relative step (`/`, `./src/**`) likewise never pins to a real boundary.
+// True when the pre-`**` prefix names a real directory that anchors the walk
+// away from the root. Leading root-relative notation (`.`/`..`/empty) does not
+// pin; interior `.`/`..`/empty segments collapse first, so only a surviving
+// name segment counts.
 function hasLiteralBefore(prefix: string): boolean {
   const segments = prefix.split("/");
-  // A leading separator, dot, or dotdot step is root-relative notation that
-  // does not pin to a concrete boundary, even when a name follows (`./src/**`
-  // still walks from the root). `*/src/**` is unaffected: `*` is not a `..`.
   if (segments[0] === "" || segments[0] === "." || segments[0] === "..") {
     return false;
   }
-  // Stack of surviving segments (true = name-bearing pin). `.`/empty are
-  // skipped; `..` pops the top; all-wildcard runs push a non-name slot.
-  const stack: boolean[] = [];
+  const names: string[] = [];
   for (const segment of segments) {
-    if (segment.length === 0 || segment === ".") continue;
+    if (segment === "" || segment === ".") continue;
     if (segment === "..") {
-      if (stack.length === 0) return false; // pop above the workspace root
-      stack.pop();
+      names.pop();
       continue;
     }
-    let isName = false;
-    for (const char of segment) {
-      if (char !== "*") {
-        isName = true;
-        break;
-      }
-    }
-    stack.push(isName);
+    names.push(segment);
   }
-  return stack.some(Boolean); // at least one name-bearing pin survives
+  return names.some((segment) => [...segment].some((char) => char !== "*"));
 }
 
 // The raw path argument resolved against the session root: omitted, empty,