@drewpayment/mink 0.11.0 → 0.12.0-beta.2

package/src/commands/scan.ts

@@ -1,7 +1,7 @@
 import { readFileSync } from "fs";
+import { createHash } from "crypto";
 import { join, relative } from "path";
-import { fileIndexPath, configPath } from "../core/paths";
-import { atomicWriteJson, safeReadJson } from "../core/fs-utils";
+import { configPath } from "../core/paths";
 import {
   scanProject,
   scanProjectWithStats,
@@ -10,45 +10,39 @@ import {
 } from "../core/scanner";
 import { extractDescription } from "../core/description";
 import { estimateTokens } from "../core/token-estimate";
-import {
-  createEmptyIndex,
-  isFileIndex,
-  upsertEntry,
-  checkStaleness,
-} from "../core/index-store";
-import type { FileIndex, FileIndexEntry } from "../types/file-index";
+import { FileIndexRepo } from "../repositories/file-index-repo";
+import type { FileIndexEntry } from "../types/file-index";
 
 function configRelativePath(cfgPath: string, cwd: string): string {
   const rel = relative(cwd, cfgPath);
   return rel.startsWith("..") ? cfgPath : rel;
 }
 
-function loadExistingIndex(indexPath: string): FileIndex {
-  const raw = safeReadJson(indexPath);
-  if (isFileIndex(raw)) return raw;
-  if (raw !== null) {
-    console.error("[mink] file-index.json is corrupt — starting fresh");
-  }
-  return createEmptyIndex();
+// Truncated SHA-1 — 16 hex chars is plenty to distinguish content
+// versions of the same file. Cheaper than cryptographic strength;
+// we only use it for change detection, never as a security boundary.
+function contentHashOf(content: string): string {
+  return createHash("sha1").update(content).digest("hex").slice(0, 16);
 }
 
 export function scan(cwd: string, options: { check: boolean }): void {
-  const idxPath = fileIndexPath(cwd);
   const cfgPath = configPath(cwd);
   const config = loadConfig(cfgPath);
   const excludes = getExcludes(config);
-  const maxFiles = config.maxFiles ?? 500;
+  // No default cap as of Phase 5 — per-row write cost is flat in SQLite.
+  // Users who still want a cap set `maxFiles` in config.json.
+  const maxFiles = config.maxFiles;
+  const repo = FileIndexRepo.for(cwd);
 
   if (options.check) {
-    const existing = safeReadJson(idxPath);
-    if (!isFileIndex(existing)) {
+    if (repo.totalFiles() === 0) {
       console.error("[mink] no index found — run mink scan first");
       process.exit(1);
     }
 
     const scanned = scanProject(cwd, excludes, maxFiles);
     const scannedPaths = scanned.map((f) => f.relativePath);
-    const report = checkStaleness(existing, scannedPaths);
+    const report = repo.checkStaleness(scannedPaths);
 
     if (!report.isStale) {
       console.log("[mink] index is up to date");
@@ -70,45 +64,103 @@ export function scan(cwd: string, options: { check: boolean }): void {
     process.exit(1);
   }
 
-  // Full scan
+  // Incremental scan — the actual 20k-file win.
+  //   1. Walk the tree (cheap; just stat + readdir).
+  //   2. Repo.staleSet(scanned) returns only paths whose mtime differs
+  //      from what's stored (or never indexed at all). Everything else
+  //      gets skipped — no readFileSync, no description extract, no
+  //      token estimate.
+  //   3. For stale paths, read content + compute a content hash. If the
+  //      stored content_hash matches, the file was just touched
+  //      without an edit — skip the description/tokens re-extract and
+  //      only refresh mtime/last_indexed. Otherwise do the full
+  //      re-extract.
+  //   4. Bulk upsert in a single transaction, then prune orphans.
   const start = Date.now();
-  const index = loadExistingIndex(idxPath);
 
   const stats = scanProjectWithStats(cwd, excludes, maxFiles);
   const scanned = stats.files;
 
-  // Build new entries, preserving lifetime counters
-  const newIndex = createEmptyIndex();
-  newIndex.header.lifetimeHits = index.header.lifetimeHits;
-  newIndex.header.lifetimeMisses = index.header.lifetimeMisses;
+  const stalePaths = new Set(repo.staleSet(scanned));
+  const batch: Array<{
+    entry: FileIndexEntry;
+    opts: { mtimeMs: number; contentHash: string | null; sizeBytes: number };
+  }> = [];
+  let touchOnlyCount = 0;
+  let extractedCount = 0;
 
   for (const file of scanned) {
+    if (!stalePaths.has(file.relativePath)) {
+      // mtime matches what we have — nothing to do for this file.
+      continue;
+    }
+
     const fullPath = join(cwd, file.relativePath);
     let content: string;
     try {
       content = readFileSync(fullPath, "utf-8");
     } catch {
-      continue; // Skip unreadable files
+      continue; // Skip unreadable files (permissions, race condition)
+    }
+
+    const hash = contentHashOf(content);
+    const existing = repo.lookupEntry(file.relativePath);
+    const existingHash = existing ? repo.contentHashFor(file.relativePath) : null;
+
+    if (existing && existingHash === hash) {
+      // Touched but unchanged — bump mtime/last_indexed only, keep the
+      // stored description + token estimate.
+      batch.push({
+        entry: {
+          filePath: file.relativePath,
+          description: existing.description,
+          estimatedTokens: existing.estimatedTokens,
+          lastModified: new Date(file.mtimeMs).toISOString(),
+          lastIndexed: new Date().toISOString(),
+        },
+        opts: {
+          mtimeMs: Math.floor(file.mtimeMs),
+          contentHash: hash,
+          sizeBytes: content.length,
+        },
+      });
+      touchOnlyCount++;
+      continue;
     }
 
-    const entry: FileIndexEntry = {
-      filePath: file.relativePath,
-      description: extractDescription(file.relativePath, content),
-      estimatedTokens: estimateTokens(content, file.relativePath),
-      lastModified: new Date(file.mtimeMs).toISOString(),
-      lastIndexed: new Date().toISOString(),
-    };
-    upsertEntry(newIndex, entry);
+    // Full re-extract.
+    batch.push({
+      entry: {
+        filePath: file.relativePath,
+        description: extractDescription(file.relativePath, content),
+        estimatedTokens: estimateTokens(content, file.relativePath),
+        lastModified: new Date(file.mtimeMs).toISOString(),
+        lastIndexed: new Date().toISOString(),
+      },
+      opts: {
+        mtimeMs: Math.floor(file.mtimeMs),
+        contentHash: hash,
+        sizeBytes: content.length,
+      },
+    });
+    extractedCount++;
   }
 
-  newIndex.header.lastScanTimestamp = new Date().toISOString();
+  // Single transaction — ~50x faster than per-file commits at 20k files.
+  if (batch.length > 0) repo.upsertMany(batch);
+
+  // Prune orphans: every entry whose file is no longer on disk.
+  const removed = repo.retainOnly(scanned.map((f) => f.relativePath));
 
-  atomicWriteJson(idxPath, newIndex);
+  repo.setLastScanTimestamp(new Date().toISOString());
 
   const elapsed = Date.now() - start;
+  const indexed = repo.totalFiles();
+  const skipped = scanned.length - stalePaths.size;
+
   if (stats.truncated > 0) {
     console.log(
-      `[mink] scanned ${stats.totalScanned} files; indexed ${newIndex.header.totalFiles} most recent in ${elapsed}ms`
+      `[mink] scanned ${stats.totalScanned} files; indexed ${indexed} most recent in ${elapsed}ms`
     );
     console.log(
       `  ${stats.truncated} files past maxFiles=${maxFiles} were not indexed`
@@ -116,9 +168,20 @@ export function scan(cwd: string, options: { check: boolean }): void {
     console.log(
       `  raise the cap by setting "maxFiles" in ${configRelativePath(cfgPath, cwd)}`
     );
+    return;
+  }
+
+  if (skipped === scanned.length && extractedCount === 0 && touchOnlyCount === 0 && removed === 0) {
+    console.log(`[mink] indexed ${indexed} files in ${elapsed}ms (no changes)`);
   } else {
+    const parts: string[] = [];
+    if (extractedCount > 0) parts.push(`${extractedCount} re-indexed`);
+    if (touchOnlyCount > 0) parts.push(`${touchOnlyCount} touch-only`);
+    if (removed > 0) parts.push(`${removed} pruned`);
+    if (skipped > 0)  parts.push(`${skipped} unchanged`);
     console.log(
-      `[mink] indexed ${newIndex.header.totalFiles} files in ${elapsed}ms`
+      `[mink] indexed ${indexed} files in ${elapsed}ms (${parts.join(", ")})`
     );
   }
 }
+

package/src/commands/status.ts

@@ -1,18 +1,14 @@
 import { existsSync, readFileSync, statSync } from "fs";
 import {
   sessionPath,
-  fileIndexPath,
+  projectDbPath,
   configPath,
   learningMemoryPath,
-  tokenLedgerPath,
-  bugMemoryPath,
   actionLogPath,
 } from "../core/paths";
 import { safeReadJson } from "../core/fs-utils";
-import { isFileIndex } from "../core/index-store";
-import { loadLedger } from "../core/token-ledger";
-import { parseLearningMemory, totalEntryCount } from "../core/learning-memory";
-import { loadBugMemory } from "../core/bug-memory";
+import { FileIndexRepo } from "../repositories/file-index-repo";
+import { openProjectDb } from "../storage/db";
 import {
   aggregateTokenLedger,
   aggregateBugMemory,
@@ -20,6 +16,7 @@ import {
 } from "../core/state-aggregator";
 import { loadCounters } from "../core/state-counters";
 import { getDaemonStatus } from "../core/daemon";
+import { totalEntryCount } from "../core/learning-memory";
 
 interface FileCheck {
   name: string;
@@ -45,18 +42,42 @@ function checkTextFile(name: string, filePath: string): FileCheck {
   }
 }
 
+function checkDbFile(name: string, filePath: string): FileCheck {
+  if (!existsSync(filePath)) return { name, path: filePath, status: "missing" };
+  try {
+    const header = readFileSync(filePath).slice(0, 16).toString("utf-8");
+    if (!header.startsWith("SQLite format 3")) {
+      return { name, path: filePath, status: "corrupt" };
+    }
+    return { name, path: filePath, status: "ok" };
+  } catch {
+    return { name, path: filePath, status: "corrupt" };
+  }
+}
+
 export function status(cwd: string): void {
   console.log("[mink] project status");
   console.log();
 
-  // Section 1: State directory integrity
+  // Open the project DB up-front so the lazy JSON → SQLite migration
+  // runs before checkDbFile inspects mink.db. Otherwise the integrity
+  // section would always report "missing" on a project that has only
+  // legacy JSON state.
+  try {
+    openProjectDb(cwd);
+  } catch {
+    // Migration failures are non-fatal — report the DB as corrupt below.
+  }
+
+  // Section 1: State directory integrity. file-index, bug-memory, and
+  // token-ledger all live inside mink.db. The remaining JSON/MD files
+  // are intentionally separate — session is per-process, config is
+  // user-editable, learning-memory and action-log are human-readable.
   const checks: FileCheck[] = [
     checkJsonFile("session.json", sessionPath(cwd)),
-    checkJsonFile("file-index.json", fileIndexPath(cwd), isFileIndex),
+    checkDbFile("mink.db", projectDbPath(cwd)),
     checkJsonFile("config.json", configPath(cwd)),
     checkTextFile("learning-memory.md", learningMemoryPath(cwd)),
-    checkJsonFile("token-ledger.json", tokenLedgerPath(cwd)),
-    checkJsonFile("bug-memory.json", bugMemoryPath(cwd)),
     checkTextFile("action-log.md", actionLogPath(cwd)),
   ];
 
@@ -73,24 +94,22 @@ export function status(cwd: string): void {
   }
   console.log();
 
-  // Section 2: File index
+  // Section 2: File index — sourced from mink.db.
   try {
-    const raw = safeReadJson(fileIndexPath(cwd));
-    if (raw && isFileIndex(raw)) {
-      const h = raw.header;
-      // Hit/miss counters live in the per-device counter file, fall back to
-      // legacy header counters for unmigrated repos.
+    const repo = FileIndexRepo.for(cwd);
+    const total = repo.totalFiles();
+    if (total === 0) {
+      console.log("  File index: not available");
+    } else {
       const counters = loadCounters(cwd);
-      const hits = counters.fileIndexHits || h.lifetimeHits;
-      const misses = counters.fileIndexMisses || h.lifetimeMisses;
-      const total = hits + misses;
-      const ratio = total > 0 ? ((hits / total) * 100).toFixed(1) : "N/A";
+      const hits = counters.fileIndexHits;
+      const misses = counters.fileIndexMisses;
+      const totalLookups = hits + misses;
+      const ratio = totalLookups > 0 ? ((hits / totalLookups) * 100).toFixed(1) : "N/A";
       console.log("  File index:");
-      console.log(`    Files: ${h.totalFiles}`);
-      console.log(`    Last scan: ${h.lastScanTimestamp || "never"}`);
-      console.log(`    Hit/miss ratio: ${ratio}${total > 0 ? "%" : ""} (${hits} hits, ${misses} misses)`);
-    } else {
-      console.log("  File index: not available");
+      console.log(`    Files: ${total}`);
+      console.log(`    Last scan: ${repo.getLastScanTimestamp() || "never"}`);
+      console.log(`    Hit/miss ratio: ${ratio}${totalLookups > 0 ? "%" : ""} (${hits} hits, ${misses} misses)`);
     }
   } catch {
     console.log("  File index: error reading");

package/src/core/bug-memory.ts

@@ -1,20 +1,17 @@
-import { safeReadJson, atomicWriteJson } from "./fs-utils";
+// Wrapper over the SQLite bug-memory storage layer. The function-based
+// API below stays compatible with existing unit tests (which build
+// in-memory BugMemory objects), while the repo-aware paths route through
+// BugMemoryRepo so 20k+ bug histories stay searchable in milliseconds.
+//
+// FTS5 is the search backbone — see BugMemoryRepo.searchBugs for the
+// query semantics, score normalization, and false-positive guards.
+
 import type { BugEntry, BugMemory, SimilarityMatch } from "../types/bug-memory";
 
 export function createEmptyBugMemory(): BugMemory {
   return { entries: [], nextId: 1 };
 }
 
-export function loadBugMemory(path: string): BugMemory {
-  const raw = safeReadJson(path);
-  if (raw !== null && isBugMemory(raw)) return raw;
-  return createEmptyBugMemory();
-}
-
-export function saveBugMemory(path: string, memory: BugMemory): void {
-  atomicWriteJson(path, memory);
-}
-
 export function isBugMemory(value: unknown): value is BugMemory {
   if (value === null || typeof value !== "object") return false;
   const obj = value as Record<string, unknown>;
@@ -25,6 +22,8 @@ export function generateBugId(nextId: number): string {
   return `bug-${String(nextId).padStart(3, "0")}`;
 }
 
+// ── In-memory operations (used by unit tests and the JSON migration importer) ──
+
 export function findDuplicate(
   memory: BugMemory,
   errorMessage: string,
@@ -42,9 +41,7 @@ export function addBugEntry(
   fields: Omit<BugEntry, "id" | "createdAt" | "lastSeenAt" | "occurrenceCount">
 ): BugMemory {
   const existing = findDuplicate(memory, fields.errorMessage, fields.filePath);
-  if (existing) {
-    return updateOccurrence(memory, existing.id);
-  }
+  if (existing) return updateOccurrence(memory, existing.id);
 
   const now = new Date().toISOString();
   const entry: BugEntry = {
@@ -73,14 +70,11 @@ export function updateOccurrence(memory: BugMemory, id: string): BugMemory {
   };
 }
 
-// --- Similarity scoring ---
+// ── Similarity scoring (in-memory) ────────────────────────────────────────
 
 function tokenize(text: string): Set<string> {
   return new Set(
-    text
-      .toLowerCase()
-      .split(/\W+/)
-      .filter((w) => w.length > 0)
+    text.toLowerCase().split(/\W+/).filter((w) => w.length > 0)
   );
 }
 
@@ -101,18 +95,12 @@ export function computeSimilarity(
   const matchReasons: string[] = [];
   let score = 0;
 
-  // 1. Exact substring match on error message
-  if (
-    entry.errorMessage.length > 0 &&
-    entry.errorMessage.includes(query)
-  ) {
+  if (entry.errorMessage.length > 0 && entry.errorMessage.includes(query)) {
     score += 1.0;
     matchReasons.push("exact_error_match");
   }
 
-  // 2. Word overlap (Jaccard) across searchable fields
   const queryTokens = tokenize(query);
-
   const fields: [string, string][] = [
     ["error_message", entry.errorMessage],
     ["root_cause", entry.rootCause],
@@ -142,6 +130,8 @@ function hasTagOverlap(entry: BugEntry, query: string): boolean {
   return entry.tags.some((tag) => queryTokens.has(tag.toLowerCase()));
 }
 
+// Pure-memory search — kept for unit tests that don't open a DB. Production
+// call sites use BugMemoryRepo.searchBugs which goes through FTS5.
 export function searchBugs(
   memory: BugMemory,
   query: string,
@@ -153,23 +143,16 @@ export function searchBugs(
 
   for (const entry of memory.entries) {
     const match = computeSimilarity(query, entry);
-
-    // False positive guard: require file-path match OR tag overlap
     const fileMatch = hasFilePathMatch(entry, options?.filePath);
     const tagMatch = hasTagOverlap(entry, query);
     if (!fileMatch && !tagMatch && match.score <= 0.3) continue;
-
-    // Boost same-file matches
     if (fileMatch) {
       match.score += 0.2;
       if (!match.matchReasons.includes("file_path")) {
         match.matchReasons.push("file_path");
       }
     }
-
-    if (match.score > 0.3) {
-      results.push(match);
-    }
+    if (match.score > 0.3) results.push(match);
   }
 
   return results.sort((a, b) => b.score - a.score);
@@ -221,3 +204,18 @@ export function hasBugForFileInSession(
       new Date(e.createdAt).getTime() >= sessionStart
   );
 }
+
+// ── JSON shim — kept so the migration importer + state-aggregator can still
+// read legacy files during the rollout window. New writes go through the repo.
+
+import { safeReadJson, atomicWriteJson } from "./fs-utils";
+
+export function loadBugMemory(path: string): BugMemory {
+  const raw = safeReadJson(path);
+  if (raw !== null && isBugMemory(raw)) return raw;
+  return createEmptyBugMemory();
+}
+
+export function saveBugMemory(path: string, memory: BugMemory): void {
+  atomicWriteJson(path, memory);
+}

package/src/core/dashboard-api.ts

@@ -1,9 +1,7 @@
 import { existsSync, readFileSync } from "fs";
 import {
   projectDir,
-  fileIndexPath,
-  tokenLedgerPath,
-  bugMemoryPath,
+  projectDbPath,
   actionLogPath,
   learningMemoryPath,
   projectMetaPath,
@@ -13,7 +11,8 @@ import {
   designReportPath,
 } from "./paths";
 import { safeReadJson } from "./fs-utils";
-import { isFileIndex } from "./index-store";
+import { FileIndexRepo } from "../repositories/file-index-repo";
+import { CountersRepo } from "../repositories/counters-repo";
 import { loadLedger } from "./token-ledger";
 import { parseLearningMemory } from "./learning-memory";
 import { loadBugMemory } from "./bug-memory";
@@ -125,6 +124,18 @@ function checkTextFile(name: string, filePath: string): FileStatus {
   }
 }
 
+function checkDbFile(name: string, filePath: string): FileStatus {
+  if (!existsSync(filePath)) return { name, status: "missing" };
+  try {
+    const header = readFileSync(filePath).slice(0, 16).toString("utf-8");
+    return header.startsWith("SQLite format 3")
+      ? { name, status: "ok" }
+      : { name, status: "corrupt" };
+  } catch {
+    return { name, status: "corrupt" };
+  }
+}
+
 // ── Panel Loaders ──────────────────────────────────────────────────────────
 
 export function loadOverview(cwd: string): OverviewPayload {
@@ -163,14 +174,13 @@ export function loadOverview(cwd: string): OverviewPayload {
     estimatedSavings: ledger.lifetime.totalEstimatedSavings,
   };
 
-  // State file health
+  // State file health. mink.db replaced file-index.json in Phase 2; the
+  // other JSON checks remain until Phases 3 (bug-memory) and 4 (ledger).
   const stateFiles: FileStatus[] = [
     checkJsonFile("session.json", sessionPath(cwd)),
-    checkJsonFile("file-index.json", fileIndexPath(cwd), isFileIndex),
+    checkDbFile("mink.db", projectDbPath(cwd)),
     checkJsonFile("config.json", configPath(cwd)),
     checkTextFile("learning-memory.md", learningMemoryPath(cwd)),
-    checkJsonFile("token-ledger.json", tokenLedgerPath(cwd)),
-    checkJsonFile("bug-memory.json", bugMemoryPath(cwd)),
     checkTextFile("action-log.md", actionLogPath(cwd)),
     checkJsonFile("scheduler-manifest.json", schedulerManifestPath(cwd)),
   ];
@@ -188,21 +198,33 @@ export function loadTokenLedgerPanel(cwd: string): TokenLedgerPayload {
 }
 
 export function loadFileIndexPanel(cwd: string): FileIndexPayload {
-  const raw = safeReadJson(fileIndexPath(cwd));
-  if (raw && isFileIndex(raw)) {
-    const index = raw as FileIndex;
-    const entries: FileIndexEntry[] = Object.values(index.entries);
-    return { header: index.header, entries };
+  // file_index + per-device counters now live in mink.db; we synthesize
+  // the FileIndexPayload shape the dashboard expects so the frontend
+  // doesn't need to change in this phase.
+  try {
+    const repo = FileIndexRepo.for(cwd);
+    const entries: FileIndexEntry[] = repo.listAll();
+    const totals = CountersRepo.for(cwd).totals();
+    return {
+      header: {
+        lastScanTimestamp: repo.getLastScanTimestamp(),
+        totalFiles: repo.totalFiles(),
+        lifetimeHits: totals.hits,
+        lifetimeMisses: totals.misses,
+      },
+      entries,
+    };
+  } catch {
+    return {
+      header: {
+        lastScanTimestamp: "",
+        totalFiles: 0,
+        lifetimeHits: 0,
+        lifetimeMisses: 0,
+      },
+      entries: [],
+    };
   }
-  return {
-    header: {
-      lastScanTimestamp: "",
-      totalFiles: 0,
-      lifetimeHits: 0,
-      lifetimeMisses: 0,
-    },
-    entries: [],
-  };
 }
 
 export function loadSchedulerPanel(cwd: string): SchedulerPayload {

package/src/core/index-store.ts

@@ -1,6 +1,19 @@
+// Wrapper over the file-index storage layer. Hooks and `mink scan` write
+// through to the SQLite repository at `src/repositories/file-index-repo.ts`;
+// the in-memory `FileIndex` helpers below stay around so unit tests can
+// build fixtures without spinning up a DB. The on-disk file-index.json is
+// no longer the source of truth — Phase 1's migrator moves any existing
+// JSON into the DB on first open.
+//
+// Callers that need lookup-only access should prefer the IndexLookup
+// interface (see src/types/file-index.ts) — it's the minimal surface the
+// hook hot path depends on and is satisfied by both FileIndexRepo and the
+// in-memory adapter below.
+
 import type {
   FileIndex,
   FileIndexEntry,
+  IndexLookup,
   StalenessReport,
 } from "../types/file-index";
 
@@ -70,3 +83,13 @@ export function checkStaleness(
     isStale: missingFromIndex.length > 0 || orphanedEntries.length > 0,
   };
 }
+
+// Adapter: lets analyzers that have an in-memory FileIndex (typically
+// unit tests) pass it to functions expecting the IndexLookup contract
+// without duplicating the lookup logic.
+export function indexAsLookup(index: FileIndex | null): IndexLookup | null {
+  if (index === null) return null;
+  return {
+    lookupEntry: (filePath: string) => lookupEntry(index, filePath),
+  };
+}

package/src/core/paths.ts

@@ -68,6 +68,13 @@ export function bugMemoryPath(cwd: string): string {
   return join(projectDir(cwd), "bug-memory.json");
 }
 
+// SQLite-backed state introduced in spec 17 (file index + bug memory +
+// token ledger). The legacy JSON path helpers above remain valid for
+// backup / rollback during the migration window.
+export function projectDbPath(cwd: string): string {
+  return join(projectDir(cwd), "mink.db");
+}
+
 export function actionLogPath(cwd: string): string {
   return join(projectDir(cwd), "action-log.md");
 }

package/src/core/scanner.ts

@@ -21,7 +21,10 @@ export const DEFAULT_EXCLUDES: string[] = [
   ".mink",
 ];
 
-const DEFAULT_MAX_FILES = 500;
+// Phase 5 of the SQLite migration drops the legacy default cap; callers
+// that want one set `maxFiles` explicitly. SQLite's per-row write cost is
+// flat in index size, so capping by default no longer pays off.
+const NO_CAP = Number.POSITIVE_INFINITY;
 
 function matchesPattern(name: string, pattern: string): boolean {
   if (pattern.includes("*")) {
@@ -96,20 +99,21 @@ export interface ScanStats {
 export function scanProjectWithStats(
   projectRoot: string,
   excludes: string[],
-  maxFiles: number = DEFAULT_MAX_FILES
+  maxFiles: number | undefined = NO_CAP
 ): ScanStats {
   const results: ScannedFile[] = [];
   walkDirectory(projectRoot, projectRoot, excludes, results);
   results.sort((a, b) => b.mtimeMs - a.mtimeMs);
   const totalScanned = results.length;
-  const files = results.slice(0, maxFiles);
+  const cap = maxFiles ?? NO_CAP;
+  const files = Number.isFinite(cap) ? results.slice(0, cap) : results;
   return { files, totalScanned, truncated: totalScanned - files.length };
 }
 
 export function scanProject(
   projectRoot: string,
   excludes: string[],
-  maxFiles: number = DEFAULT_MAX_FILES
+  maxFiles: number | undefined = NO_CAP
 ): ScannedFile[] {
   return scanProjectWithStats(projectRoot, excludes, maxFiles).files;
 }