glassbox 0.13.3 → 0.14.0

package/dist/cli.js

@@ -15851,7 +15851,7 @@ __export(difftool_exports, {
   unregisterDifftool: () => unregisterDifftool
 });
 import { spawnSync as spawnSync9 } from "child_process";
-function git3(args, cwd) {
+function git2(args, cwd) {
   const r = spawnSync9("git", args, { encoding: "utf-8", cwd });
   if (r.error !== void 0) {
     const code = r.error.code ?? "UNKNOWN";
@@ -15860,7 +15860,7 @@ function git3(args, cwd) {
   return { status: r.status ?? -1, stdout: (r.stdout || "").trim(), stderr: (r.stderr || "").trim() };
 }
 function readConfig(key, scope, cwd) {
-  const r = git3(["config", `--${scope}`, "--get", key], cwd);
+  const r = git2(["config", `--${scope}`, "--get", key], cwd);
   return r.status === 0 ? r.stdout : null;
 }
 function getDifftoolStatus(scope = "global", cwd) {
@@ -15884,7 +15884,7 @@ function registerDifftool(opts = {}) {
     ["difftool.prompt", "false"]
   ];
   for (const [key, value] of sets) {
-    const r = git3(["config", `--${scope}`, key, value], opts.cwd);
+    const r = git2(["config", `--${scope}`, key, value], opts.cwd);
     if (r.status !== 0) {
       const detail = r.stderr || `(no stderr; exit ${String(r.status)})`;
       return { ok: false, reason: "git-failed", message: `\`git config --${scope} ${key}\` failed: ${detail}` };
@@ -15899,7 +15899,7 @@ function unregisterDifftool(opts = {}) {
     return { ok: true, removed: false };
   }
   const tryUnset = (key) => {
-    const r = git3(["config", `--${scope}`, "--unset", key], opts.cwd);
+    const r = git2(["config", `--${scope}`, "--unset", key], opts.cwd);
     if (r.status !== 0 && r.status !== 5) {
       console.error(`git config --unset ${key} failed: ${r.stderr}`);
     }
@@ -16195,8 +16195,9 @@ var PLATFORMS = {
 };
 var MODELS = {
   anthropic: [
-    { id: "claude-sonnet-4-20250514", name: "Claude Sonnet 4", contextWindow: 2e5, isDefault: true },
-    { id: "claude-haiku-4-20250514", name: "Claude Haiku 4", contextWindow: 2e5, isDefault: false }
+    { id: "claude-opus-4-8", name: "Claude Opus 4.8", contextWindow: 1e6, isDefault: false },
+    { id: "claude-sonnet-4-6", name: "Claude Sonnet 4.6", contextWindow: 1e6, isDefault: true },
+    { id: "claude-haiku-4-5", name: "Claude Haiku 4.5", contextWindow: 2e5, isDefault: false }
   ],
   openai: [
     { id: "gpt-4o", name: "GPT-4o", contextWindow: 128e3, isDefault: true },
@@ -16221,6 +16222,28 @@ function getModelContextWindow(platform, modelId) {
   const model = MODELS[platform].find((m) => m.id === modelId);
   return model ? model.contextWindow : 128e3;
 }
+function modelFamily(id) {
+  const lower = id.toLowerCase();
+  for (const tier of ["opus", "sonnet", "haiku"]) {
+    if (lower.includes(tier)) return `anthropic:${tier}`;
+  }
+  if (lower.includes("gemini")) {
+    if (lower.includes("flash")) return "google:flash";
+    if (lower.includes("pro")) return "google:pro";
+    return "google:gemini";
+  }
+  if (lower.includes("gpt") || lower.startsWith("o1") || lower.startsWith("o3")) {
+    return lower.includes("mini") ? "openai:mini" : "openai:gpt";
+  }
+  return lower;
+}
+function resolveModelId(platform, modelId) {
+  const models = MODELS[platform];
+  if (models.some((m) => m.id === modelId)) return modelId;
+  const family = modelFamily(modelId);
+  const familyMatch = models.find((m) => modelFamily(m.id) === family);
+  return familyMatch ? familyMatch.id : getDefaultModel(platform);
+}
 
 // src/ai/api-keys.ts
 function getKeyFromEnv(platform) {
@@ -16317,7 +16340,7 @@ function loadAIConfig() {
   const config2 = readConfigFile();
   const platformRaw = config2.ai?.platform ?? "anthropic";
   const platform = AIPlatformSchema.safeParse(platformRaw).success ? AIPlatformSchema.parse(platformRaw) : "anthropic";
-  const model = config2.ai?.model ?? getDefaultModel(platform);
+  const model = resolveModelId(platform, config2.ai?.model ?? getDefaultModel(platform));
   const { key, source } = resolveAPIKey(platform);
   return { platform, model, apiKey: key, keySource: source };
 }
@@ -17017,12 +17040,14 @@ async function setupAnnotations(fileIdMap) {
 }
 
 // src/git/diff.ts
-import { spawnSync as spawnSync4 } from "child_process";
 import { existsSync as existsSync2, mkdirSync as mkdirSync3, mkdtempSync, readFileSync as readFileSync2, rmSync as rmSync2, statSync, writeFileSync as writeFileSync2 } from "fs";
 import { tmpdir } from "os";
 import { basename, dirname, join as join3, resolve } from "path";
 
 // src/git/repo.ts
+import { spawnSync as spawnSync4 } from "child_process";
+
+// src/git/spawn.ts
 import { spawnSync as spawnSync3 } from "child_process";
 function scrubbedGitEnv() {
   const env = { ...process.env };
@@ -17041,6 +17066,8 @@ function git(args, cwd) {
   err.status = result.status;
   throw err;
 }
+
+// src/git/repo.ts
 function getRepoRoot(cwd) {
   return git(["rev-parse", "--show-toplevel"], cwd).trim();
 }
@@ -17057,7 +17084,7 @@ function isGitRepo(cwd) {
   }
 }
 function getHeadCommit(cwd) {
-  return spawnSync3("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf-8", env: scrubbedGitEnv() }).stdout.trim();
+  return spawnSync4("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf-8", env: scrubbedGitEnv() }).stdout.trim();
 }
 
 // src/git/types.ts
@@ -17107,15 +17134,13 @@ function parseDiffData(raw) {
 
 // src/git/diff.ts
 var toGitArg = (p) => process.platform === "win32" ? p.replace(/\\/g, "/") : p;
-function git2(args, cwd) {
-  const result = spawnSync4("git", args, { cwd, encoding: "utf-8", maxBuffer: 50 * 1024 * 1024, env: scrubbedGitEnv() });
-  if (result.status === 0) return result.stdout;
-  if (result.stdout !== "") return result.stdout;
-  const err = new Error(result.stderr);
-  err.stdout = result.stdout;
-  err.stderr = result.stderr;
-  err.status = result.status;
-  throw err;
+function gitOrEmpty(args, cwd) {
+  try {
+    return git(args, cwd);
+  } catch (err) {
+    debugLog(`git ${args.join(" ")} failed (treating as empty diff): ${err instanceof Error ? err.message : String(err)}`);
+    return "";
+  }
 }
 function getDiffArgs(mode) {
   switch (mode.type) {
@@ -17166,12 +17191,7 @@ function normalizeDiffPaths(diffs, rootA, rootB) {
 }
 function getDirectComparisonFiles(mode, cwd) {
   const { rootA, rootB } = directComparisonRoots(mode);
-  let rawDiff;
-  try {
-    rawDiff = git2(["diff", "--no-index", "-U3", toGitArg(mode.pathA), toGitArg(mode.pathB)], cwd);
-  } catch {
-    rawDiff = "";
-  }
+  const rawDiff = gitOrEmpty(["diff", "--no-index", "-U3", toGitArg(mode.pathA), toGitArg(mode.pathB)], cwd);
   return normalizeDiffPaths(parseDiff(rawDiff), rootA, rootB);
 }
 function diffRawContent(displayPath, oldContent, newContent) {
@@ -17187,12 +17207,7 @@ function diffRawContent(displayPath, oldContent, newContent) {
     mkdirSync3(dirname(newAbs), { recursive: true });
     writeFileSync2(oldAbs, oldContent);
     writeFileSync2(newAbs, newContent);
-    let rawDiff;
-    try {
-      rawDiff = git2(["diff", "--no-index", "-U3", toGitArg(oldAbs), toGitArg(newAbs)], work);
-    } catch {
-      rawDiff = "";
-    }
+    const rawDiff = gitOrEmpty(["diff", "--no-index", "-U3", toGitArg(oldAbs), toGitArg(newAbs)], work);
     const diffs = normalizeDiffPaths(parseDiff(rawDiff), rootA, rootB);
     if (diffs.length === 0) {
       return { filePath: safeRel, oldPath: null, status: "modified", hunks: [], isBinary: false };
@@ -17218,15 +17233,10 @@ function getFileDiffs(mode, cwd) {
     return getAllFiles(repoRoot);
   }
   const diffArgs = getDiffArgs(mode);
-  let rawDiff;
-  try {
-    rawDiff = git2([...diffArgs, "-U3"], repoRoot);
-  } catch {
-    rawDiff = "";
-  }
+  const rawDiff = gitOrEmpty([...diffArgs, "-U3"], repoRoot);
   const diffs = parseDiff(rawDiff);
   if (mode.type === "uncommitted") {
-    const untracked = git2(["ls-files", "--others", "--exclude-standard"], repoRoot).trim();
+    const untracked = git(["ls-files", "--others", "--exclude-standard"], repoRoot).trim();
     if (untracked) {
       for (const file2 of untracked.split("\n").filter(Boolean)) {
         if (!diffs.some((d) => d.filePath === file2)) {
@@ -17238,7 +17248,7 @@ function getFileDiffs(mode, cwd) {
   return diffs;
 }
 function getAllFiles(repoRoot) {
-  const files = git2(["ls-files"], repoRoot).trim().split("\n").filter(Boolean);
+  const files = git(["ls-files"], repoRoot).trim().split("\n").filter(Boolean);
   return files.map((file2) => createNewFileDiff(file2, repoRoot));
 }
 function createNewFileDiff(filePath, repoRoot) {
@@ -17366,7 +17376,7 @@ function getFileContent(filePath, ref, cwd) {
     if (ref === "working") {
       return readFileSync2(resolve(repoRoot, filePath), "utf-8");
     }
-    return git2(["show", `${ref}:${filePath}`], repoRoot);
+    return git(["show", `${ref}:${filePath}`], repoRoot);
   } catch {
     return "";
   }
@@ -17418,12 +17428,7 @@ function getSingleFileDiff(mode, filePath, repoRoot, extraFlags = "") {
     const args2 = ["diff", "--no-index", "-U3"];
     if (extraFlags) args2.push(...extraFlags.split(" ").filter(Boolean));
     args2.push(toGitArg(oldAbs), toGitArg(newAbs));
-    let rawDiff2;
-    try {
-      rawDiff2 = git2(args2, repoRoot);
-    } catch {
-      rawDiff2 = "";
-    }
+    const rawDiff2 = gitOrEmpty(args2, repoRoot);
     const diffs2 = normalizeDiffPaths(parseDiff(rawDiff2), rootA, rootB);
     return diffs2[0] ?? null;
   }
@@ -17431,12 +17436,7 @@ function getSingleFileDiff(mode, filePath, repoRoot, extraFlags = "") {
   const args = [...diffArgs, "-U3"];
   if (extraFlags) args.push(...extraFlags.split(" ").filter(Boolean));
   args.push("--", filePath);
-  let rawDiff;
-  try {
-    rawDiff = git2(args, repoRoot);
-  } catch {
-    rawDiff = "";
-  }
+  const rawDiff = gitOrEmpty(args, repoRoot);
   const diffs = parseDiff(rawDiff);
   return diffs[0] ?? null;
 }
@@ -19032,16 +19032,22 @@ async function getContextLines(req) {
 var files_exports = {};
 __export(files_exports, {
   FileStatusSchema: () => FileStatusSchema,
+  GetFilePathReqSchema: () => GetFilePathReqSchema,
+  GetFilePathRespSchema: () => GetFilePathRespSchema,
   GetFileReqSchema: () => GetFileReqSchema,
   GetFileRespSchema: () => GetFileRespSchema,
   ListFilesRespSchema: () => ListFilesRespSchema,
+  OpenFileReqSchema: () => OpenFileReqSchema,
+  OpenFileRespSchema: () => OpenFileRespSchema,
   RevealFileReqSchema: () => RevealFileReqSchema,
   RevealFileRespSchema: () => RevealFileRespSchema,
   SetFileStatusBodySchema: () => SetFileStatusBodySchema,
   SetFileStatusReqSchema: () => SetFileStatusReqSchema,
   SetFileStatusRespSchema: () => SetFileStatusRespSchema,
   getFile: () => getFile,
+  getFilePath: () => getFilePath,
   listFiles: () => listFiles,
+  openFileInEditor: () => openFileInEditor,
   revealFile: () => revealFile,
   setFileStatus: () => setFileStatus
 });
@@ -19066,6 +19072,13 @@ var SetFileStatusBodySchema = SetFileStatusReqSchema.omit({ fileId: true });
 var SetFileStatusRespSchema = OkResponseSchema;
 var RevealFileReqSchema = external_exports.object({ fileId: external_exports.string() });
 var RevealFileRespSchema = OkResponseSchema;
+var GetFilePathReqSchema = external_exports.object({ fileId: external_exports.string() });
+var GetFilePathRespSchema = external_exports.object({
+  relativePath: external_exports.string(),
+  absolutePath: external_exports.string()
+});
+var OpenFileReqSchema = external_exports.object({ fileId: external_exports.string() });
+var OpenFileRespSchema = OkResponseSchema;
 async function listFiles() {
   return apiCall(ListFilesRespSchema, "/files");
 }
@@ -19081,6 +19094,12 @@ async function setFileStatus(req) {
 async function revealFile(req) {
   return apiCall(RevealFileRespSchema, `/files/${req.fileId}/reveal`, { method: "POST" });
 }
+async function getFilePath(req) {
+  return apiCall(GetFilePathRespSchema, `/files/${req.fileId}/path`);
+}
+async function openFileInEditor(req) {
+  return apiCall(OpenFileRespSchema, `/files/${req.fileId}/open`, { method: "POST" });
+}
 
 // src/api/image.ts
 var image_exports = {};
@@ -19998,6 +20017,7 @@ function resolveReviewId(c) {
 
 // src/routes/ai-analysis.ts
 var aiAnalysisRoutes = new Hono();
+var ANALYSIS_REUSE_TIMEOUT_MS = 15 * 60 * 1e3;
 function parseAnalysisTimestamp(updatedAt) {
   if (updatedAt.endsWith("Z") || /[+-]\d{2}:?\d{2}$/.test(updatedAt)) {
     return new Date(updatedAt);
@@ -20058,7 +20078,7 @@ aiAnalysisRoutes.post("/analyze", async (c) => {
     if (existing !== void 0 && existing.status === "running") {
       const ageMs = Date.now() - parseAnalysisTimestamp(existing.updated_at).getTime();
       debugLog(`POST /analyze: existing analysis age=${String(Math.round(ageMs / 1e3))}s`);
-      if (ageMs < 15 * 60 * 1e3) {
+      if (ageMs < ANALYSIS_REUSE_TIMEOUT_MS) {
         debugLog("POST /analyze: reusing existing running analysis");
         return c.json({ analysisId: existing.id, status: "running" });
       }
@@ -20078,6 +20098,8 @@ aiAnalysisRoutes.post("/analyze", async (c) => {
     repoRoot,
     guidedReview,
     invalidateCache
+  }).catch((err) => {
+    debugLog(`executeAnalysis dispatch rejected for ${analysis.id}: ${err instanceof Error ? err.message : String(err)}`);
   });
   return c.json({ analysisId: analysis.id, status: "running" });
 });
@@ -20395,6 +20417,99 @@ aiAnalysisRoutes.post("/preferences", async (c) => {
 
 // src/routes/ai-config.ts
 import { Hono as Hono2 } from "hono";
+
+// src/ai/list-models.ts
+init_zod();
+var FETCH_TIMEOUT_MS = 8e3;
+async function getJson(url2, headers) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => {
+    controller.abort();
+  }, FETCH_TIMEOUT_MS);
+  try {
+    const res = await fetch(url2, { headers, signal: controller.signal });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var AnthropicListSchema = external_exports.object({
+  data: external_exports.array(external_exports.object({ id: external_exports.string(), display_name: external_exports.string().optional() }))
+});
+function anthropicContextWindow(id) {
+  return id.toLowerCase().includes("haiku") ? 2e5 : 1e6;
+}
+async function fetchAnthropic(apiKey) {
+  const raw = await getJson("https://api.anthropic.com/v1/models?limit=1000", {
+    "x-api-key": apiKey,
+    "anthropic-version": "2023-06-01"
+  });
+  const parsed = AnthropicListSchema.safeParse(raw);
+  if (!parsed.success) return null;
+  return parsed.data.data.map((m) => ({
+    id: m.id,
+    name: m.display_name ?? m.id,
+    contextWindow: anthropicContextWindow(m.id),
+    isDefault: false
+  }));
+}
+var OpenAIListSchema = external_exports.object({
+  data: external_exports.array(external_exports.object({ id: external_exports.string() }))
+});
+function isOpenAIChatModel(id) {
+  const l = id.toLowerCase();
+  const isChat = /^(gpt-|chatgpt-|o\d)/.test(l);
+  const isNonChat = /(embedding|whisper|tts|audio|realtime|transcribe|moderation|dall-e|image|search|babbage|davinci|instruct)/.test(l);
+  return isChat && !isNonChat;
+}
+async function fetchOpenAI(apiKey) {
+  const raw = await getJson("https://api.openai.com/v1/models", {
+    Authorization: `Bearer ${apiKey}`
+  });
+  const parsed = OpenAIListSchema.safeParse(raw);
+  if (!parsed.success) return null;
+  return parsed.data.data.filter((m) => isOpenAIChatModel(m.id)).map((m) => ({ id: m.id, name: m.id, contextWindow: 128e3, isDefault: false }));
+}
+var GoogleListSchema = external_exports.object({
+  models: external_exports.array(external_exports.object({
+    name: external_exports.string(),
+    displayName: external_exports.string().optional(),
+    inputTokenLimit: external_exports.number().optional(),
+    supportedGenerationMethods: external_exports.array(external_exports.string()).optional()
+  }))
+});
+async function fetchGoogle(apiKey) {
+  const raw = await getJson(
+    `https://generativelanguage.googleapis.com/v1beta/models?pageSize=1000&key=${encodeURIComponent(apiKey)}`,
+    {}
+  );
+  const parsed = GoogleListSchema.safeParse(raw);
+  if (!parsed.success) return null;
+  return parsed.data.models.filter((m) => (m.supportedGenerationMethods ?? []).includes("generateContent")).map((m) => ({
+    id: m.name.replace(/^models\//, ""),
+    name: m.displayName ?? m.name.replace(/^models\//, ""),
+    contextWindow: m.inputTokenLimit !== void 0 && m.inputTokenLimit > 0 ? m.inputTokenLimit : 1e6,
+    isDefault: false
+  }));
+}
+async function fetchAvailableModels(platform, apiKey) {
+  let models;
+  if (platform === "anthropic") models = await fetchAnthropic(apiKey);
+  else if (platform === "openai") models = await fetchOpenAI(apiKey);
+  else models = await fetchGoogle(apiKey);
+  if (models === null || models.length === 0) return null;
+  const defaultId = getDefaultModel(platform);
+  const hasDefault = models.some((m) => m.id === defaultId);
+  return models.map((m, i) => ({
+    ...m,
+    isDefault: hasDefault ? m.id === defaultId : i === 0
+  }));
+}
+
+// src/routes/ai-config.ts
 var aiConfigRoutes = new Hono2();
 aiConfigRoutes.get("/config", (c) => {
   const config2 = loadAIConfig();
@@ -20416,8 +20531,18 @@ aiConfigRoutes.post("/config", async (c) => {
   }
   return c.json({ ok: true });
 });
-aiConfigRoutes.get("/models", (c) => {
-  return c.json({ platforms: PLATFORMS, models: MODELS });
+aiConfigRoutes.get("/models", async (c) => {
+  const platforms = ["anthropic", "openai", "google"];
+  const models = { anthropic: MODELS.anthropic, openai: MODELS.openai, google: MODELS.google };
+  if (!isAIServiceTest() && getDemoMode() === null) {
+    await Promise.all(platforms.map(async (platform) => {
+      const { key } = resolveAPIKey(platform);
+      if (key === null) return;
+      const live = await fetchAvailableModels(platform, key);
+      if (live !== null && live.length > 0) models[platform] = live;
+    }));
+  }
+  return c.json({ platforms: PLATFORMS, models });
 });
 aiConfigRoutes.get("/key-status", (c) => {
   const platforms = ["anthropic", "openai", "google"];
@@ -20719,6 +20844,16 @@ init_queries();
 import { execFileSync, spawn } from "child_process";
 import { resolve as resolve3 } from "path";
 function openOS(target, mode) {
+  if (mode === "edit") {
+    if (process.platform === "darwin") {
+      launchDetached("open", [target]);
+    } else if (process.platform === "win32") {
+      launchDetached("cmd", ["/c", "start", "", target]);
+    } else {
+      launchDetached("xdg-open", [target]);
+    }
+    return;
+  }
   if (mode === "reveal") {
     if (process.platform === "darwin") {
       launchDetached("open", ["-R", target]);
@@ -20739,7 +20874,8 @@ function openOS(target, mode) {
 }
 function launchDetached(command, args) {
   const child = spawn(command, args, { detached: true, stdio: "ignore" });
-  child.on("error", () => {
+  child.on("error", (err) => {
+    debugLog(`launchDetached(${command}) failed: ${err.message}`);
   });
   child.unref();
 }
@@ -20780,7 +20916,30 @@ filesRoutes.post("/files/:fileId/reveal", async (c) => {
   const fullPath = resolve4(repoRoot, file2.file_path);
   try {
     openOS(fullPath, "reveal");
-  } catch {
+  } catch (err) {
+    debugLog(`reveal failed for ${fullPath}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  return c.json({ ok: true });
+});
+filesRoutes.get("/files/:fileId/path", async (c) => {
+  const fileId = requirePathParam(c, "fileId");
+  if (!fileId.ok) return fileId.response;
+  const file2 = await getReviewFile(fileId.data);
+  if (!file2) return c.json({ error: "Not found" }, 404);
+  const repoRoot = c.get("repoRoot");
+  return c.json({ relativePath: file2.file_path, absolutePath: resolve4(repoRoot, file2.file_path) });
+});
+filesRoutes.post("/files/:fileId/open", async (c) => {
+  const fileId = requirePathParam(c, "fileId");
+  if (!fileId.ok) return fileId.response;
+  const file2 = await getReviewFile(fileId.data);
+  if (!file2) return c.json({ error: "Not found" }, 404);
+  const repoRoot = c.get("repoRoot");
+  const fullPath = resolve4(repoRoot, file2.file_path);
+  try {
+    openOS(fullPath, "edit");
+  } catch (err) {
+    debugLog(`open-in-editor failed for ${fullPath}: ${err instanceof Error ? err.message : String(err)}`);
   }
   return c.json({ ok: true });
 });
@@ -21746,6 +21905,7 @@ function pushIndentSymbol(root, stack, sym, indent, lines, lineIdx) {
 
 // src/routes/api/outline.ts
 var outlineRoutes = new Hono8();
+var MAX_REPO_SCAN_FILES = 2e3;
 outlineRoutes.get("/outline/:fileId", async (c) => {
   const repoRoot = c.get("repoRoot");
   const fileId = requirePathParam(c, "fileId");
@@ -21789,16 +21949,22 @@ outlineRoutes.get("/symbol-definition", async (c) => {
   if (definitions.length === 0) {
     try {
       const allFiles = spawnSync7("git", ["ls-files"], { cwd: repoRoot, encoding: "utf-8" }).stdout.trim().split("\n").filter(Boolean);
+      let scanned = 0;
       for (const filePath of allFiles) {
         if (searchedPaths.has(filePath)) continue;
         const ext = filePath.slice(filePath.lastIndexOf("."));
         if (!/\.(js|mjs|cjs|jsx|ts|tsx|mts|cts|java|go|rs|c|h|cpp|cc|cxx|hpp|cs|swift|php|kt|kts|scala|dart|groovy|py|rb)$/i.test(ext)) continue;
+        if (scanned >= MAX_REPO_SCAN_FILES) {
+          debugLog(`outline: repo scan hit ${String(MAX_REPO_SCAN_FILES)}-file budget for "${name}" without a match, stopping early`);
+          break;
+        }
         let content = "";
         try {
           content = readFileSync9(resolve6(repoRoot, filePath), "utf-8");
         } catch {
           continue;
         }
+        scanned++;
         if (!content) continue;
         const symbols = parseOutline(content, filePath);
         collectDefinitions(symbols, name, null, filePath, definitions);
@@ -23821,7 +23987,7 @@ async function main() {
     console.log("AI service test mode enabled \u2014 using mock AI responses");
   }
   if (debug) {
-    console.log(`[debug] Build timestamp: ${"2026-06-17T07:20:59.383Z"}`);
+    console.log(`[debug] Build timestamp: ${"2026-06-17T13:45:47.895Z"}`);
   }
   if (projectDir !== null) {
     process.chdir(projectDir);