homegraph 1.5.1 → 1.5.3

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

@@ -1,93 +0,0 @@
-#!/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 +0,0 @@
-#!/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 +0,0 @@
-#!/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 +0,0 @@
-#!/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 +0,0 @@
-#!/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}`);

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

@@ -1,20 +0,0 @@
-#!/usr/bin/env node
-// Probe homegraph_trace against an index using the built dist.
-// Usage: node probe-trace.mjs <repo-with-.homegraph> <from> <to>
-import { pathToFileURL } from 'node:url';
-import { resolve } from 'node:path';
-
-const [, , repo, from, to] = process.argv;
-if (!repo || !from || !to) { console.error('usage: probe-trace.mjs <repo> <from> <to>'); 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_trace', { from, to });
-console.log(res.content?.[0]?.text ?? '(no text)');
-try { cg.close?.(); } catch {}

package/scripts/agent-eval/redirect-read-hook.sh

@@ -1,38 +0,0 @@
-#!/usr/bin/env bash
-# PreToolUse(Read) REDIRECT hook — prototype for A/B (P1: get agents off Read and
-# onto homegraph_node during implementation, not just for Q&A).
-#
-# When the agent Reads a SOURCE file, deny it and steer to homegraph_node's
-# file-view, which (as of the Lever-1 change) returns the WHOLE file verbatim
-# WITH line numbers — imports, top-level code, comments and all — PLUS the file's
-# blast radius, in one call. That output is a strict superset of Read, so the
-# redirect is lossless: the agent loses nothing by taking it, and gains who-
-# depends-on-this for the edit it's about to make.
-#
-# Differs from block-read-hook.sh (which steers to explore/node-by-symbol): this
-# names the FILE-VIEW path explicitly (file:"<base>" + includeCode:true), the
-# 1:1 Read replacement we're trying to get picked during implementation.
-#
-# Non-source files (configs, docs, lockfiles, .env) pass through to a real Read.
-# A redirect to a file homegraph hasn't indexed SELF-CORRECTS: the file-view
-# replies "No indexed file matches … Read it directly", so a just-created file
-# never dead-ends — the agent Reads it on the next turn.
-#
-# Wire via:  claude ... --settings <settings-with-this-as-PreToolUse(Read)>
-# Eval artifact only. The production version is an indexed-aware `homegraph`
-# subcommand (cross-platform — no bash/jq — and queries the index so it never
-# bounces a new/un-indexed file), wired opt-in by the installer.
-set -uo pipefail
-input="$(cat)"
-fp="$(printf '%s' "$input" | jq -r '.tool_input.file_path // empty' 2>/dev/null)"
-[ -n "$fp" ] || exit 0
-base="$(basename "$fp")"
-
-case "$fp" in
-  *.ts|*.tsx|*.js|*.jsx|*.mjs|*.cjs|*.py|*.go|*.rs|*.java|*.rb|*.php|*.swift|*.kt|*.kts|*.scala|*.c|*.cc|*.cpp|*.h|*.hpp|*.cs|*.lua|*.vue|*.svelte|*.m|*.mm)
-    msg="homegraph has this file indexed (kept in sync on every edit). Call homegraph_node with file:\"$base\" and includeCode:true instead of Read — it returns the WHOLE file verbatim WITH line numbers (imports, top-level code and all — safe to base an Edit on) PLUS which files depend on it, in one call. Treat its output as already-Read; do not Read this file. (If it answers that the file isn't indexed — e.g. you just created it — then Read it directly.)"
-    jq -n --arg m "$msg" '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"deny",permissionDecisionReason:$m}}'
-    exit 0
-    ;;
-esac
-exit 0

package/scripts/agent-eval/repro-concurrent-explore.mjs

@@ -1,119 +0,0 @@
-#!/usr/bin/env node
-// Reproduction harness A — does the shared daemon serialize concurrent explore?
-//
-// Mirrors the daemon's reality: ONE CodeGraph + ONE ToolHandler (as MCPEngine
-// shares across all sessions), then fires N concurrent codegraph_explore calls
-// and measures:
-//   - each call's wall-clock latency + completion order
-//   - an event-loop HEARTBEAT (setInterval 50ms): the max gap between ticks is a
-//     direct measure of how long synchronous compute blocked the loop. In the
-//     real daemon a blocked loop can't flush a finished response or read the
-//     next request, so this gap is what starves the MCP transport.
-//
-// Usage: node repro-concurrent-explore.mjs <repo-with-.codegraph> <N> [timeoutMs]
-import { pathToFileURL } from 'node:url';
-import { resolve } from 'node:path';
-import { performance } from 'node:perf_hooks';
-
-const [, , repo, nRaw, timeoutRaw] = process.argv;
-if (!repo) {
-  console.error('usage: repro-concurrent-explore.mjs <repo> <N=10> [timeoutMs=60000]');
-  process.exit(1);
-}
-const N = Number(nRaw) || 10;
-const TIMEOUT_MS = Number(timeoutRaw) || 60000; // ~ MCP SDK default request timeout
-
-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 CodeGraph = idx.default?.default ?? idx.default ?? idx.CodeGraph;
-const ToolHandler = tools.ToolHandler ?? tools.default?.ToolHandler;
-
-// Distinct queries so no two calls are trivially identical. Mix of NL questions
-// (exercise FTS + RWR over the whole graph) — the expensive explore path.
-const QUERIES = [
-  'how does the text model handle edits and undo',
-  'how does the file service watch for changes on disk',
-  'how does the keybinding service resolve a chord to a command',
-  'how does the extension host activate an extension',
-  'how does the editor render decorations in the viewport',
-  'how does the search service stream results to the UI',
-  'how does the terminal process manager spawn a shell',
-  'how does the configuration service merge user and workspace settings',
-  'how does the debug adapter forward breakpoints to the runtime',
-  'how does the quick input widget filter its items',
-  'how does the notification service queue and show toasts',
-  'how does the git extension compute the diff for a file',
-  'how does the language features registry dispatch a hover request',
-  'how does the workbench layout restore editor groups on reload',
-  'how does the storage service persist state between sessions',
-  'how does the menu service build a context menu from contributions',
-];
-
-const cg = CodeGraph.openSync(repo);
-let fileCount = 0;
-try { fileCount = cg.getStats().fileCount; } catch {}
-const handler = new ToolHandler(cg);
-
-// --- event-loop heartbeat ---
-let lastTick = performance.now();
-let maxGap = 0;
-const gaps = [];
-const hb = setInterval(() => {
-  const now = performance.now();
-  const gap = now - lastTick;
-  lastTick = now;
-  if (gap > 60) gaps.push(Math.round(gap)); // expected ~50ms; record stalls
-  if (gap > maxGap) maxGap = gap;
-}, 50);
-
-function runOne(i) {
-  const q = QUERIES[i % QUERIES.length];
-  const startedAt = performance.now();
-  let timer;
-  const timeout = new Promise((res) => {
-    timer = setTimeout(() => res({ timedOut: true }), TIMEOUT_MS);
-  });
-  const work = handler
-    .execute('codegraph_explore', { query: q })
-    .then((r) => ({ ok: !r.isError, chars: r.content?.[0]?.text?.length ?? 0 }))
-    .catch((e) => ({ ok: false, err: String(e?.message ?? e) }));
-  return Promise.race([work, timeout]).then((r) => {
-    clearTimeout(timer);
-    return { i, q, ms: Math.round(performance.now() - startedAt), ...r };
-  });
-}
-
-// Baseline: one warm single call (so the first-call cold paths don't skew N).
-const warmStart = performance.now();
-await runOne(0);
-const warmMs = Math.round(performance.now() - warmStart);
-
-// Reset heartbeat stats for the concurrent run.
-gaps.length = 0; maxGap = 0; lastTick = performance.now();
-
-const batchStart = performance.now();
-const results = await Promise.all(Array.from({ length: N }, (_, i) => runOne(i)));
-const batchMs = Math.round(performance.now() - batchStart);
-clearInterval(hb);
-
-const lat = results.map((r) => r.ms).sort((a, b) => a - b);
-const timeouts = results.filter((r) => r.timedOut).length;
-const p = (q) => lat[Math.min(lat.length - 1, Math.floor(q * lat.length))];
-
-console.log('='.repeat(64));
-console.log(`repo=${repo}`);
-console.log(`fileCount=${fileCount}  N=${N}  perCallTimeout=${TIMEOUT_MS}ms`);
-console.log(`single warm explore: ${warmMs}ms`);
-console.log('-'.repeat(64));
-console.log(`concurrent batch wall-clock: ${batchMs}ms`);
-console.log(`per-call latency  min=${lat[0]}  p50=${p(0.5)}  p90=${p(0.9)}  max=${lat[lat.length - 1]}  (ms)`);
-console.log(`TIMEOUTS (>${TIMEOUT_MS}ms): ${timeouts} / ${N}`);
-console.log(`event-loop max stall: ${Math.round(maxGap)}ms   stalls>60ms: ${gaps.length}`);
-console.log(`  sum of stalls: ${gaps.reduce((a, b) => a + b, 0)}ms   biggest 5: ${gaps.sort((a,b)=>b-a).slice(0,5).join(', ')}`);
-console.log('-'.repeat(64));
-console.log('SERIALIZATION CHECK:');
-console.log(`  if serialized, batch ≈ N×single = ~${N * warmMs}ms;  actual=${batchMs}ms  (ratio ${(batchMs / (N * warmMs)).toFixed(2)})`);
-console.log(`  max latency / single = ${(lat[lat.length - 1] / warmMs).toFixed(1)}× (≈N means last call waited for all others)`);
-console.log('='.repeat(64));
-try { cg.close?.(); } catch {}

package/scripts/agent-eval/repro-daemon-clients.mjs

@@ -1,125 +0,0 @@
-#!/usr/bin/env node
-// Reproduction harness B — the FAITHFUL opencode scenario.
-//
-// Spawns N real `codegraph serve --mcp --path <repo>` processes (each becomes a
-// proxy that attaches to ONE shared daemon — exactly what opencode does with N
-// subagents), drives clean MCP JSON-RPC over each child's stdio, then fires ONE
-// concurrent wave of codegraph_explore tools/call across all N and measures
-// end-to-end latency + timeouts. This captures transport-flush starvation: a
-// daemon event-loop blocked in synchronous explore compute can neither read the
-// next request nor flush a finished response.
-//
-// Usage: node repro-daemon-clients.mjs <repo> <N=10> [perCallTimeoutMs=60000] [warm=1]
-import { spawn } from 'node:child_process';
-import { performance } from 'node:perf_hooks';
-import { resolve } from 'node:path';
-
-const [, , repoRaw, nRaw, timeoutRaw, warmRaw] = process.argv;
-const repo = resolve(repoRaw || '.');
-const N = Number(nRaw) || 10;
-const TIMEOUT_MS = Number(timeoutRaw) || 60000;
-const WARM = warmRaw === undefined ? true : warmRaw !== '0';
-const CLI = resolve('dist/bin/codegraph.js');
-
-const QUERIES = [
-  'how does the text model handle edits and undo',
-  'how does the file service watch for changes on disk',
-  'how does the keybinding service resolve a chord to a command',
-  'how does the extension host activate an extension',
-  'how does the editor render decorations in the viewport',
-  'how does the search service stream results to the UI',
-  'how does the terminal process manager spawn a shell',
-  'how does the configuration service merge user and workspace settings',
-  'how does the debug adapter forward breakpoints to the runtime',
-  'how does the quick input widget filter its items',
-  'how does the notification service queue and show toasts',
-  'how does the git extension compute the diff for a file',
-];
-
-function makeClient(id) {
-  const child = spawn('node', [CLI, 'serve', '--mcp', '--path', repo], {
-    env: { ...process.env, CODEGRAPH_TELEMETRY: '0', DO_NOT_TRACK: '1', CODEGRAPH_MCP_LOG_ATTACH: '0' },
-    stdio: ['pipe', 'pipe', 'inherit'],
-  });
-  let buf = '';
-  const waiters = new Map(); // id -> resolve
-  child.stdout.setEncoding('utf8');
-  child.stdout.on('data', (chunk) => {
-    buf += chunk;
-    let idx;
-    while ((idx = buf.indexOf('\n')) !== -1) {
-      const line = buf.slice(0, idx).trim();
-      buf = buf.slice(idx + 1);
-      if (!line) continue;
-      let msg; try { msg = JSON.parse(line); } catch { continue; }
-      if (msg.id !== undefined && waiters.has(msg.id)) {
-        waiters.get(msg.id)(msg);
-        waiters.delete(msg.id);
-      }
-    }
-  });
-  const send = (obj) => child.stdin.write(JSON.stringify(obj) + '\n');
-  const request = (method, params, rpcId, timeoutMs) =>
-    new Promise((res) => {
-      let timer;
-      if (timeoutMs) timer = setTimeout(() => { waiters.delete(rpcId); res({ __timeout: true }); }, timeoutMs);
-      waiters.set(rpcId, (m) => { if (timer) clearTimeout(timer); res(m); });
-      send({ jsonrpc: '2.0', id: rpcId, method, params });
-    });
-  return { id, child, send, request };
-}
-
-const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-
-const clients = Array.from({ length: N }, (_, i) => makeClient(i));
-
-// Initialize every client (handshake is answered locally by each proxy, instant).
-await Promise.all(clients.map((c) =>
-  c.request('initialize', { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'repro', version: '1' } }, `init-${c.id}`, 10000)
-    .then(() => c.send({ jsonrpc: '2.0', method: 'initialized' }))
-));
-
-// Warm the daemon: one explore through client 0 forces daemon spawn + project
-// open + catch-up gate to complete, so the concurrent wave measures the STEADY
-// state (the user's real scenario after the first call), not cold start.
-if (WARM) {
-  process.stderr.write('[repro] warming daemon (first explore triggers spawn+open+catchup)...\n');
-  const t0 = performance.now();
-  const r = await clients[0].request('tools/call', { name: 'codegraph_explore', arguments: { query: QUERIES[0] } }, 'warm-0', 120000);
-  process.stderr.write(`[repro] warm explore took ${Math.round(performance.now() - t0)}ms (timeout=${!!r.__timeout})\n`);
-  await sleep(500);
-}
-
-// THE WAVE: fire one explore on every client as simultaneously as possible.
-process.stderr.write(`[repro] firing ${N} concurrent explores...\n`);
-const waveStart = performance.now();
-const results = await Promise.all(clients.map((c, i) => {
-  const started = performance.now();
-  return c.request('tools/call', { name: 'codegraph_explore', arguments: { query: QUERIES[i % QUERIES.length] } }, `call-${c.id}`, TIMEOUT_MS)
-    .then((m) => ({
-      id: c.id,
-      ms: Math.round(performance.now() - started),
-      timedOut: !!m.__timeout,
-      ok: !!m.result && !m.result.isError,
-      chars: m.result?.content?.[0]?.text?.length ?? 0,
-    }));
-}));
-const waveMs = Math.round(performance.now() - waveStart);
-
-const lat = results.map((r) => r.ms).sort((a, b) => a - b);
-const timeouts = results.filter((r) => r.timedOut).length;
-const p = (q) => lat[Math.min(lat.length - 1, Math.floor(q * lat.length))];
-
-console.log('='.repeat(64));
-console.log(`HARNESS B (real daemon + ${N} proxies)   repo=${repo}`);
-console.log(`warm=${WARM}  perCallTimeout=${TIMEOUT_MS}ms`);
-console.log('-'.repeat(64));
-console.log(`wave wall-clock: ${waveMs}ms`);
-console.log(`per-call latency  min=${lat[0]}  p50=${p(0.5)}  p90=${p(0.9)}  max=${lat[lat.length - 1]}  (ms)`);
-console.log(`TIMEOUTS (>${TIMEOUT_MS}ms): ${timeouts} / ${N}`);
-console.log(`completion order (id:ms): ${results.slice().sort((a,b)=>a.ms-b.ms).map(r=>`${r.id}:${r.ms}`).join('  ')}`);
-console.log('='.repeat(64));
-
-for (const c of clients) { try { c.child.stdin.end(); c.child.kill('SIGTERM'); } catch {} }
-await sleep(300);
-process.exit(0);

package/scripts/agent-eval/run-agent.sh

@@ -1,34 +0,0 @@
-#!/usr/bin/env bash
-# Headless Claude Code run against a repo with homegraph MCP, capturing the
-# full stream-json so we can see tool calls + token usage. Complements the
-# interactive itrun.sh: headless gives a clean per-tool breakdown + exact
-# tokens/cost, but defaults to the general-purpose subagent (not Explore).
-# To force the Explore path, ask for it in the prompt.
-#
-# Usage: run-agent.sh <repo-path> <label> "<prompt>"
-# Env: AGENT_EVAL_OUT (default /tmp/agent-eval), CG_BIN (homegraph dist binary)
-set -uo pipefail
-
-REPO="$1"; LABEL="$2"; PROMPT="$3"
-CG_BIN="${CG_BIN:-$(command -v homegraph || echo /usr/local/bin/homegraph)}"
-OUT_DIR="${AGENT_EVAL_OUT:-/tmp/agent-eval}"; mkdir -p "$OUT_DIR"
-OUT="$OUT_DIR/run-${LABEL}.jsonl"
-
-MCP_CONFIG=$(cat <<JSON
-{"mcpServers":{"homegraph":{"command":"${CG_BIN}","args":["serve","--mcp","--path","${REPO}"]}}}
-JSON
-)
-
-echo "→ running [$LABEL] in $REPO"
-cd "$REPO" || exit 1
-
-claude -p "$PROMPT" \
-  --output-format stream-json --verbose \
-  --permission-mode bypassPermissions \
-  --model "${MODEL:-sonnet}" --effort "${EFFORT:-high}" \
-  --max-budget-usd 2 \
-  --strict-mcp-config --mcp-config "$MCP_CONFIG" \
-  > "$OUT" 2>"$OUT_DIR/run-${LABEL}.err"
-
-echo "exit: $? | wrote $OUT ($(wc -l < "$OUT") lines)"
-node "$(cd "$(dirname "$0")" && pwd)/parse-run.mjs" "$OUT" 2>/dev/null || true