homegraph 1.1.2 → 1.1.3

package/scripts/agent-eval/parse-session.mjs

@@ -1,93 +1,93 @@
-#!/usr/bin/env node
-// Parse the newest Claude Code session log for a project + its subagent logs,
-// and report the tool-call breakdown (main + subagents). Works for interactive
-// runs (driven via itrun.sh) — Claude Code writes full transcripts to
-// ~/.claude/projects/<escaped-cwd>/<session>.jsonl with subagents/ alongside.
-import { readFileSync, readdirSync, statSync, existsSync, realpathSync } from 'fs';
-import { join } from 'path';
-import { homedir } from 'os';
-
-const projectArg = process.argv[2];
-if (!projectArg) { console.error('usage: parse-session.mjs <project-dir>'); process.exit(1); }
-
-// Claude Code escapes the (real) cwd by replacing every "/" with "-".
-const real = realpathSync(projectArg);
-const escaped = real.replace(/\//g, '-');
-const projDir = join(homedir(), '.claude', 'projects', escaped);
-if (!existsSync(projDir)) { console.error('no session logs at', projDir); process.exit(1); }
-
-// Newest top-level session .jsonl
-const sessions = readdirSync(projDir)
-  .filter(f => f.endsWith('.jsonl'))
-  .map(f => ({ f, m: statSync(join(projDir, f)).mtimeMs }))
-  .sort((a, b) => b.m - a.m);
-if (sessions.length === 0) { console.error('no .jsonl sessions in', projDir); process.exit(1); }
-const sessionId = sessions[0].f.replace('.jsonl', '');
-
-function tally(file) {
-  const counts = {};
-  for (const line of readFileSync(file, 'utf8').split('\n')) {
-    if (!line) continue;
-    let ev; try { ev = JSON.parse(line); } catch { continue; }
-    const content = ev.message?.content;
-    if (!Array.isArray(content)) continue;
-    for (const b of content) {
-      if (b.type === 'tool_use') counts[b.name] = (counts[b.name] || 0) + 1;
-    }
-  }
-  return counts;
-}
-
-// Sum token usage from a transcript. The TUI's "Done (…Xk tokens…)" line only
-// covers a subagent's throughput; this works for main-thread runs too and is
-// consistent across both paths. `gen` = output, `fresh` = uncached input
-// (input + cache_creation), `cached` = cache reads (≈free), `total` = all.
-function sumTokens(file) {
-  const t = { gen: 0, fresh: 0, cached: 0 };
-  for (const line of readFileSync(file, 'utf8').split('\n')) {
-    if (!line) continue;
-    let ev; try { ev = JSON.parse(line); } catch { continue; }
-    const u = ev.message?.usage;
-    if (!u) continue;
-    t.gen += u.output_tokens || 0;
-    t.fresh += (u.input_tokens || 0) + (u.cache_creation_input_tokens || 0);
-    t.cached += u.cache_read_input_tokens || 0;
-  }
-  return t;
-}
-
-const mainCounts = tally(join(projDir, sessionId + '.jsonl'));
-
-// Subagent transcripts live under <session>/subagents/*.jsonl
-const subDir = join(projDir, sessionId, 'subagents');
-const subCounts = {};
-let subAgentFiles = 0;
-if (existsSync(subDir)) {
-  for (const f of readdirSync(subDir).filter(f => f.endsWith('.jsonl'))) {
-    subAgentFiles++;
-    const c = tally(join(subDir, f));
-    for (const [k, v] of Object.entries(c)) subCounts[k] = (subCounts[k] || 0) + v;
-  }
-}
-
-const fmt = (counts) => Object.entries(counts).sort((a, b) => b[1] - a[1])
-  .map(([k, v]) => `    ${String(v).padStart(3)}  ${k}`).join('\n') || '    (none)';
-
-console.log(`session: ${sessionId}`);
-console.log(`\nMAIN thread tools:\n${fmt(mainCounts)}`);
-console.log(`\nSUBAGENT tools (${subAgentFiles} subagent transcript${subAgentFiles === 1 ? '' : 's'}):\n${fmt(subCounts)}`);
-
-const explore = subCounts['mcp__homegraph__homegraph_explore'] || mainCounts['mcp__homegraph__homegraph_explore'] || 0;
-const reads = (subCounts['Read'] || 0) + (mainCounts['Read'] || 0);
-const greps = (subCounts['Grep'] || 0) + (mainCounts['Grep'] || 0) + (subCounts['Bash'] || 0) + (mainCounts['Bash'] || 0);
-console.log(`\nVERDICT: homegraph_explore used ${explore}x | Read ${reads} | Grep/Bash ${greps}`);
-
-// Token totals (main + subagents), consistent across main-thread and subagent runs.
-const tok = { gen: 0, fresh: 0, cached: 0 };
-const addTok = (t) => { tok.gen += t.gen; tok.fresh += t.fresh; tok.cached += t.cached; };
-addTok(sumTokens(join(projDir, sessionId + '.jsonl')));
-if (existsSync(subDir)) {
-  for (const f of readdirSync(subDir).filter(f => f.endsWith('.jsonl'))) addTok(sumTokens(join(subDir, f)));
-}
-const k = (n) => (n / 1000).toFixed(1) + 'k';
-console.log(`TOKENS: gen ${k(tok.gen)} | fresh-in ${k(tok.fresh)} | cached-in ${k(tok.cached)} | billable≈ ${k(tok.gen + tok.fresh)}`);
+#!/usr/bin/env node
+// Parse the newest Claude Code session log for a project + its subagent logs,
+// and report the tool-call breakdown (main + subagents). Works for interactive
+// runs (driven via itrun.sh) — Claude Code writes full transcripts to
+// ~/.claude/projects/<escaped-cwd>/<session>.jsonl with subagents/ alongside.
+import { readFileSync, readdirSync, statSync, existsSync, realpathSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const projectArg = process.argv[2];
+if (!projectArg) { console.error('usage: parse-session.mjs <project-dir>'); process.exit(1); }
+
+// Claude Code escapes the (real) cwd by replacing every "/" with "-".
+const real = realpathSync(projectArg);
+const escaped = real.replace(/\//g, '-');
+const projDir = join(homedir(), '.claude', 'projects', escaped);
+if (!existsSync(projDir)) { console.error('no session logs at', projDir); process.exit(1); }
+
+// Newest top-level session .jsonl
+const sessions = readdirSync(projDir)
+  .filter(f => f.endsWith('.jsonl'))
+  .map(f => ({ f, m: statSync(join(projDir, f)).mtimeMs }))
+  .sort((a, b) => b.m - a.m);
+if (sessions.length === 0) { console.error('no .jsonl sessions in', projDir); process.exit(1); }
+const sessionId = sessions[0].f.replace('.jsonl', '');
+
+function tally(file) {
+  const counts = {};
+  for (const line of readFileSync(file, 'utf8').split('\n')) {
+    if (!line) continue;
+    let ev; try { ev = JSON.parse(line); } catch { continue; }
+    const content = ev.message?.content;
+    if (!Array.isArray(content)) continue;
+    for (const b of content) {
+      if (b.type === 'tool_use') counts[b.name] = (counts[b.name] || 0) + 1;
+    }
+  }
+  return counts;
+}
+
+// Sum token usage from a transcript. The TUI's "Done (…Xk tokens…)" line only
+// covers a subagent's throughput; this works for main-thread runs too and is
+// consistent across both paths. `gen` = output, `fresh` = uncached input
+// (input + cache_creation), `cached` = cache reads (≈free), `total` = all.
+function sumTokens(file) {
+  const t = { gen: 0, fresh: 0, cached: 0 };
+  for (const line of readFileSync(file, 'utf8').split('\n')) {
+    if (!line) continue;
+    let ev; try { ev = JSON.parse(line); } catch { continue; }
+    const u = ev.message?.usage;
+    if (!u) continue;
+    t.gen += u.output_tokens || 0;
+    t.fresh += (u.input_tokens || 0) + (u.cache_creation_input_tokens || 0);
+    t.cached += u.cache_read_input_tokens || 0;
+  }
+  return t;
+}
+
+const mainCounts = tally(join(projDir, sessionId + '.jsonl'));
+
+// Subagent transcripts live under <session>/subagents/*.jsonl
+const subDir = join(projDir, sessionId, 'subagents');
+const subCounts = {};
+let subAgentFiles = 0;
+if (existsSync(subDir)) {
+  for (const f of readdirSync(subDir).filter(f => f.endsWith('.jsonl'))) {
+    subAgentFiles++;
+    const c = tally(join(subDir, f));
+    for (const [k, v] of Object.entries(c)) subCounts[k] = (subCounts[k] || 0) + v;
+  }
+}
+
+const fmt = (counts) => Object.entries(counts).sort((a, b) => b[1] - a[1])
+  .map(([k, v]) => `    ${String(v).padStart(3)}  ${k}`).join('\n') || '    (none)';
+
+console.log(`session: ${sessionId}`);
+console.log(`\nMAIN thread tools:\n${fmt(mainCounts)}`);
+console.log(`\nSUBAGENT tools (${subAgentFiles} subagent transcript${subAgentFiles === 1 ? '' : 's'}):\n${fmt(subCounts)}`);
+
+const explore = subCounts['mcp__homegraph__homegraph_explore'] || mainCounts['mcp__homegraph__homegraph_explore'] || 0;
+const reads = (subCounts['Read'] || 0) + (mainCounts['Read'] || 0);
+const greps = (subCounts['Grep'] || 0) + (mainCounts['Grep'] || 0) + (subCounts['Bash'] || 0) + (mainCounts['Bash'] || 0);
+console.log(`\nVERDICT: homegraph_explore used ${explore}x | Read ${reads} | Grep/Bash ${greps}`);
+
+// Token totals (main + subagents), consistent across main-thread and subagent runs.
+const tok = { gen: 0, fresh: 0, cached: 0 };
+const addTok = (t) => { tok.gen += t.gen; tok.fresh += t.fresh; tok.cached += t.cached; };
+addTok(sumTokens(join(projDir, sessionId + '.jsonl')));
+if (existsSync(subDir)) {
+  for (const f of readdirSync(subDir).filter(f => f.endsWith('.jsonl'))) addTok(sumTokens(join(subDir, f)));
+}
+const k = (n) => (n / 1000).toFixed(1) + 'k';
+console.log(`TOKENS: gen ${k(tok.gen)} | fresh-in ${k(tok.fresh)} | cached-in ${k(tok.cached)} | billable≈ ${k(tok.gen + tok.fresh)}`);

package/scripts/agent-eval/probe-context.mjs

@@ -1,21 +1,21 @@
-#!/usr/bin/env node
-// Probe homegraph_context (with call-paths) against an index using the built dist.
-// Usage: node probe-context.mjs <repo-with-.homegraph> <task words...>
-import { pathToFileURL } from 'node:url';
-import { resolve } from 'node:path';
-
-const [, , repo, ...taskParts] = process.argv;
-const task = taskParts.join(' ');
-if (!repo || !task) { console.error('usage: probe-context.mjs <repo> <task...>'); process.exit(1); }
-
-const load = async (rel) => import(pathToFileURL(resolve(rel)).href);
-const idx = await load('dist/index.js');
-const tools = await load('dist/mcp/tools.js');
-const HomeGraph = idx.default?.default ?? idx.default ?? idx.HomeGraph;
-const ToolHandler = tools.ToolHandler ?? tools.default?.ToolHandler;
-
-const cg = HomeGraph.openSync(repo);
-const h = new ToolHandler(cg);
-const res = await h.execute('homegraph_context', { task });
-console.log(res.content?.[0]?.text ?? '(no text)');
-try { cg.close?.(); } catch {}
+#!/usr/bin/env node
+// Probe homegraph_context (with call-paths) against an index using the built dist.
+// Usage: node probe-context.mjs <repo-with-.homegraph> <task words...>
+import { pathToFileURL } from 'node:url';
+import { resolve } from 'node:path';
+
+const [, , repo, ...taskParts] = process.argv;
+const task = taskParts.join(' ');
+if (!repo || !task) { console.error('usage: probe-context.mjs <repo> <task...>'); process.exit(1); }
+
+const load = async (rel) => import(pathToFileURL(resolve(rel)).href);
+const idx = await load('dist/index.js');
+const tools = await load('dist/mcp/tools.js');
+const HomeGraph = idx.default?.default ?? idx.default ?? idx.HomeGraph;
+const ToolHandler = tools.ToolHandler ?? tools.default?.ToolHandler;
+
+const cg = HomeGraph.openSync(repo);
+const h = new ToolHandler(cg);
+const res = await h.execute('homegraph_context', { task });
+console.log(res.content?.[0]?.text ?? '(no text)');
+try { cg.close?.(); } catch {}

package/scripts/agent-eval/probe-explore.mjs

@@ -1,40 +1,40 @@
-#!/usr/bin/env node
-// One-shot probe: run handleExplore against an existing index using the built
-// dist, print the output + a few stats. Lets us verify explore's coverage fix
-// without a full agent run. Usage: node probe-explore.mjs <repo-with-.homegraph> "<query>"
-import { pathToFileURL } from 'node:url';
-import { resolve } from 'node:path';
-
-const [, , repo, query] = process.argv;
-if (!repo || !query) {
-  console.error('usage: probe-explore.mjs <repo> "<query>"');
-  process.exit(1);
-}
-
-const load = async (rel) => import(pathToFileURL(resolve(rel)).href);
-const idx = await load('dist/index.js');
-const tools = await load('dist/mcp/tools.js');
-
-// esModuleInterop: dynamic import of CJS yields { default: module.exports, ...named }
-const HomeGraph = idx.default?.default ?? idx.default ?? idx.HomeGraph;
-const ToolHandler = tools.ToolHandler ?? tools.default?.ToolHandler;
-
-if (typeof HomeGraph?.openSync !== 'function') {
-  console.error('could not resolve HomeGraph.openSync; index keys:', Object.keys(idx), 'default keys:', idx.default && Object.keys(idx.default));
-  process.exit(2);
-}
-if (typeof ToolHandler !== 'function') {
-  console.error('could not resolve ToolHandler; tools keys:', Object.keys(tools));
-  process.exit(2);
-}
-
-const cg = HomeGraph.openSync(repo);
-const h = new ToolHandler(cg);
-const res = await h.execute('homegraph_explore', { query });
-const text = res.content?.[0]?.text ?? '(no text)';
-console.log(text);
-console.error('\n--- PROBE STATS ---');
-console.error('output chars:', text.length);
-console.error('triggerRender body present (-> setState({})):', /triggerRender[\s\S]{0,400}setState\(\{\}\)/.test(text));
-console.error('App.tsx in source section:', /\*\*`.*App\.tsx`\*\* —/.test(text));
-try { cg.close?.(); } catch {}
+#!/usr/bin/env node
+// One-shot probe: run handleExplore against an existing index using the built
+// dist, print the output + a few stats. Lets us verify explore's coverage fix
+// without a full agent run. Usage: node probe-explore.mjs <repo-with-.homegraph> "<query>"
+import { pathToFileURL } from 'node:url';
+import { resolve } from 'node:path';
+
+const [, , repo, query] = process.argv;
+if (!repo || !query) {
+  console.error('usage: probe-explore.mjs <repo> "<query>"');
+  process.exit(1);
+}
+
+const load = async (rel) => import(pathToFileURL(resolve(rel)).href);
+const idx = await load('dist/index.js');
+const tools = await load('dist/mcp/tools.js');
+
+// esModuleInterop: dynamic import of CJS yields { default: module.exports, ...named }
+const HomeGraph = idx.default?.default ?? idx.default ?? idx.HomeGraph;
+const ToolHandler = tools.ToolHandler ?? tools.default?.ToolHandler;
+
+if (typeof HomeGraph?.openSync !== 'function') {
+  console.error('could not resolve HomeGraph.openSync; index keys:', Object.keys(idx), 'default keys:', idx.default && Object.keys(idx.default));
+  process.exit(2);
+}
+if (typeof ToolHandler !== 'function') {
+  console.error('could not resolve ToolHandler; tools keys:', Object.keys(tools));
+  process.exit(2);
+}
+
+const cg = HomeGraph.openSync(repo);
+const h = new ToolHandler(cg);
+const res = await h.execute('homegraph_explore', { query });
+const text = res.content?.[0]?.text ?? '(no text)';
+console.log(text);
+console.error('\n--- PROBE STATS ---');
+console.error('output chars:', text.length);
+console.error('triggerRender body present (-> setState({})):', /triggerRender[\s\S]{0,400}setState\(\{\}\)/.test(text));
+console.error('App.tsx in source section:', /\*\*`.*App\.tsx`\*\* —/.test(text));
+try { cg.close?.(); } catch {}

package/scripts/agent-eval/probe-node.mjs

@@ -1,20 +1,20 @@
-#!/usr/bin/env node
-// Probe homegraph_node (with trail) against an index using the built dist.
-// Usage: node probe-node.mjs <repo-with-.homegraph> <symbol> [code]
-import { pathToFileURL } from 'node:url';
-import { resolve } from 'node:path';
-
-const [, , repo, symbol, code] = process.argv;
-if (!repo || !symbol) { console.error('usage: probe-node.mjs <repo> <symbol> [code]'); process.exit(1); }
-
-const load = async (rel) => import(pathToFileURL(resolve(rel)).href);
-const idx = await load('dist/index.js');
-const tools = await load('dist/mcp/tools.js');
-const HomeGraph = idx.default?.default ?? idx.default ?? idx.HomeGraph;
-const ToolHandler = tools.ToolHandler ?? tools.default?.ToolHandler;
-
-const cg = HomeGraph.openSync(repo);
-const h = new ToolHandler(cg);
-const res = await h.execute('homegraph_node', { symbol, includeCode: code === 'code' });
-console.log(res.content?.[0]?.text ?? '(no text)');
-try { cg.close?.(); } catch {}
+#!/usr/bin/env node
+// Probe homegraph_node (with trail) against an index using the built dist.
+// Usage: node probe-node.mjs <repo-with-.homegraph> <symbol> [code]
+import { pathToFileURL } from 'node:url';
+import { resolve } from 'node:path';
+
+const [, , repo, symbol, code] = process.argv;
+if (!repo || !symbol) { console.error('usage: probe-node.mjs <repo> <symbol> [code]'); process.exit(1); }
+
+const load = async (rel) => import(pathToFileURL(resolve(rel)).href);
+const idx = await load('dist/index.js');
+const tools = await load('dist/mcp/tools.js');
+const HomeGraph = idx.default?.default ?? idx.default ?? idx.HomeGraph;
+const ToolHandler = tools.ToolHandler ?? tools.default?.ToolHandler;
+
+const cg = HomeGraph.openSync(repo);
+const h = new ToolHandler(cg);
+const res = await h.execute('homegraph_node', { symbol, includeCode: code === 'code' });
+console.log(res.content?.[0]?.text ?? '(no text)');
+try { cg.close?.(); } catch {}

package/scripts/agent-eval/probe-sweep.mjs

@@ -1,119 +1,119 @@
-#!/usr/bin/env node
-// probe-sweep — direct MCP test across N repos × N tools, no claude needed.
-//
-// Measures response characteristics (size, sections present, signals fired)
-// for each (repo, query) pair against the built dist/. Sub-second per probe;
-// the full sweep below runs in ~10-30s vs hours for a real claude audit.
-//
-// Use this to iterate on backend changes rapidly: change tools.ts /
-// context-builder, npm run build, re-run probe-sweep, compare. Once a
-// change looks good on probe metrics, run a focused claude audit for the
-// few repos that matter to confirm end-to-end cost behavior.
-//
-// Usage: node scripts/agent-eval/probe-sweep.mjs [--tool=context|explore|trace] [--repos=a,b,c]
-import { pathToFileURL } from 'node:url';
-import { resolve } from 'node:path';
-
-const args = Object.fromEntries(
-  process.argv.slice(2).map(a => a.startsWith('--') ? a.slice(2).split('=') : [a, true])
-);
-const TOOL = args.tool ?? 'context';
-
-const load = (rel) => import(pathToFileURL(resolve(rel)).href);
-const idx = await load('dist/index.js');
-const tools = await load('dist/mcp/tools.js');
-const HomeGraph = idx.default?.default ?? idx.default ?? idx.HomeGraph;
-const ToolHandler = tools.ToolHandler ?? tools.default?.ToolHandler;
-
-// Each entry: repo, query, optional 2nd arg for trace (from, to).
-// The query is the same prompt used in the real claude audits, so probe
-// output is directly comparable to the agent's would-be input.
-const SWEEP = [
-  // Small realworld template repos (the loss cases from the cross-language sweep)
-  { id: 'gin-rw',        repo: '/tmp/homegraph-corpus/gin-realworld',         q: 'How does this Gin app route a request through its middleware chain to a handler?' },
-  { id: 'go-mux',        repo: '/tmp/homegraph-corpus/go-mux',                q: 'How does this gorilla/mux app route a request to its handler?' },
-  { id: 'fastapi-rw',    repo: '/tmp/homegraph-corpus/fastapi-realworld',     q: 'How does FastAPI route a request through its dependencies to a handler?' },
-  { id: 'spring-pc',     repo: '/tmp/homegraph-corpus/spring-petclinic',      q: 'How does Spring route an HTTP request to a controller method?' },
-  { id: 'axum-rw',       repo: '/tmp/homegraph-corpus/rust-axum-realworld',   q: 'How does Axum route a request to its handler in this app?' },
-  { id: 'express-rw',    repo: '/tmp/homegraph-corpus/express-realworld',     q: 'How does this Express app route a request through middleware to a handler?' },
-  { id: 'kotlin-pc',     repo: '/tmp/homegraph-corpus/kotlin-petclinic',      q: 'How does the Kotlin Spring app route an HTTP request to its handler?' },
-  { id: 'flask-mb',      repo: '/tmp/homegraph-corpus/flask-microblog',       q: 'How does this Flask app route a request to a view function?' },
-  { id: 'vapor-tpl',     repo: '/tmp/homegraph-corpus/vapor-template',        q: 'How does Vapor route an HTTP request to its handler?' },
-  { id: 'cpp-leveldb',   repo: '/tmp/homegraph-corpus/cpp-leveldb',           q: 'How does LevelDB handle a Put operation through to disk?' },
-  { id: 'lualine',       repo: '/tmp/homegraph-corpus/lualine.nvim',          q: 'How does lualine assemble and render the statusline?' },
-  { id: 'drupal-admin',  repo: '/tmp/homegraph-corpus/drupal-admintoolbar',   q: 'How does the Drupal admin toolbar module render its toolbar?' },
-  { id: 'svelte-rw',     repo: '/tmp/homegraph-corpus/svelte-realworld',      q: 'How does this SvelteKit app route a request to a handler?' },
-  { id: 'react-rw',      repo: '/tmp/homegraph-corpus/react-realworld',       q: 'How does this React app fetch and display articles?' },
-  { id: 'rails-rw',      repo: '/tmp/homegraph-corpus/rails-realworld',       q: 'How does Rails route a request to a controller action?' },
-  { id: 'flask-rest',    repo: '/tmp/homegraph-corpus/flask-restful-realworld', q: 'How does Flask-RESTful route a request to a resource method?' },
-  { id: 'laravel-rw',    repo: '/tmp/homegraph-corpus/laravel-realworld',     q: 'How does Laravel route a request to the controller method?' },
-  { id: 'aspnet-rw',     repo: '/tmp/homegraph-corpus/aspnet-realworld',      q: 'How does ASP.NET route a request to the controller action?' },
-  // The iter7 wins/ties (to make sure we don't regress)
-  { id: 'cobra',         repo: '/tmp/homegraph-corpus/cobra',                 q: 'How does cobra parse commands and flags?' },
-  { id: 'sinatra',       repo: '/tmp/homegraph-corpus/sinatra',               q: 'How does sinatra route a request to its handler?' },
-  { id: 'slim',          repo: '/tmp/homegraph-corpus/slim',                  q: 'How does slim route a request and apply middleware?' },
-];
-
-// Detect signals in response text — these are the levers we've added that
-// otherwise only show up via "agent ran X more tool calls" downstream.
-const detect = (text) => ({
-  hasEntryPoints: /^### Entry Points/m.test(text),
-  hasRelatedSymbols: /^### Related Symbols/m.test(text),
-  hasFlowTrace: /^## Inline flow trace/m.test(text),
-  hasRouteManifest: /^## Routing manifest/m.test(text),
-  hasTopHandler: /^### Top handler file/m.test(text),
-  hasSmallRepoTail: /This project is small/.test(text),
-});
-
-const filterRepos = args.repos ? new Set(String(args.repos).split(',')) : null;
-const subjects = SWEEP.filter(s => !filterRepos || filterRepos.has(s.id));
-
-const t0 = Date.now();
-const rows = [];
-for (const s of subjects) {
-  try {
-    const cg = HomeGraph.openSync(s.repo);
-    const handler = new ToolHandler(cg);
-    const t1 = Date.now();
-    const res = await handler.execute('homegraph_' + TOOL,
-      TOOL === 'context' ? { task: s.q } :
-      TOOL === 'explore' ? { query: s.q } : { from: 'main', to: 'main' });
-    const text = res.content?.[0]?.text ?? '';
-    const signals = detect(text);
-    rows.push({
-      id: s.id,
-      ms: Date.now() - t1,
-      chars: text.length,
-      lines: text.split('\n').length,
-      ...signals,
-    });
-    try { cg.close?.(); } catch {}
-  } catch (e) {
-    rows.push({ id: s.id, error: String(e).slice(0, 80) });
-  }
-}
-
-// Pretty-print as a compact table.
-const fmt = (r) =>
-  r.error
-    ? `  ${r.id.padEnd(13)} ERROR: ${r.error}`
-    : `  ${r.id.padEnd(13)} ${String(r.chars).padStart(6)}c ${String(r.lines).padStart(4)}L ${String(r.ms).padStart(4)}ms` +
-      ` ${r.hasEntryPoints ? 'EP ' : '   '}` +
-      `${r.hasFlowTrace ? 'TRC ' : '    '}` +
-      `${r.hasRouteManifest ? 'MAN ' : '    '}` +
-      `${r.hasTopHandler ? 'HND ' : '    '}` +
-      `${r.hasSmallRepoTail ? 'TAIL' : '    '}`;
-console.log(`=== probe-sweep tool=${TOOL} n=${subjects.length} (${Date.now() - t0}ms total) ===`);
-console.log('  id            chars  lines    ms signals');
-console.log('  ' + '-'.repeat(56));
-for (const r of rows) console.log(fmt(r));
-
-// Sum + medians for the size pillar
-const sizes = rows.filter(r => !r.error).map(r => r.chars);
-sizes.sort((a, b) => a - b);
-const median = sizes[Math.floor(sizes.length / 2)];
-const sum = sizes.reduce((a, b) => a + b, 0);
-console.log(`  ${'-'.repeat(64)}`);
-console.log(`  median=${median}c  total=${sum}c  ` +
-  `manifest=${rows.filter(r => r.hasRouteManifest).length}/${rows.filter(r => !r.error).length}  ` +
-  `top-handler=${rows.filter(r => r.hasTopHandler).length}/${rows.filter(r => !r.error).length}`);
+#!/usr/bin/env node
+// probe-sweep — direct MCP test across N repos × N tools, no claude needed.
+//
+// Measures response characteristics (size, sections present, signals fired)
+// for each (repo, query) pair against the built dist/. Sub-second per probe;
+// the full sweep below runs in ~10-30s vs hours for a real claude audit.
+//
+// Use this to iterate on backend changes rapidly: change tools.ts /
+// context-builder, npm run build, re-run probe-sweep, compare. Once a
+// change looks good on probe metrics, run a focused claude audit for the
+// few repos that matter to confirm end-to-end cost behavior.
+//
+// Usage: node scripts/agent-eval/probe-sweep.mjs [--tool=context|explore|trace] [--repos=a,b,c]
+import { pathToFileURL } from 'node:url';
+import { resolve } from 'node:path';
+
+const args = Object.fromEntries(
+  process.argv.slice(2).map(a => a.startsWith('--') ? a.slice(2).split('=') : [a, true])
+);
+const TOOL = args.tool ?? 'context';
+
+const load = (rel) => import(pathToFileURL(resolve(rel)).href);
+const idx = await load('dist/index.js');
+const tools = await load('dist/mcp/tools.js');
+const HomeGraph = idx.default?.default ?? idx.default ?? idx.HomeGraph;
+const ToolHandler = tools.ToolHandler ?? tools.default?.ToolHandler;
+
+// Each entry: repo, query, optional 2nd arg for trace (from, to).
+// The query is the same prompt used in the real claude audits, so probe
+// output is directly comparable to the agent's would-be input.
+const SWEEP = [
+  // Small realworld template repos (the loss cases from the cross-language sweep)
+  { id: 'gin-rw',        repo: '/tmp/homegraph-corpus/gin-realworld',         q: 'How does this Gin app route a request through its middleware chain to a handler?' },
+  { id: 'go-mux',        repo: '/tmp/homegraph-corpus/go-mux',                q: 'How does this gorilla/mux app route a request to its handler?' },
+  { id: 'fastapi-rw',    repo: '/tmp/homegraph-corpus/fastapi-realworld',     q: 'How does FastAPI route a request through its dependencies to a handler?' },
+  { id: 'spring-pc',     repo: '/tmp/homegraph-corpus/spring-petclinic',      q: 'How does Spring route an HTTP request to a controller method?' },
+  { id: 'axum-rw',       repo: '/tmp/homegraph-corpus/rust-axum-realworld',   q: 'How does Axum route a request to its handler in this app?' },
+  { id: 'express-rw',    repo: '/tmp/homegraph-corpus/express-realworld',     q: 'How does this Express app route a request through middleware to a handler?' },
+  { id: 'kotlin-pc',     repo: '/tmp/homegraph-corpus/kotlin-petclinic',      q: 'How does the Kotlin Spring app route an HTTP request to its handler?' },
+  { id: 'flask-mb',      repo: '/tmp/homegraph-corpus/flask-microblog',       q: 'How does this Flask app route a request to a view function?' },
+  { id: 'vapor-tpl',     repo: '/tmp/homegraph-corpus/vapor-template',        q: 'How does Vapor route an HTTP request to its handler?' },
+  { id: 'cpp-leveldb',   repo: '/tmp/homegraph-corpus/cpp-leveldb',           q: 'How does LevelDB handle a Put operation through to disk?' },
+  { id: 'lualine',       repo: '/tmp/homegraph-corpus/lualine.nvim',          q: 'How does lualine assemble and render the statusline?' },
+  { id: 'drupal-admin',  repo: '/tmp/homegraph-corpus/drupal-admintoolbar',   q: 'How does the Drupal admin toolbar module render its toolbar?' },
+  { id: 'svelte-rw',     repo: '/tmp/homegraph-corpus/svelte-realworld',      q: 'How does this SvelteKit app route a request to a handler?' },
+  { id: 'react-rw',      repo: '/tmp/homegraph-corpus/react-realworld',       q: 'How does this React app fetch and display articles?' },
+  { id: 'rails-rw',      repo: '/tmp/homegraph-corpus/rails-realworld',       q: 'How does Rails route a request to a controller action?' },
+  { id: 'flask-rest',    repo: '/tmp/homegraph-corpus/flask-restful-realworld', q: 'How does Flask-RESTful route a request to a resource method?' },
+  { id: 'laravel-rw',    repo: '/tmp/homegraph-corpus/laravel-realworld',     q: 'How does Laravel route a request to the controller method?' },
+  { id: 'aspnet-rw',     repo: '/tmp/homegraph-corpus/aspnet-realworld',      q: 'How does ASP.NET route a request to the controller action?' },
+  // The iter7 wins/ties (to make sure we don't regress)
+  { id: 'cobra',         repo: '/tmp/homegraph-corpus/cobra',                 q: 'How does cobra parse commands and flags?' },
+  { id: 'sinatra',       repo: '/tmp/homegraph-corpus/sinatra',               q: 'How does sinatra route a request to its handler?' },
+  { id: 'slim',          repo: '/tmp/homegraph-corpus/slim',                  q: 'How does slim route a request and apply middleware?' },
+];
+
+// Detect signals in response text — these are the levers we've added that
+// otherwise only show up via "agent ran X more tool calls" downstream.
+const detect = (text) => ({
+  hasEntryPoints: /^### Entry Points/m.test(text),
+  hasRelatedSymbols: /^### Related Symbols/m.test(text),
+  hasFlowTrace: /^## Inline flow trace/m.test(text),
+  hasRouteManifest: /^## Routing manifest/m.test(text),
+  hasTopHandler: /^### Top handler file/m.test(text),
+  hasSmallRepoTail: /This project is small/.test(text),
+});
+
+const filterRepos = args.repos ? new Set(String(args.repos).split(',')) : null;
+const subjects = SWEEP.filter(s => !filterRepos || filterRepos.has(s.id));
+
+const t0 = Date.now();
+const rows = [];
+for (const s of subjects) {
+  try {
+    const cg = HomeGraph.openSync(s.repo);
+    const handler = new ToolHandler(cg);
+    const t1 = Date.now();
+    const res = await handler.execute('homegraph_' + TOOL,
+      TOOL === 'context' ? { task: s.q } :
+      TOOL === 'explore' ? { query: s.q } : { from: 'main', to: 'main' });
+    const text = res.content?.[0]?.text ?? '';
+    const signals = detect(text);
+    rows.push({
+      id: s.id,
+      ms: Date.now() - t1,
+      chars: text.length,
+      lines: text.split('\n').length,
+      ...signals,
+    });
+    try { cg.close?.(); } catch {}
+  } catch (e) {
+    rows.push({ id: s.id, error: String(e).slice(0, 80) });
+  }
+}
+
+// Pretty-print as a compact table.
+const fmt = (r) =>
+  r.error
+    ? `  ${r.id.padEnd(13)} ERROR: ${r.error}`
+    : `  ${r.id.padEnd(13)} ${String(r.chars).padStart(6)}c ${String(r.lines).padStart(4)}L ${String(r.ms).padStart(4)}ms` +
+      ` ${r.hasEntryPoints ? 'EP ' : '   '}` +
+      `${r.hasFlowTrace ? 'TRC ' : '    '}` +
+      `${r.hasRouteManifest ? 'MAN ' : '    '}` +
+      `${r.hasTopHandler ? 'HND ' : '    '}` +
+      `${r.hasSmallRepoTail ? 'TAIL' : '    '}`;
+console.log(`=== probe-sweep tool=${TOOL} n=${subjects.length} (${Date.now() - t0}ms total) ===`);
+console.log('  id            chars  lines    ms signals');
+console.log('  ' + '-'.repeat(56));
+for (const r of rows) console.log(fmt(r));
+
+// Sum + medians for the size pillar
+const sizes = rows.filter(r => !r.error).map(r => r.chars);
+sizes.sort((a, b) => a - b);
+const median = sizes[Math.floor(sizes.length / 2)];
+const sum = sizes.reduce((a, b) => a + b, 0);
+console.log(`  ${'-'.repeat(64)}`);
+console.log(`  median=${median}c  total=${sum}c  ` +
+  `manifest=${rows.filter(r => r.hasRouteManifest).length}/${rows.filter(r => !r.error).length}  ` +
+  `top-handler=${rows.filter(r => r.hasTopHandler).length}/${rows.filter(r => !r.error).length}`);