homegraph 1.5.0 → 1.5.2

package/scripts/agent-eval/offload-eval-styles.sh

@@ -1,72 +0,0 @@
-#!/usr/bin/env bash
-# Offload reasoning-OUTPUT-STYLE A/B — all homegraph-on, isolating the Worker's
-# output shape's effect on main-session tokens / latency / accuracy:
-#   raw  : HOMEGRAPH_OFFLOAD_DISABLE=1            (verbatim explore source, the floor)
-#   refs : managed offload, default              (Cerebras map re-expanded to verbatim, ~24K)
-#   map  : managed offload, STYLE=map            (compact reasoned map + file:line anchors, ~1-3K)
-#   src  : managed offload, STYLE=src            (map + cited line ranges only, ~1-5K)
-# Delegation BLOCKED by default (DISALLOW=Agent) so we measure the offload payload's
-# effect on the main Sonnet agent, not whether it spawns a Haiku Explore subagent.
-#
-# Usage: offload-eval-styles.sh <indexed-repo> <reps> "<question>"
-# Env:   RESULTS=<file>  AGENT_EVAL_OUT=<dir>  REP_START=1  DISALLOW=Agent  MODEL/EFFORT
-set -uo pipefail
-HERE="$(cd "$(dirname "$0")" && pwd)"
-ENGINE="$(cd "$HERE/../.." && pwd)"
-BIN="$ENGINE/dist/bin/homegraph.js"
-OUT="${AGENT_EVAL_OUT:-/tmp/cg-offload-eval}"
-TARGET="${1:?usage: offload-eval-styles.sh <indexed-repo> <reps> \"<question>\"}"
-REPS="${2:?reps}"; Q="${3:?question}"
-RUNS="$OUT/runs"; EXTRACT="$HERE/offload-eval-metrics.mjs"
-RESULTS="${RESULTS:-$OUT/results-styles.jsonl}"
-REPO=$(basename "$TARGET")
-DISALLOW="${DISALLOW-Agent}"   # default: block delegation. `DISALLOW= ` to allow.
-START="${REP_START:-1}"; END=$((START + REPS - 1))
-mkdir -p "$RUNS"
-command -v claude >/dev/null || { echo "no claude on PATH"; exit 1; }
-[ -d "$TARGET/.homegraph" ] || { echo "not indexed: $TARGET"; exit 1; }
-TARGET=$(cd "$TARGET" && pwd -P)
-
-prewarm() { # path  extra-env
-  pkill -9 -f "serve --mcp --path $1" 2>/dev/null; rm -f "$1/.homegraph/daemon.sock" 2>/dev/null; sleep 0.6
-  env ${2:-} HOMEGRAPH_DAEMON_IDLE_TIMEOUT_MS=1800000 node "$BIN" serve --mcp --path "$1" </dev/null >/dev/null 2>&1 &
-  node -e 'const fs=require("fs");let n=0;const t=setInterval(()=>{if(fs.existsSync(process.argv[1]+"/.homegraph/daemon.sock")){clearInterval(t);process.exit(0)}if(n++>150){clearInterval(t);process.exit(1)}},100)' "$1" \
-    && echo "  daemon warm" || echo "  WARN daemon never bound"
-}
-kill_daemon() { pkill -9 -f "serve --mcp --path $TARGET" 2>/dev/null; rm -f "$TARGET/.homegraph/daemon.sock" 2>/dev/null; sleep 1; }
-
-run() { # arm rep mcp-config usage-log-or-dash
-  local arm="$1" rep="$2" cfg="$3" usage="$4" tag="$REPO-$1-$2"
-  [ "$usage" != "-" ] && : > "$usage"
-  ( cd "$TARGET" && claude -p "$Q" \
-      --output-format stream-json --verbose --permission-mode bypassPermissions \
-      --model "${MODEL:-sonnet}" --effort "${EFFORT:-high}" --max-budget-usd 4 \
-      ${DISALLOW:+--disallowedTools "$DISALLOW"} \
-      --strict-mcp-config --mcp-config "$cfg" \
-      </dev/null > "$RUNS/$tag.jsonl" 2>"$RUNS/$tag.err" )
-  node "$EXTRACT" --run "$RUNS/$tag.jsonl" --usage "$usage" --arm "$arm" --rep "$rep" \
-      --repo "$REPO" --tier styles --q "$Q" >> "$RESULTS"
-  node -e 'const o=JSON.parse(require("fs").readFileSync(process.argv[1],"utf8").trim().split("\n").pop());console.log(`  [${o.arm} #${o.rep}] ${o.durationSec}s | ${o.tokBillable} billable tok | read=${o.read} grep=${o.grep} explore=${o.explore} offload=${o.offloadFired} | AI ${o.ai.calls}c/${o.ai.totalTokens}t | ok=${o.ok}`)' "$RESULTS"
-}
-
-# MCP configs: env baked into the daemon-spawn command claude uses.
-USAGE="$RUNS/$REPO-usage.jsonl"
-mkcfg() { # file extra-env-pairs(JSON array entries, comma-led or empty)
-  printf '{"mcpServers":{"homegraph":{"command":"env","args":["HOMEGRAPH_WASM_RELAUNCHED=1"%s,"node","%s","serve","--mcp","--path","%s"]}}}' "$1" "$BIN" "$TARGET"
-}
-CFG_RAW="$RUNS/mcp-sty-raw-$REPO.json";   mkcfg ',"HOMEGRAPH_OFFLOAD_DISABLE=1"' > "$CFG_RAW"
-CFG_REFS="$RUNS/mcp-sty-refs-$REPO.json"; mkcfg ",\"HOMEGRAPH_OFFLOAD_USAGE_LOG=$USAGE\"" > "$CFG_REFS"
-CFG_MAP="$RUNS/mcp-sty-map-$REPO.json";   mkcfg ",\"HOMEGRAPH_OFFLOAD_USAGE_LOG=$USAGE\",\"HOMEGRAPH_OFFLOAD_STYLE=map\"" > "$CFG_MAP"
-CFG_SRC="$RUNS/mcp-sty-src-$REPO.json";   mkcfg ",\"HOMEGRAPH_OFFLOAD_USAGE_LOG=$USAGE\",\"HOMEGRAPH_OFFLOAD_STYLE=src\"" > "$CFG_SRC"
-
-echo "###### repo=$REPO reps=$START..$END model=${MODEL:-sonnet}/${EFFORT:-high} disallow=${DISALLOW:-<none>}"
-echo "###### Q=$Q"
-echo "== ARM raw ==";  prewarm "$TARGET" "HOMEGRAPH_OFFLOAD_DISABLE=1"
-for r in $(seq "$START" "$END"); do run raw  "$r" "$CFG_RAW"  "-"; done; kill_daemon
-echo "== ARM refs =="; prewarm "$TARGET" "HOMEGRAPH_OFFLOAD_USAGE_LOG=$USAGE"
-for r in $(seq "$START" "$END"); do run refs "$r" "$CFG_REFS" "$USAGE"; done; kill_daemon
-echo "== ARM map ==";  prewarm "$TARGET" "HOMEGRAPH_OFFLOAD_USAGE_LOG=$USAGE HOMEGRAPH_OFFLOAD_STYLE=map"
-for r in $(seq "$START" "$END"); do run map  "$r" "$CFG_MAP"  "$USAGE"; done; kill_daemon
-echo "== ARM src ==";  prewarm "$TARGET" "HOMEGRAPH_OFFLOAD_USAGE_LOG=$USAGE HOMEGRAPH_OFFLOAD_STYLE=src"
-for r in $(seq "$START" "$END"); do run src  "$r" "$CFG_SRC"  "$USAGE"; done; kill_daemon
-echo "###### DONE $REPO — judge: node $HERE/offload-eval-judge.mjs --results $RESULTS --truth $HERE/offload-eval-ground-truth.json --out $OUT/judged-styles.jsonl"

package/scripts/agent-eval/offload-eval-summarize.mjs

@@ -1,68 +0,0 @@
-#!/usr/bin/env node
-// Aggregate judged.jsonl (or results.jsonl) into a per-repo, per-arm report:
-// time, main tokens/cost, AI tokens/cost, total cost, tool mix, accuracy.
-// Usage: summarize.mjs <judged-or-results.jsonl>
-import { readFileSync } from 'fs';
-const rows = readFileSync(process.argv[2], 'utf8').split('\n').filter(Boolean).map(l => JSON.parse(l));
-
-const med = (xs) => { const a = xs.filter(x => x != null).sort((p, q) => p - q); if (!a.length) return null; const m = Math.floor(a.length / 2); return a.length % 2 ? a[m] : (a[m - 1] + a[m]) / 2; };
-const rng = (xs) => { const a = xs.filter(x => x != null); return a.length ? `${Math.min(...a)}–${Math.max(...a)}` : '—'; };
-const d2 = (x) => x == null ? '—' : (+x).toFixed(2);
-const d3 = (x) => x == null ? '—' : (+x).toFixed(3);
-const d4 = (x) => x == null ? '—' : (+x).toFixed(4);
-
-const ARM_ORDER = ['frontload', 'offload', 'raw', 'nocg'];
-const byRepo = {};
-for (const r of rows) (byRepo[r.repo] ??= {});
-for (const r of rows) ((byRepo[r.repo][r.arm] ??= []).push(r));
-
-const verdictTally = (rs, field) => {
-  const t = { pass: 0, partial: 0, fail: 0, error: 0 };
-  for (const r of rs) { const v = r[field]?.verdict; if (v in t) t[v]++; }
-  return t;
-};
-
-for (const repo of Object.keys(byRepo)) {
-  const tier = byRepo[repo][Object.keys(byRepo[repo])[0]][0].tier;
-  console.log(`\n${'='.repeat(78)}\n${repo}  [${tier}]\n${'='.repeat(78)}`);
-  console.log(`${'arm'.padEnd(9)} n  ${'time(s)'.padStart(9)} ${'mainCost'.padStart(9)} ${'aiCost'.padStart(8)} ${'totCost'.padStart(8)} ${'mainTok'.padStart(8)} ${'aiTok'.padStart(7)} ${'rd'.padStart(3)} ${'gr'.padStart(3)} ${'exp'.padStart(3)} ${'off'.padStart(3)}  e2e(P/p/F)  fidScore`);
-  for (const arm of ARM_ORDER) {
-    const rs = byRepo[repo][arm]; if (!rs) continue;
-    const n = rs.length;
-    const mainCost = med(rs.map(r => r.costUsdMain));
-    const aiCost = med(rs.map(r => r.ai?.costUsd ?? 0));
-    const totCost = (mainCost ?? 0) + (aiCost ?? 0);
-    const e2e = verdictTally(rs, 'e2e');
-    const fidScores = arm === 'offload' ? rs.flatMap(r => r.fidelity?.scores ?? []) : [];
-    const fid = fidScores.length ? med(fidScores) : null;
-    const fab = arm === 'offload' && rs.some(r => r.fidelity?.anyFabrication);
-    const e2eScore = med(rs.map(r => r.e2e?.score).filter(x => x != null));
-    console.log(
-      `${arm.padEnd(9)} ${String(n).padStart(1)}  ${String(med(rs.map(r => r.durationSec))).padStart(9)} ` +
-      `${('$' + d3(mainCost)).padStart(9)} ${('$' + d3(aiCost)).padStart(8)} ${('$' + d3(totCost)).padStart(8)} ` +
-      `${String(Math.round(med(rs.map(r => r.tokBillable)) / 1000) + 'k').padStart(8)} ${String(Math.round(med(rs.map(r => r.ai?.totalTokens ?? 0)) / 1000) + 'k').padStart(7)} ` +
-      `${String(med(rs.map(r => r.read))).padStart(3)} ${String(med(rs.map(r => r.grep))).padStart(3)} ${String(med(rs.map(r => r.explore))).padStart(3)} ${String(med(rs.map(r => r.offloadFired))).padStart(3)}  ` +
-      `${(e2e.pass + '/' + e2e.partial + '/' + e2e.fail).padStart(9)}  ${e2eScore != null ? 'e2e=' + e2eScore : ''} ${fid != null ? 'fid=' + fid + (fab ? ' FAB!' : '') : ''}`
-    );
-  }
-  // ranges line for the two key metrics (variance matters)
-  for (const arm of ARM_ORDER) {
-    const rs = byRepo[repo][arm]; if (!rs) continue;
-    console.log(`   ${arm} ranges: time ${rng(rs.map(r => r.durationSec))}s · mainCost $${rng(rs.map(r => r.costUsdMain))} · read ${rng(rs.map(r => r.read))} · explore ${rng(rs.map(r => r.explore))} · offloadFired ${rng(rs.map(r => r.offloadFired))}`);
-  }
-}
-
-// Cross-repo roll-up: offload vs raw vs nocg deltas
-console.log(`\n${'='.repeat(78)}\nCROSS-REPO SUMMARY (medians per repo, then averaged)\n${'='.repeat(78)}`);
-console.log(`${'repo'.padEnd(12)} ${'arm'.padEnd(8)} ${'time'.padStart(7)} ${'totCost'.padStart(8)} ${'read'.padStart(5)} ${'e2e pass%'.padStart(9)} ${'fid'.padStart(5)}`);
-for (const repo of Object.keys(byRepo)) {
-  for (const arm of ARM_ORDER) {
-    const rs = byRepo[repo][arm]; if (!rs) continue;
-    const e2e = verdictTally(rs, 'e2e');
-    const passPct = Math.round(100 * e2e.pass / rs.length);
-    const totCost = (med(rs.map(r => r.costUsdMain)) ?? 0) + (med(rs.map(r => r.ai?.costUsd ?? 0)) ?? 0);
-    const fid = arm === 'offload' ? med(rs.flatMap(r => r.fidelity?.scores ?? [])) : null;
-    console.log(`${repo.padEnd(12)} ${arm.padEnd(8)} ${(med(rs.map(r => r.durationSec)) + 's').padStart(7)} ${('$' + d3(totCost)).padStart(8)} ${String(med(rs.map(r => r.read))).padStart(5)} ${(passPct + '%').padStart(9)} ${String(fid ?? '—').padStart(5)}`);
-  }
-}
-console.log('');

package/scripts/agent-eval/offload-eval.md

@@ -1,76 +0,0 @@
-# HomeGraph AI offload — accuracy & adoption eval harness
-
-Measures the managed **offload** (`homegraph_explore` → reasoning model synthesis) and the
-**front-load hook** (approach 1) against plain homegraph and no-homegraph, across repo sizes,
-on **time · main-session tokens/cost · HomeGraph-AI tokens/cost · accuracy**.
-
-All agent arms run `claude -p --model sonnet --effort high` (the deliberate floor model — an
-affordance that lands on Sonnet generalizes up). Everything writes to a scratch dir
-(`AGENT_EVAL_OUT`, default `/tmp/cg-offload-eval`); nothing here is shipped to users.
-
-## Repos (selected via a memory-probe gate — NOT trained on)
-
-Famous repos (express, excalidraw, n8n, …) are useless for *accuracy* evals: Sonnet answers their
-flow questions from memory, so the no-homegraph baseline is dishonest. These four passed a no-tools
-probe (Sonnet could not name their real flow internals) and are cloned fresh by `offload-eval-setup.sh`:
-
-| tier | repo | ~src files | canonical flow |
-|---|---|---|---|
-| small | MTKruto/MTKruto | 322 TS | `sendMessage` → invoke → TL serialize → transport |
-| medium | mvdicarlo/postybirb-plus | 608 TS | submission → queue → per-website `.post()` |
-| complex | shapeshift/web | 3.2k TS (35-pkg monorepo) | swap → swapper registry → concrete swapper |
-| large | trezor/trezor-suite | 8k TS monorepo | send-form → sign thunk → `@trezor/connect` |
-
-Verified ground-truth flows (the judge's reference) live in `offload-eval-ground-truth.json`.
-
-## Arms
-
-- **offload** — homegraph + managed offload ON (requires `homegraph login`); records AI tokens/credits via `HOMEGRAPH_OFFLOAD_USAGE_LOG`.
-- **raw** — homegraph, `HOMEGRAPH_OFFLOAD_DISABLE=1` (returns raw source).
-- **nocg** — empty MCP config; Read/Grep baseline.
-- **frontload** — homegraph (offload-disabled) + a `UserPromptSubmit` hook (`offload-eval-hook.mjs`) that runs raw explore on the prompt and injects the result into context (approach 1).
-
-## Run it
-
-```bash
-npm run build                       # the harness shells out to dist/
-homegraph login                     # only needed for the offload arm
-export AGENT_EVAL_OUT=/tmp/cg-offload-eval
-
-bash scripts/agent-eval/offload-eval-setup.sh            # clone + index the 4 repos
-bash scripts/agent-eval/offload-eval-matrix.sh           # 3 arms × 4 tiers × REPS (default 3)
-node scripts/agent-eval/offload-eval-judge.mjs \
-     --results $AGENT_EVAL_OUT/results.jsonl \
-     --truth  scripts/agent-eval/offload-eval-ground-truth.json \
-     --out    $AGENT_EVAL_OUT/judged.jsonl
-node scripts/agent-eval/offload-eval-summarize.mjs $AGENT_EVAL_OUT/judged.jsonl
-
-bash scripts/agent-eval/offload-eval-frontload-matrix.sh # frontload arm + judge + merged summary
-```
-
-Single repo: `offload-eval-3arm.sh <indexed-repo> <tier> <reps> "<question>"` (or `-frontload.sh`).
-
-## Files
-
-- `offload-eval-setup.sh` — clone + index the 4 repos.
-- `offload-eval-3arm.sh` / `-frontload.sh` — one repo, the arms.
-- `offload-eval-matrix.sh` / `-frontload-matrix.sh` — drive all 4 tiers.
-- `offload-eval-hook.mjs` — the front-load `UserPromptSubmit` hook (resolves its own engine; `CG_FRONTLOAD_DEBUG=<path>` to log injections; `CG_FRONTLOAD_BUDGET` to cap injected chars).
-- `offload-eval-metrics.mjs` — one run's stream-json + usage log → one JSON metrics line.
-- `offload-eval-judge.mjs` — Sonnet judge: end-to-end (agent final vs ground truth) + per-answer offload fidelity.
-- `offload-eval-summarize.mjs` — per-tier, per-arm table + cross-repo roll-up.
-- `offload-eval-ground-truth.json` — source-verified canonical flows.
-
-## Findings (2026-06, n=3 — direction consistent, magnitudes noisy)
-
-- **Raw homegraph is the efficiency win** — ~nocg accuracy, fewer reads, faster, no AI cost.
-- **The offload is the least-accurate arm in all 4 tiers** — synthesized fidelity 12–27/100 with
-  fabrication in 3/4 (e.g. invented website services; traced `ClientPlain`/`SessionPlain` instead of
-  the real encrypted path). Its speed/cost win is narrow (medium-only) and inversely correlated with
-  accuracy. **Use raw until offload fidelity is fixed.**
-- **The front-load hook SOLVES adoption** — reads → 0–1 in every tier (incl. large, where the agent
-  otherwise read 12–24 files); fired 12/12, 0 errors. Wins on medium/complex (100% pass). But it
-  **regresses small/large to partial** — it suppresses the reads that compensate for explore's gaps at
-  **dynamic boundaries** (async queues, redux thunks, facade/factory indirection).
-- **Master lever for BOTH:** explore's dynamic-dispatch coverage. Fix it → front-load is complete
-  everywhere and the offload has the full flow to synthesize.

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

@@ -1,116 +0,0 @@
-#!/usr/bin/env node
-// Analyze the tool-surface ablation (/tmp/arms/<repo>/<arm>-r<n>.jsonl).
-// Compares arms A–E on trace adoption, Read/Grep fallback, homegraph payload,
-// round-trips, and duration — averaged across runs per arm.
-//
-// The decisive signal is READS: if removing a tool raises Reads on a question
-// class, that tool was load-bearing for it (not redundant). If removing it
-// changes nothing, it was redundant.
-//
-//   A control       all tools            no steering   (baseline)
-//   B steer         all tools            trace-first   (adoption)
-//   C no-explore    hide explore         trace-first   (is explore redundant?)
-//   D trace-centric hide explore+context trace-first   (is the survey pair redundant?)
-//   E control-probe hide explore+context trace-first   (NON-flow Q — should degrade)
-//
-// Usage: node scripts/agent-eval/parse-arms.mjs [/tmp/arms]
-import { readFileSync, readdirSync, existsSync, statSync } from 'fs';
-import { join } from 'path';
-
-const ROOT = process.argv[2] || '/tmp/arms';
-const cgShort = (n) => n.replace('mcp__homegraph__homegraph_', '').replace('mcp__homegraph__', '');
-
-function parse(file) {
-  if (!existsSync(file)) return null;
-  const lines = readFileSync(file, 'utf8').split('\n').filter(Boolean);
-  const calls = []; let result = null, initCg = 0;
-  for (const l of lines) {
-    let ev; try { ev = JSON.parse(l); } catch { continue; }
-    if (ev.type === 'system' && ev.subtype === 'init') initCg = (ev.tools || []).filter(t => /homegraph/.test(t)).length;
-    if (ev.type === 'assistant') for (const b of (ev.message?.content || [])) if (b.type === 'tool_use')
-      calls.push({ id: b.id, name: b.name, out: 0 });
-    if (ev.type === 'user') for (const b of (ev.message?.content || [])) if (b.type === 'tool_result') {
-      const c = b.content;
-      const txt = typeof c === 'string' ? c : Array.isArray(c) ? c.map(x => x?.text || '').join('') : '';
-      const call = calls.find(k => k.id === b.tool_use_id); if (call) call.out = txt.length;
-    }
-    if (ev.type === 'result') result = ev;
-  }
-  const cg = calls.filter(c => c.name.includes('homegraph'));
-  return {
-    initCg,
-    reads: calls.filter(c => c.name === 'Read').length,
-    greps: calls.filter(c => c.name === 'Grep').length + calls.filter(c => c.name === 'Glob').length,
-    cgCalls: cg.length,
-    cgSeq: cg.map(c => cgShort(c.name)),
-    cgOut: cg.reduce((s, c) => s + c.out, 0),
-    traceUsed: cg.some(c => c.name.includes('trace')),
-    turns: result?.num_turns ?? null,
-    dur: result?.duration_ms ? Math.round(result.duration_ms / 1000) : null,
-    cost: result?.total_cost_usd || 0,
-    ok: result?.subtype === 'success',
-  };
-}
-
-// repo -> arm -> [runs]
-const data = {};
-if (!existsSync(ROOT)) { console.error(`no ${ROOT}`); process.exit(1); }
-for (const repo of readdirSync(ROOT)) {
-  const rdir = join(ROOT, repo);
-  if (!statSync(rdir).isDirectory()) continue;
-  for (const f of readdirSync(rdir)) {
-    const m = f.match(/^([A-I])-r(\d+)\.jsonl$/); if (!m) continue;
-    const p = parse(join(rdir, f)); if (!p || !p.ok) continue;
-    (((data[repo] ??= {})[m[1]]) ??= []).push(p);
-  }
-}
-
-const avg = (a, f) => a.length ? a.reduce((s, x) => s + (f(x) || 0), 0) / a.length : 0;
-const k = (n) => (n / 1000).toFixed(1);
-const pad = (s, n) => String(s).padEnd(n);
-const ARMS = ['A', 'H', 'I', 'B', 'F', 'G', 'C', 'D', 'E'];
-const LABEL = { A: 'A all/none(old)', H: 'H body-trace/none', I: 'I bodytrace+dest', B: 'B all/steer(thin)', F: 'F all/steer(body)', G: 'G ported(noprompt)', C: 'C no-explore', D: 'D trace-centric', E: 'E nonflow-probe' };
-
-// ---- per repo × arm ----
-console.log('\n=== PER REPO × ARM (avg over runs) ===');
-console.log(pad('repo', 22), pad('arm', 16), 'tools', 'trace', pad('reads', 6), pad('cgOutK', 7), pad('turns', 6), 'dur');
-for (const repo of Object.keys(data).sort()) {
-  for (const arm of ARMS) {
-    const runs = data[repo][arm]; if (!runs?.length) continue;
-    console.log(
-      pad(repo, 22), pad(LABEL[arm], 16),
-      pad(runs[0].initCg, 5),
-      pad(runs.filter(r => r.traceUsed).length + '/' + runs.length, 5),
-      pad(avg(runs, r => r.reads).toFixed(1), 6),
-      pad(k(avg(runs, r => r.cgOut)), 7),
-      pad(avg(runs, r => r.turns).toFixed(1), 6),
-      avg(runs, r => r.dur).toFixed(0) + 's',
-    );
-  }
-}
-
-// ---- aggregate per arm (flow arms A–D over the flow repos; E shown apart) ----
-console.log('\n=== AGGREGATE PER ARM (mean across repos) ===');
-console.log(pad('arm', 16), pad('adoption', 9), pad('reads', 7), pad('greps', 7), pad('cgOutK', 8), pad('turns', 7), pad('dur', 6), 'cost');
-for (const arm of ARMS) {
-  const all = [];
-  for (const repo of Object.keys(data)) for (const r of (data[repo][arm] || [])) all.push({ ...r, repo });
-  if (!all.length) continue;
-  const repos = new Set(all.map(r => r.repo)).size;
-  const adopt = all.filter(r => r.traceUsed).length;
-  console.log(
-    pad(LABEL[arm], 16),
-    pad(`${adopt}/${all.length}`, 9),
-    pad(avg(all, r => r.reads).toFixed(2), 7),
-    pad(avg(all, r => r.greps).toFixed(2), 7),
-    pad(k(avg(all, r => r.cgOut)), 8),
-    pad(avg(all, r => r.turns).toFixed(1), 7),
-    pad(avg(all, r => r.dur).toFixed(0) + 's', 6),
-    '$' + avg(all, r => r.cost).toFixed(3),
-    `  (${repos} repos)`,
-  );
-}
-
-console.log('\nRead the signal: B vs A = does steering alone fix adoption + cut payload.');
-console.log('C vs B = is explore redundant (reads should NOT jump). D vs C = is context redundant.');
-console.log('E = non-flow under trace-centric; reads SHOULD jump (proves survey tools are load-bearing).');

package/scripts/agent-eval/parse-bench-readme.mjs

@@ -1,84 +0,0 @@
-#!/usr/bin/env node
-// Aggregate the README A/B (bench-readme.sh output): per repo, median of N runs
-// per arm → time, tool calls, tokens, cost, and % saved. Plus an average row.
-//
-// Tokens = SUM of per-turn assistant `usage` (input + output + cache read +
-// cache creation) — the cumulative "total tokens processed". NOTE: `result.usage`
-// is last-turn-only in current Claude Code, so it under-counts badly; don't use it.
-// `total_cost_usd` and `duration_ms` are already cumulative.
-//
-// Usage: node parse-bench-readme.mjs [/tmp/ab-readme]
-import { readFileSync, existsSync, readdirSync } from 'fs';
-import { join } from 'path';
-const ROOT = process.argv[2] || '/tmp/ab-readme';
-const REPOS = ['vscode', 'excalidraw', 'django', 'tokio', 'okhttp', 'gin', 'alamofire'];
-
-function parse(file) {
-  if (!existsSync(file)) return null;
-  const L = readFileSync(file, 'utf8').split('\n').filter(Boolean);
-  let tools = 0, reads = 0, grep = 0, cg = 0, tokens = 0, r = null, raced = false;
-  for (const l of L) { let e; try { e = JSON.parse(l); } catch { continue; }
-    if (e.type === 'assistant') {
-      const u = e.message?.usage;
-      if (u) tokens += (u.input_tokens || 0) + (u.output_tokens || 0) + (u.cache_read_input_tokens || 0) + (u.cache_creation_input_tokens || 0);
-      for (const b of (e.message?.content || [])) if (b.type === 'tool_use') {
-        const n = b.name;
-        if (n === 'ToolSearch') continue;
-        tools++;
-        if (n === 'Read') reads++;
-        else if (n === 'Grep' || n === 'Glob') grep++;
-        else if (/homegraph/.test(n)) cg++;
-      }
-    }
-    // MCP cold-start race: the headless agent fired before `homegraph serve --mcp`
-    // finished registering its tools, so early calls returned "No such tool
-    // available" and the agent floundered into grep/Read. That measures HomeGraph's
-    // startup latency, NOT its steady-state value — flag the run so the aggregate
-    // can exclude it (an artifact of headless first-turn timing, not the tool).
-    if (e.type === 'user') for (const b of (Array.isArray(e.message?.content) ? e.message.content : [])) {
-      if (b.type === 'tool_result') {
-        const t = Array.isArray(b.content) ? b.content.map(c => c.text || '').join('') : (b.content || '');
-        if (/No such tool available/.test(t)) raced = true;
-      }
-    }
-    if (e.type === 'result') r = e;
-  }
-  if (!r || r.subtype !== 'success') return null;
-  return { dur: r.duration_ms / 1000, tools, reads, grep, cg, tokens, cost: r.total_cost_usd || 0, raced };
-}
-const median = (arr) => { const v = [...arr].sort((a, b) => a - b); const n = v.length; return n === 0 ? 0 : n % 2 ? v[(n - 1) / 2] : (v[n / 2 - 1] + v[n / 2]) / 2; };
-const fmtTime = (s) => s >= 60 ? `${Math.floor(s / 60)}m ${Math.round(s % 60)}s` : `${Math.round(s)}s`;
-const fmtTok = (t) => t >= 1e6 ? `${(t / 1e6).toFixed(1)}M` : `${Math.round(t / 1000)}k`;
-const pct = (w, wo) => wo > 0 ? Math.round((1 - w / wo) * 100) : 0;
-
-console.log('repo        n(w/wo)  time WITH→WITHOUT      tools W→WO   tokens W→WO (saved)     cost W→WO (saved)');
-const savings = { cost: [], tokens: [], time: [], tools: [] };
-for (const repo of REPOS) {
-  const dir = join(ROOT, repo);
-  const runDirs = existsSync(dir) ? readdirSync(dir).filter(d => /^run\d+$/.test(d)) : [];
-  // Exclude MCP-cold-start-raced WITH runs by default — they measure a startup
-  // race, not steady-state value. `CG_INCLUDE_RACED=1` keeps them (to see the raw
-  // distribution). The WITHOUT arm has no MCP, so it's never raced.
-  const includeRaced = process.env.CG_INCLUDE_RACED === '1';
-  const W = [], WO = []; let racedExcluded = 0;
-  for (const rd of runDirs) {
-    const w = parse(join(dir, rd, 'run-headless-with.jsonl'));
-    if (w) { if (w.raced && !includeRaced) racedExcluded++; else W.push(w); }
-    const wo = parse(join(dir, rd, 'run-headless-without.jsonl')); if (wo) WO.push(wo);
-  }
-  if (!W.length || !WO.length) { console.log(`${repo.padEnd(11)} (incomplete: w=${W.length} wo=${WO.length})`); continue; }
-  const m = (arr, k) => median(arr.map(x => x[k]));
-  const wT = m(W, 'dur'), woT = m(WO, 'dur'), wTok = m(W, 'tokens'), woTok = m(WO, 'tokens');
-  const wC = m(W, 'cost'), woC = m(WO, 'cost'), wTl = m(W, 'tools'), woTl = m(WO, 'tools');
-  savings.time.push(pct(wT, woT)); savings.tokens.push(pct(wTok, woTok)); savings.cost.push(pct(wC, woC)); savings.tools.push(pct(wTl, woTl));
-  console.log(
-    `${repo.padEnd(11)} ${W.length}/${WO.length}      ` +
-    `${(fmtTime(wT) + '→' + fmtTime(woT)).padEnd(22)}` +
-    `${(Math.round(wTl) + '→' + Math.round(woTl)).padEnd(12)}` +
-    `${(fmtTok(wTok) + '→' + fmtTok(woTok) + ' (' + pct(wTok, woTok) + '%)').padEnd(24)}` +
-    `$${wC.toFixed(2)}→$${woC.toFixed(2)} (${pct(wC, woC)}%)` +
-    (racedExcluded ? `  [${racedExcluded} raced run${racedExcluded === 1 ? '' : 's'} excluded]` : '')
-  );
-}
-const avg = (a) => a.length ? Math.round(a.reduce((s, x) => s + x, 0) / a.length) : 0;
-console.log(`\nAVERAGE saved:  cost ${avg(savings.cost)}%  ·  tokens ${avg(savings.tokens)}%  ·  time ${avg(savings.time)}%  ·  tool calls ${avg(savings.tools)}%`);

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

@@ -1,45 +0,0 @@
-#!/usr/bin/env node
-// Parse a Claude Code stream-json run log: tool-call sequence + token usage.
-import { readFileSync } from 'fs';
-const file = process.argv[2];
-const lines = readFileSync(file, 'utf8').split('\n').filter(Boolean);
-
-const toolCalls = [];
-let result = null;
-let initTools = null;
-
-for (const line of lines) {
-  let ev;
-  try { ev = JSON.parse(line); } catch { continue; }
-  if (ev.type === 'system' && ev.subtype === 'init') {
-    initTools = (ev.tools || []).filter(t => /homegraph/.test(t));
-  }
-  if (ev.type === 'assistant' && ev.message?.content) {
-    for (const block of ev.message.content) {
-      if (block.type === 'tool_use') {
-        let detail = '';
-        if (block.name === 'Task') detail = ` [subagent_type=${block.input?.subagent_type ?? '?'}] ${(block.input?.description ?? '').slice(0,40)}`;
-        else if (/homegraph/.test(block.name)) detail = ` ${JSON.stringify(block.input?.query ?? block.input?.task ?? block.input?.symbol ?? '').slice(0,60)}`;
-        else if (block.name === 'Bash') detail = ` ${(block.input?.command ?? '').slice(0,50)}`;
-        else if (block.name === 'Read') detail = ` ${(block.input?.file_path ?? '').split('/').slice(-1)[0]}`;
-        toolCalls.push(`${block.name}${detail}`);
-      }
-    }
-  }
-  if (ev.type === 'result') result = ev;
-}
-
-console.log(`\n=== ${file.split('/').pop()} ===`);
-console.log(`homegraph tools exposed: ${initTools ? initTools.length : '?'}`);
-console.log(`\nTool calls (${toolCalls.length}):`);
-const counts = {};
-for (const tc of toolCalls) { const n = tc.split(' ')[0]; counts[n] = (counts[n]||0)+1; }
-console.log('  by type:', JSON.stringify(counts));
-toolCalls.forEach((tc, i) => console.log(`  ${i+1}. ${tc}`));
-
-if (result) {
-  const u = result.usage || {};
-  const totalIn = (u.input_tokens||0) + (u.cache_read_input_tokens||0) + (u.cache_creation_input_tokens||0);
-  console.log(`\nResult: ${result.subtype} | duration ${(result.duration_ms/1000).toFixed(0)}s | turns ${result.num_turns}`);
-  console.log(`  tokens: in=${totalIn} out=${u.output_tokens||0} | cost $${(result.total_cost_usd||0).toFixed(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 {}