@bastani/atomic 0.6.3-0 → 0.6.4-0

package/src/sdk/workflows/builtin/deep-research-codebase/helpers/prompts.ts

@@ -49,6 +49,14 @@ const TRAILING_PROSE_REMINDER =
   "Do NOT end the turn on a tool call — downstream stages read your assistant " +
   "transcript and will see nothing if the final message is a tool invocation.";
 
+const AST_GREP_ENV_NOTICE =
+  "You are operating in an environment where ast-grep is installed. For any " +
+  "code search that requires understanding of syntax or code structure, you " +
+  "should default to using `ast-grep --lang [language] -p '<pattern>'`. Rely " +
+  "on your ast-grep skill for best practices. Adjust the --lang flag as " +
+  "needed for the specific programming language. Avoid using text-only " +
+  "search tools unless a plain-text search is explicitly requested.";
+
 /** Slugify the user's prompt for use in the final research filename. */
 export function slugifyPrompt(prompt: string): string {
   const slug = prompt
@@ -78,8 +86,15 @@ function renderPartitionDirs(partition: PartitionUnit[]): string {
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
-// Stage 1a — codebase-scout (single LLM orientation call)
+// Stage 1a — codebase-scout + query planner (single LLM call)
 // ─────────────────────────────────────────────────────────────────────────────
+//
+// The scout produces both a ≤300-word architectural orientation AND a list of
+// per-partition ast-grep query seeds. The combined output is embedded verbatim
+// into each specialist sub-agent's prompt as a single <ARCHITECTURAL_ORIENTATION>
+// block — no JSON envelope, no deterministic parser. Specialists locate "their"
+// partition's seeds by searching for the matching section header inside the
+// block and treat them as starting points, not commands.
 
 export function buildScoutPrompt(opts: {
   question: string;
@@ -103,8 +118,9 @@ export function buildScoutPrompt(opts: {
     `</RESEARCH_QUESTION>`,
     ``,
     `<CONTEXT>`,
-    `You are the codebase scout for the deep-research-codebase workflow. The`,
-    `workflow has already computed the codebase layout deterministically:`,
+    `You are the codebase scout AND query planner for the deep-research-codebase`,
+    `workflow. The workflow has already computed the codebase layout`,
+    `deterministically:`,
     ``,
     `- Total source files: ${opts.totalFiles.toLocaleString()}`,
     `- Total LOC: ${opts.totalLoc.toLocaleString()}`,
@@ -119,25 +135,49 @@ export function buildScoutPrompt(opts: {
     "```",
     `</CONTEXT>`,
     ``,
+    `<TOOLING>`,
+    AST_GREP_ENV_NOTICE,
+    `Consult https://ast-grep.github.io/reference/languages.html for the`,
+    `canonical language list, and https://ast-grep.github.io/llms-full.txt for`,
+    `the full rule reference, when you need them.`,
+    `</TOOLING>`,
+    ``,
     `<TASK>`,
-    `Read the tree above and produce a brief architectural orientation that`,
-    `the downstream specialist sub-agents will use to anchor their searches.`,
+    `Produce TWO sections — both will be embedded verbatim into the specialist`,
+    `sub-agents' prompts. Use the markdown headers shown so specialists can`,
+    `find their partition's seeds.`,
     ``,
-    `Cover, in ≤300 words:`,
+    `## Orientation`,
+    `In ≤300 words, cover:`,
     `  1. The repo's overall shape (monorepo vs single package, polyglot or not)`,
     `  2. The 3-5 most important top-level directories and what each contains`,
-    `  3. Architectural boundaries / layering you can see from the tree`,
+    `  3. Architectural boundaries / layering visible from the tree`,
     `  4. Where entry points or main modules likely live`,
     ``,
-    `Do NOT attempt to answer the research question yet — your job is`,
-    `orientation for downstream specialists, not investigation. You may use`,
-    `Read/Glob/Grep sparingly to verify guesses about a few key files,`,
-    `but keep the output short.`,
+    `## Query Seeds`,
+    `For each of the ${opts.explorerCount} partitions, suggest 2-4 ast-grep`,
+    `query seeds the specialists could start from. Format each seed as:`,
+    ``,
+    `### Partition <n>`,
+    `- Query: \`ast-grep --lang <language> -p '<pattern>'\``,
+    `  Why: <one sentence>`,
+    ``,
+    `For structural rules (kind + has/inside), use a fenced YAML block instead`,
+    `of the \`-p\` form, with the same Why line.`,
+    ``,
+    `Seeds are starting points, not commands — specialists adapt as they find`,
+    `things. If a partition is clearly irrelevant to the question, write a`,
+    `single-line note explaining why and skip its seeds.`,
     `</TASK>`,
     ``,
     `<CONSTRAINTS>`,
     DOCUMENTARIAN_DISCLAIMER,
-    `Stay under 300 words. No bullet lists longer than 5 items.`,
+    `Do NOT investigate the codebase to answer the question yourself — your`,
+    `job is orientation + seeding, not investigation. You may use Read/Glob/`,
+    `Grep/ast-grep sparingly to verify guesses about a few key files or to`,
+    `confirm a pattern parses, but keep output focused.`,
+    `Stay under 300 words for the Orientation section. Plain markdown only —`,
+    `no JSON envelope, no structured output.`,
     TRAILING_PROSE_REMINDER,
     `</CONSTRAINTS>`,
     ``,
@@ -186,7 +226,16 @@ export function buildLocatorPrompt(opts: {
     `relates to the research question, and return a categorized index.`,
     `</MISSION>`,
     ``,
+    `<TOOLING>`,
+    AST_GREP_ENV_NOTICE,
+    `</TOOLING>`,
+    ``,
     `<ARCHITECTURAL_ORIENTATION>`,
+    `The briefing below contains both a high-level orientation AND per-partition`,
+    `ast-grep query seeds. Find the **Partition ${opts.index}** section for the`,
+    `seeds scoped to your investigation — treat them as starting points, not`,
+    `commands. Adapt or skip seeds that don't fit what you actually find.`,
+    ``,
     orientation,
     `</ARCHITECTURAL_ORIENTATION>`,
     ``,
@@ -267,7 +316,16 @@ export function buildPatternFinderPrompt(opts: {
     `Return runnable-looking snippets, not abstract descriptions.`,
     `</MISSION>`,
     ``,
+    `<TOOLING>`,
+    AST_GREP_ENV_NOTICE,
+    `</TOOLING>`,
+    ``,
     `<ARCHITECTURAL_ORIENTATION>`,
+    `The briefing below contains both a high-level orientation AND per-partition`,
+    `ast-grep query seeds. Find the **Partition ${opts.index}** section for the`,
+    `seeds scoped to your investigation — treat them as starting points, not`,
+    `commands. Adapt or skip seeds that don't fit what you actually find.`,
+    ``,
     orientation,
     `</ARCHITECTURAL_ORIENTATION>`,
     ``,
@@ -337,7 +395,16 @@ export function buildAnalyzerPrompt(opts: {
     `precise \`file.ts:line\` references throughout.`,
     `</MISSION>`,
     ``,
+    `<TOOLING>`,
+    AST_GREP_ENV_NOTICE,
+    `</TOOLING>`,
+    ``,
     `<ARCHITECTURAL_ORIENTATION>`,
+    `The briefing below contains both a high-level orientation AND per-partition`,
+    `ast-grep query seeds. Find the **Partition ${opts.index}** section for the`,
+    `seeds scoped to your investigation — treat them as starting points, not`,
+    `commands. Adapt or skip seeds that don't fit what you actually find.`,
+    ``,
     orientation,
     `</ARCHITECTURAL_ORIENTATION>`,
     ``,
@@ -765,3 +832,127 @@ export function buildAggregatorPrompt(opts: {
     `</RESEARCH_QUESTION_REMINDER>`,
   ].join("\n");
 }
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Stage 2 — batched specialist dispatch (Task-tool fan-out)
+// ─────────────────────────────────────────────────────────────────────────────
+//
+// To cap parallel SDK subprocesses, specialist invocations are grouped into
+// "batch sessions" (see helpers/batching.ts). Each batch session is a single
+// Claude Agent SDK call whose main thread dispatches up to N sub-agents via
+// the Task tool. The sub-agents write their verbatim findings to per-task
+// scratch files and reply with a single confirmation token, so the
+// orchestrator's context grows by N short lines rather than N transcripts
+// (filesystem-context skill).
+
+/**
+ * Wrap a specialist prompt with the "write to file, reply with token only"
+ * envelope. The envelope is what the orchestrator hands to the Task tool's
+ * `prompt` parameter — the inner specialist prompt is built by the existing
+ * `buildLocatorPrompt` / `buildPatternFinderPrompt` / etc. and embedded
+ * verbatim so prompt semantics stay identical to the unbatched workflow.
+ */
+export function wrapPromptForTaskDispatch(opts: {
+  specialistPrompt: string;
+  outputPath: string;
+  agentLabel: string;
+}): string {
+  return [
+    `<TASK_OUTPUT_CONTRACT>`,
+    `Write your COMPLETE response — the verbatim markdown findings exactly as`,
+    `the prompt below specifies — to this absolute path using the Write tool:`,
+    ``,
+    `  ${opts.outputPath}`,
+    ``,
+    `Then reply with exactly the single token "DONE" and nothing else. Your`,
+    `parent only needs confirmation; the file is the real output. Do NOT`,
+    `inline your findings into your reply, do NOT add commentary, do NOT`,
+    `summarise — just write the file, then reply "DONE".`,
+    ``,
+    `If you cannot produce useful findings (e.g. the partition has nothing`,
+    `relevant to the question), write a one-line sentinel to the file`,
+    `explaining why, then still reply "DONE". Reply with`,
+    `"FAILED: <one-line reason>" only if you could not even write the file.`,
+    `</TASK_OUTPUT_CONTRACT>`,
+    ``,
+    `<${opts.agentLabel}_TASK>`,
+    opts.specialistPrompt,
+    `</${opts.agentLabel}_TASK>`,
+  ].join("\n");
+}
+
+/**
+ * Build the orchestrator prompt for a batch session. The orchestrator's job
+ * is purely deterministic dispatch — fire one Task tool call per task in
+ * **a single assistant message** so they execute in parallel, then report a
+ * one-line tally. It must NOT inline sub-agent findings, paraphrase the
+ * embedded prompts, or retry failures — siblings still run and synthesis
+ * tolerates missing files.
+ */
+export function buildBatchOrchestratorPrompt(opts: {
+  wave: 1 | 2;
+  batchIndex: number;
+  totalBatches: number;
+  tasks: Array<{
+    subagentType: string;
+    prompt: string;
+    outputPath: string;
+  }>;
+}): string {
+  const taskBlocks = opts.tasks
+    .map((t, i) =>
+      [
+        `### Task ${i + 1} of ${opts.tasks.length} — \`${t.subagentType}\``,
+        `Output path the sub-agent will write to: \`${t.outputPath}\``,
+        ``,
+        `Verbatim prompt to pass as the Task tool's \`prompt\` parameter:`,
+        ``,
+        "````",
+        t.prompt,
+        "````",
+        ``,
+      ].join("\n"),
+    )
+    .join("\n");
+
+  return [
+    `<BATCH_DISPATCH_MISSION>`,
+    `You are the deterministic dispatcher for batch ${opts.batchIndex} of`,
+    `${opts.totalBatches} in wave ${opts.wave} of the deep-research-codebase`,
+    `workflow. Your sole job is to spawn the ${opts.tasks.length} sub-agent`,
+    `task${opts.tasks.length === 1 ? "" : "s"} listed below using the Task tool.`,
+    `</BATCH_DISPATCH_MISSION>`,
+    ``,
+    `<DISPATCH_RULES>`,
+    `1. Issue ALL ${opts.tasks.length} Task tool calls in a SINGLE assistant`,
+    `   message (parallel tool use), not sequentially across multiple turns.`,
+    `   Parallel dispatch is the only reason this batch exists — sequential`,
+    `   calls defeat its purpose.`,
+    `2. For each task: set \`subagent_type\` to the value shown, set \`prompt\``,
+    `   to the verbatim text inside the fenced block (no paraphrasing,`,
+    `   truncating, or added framing), and set \`description\` to a short`,
+    `   3–5 word label.`,
+    `3. Dispatch every task even if some look similar to others. Tasks here`,
+    `   cover DIFFERENT codebase partitions or DIFFERENT specialist roles —`,
+    `   apparent overlap is not real overlap. Do NOT merge, skip, or combine.`,
+    `4. Do NOT inline any sub-agent's findings into your reply. The sub-agents`,
+    `   write their output to disk; downstream stages read those files.`,
+    `5. Do NOT retry failed sub-agents. Siblings still run and the synthesis`,
+    `   step tolerates missing files.`,
+    `</DISPATCH_RULES>`,
+    ``,
+    `<FINAL_REPLY_FORMAT>`,
+    `After all sub-agents complete, your final assistant message must be`,
+    `exactly one line of the form:`,
+    ``,
+    `  BATCH ${opts.batchIndex} COMPLETE: <ok>/${opts.tasks.length} ok, <failed> failed`,
+    ``,
+    `where <ok> is the count that replied "DONE" and <failed> is the count`,
+    `that replied "FAILED" or otherwise did not produce a file.`,
+    `</FINAL_REPLY_FORMAT>`,
+    ``,
+    `---`,
+    ``,
+    taskBlocks,
+  ].join("\n");
+}

package/src/sdk/workflows/builtin/deep-research-codebase/helpers/scout.ts

@@ -3,7 +3,8 @@
  *
  * Responsibilities:
  *   1. Discover the codebase root (git toplevel, falling back to cwd).
- *   2. List all source files, respecting .gitignore when in a git repo.
+ *   2. List all source files, honoring `.gitignore` via git ls-files in repos
+ *      and via `rg --files` in non-repo directories that still have one.
  *   3. Count lines of code per file using batched `wc -l`.
  *   4. Render a compact directory tree (depth-bounded) for prompt context.
  *   5. Build "partition units" by aggregating LOC at depth-1, then drilling
@@ -15,32 +16,157 @@
 
 // Use Bun.spawnSync instead of node:child_process for consistency with the rest of the codebase.
 
-/** Source-file extensions we treat as "code" for LOC accounting. */
-const CODE_EXTENSIONS = new Set<string>([
-  // Web / TS / JS
-  "ts", "tsx", "js", "jsx", "mjs", "cjs",
-  "vue", "svelte", "astro",
-  // Systems
-  "c", "cc", "cpp", "cxx", "h", "hpp", "rs", "go", "zig",
-  // JVM / .NET
-  "java", "kt", "kts", "scala", "groovy", "cs", "fs",
-  // Scripting
-  "py", "rb", "php", "pl", "lua", "sh", "bash", "zsh", "fish",
-  // Mobile
-  "swift", "m", "mm",
-  // Functional / niche
-  "ex", "exs", "erl", "elm", "hs", "ml", "clj", "cljs", "edn",
-  "r", "jl", "dart", "nim",
-  // Schemas / DSLs that materially shape behavior
-  "sql", "graphql", "proto",
+import * as linguistLanguages from "linguist-languages";
+import type { Language } from "linguist-languages";
+import ignore, { type Ignore } from "ignore";
+import ignoreByDefault from "ignore-by-default";
+import { readdirSync, readFileSync } from "node:fs";
+import { join, posix as posixPath, relative, sep } from "node:path";
+
+/**
+ * Source-file extensions we treat as "code" for LOC accounting.
+ *
+ * Derived from GitHub Linguist (`linguist-languages`), filtered to
+ * `type === "programming"`. Linguist tracks 500+ programming languages and
+ * keeps the canonical extension list per language up to date — using it
+ * removes a maintenance burden and picks up obscure-but-legitimate
+ * languages we'd never enumerate by hand.
+ *
+ * Three modifications layered on top of the raw linguist data:
+ *
+ *   1. **Multi-segment extensions are skipped.** Linguist lists entries like
+ *      `.coffee.md` (Literate CoffeeScript) and `.gradle.kts` (Gradle Kotlin
+ *      DSL). Our `isCodeFile()` only sees the tail after the final dot, so
+ *      collapsing `.coffee.md` to `md` would mis-classify Markdown as code.
+ *      Skipping them is safe because the base languages they extend always
+ *      list a single-segment extension as well (`.coffee`, `.kts`).
+ *   2. **EXCLUDE_EXTENSIONS denylist.** A handful of single-segment
+ *      extensions that programming-typed languages claim but which in
+ *      practice almost always mean a non-code file (`.md` is claimed by
+ *      GCC Machine Description but means Markdown 99.9% of the time).
+ *   3. **SCHEMA_EXTENSIONS allowlist.** Schemas/DSLs that linguist
+ *      categorises as `type: "data"` but which materially shape codebase
+ *      behaviour and belong in research scope.
+ */
+const SCHEMA_EXTENSIONS = ["sql", "graphql", "proto"] as const;
+
+/**
+ * Single-segment extensions that linguist's `programming`-typed languages
+ * claim but which in real-world codebases almost always mean a non-code
+ * file. Each entry needs a one-line justification.
+ */
+const EXCLUDE_EXTENSIONS = new Set<string>([
+  "md", // claimed by "GCC Machine Description"; almost always Markdown.
 ]);
 
-/** Directories we always exclude even when not using git ls-files. */
-const FIND_IGNORE_PATTERNS = [
-  "node_modules", ".git", "dist", "build", "out",
-  ".next", ".nuxt", ".turbo", ".vercel", ".cache",
-  "target", "vendor", "__pycache__", ".venv", "venv", "coverage",
-];
+const CODE_EXTENSIONS: Set<string> = (() => {
+  const out = new Set<string>();
+  // Each named export of `linguist-languages` is a `Language`; the namespace
+  // import has no other shape, so casting `Object.values(...)` to `Language[]`
+  // is sound and removes the need for an `unknown` intermediary.
+  for (const lang of Object.values(linguistLanguages) as Language[]) {
+    if (lang.type !== "programming") continue;
+    for (const ext of lang.extensions ?? []) {
+      const cleaned = ext.replace(/^\./, "").toLowerCase();
+      // Skip multi-segment extensions — see file-level comment.
+      if (cleaned.includes(".")) continue;
+      if (EXCLUDE_EXTENSIONS.has(cleaned)) continue;
+      out.add(cleaned);
+    }
+  }
+  for (const ext of SCHEMA_EXTENSIONS) out.add(ext);
+  return out;
+})();
+
+/**
+ * Recursively walk a directory tree, honoring nested `.gitignore` files at
+ * every level and seeding with `ignore-by-default`'s minimal universal set
+ * (`node_modules`, `.git`, `coverage`, etc.). Returns repo-relative paths.
+ *
+ * Used as the last-resort discovery fallback when neither `git ls-files` nor
+ * `rg --files` is available. The walker matches `.gitignore` semantics:
+ *   • Patterns from a `.gitignore` only apply to files at or below the
+ *     `.gitignore`'s directory.
+ *   • Inherited rules from ancestor directories continue to apply.
+ *   • Negations and the rest of gitignore syntax come from the `ignore`
+ *     package, which is the de facto JS implementation.
+ *
+ * Symlinks are intentionally not followed (avoids cycles).
+ */
+function walkWithIgnore(root: string): string[] {
+  const out: string[] = [];
+
+  const baseline: Ignore = ignore().add(ignoreByDefault.directories());
+  walk(root, [{ basePath: "", matcher: baseline }]);
+
+  function walk(
+    dir: string,
+    inheritedScopes: ReadonlyArray<{ basePath: string; matcher: Ignore }>,
+  ): void {
+    let scopes = inheritedScopes;
+    try {
+      const content = readFileSync(join(dir, ".gitignore"), "utf8");
+      const here = ignore().add(content);
+      // Normalize basePath to posix so it can be combined with `posix`
+      // (forward-slash) entry paths via `posix.relative` below — mixing
+      // separators in `path.relative` is undefined behaviour on Windows.
+      const basePathRel = relative(root, dir);
+      const basePath =
+        sep === "/" ? basePathRel : basePathRel.split(sep).join("/");
+      scopes = [
+        ...inheritedScopes,
+        { basePath, matcher: here },
+      ];
+    } catch {
+      // No .gitignore at this level — keep inherited scopes.
+    }
+
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      // Skip everything that isn't a regular file or a regular directory —
+      // most importantly, skip symlinks so we don't follow cycles.
+      if (!entry.isFile() && !entry.isDirectory()) continue;
+
+      const full = join(dir, entry.name);
+      const rel = relative(root, full);
+      // The `ignore` package requires forward-slash paths.
+      const posix = sep === "/" ? rel : rel.split(sep).join("/");
+      // Trailing slash so directory-only patterns (`dist/`) match.
+      const probe = entry.isDirectory() ? `${posix}/` : posix;
+
+      let ignored = false;
+      for (const scope of scopes) {
+        const within =
+          scope.basePath === ""
+            ? probe
+            : posixPath.relative(scope.basePath, posix) +
+              (entry.isDirectory() ? "/" : "");
+        // If `within` escapes the scope (starts with `..`), the file isn't
+        // under this .gitignore's reach — skip the check.
+        if (within.startsWith("..")) continue;
+        if (scope.matcher.ignores(within)) {
+          ignored = true;
+          break;
+        }
+      }
+      if (ignored) continue;
+
+      if (entry.isDirectory()) {
+        walk(full, scopes);
+      } else {
+        out.push(rel);
+      }
+    }
+  }
+
+  return out;
+}
 
 /** Per-file LOC + path. */
 export type FileStats = { path: string; loc: number };
@@ -72,14 +198,19 @@ export type CodebaseScout = {
 
 /** Resolve the project root. Prefers `git rev-parse --show-toplevel`. */
 export function getCodebaseRoot(): string {
-  const r = Bun.spawnSync({
-    cmd: ["git", "rev-parse", "--show-toplevel"],
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-  if (r.success && r.stdout) {
-    return r.stdout.toString().trim();
-  }
+  // Bun.spawnSync throws (rather than returning success:false) when the
+  // executable is missing from PATH — wrap so the documented "falls back to
+  // cwd" contract holds even on machines without git installed.
+  try {
+    const r = Bun.spawnSync({
+      cmd: ["git", "rev-parse", "--show-toplevel"],
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    if (r.success && r.stdout) {
+      return r.stdout.toString().trim();
+    }
+  } catch { /* git not on PATH — fall back to cwd */ }
   return process.cwd();
 }
 
@@ -90,36 +221,53 @@ function isCodeFile(p: string): boolean {
   return CODE_EXTENSIONS.has(ext);
 }
 
-/** List all files in the repository. Prefers git ls-files (respects .gitignore). */
+/**
+ * List all files in the repository, honoring `.gitignore` whenever possible.
+ *
+ * Three discovery paths, tried in order — every path respects `.gitignore`:
+ *
+ *   1. **git ls-files** — for git repos. Combines `--cached` (tracked) with
+ *      `--others --exclude-standard` (untracked-but-not-ignored) so a freshly
+ *      created file the user hasn't `git add`-ed yet still appears, while
+ *      anything matching `.gitignore` / `.git/info/exclude` is excluded.
+ *   2. **ripgrep `rg --files --hidden`** — for non-git directories that still
+ *      have a `.gitignore` (or `.ignore`). `rg` honors both without needing
+ *      a repo, and always excludes `.git/`. `--hidden` keeps tracked dotfiles
+ *      like `.github/`, `.claude/` visible (matching git's behavior).
+ *   3. **In-process walker** — last-resort fallback when neither git nor rg
+ *      is available. Uses the `ignore` package to honor every `.gitignore`
+ *      it encounters (including nested ones), seeded with `ignore-by-default`
+ *      for the universal-ignore baseline (`node_modules`, `.git`, etc.).
+ */
 function listAllFiles(root: string): string[] {
-  const git = Bun.spawnSync({
-    cmd: ["git", "ls-files"],
-    cwd: root,
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-  if (git.success && git.stdout) {
-    return git.stdout.toString().split("\n").filter((l) => l.length > 0);
-  }
+  // Bun.spawnSync throws (rather than returning success:false) when the
+  // executable is missing from PATH, so each branch is wrapped in try/catch
+  // and falls through to the next discovery strategy on error.
+  try {
+    const git = Bun.spawnSync({
+      cmd: ["git", "ls-files", "--cached", "--others", "--exclude-standard"],
+      cwd: root,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    if (git.success && git.stdout) {
+      return git.stdout.toString().split("\n").filter((l) => l.length > 0);
+    }
+  } catch { /* git not on PATH — fall through to rg */ }
 
-  // Fallback: shell out to find with the standard ignore patterns.
-  const args: string[] = ["find", ".", "-type", "f"];
-  for (const pattern of FIND_IGNORE_PATTERNS) {
-    args.push("-not", "-path", `*/${pattern}/*`);
-  }
-  const find = Bun.spawnSync({
-    cmd: args,
-    cwd: root,
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-  if (find.success && find.stdout) {
-    return find.stdout.toString()
-      .split("\n")
-      .map((p) => p.replace(/^\.\//, ""))
-      .filter((p) => p.length > 0);
-  }
-  return [];
+  try {
+    const rg = Bun.spawnSync({
+      cmd: ["rg", "--files", "--hidden"],
+      cwd: root,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    if (rg.success && rg.stdout) {
+      return rg.stdout.toString().split("\n").filter((l) => l.length > 0);
+    }
+  } catch { /* rg not on PATH — fall through to in-process walker */ }
+
+  return walkWithIgnore(root);
 }
 
 /**
@@ -127,7 +275,11 @@ function listAllFiles(root: string): string[] {
  *   "  N filename"
  *   "  N total"   (when more than one file is passed)
  *
- * We batch to avoid command-line length limits.
+ * We batch to avoid command-line length limits. When `wc` is missing from
+ * PATH (typical on Windows) `Bun.spawnSync` throws ENOENT — each batch is
+ * wrapped so we can fall back to an in-process newline counter rather than
+ * aborting the workflow or silently zeroing every file's LOC (which would
+ * collapse the partition bin-packer).
  */
 function countLines(root: string, files: string[]): Map<string, number> {
   const result = new Map<string, number>();
@@ -136,22 +288,40 @@ function countLines(root: string, files: string[]): Map<string, number> {
   const BATCH = 200;
   for (let i = 0; i < files.length; i += BATCH) {
     const batch = files.slice(i, i + BATCH);
-    const r = Bun.spawnSync({
-      cmd: ["wc", "-l", "--", ...batch],
-      cwd: root,
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-    if (!r.stdout) continue;
-    for (const line of r.stdout.toString().split("\n")) {
-      const m = line.match(/^\s*(\d+)\s+(.+)$/);
-      // Regex groups are typed `string | undefined` under strict mode even
-      // when the whole match succeeded — guard explicitly.
-      const countStr = m?.[1];
-      const filename = m?.[2]?.trim();
-      if (countStr === undefined || filename === undefined) continue;
-      if (filename === "total") continue;
-      result.set(filename, parseInt(countStr, 10));
+    let wcOk = false;
+    try {
+      const r = Bun.spawnSync({
+        cmd: ["wc", "-l", "--", ...batch],
+        cwd: root,
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+      if (r.stdout) {
+        wcOk = true;
+        for (const line of r.stdout.toString().split("\n")) {
+          const m = line.match(/^\s*(\d+)\s+(.+)$/);
+          // Regex groups are typed `string | undefined` under strict mode even
+          // when the whole match succeeded — guard explicitly.
+          const countStr = m?.[1];
+          const filename = m?.[2]?.trim();
+          if (countStr === undefined || filename === undefined) continue;
+          if (filename === "total") continue;
+          result.set(filename, parseInt(countStr, 10));
+        }
+      }
+    } catch { /* wc not on PATH — fall through to in-process counter */ }
+    if (wcOk) continue;
+    // In-process fallback: count newline bytes. Matches `wc -l` semantics
+    // (a final line without a trailing `\n` is not counted).
+    for (const f of batch) {
+      try {
+        const content = readFileSync(join(root, f), "utf8");
+        let count = 0;
+        for (let j = 0; j < content.length; j++) {
+          if (content.charCodeAt(j) === 10) count++;
+        }
+        result.set(f, count);
+      } catch { /* unreadable — leave unset; consumer treats as 0 */ }
     }
   }
   return result;