homegraph 1.1.2 → 1.1.3

package/scripts/add-lang/verify-extraction.mjs

@@ -1,70 +1,70 @@
-#!/usr/bin/env node
-// Sanity-check that homegraph extracted REAL symbols (not just file/import nodes)
-// from a repo for a given language. Exits non-zero on a critical failure so it
-// can drive a write-extractor -> build -> re-check loop.
-//
-// Usage: node scripts/add-lang/verify-extraction.mjs <repo-path> <lang>
-// Reads `homegraph status <repo> --json` using whatever homegraph is on PATH,
-// so it reflects the binary that built the index.
-//
-// Exit codes: 0 = pass or soft-warn, 1 = critical fail, 2 = could not run.
-
-import { execFileSync } from 'node:child_process';
-
-const [repo, lang] = process.argv.slice(2);
-if (!repo || !lang) {
-  console.error('usage: verify-extraction.mjs <repo-path> <lang>');
-  process.exit(2);
-}
-
-let status;
-try {
-  const out = execFileSync('homegraph', ['status', repo, '--json'], { encoding: 'utf8' });
-  status = JSON.parse(out);
-} catch (e) {
-  console.error(`[verify] could not read homegraph status for ${repo}: ${e.message}`);
-  process.exit(2);
-}
-
-// Kinds that prove the extractor mapped AST node types (everything except
-// 'file' and 'import', which homegraph creates structurally for any language).
-const SYMBOL_KINDS = new Set([
-  'module', 'class', 'struct', 'interface', 'trait', 'protocol', 'function',
-  'method', 'property', 'field', 'variable', 'constant', 'enum', 'enum_member',
-  'type_alias', 'namespace', 'route', 'component',
-]);
-
-const byKind = status.nodesByKind || {};
-const langs = status.languages || [];
-const files = status.fileCount || 0;
-const edges = status.edgeCount || 0;
-const symbolKinds = Object.keys(byKind).filter((k) => SYMBOL_KINDS.has(k));
-const symbolCount = symbolKinds.reduce((s, k) => s + byKind[k], 0);
-
-const checks = [];
-const add = (severity, ok, label, detail) => checks.push({ severity, ok, label, detail });
-
-add('critical', status.initialized === true, 'index initialized', `initialized=${status.initialized}`);
-add('critical', langs.includes(lang), `language "${lang}" detected`, `languages=[${langs.join(', ')}]`);
-add('critical', symbolCount > 0, 'structural symbols extracted', `${symbolCount} symbols (${symbolKinds.join(', ') || 'NONE — only file/import nodes!'})`);
-add('soft', symbolCount >= files, 'symbol density >= 1/file', `${symbolCount} symbols across ${files} files`);
-add('soft', edges > files, 'edges resolved', `${edges} edges across ${files} files`);
-
-console.log(`\n# Extraction check — ${repo}  (lang=${lang}, backend=${status.backend})`);
-console.log(`  files=${files} nodes=${status.nodeCount} edges=${edges}`);
-console.log(`  nodesByKind: ${JSON.stringify(byKind)}\n`);
-for (const c of checks) console.log(`  ${c.ok ? '✓' : '✗'} ${c.label} — ${c.detail}`);
-
-const critical = checks.filter((c) => !c.ok && c.severity === 'critical');
-const soft = checks.filter((c) => !c.ok && c.severity === 'soft');
-console.log();
-if (critical.length) {
-  console.log(`RESULT: FAIL (${critical.length} critical) — extractor or grammar wiring is broken. Re-run dump-ast.mjs and fix the node-type mappings.`);
-  process.exit(1);
-}
-if (soft.length) {
-  console.log(`RESULT: WARN (${soft.length} soft) — extraction works but looks thin; inspect the counts above.`);
-  process.exit(0);
-}
-console.log('RESULT: PASS — extraction looks healthy.');
-process.exit(0);
+#!/usr/bin/env node
+// Sanity-check that homegraph extracted REAL symbols (not just file/import nodes)
+// from a repo for a given language. Exits non-zero on a critical failure so it
+// can drive a write-extractor -> build -> re-check loop.
+//
+// Usage: node scripts/add-lang/verify-extraction.mjs <repo-path> <lang>
+// Reads `homegraph status <repo> --json` using whatever homegraph is on PATH,
+// so it reflects the binary that built the index.
+//
+// Exit codes: 0 = pass or soft-warn, 1 = critical fail, 2 = could not run.
+
+import { execFileSync } from 'node:child_process';
+
+const [repo, lang] = process.argv.slice(2);
+if (!repo || !lang) {
+  console.error('usage: verify-extraction.mjs <repo-path> <lang>');
+  process.exit(2);
+}
+
+let status;
+try {
+  const out = execFileSync('homegraph', ['status', repo, '--json'], { encoding: 'utf8' });
+  status = JSON.parse(out);
+} catch (e) {
+  console.error(`[verify] could not read homegraph status for ${repo}: ${e.message}`);
+  process.exit(2);
+}
+
+// Kinds that prove the extractor mapped AST node types (everything except
+// 'file' and 'import', which homegraph creates structurally for any language).
+const SYMBOL_KINDS = new Set([
+  'module', 'class', 'struct', 'interface', 'trait', 'protocol', 'function',
+  'method', 'property', 'field', 'variable', 'constant', 'enum', 'enum_member',
+  'type_alias', 'namespace', 'route', 'component',
+]);
+
+const byKind = status.nodesByKind || {};
+const langs = status.languages || [];
+const files = status.fileCount || 0;
+const edges = status.edgeCount || 0;
+const symbolKinds = Object.keys(byKind).filter((k) => SYMBOL_KINDS.has(k));
+const symbolCount = symbolKinds.reduce((s, k) => s + byKind[k], 0);
+
+const checks = [];
+const add = (severity, ok, label, detail) => checks.push({ severity, ok, label, detail });
+
+add('critical', status.initialized === true, 'index initialized', `initialized=${status.initialized}`);
+add('critical', langs.includes(lang), `language "${lang}" detected`, `languages=[${langs.join(', ')}]`);
+add('critical', symbolCount > 0, 'structural symbols extracted', `${symbolCount} symbols (${symbolKinds.join(', ') || 'NONE — only file/import nodes!'})`);
+add('soft', symbolCount >= files, 'symbol density >= 1/file', `${symbolCount} symbols across ${files} files`);
+add('soft', edges > files, 'edges resolved', `${edges} edges across ${files} files`);
+
+console.log(`\n# Extraction check — ${repo}  (lang=${lang}, backend=${status.backend})`);
+console.log(`  files=${files} nodes=${status.nodeCount} edges=${edges}`);
+console.log(`  nodesByKind: ${JSON.stringify(byKind)}\n`);
+for (const c of checks) console.log(`  ${c.ok ? '✓' : '✗'} ${c.label} — ${c.detail}`);
+
+const critical = checks.filter((c) => !c.ok && c.severity === 'critical');
+const soft = checks.filter((c) => !c.ok && c.severity === 'soft');
+console.log();
+if (critical.length) {
+  console.log(`RESULT: FAIL (${critical.length} critical) — extractor or grammar wiring is broken. Re-run dump-ast.mjs and fix the node-type mappings.`);
+  process.exit(1);
+}
+if (soft.length) {
+  console.log(`RESULT: WARN (${soft.length} soft) — extraction works but looks thin; inspect the counts above.`);
+  process.exit(0);
+}
+console.log('RESULT: PASS — extraction looks healthy.');
+process.exit(0);

package/scripts/agent-eval/ab-adoption.sh

@@ -1,91 +1,91 @@
-#!/usr/bin/env bash
-# Does the agent PICK homegraph_node to read a file, vs the built-in Read tool?
-# Build A/B: NEW build (HEAD, homegraph_node has Read parity) vs BASELINE build
-# (a ref where it doesn't), BOTH homegraph-attached + pre-warmed, same task. The
-# metric is tool CHOICE: Read calls vs homegraph_node[file] calls per run.
-#
-# Usage: ab-adoption.sh <indexed-repo> "<task>" [runs-per-arm] [baseline-ref]
-# Env: AGENT_EVAL_OUT (default: /tmp/ab-adoption)
-set -uo pipefail
-TARGET="${1:?usage: ab-adoption.sh <indexed-repo> \"<task>\" [runs] [baseline-ref]}"
-TASK="${2:?task required}"
-RUNS="${3:-2}"
-BASE_REF="${4:-HEAD~1}"
-ENGINE="$(cd "$(dirname "$0")/../.." && pwd)"
-BIN="$ENGINE/dist/bin/homegraph.js"
-OUT="${AGENT_EVAL_OUT:-/tmp/ab-adoption}"
-
-command -v claude >/dev/null || { echo "claude CLI not on PATH"; exit 1; }
-[ -d "$TARGET/.homegraph" ] || { echo "target not indexed: run 'homegraph init $TARGET' first"; exit 1; }
-git -C "$ENGINE" diff --quiet && git -C "$ENGINE" diff --cached --quiet || { echo "engine has uncommitted changes — commit/stash first"; exit 1; }
-CHANGED=$(git -C "$ENGINE" diff --name-only "$BASE_REF" HEAD -- src 2>/dev/null)
-[ -n "$CHANGED" ] || { echo "no src/ changes between $BASE_REF and HEAD"; exit 1; }
-
-cleanup() {
-  pkill -9 -f "serve --mcp --path $OUT/" 2>/dev/null
-  git -C "$ENGINE" checkout HEAD -- $CHANGED 2>/dev/null
-  ( cd "$ENGINE" && npm run build >/dev/null 2>&1 )
-}
-trap cleanup EXIT
-mkdir -p "$OUT"
-echo "###### target=$TARGET  runs/arm=$RUNS  baseline=$BASE_REF"
-echo "###### changed: $(echo "$CHANGED" | tr '\n' ' ')"
-echo "###### task=$TASK"; echo
-
-prewarm() {
-  pkill -9 -f "serve --mcp --path $1" 2>/dev/null
-  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" >/dev/null 2>&1
-}
-
-# Per-run tool-choice counts: Read vs homegraph_node[file] vs [symbol].
-count() {
-  node -e '
-    const fs=require("fs");
-    const lines=fs.readFileSync(process.argv[1],"utf8").split("\n").filter(Boolean);
-    let read=0,cgFile=0,cgSym=0,cgOther=0,exposed="?";
-    for(const l of lines){try{const o=JSON.parse(l);
-      if(o.type==="system"&&o.subtype==="init"){exposed=(o.tools||[]).filter(t=>/homegraph/.test(t)).length;}
-      const blocks=o.message?.content||[];
-      for(const b of (Array.isArray(blocks)?blocks:[])){
-        if(b.type!=="tool_use")continue;
-        if(b.name==="Read")read++;
-        else if(b.name==="mcp__homegraph__homegraph_node"){ if(b.input&&b.input.symbol)cgSym++; else cgFile++; }
-        else if(/mcp__homegraph__/.test(b.name))cgOther++;
-      }
-    }catch{}}
-    console.log(`    Read=${read}  homegraph_node[file]=${cgFile}  homegraph_node[symbol]=${cgSym}  other_cg=${cgOther}  (cg exposed=${exposed})`);
-  ' "$1"
-}
-
-run_arm() { # label, N
-  local label="$1" n="$2"
-  local c="$OUT/mcp-$label.json"
-  for i in $(seq 1 "$n"); do
-    local tgt="$OUT/t-$label-$i"
-    rm -rf "$tgt"
-    rsync -a --exclude node_modules --exclude .git --exclude dist --exclude .homegraph "$TARGET/" "$tgt/"
-    node "$BIN" init "$tgt" >/dev/null 2>&1
-    printf '{"mcpServers":{"homegraph":{"command":"env","args":["HOMEGRAPH_WASM_RELAUNCHED=1","node","%s","serve","--mcp","--path","%s"]}}}' "$BIN" "$tgt" > "$c"
-    prewarm "$tgt"
-    echo "----- [$label] run $i -----"
-    ( cd "$tgt" && claude -p "$TASK" \
-        --output-format stream-json --verbose --permission-mode bypassPermissions \
-        --model "${MODEL:-sonnet}" --effort "${EFFORT:-high}" --max-budget-usd 4 --strict-mcp-config --mcp-config "$c" \
-        </dev/null > "$OUT/run-$label-$i.jsonl" 2>"$OUT/run-$label-$i.err" )
-    count "$OUT/run-$label-$i.jsonl"
-    pkill -9 -f "serve --mcp --path $tgt" 2>/dev/null
-  done
-  echo
-}
-
-echo "== NEW build (HEAD: homegraph_node has Read parity) =="
-( cd "$ENGINE" && npm run build >/dev/null 2>&1 ) && echo "built"
-run_arm new "$RUNS"
-
-echo "== BASELINE build ($BASE_REF) =="
-git -C "$ENGINE" checkout "$BASE_REF" -- $CHANGED
-( cd "$ENGINE" && npm run build >/dev/null 2>&1 ) && echo "built"
-run_arm baseline "$RUNS"
-
-echo "###### DONE — compare [new] vs [baseline]: does homegraph_node[file] rise / Read fall? Logs: $OUT"
+#!/usr/bin/env bash
+# Does the agent PICK homegraph_node to read a file, vs the built-in Read tool?
+# Build A/B: NEW build (HEAD, homegraph_node has Read parity) vs BASELINE build
+# (a ref where it doesn't), BOTH homegraph-attached + pre-warmed, same task. The
+# metric is tool CHOICE: Read calls vs homegraph_node[file] calls per run.
+#
+# Usage: ab-adoption.sh <indexed-repo> "<task>" [runs-per-arm] [baseline-ref]
+# Env: AGENT_EVAL_OUT (default: /tmp/ab-adoption)
+set -uo pipefail
+TARGET="${1:?usage: ab-adoption.sh <indexed-repo> \"<task>\" [runs] [baseline-ref]}"
+TASK="${2:?task required}"
+RUNS="${3:-2}"
+BASE_REF="${4:-HEAD~1}"
+ENGINE="$(cd "$(dirname "$0")/../.." && pwd)"
+BIN="$ENGINE/dist/bin/homegraph.js"
+OUT="${AGENT_EVAL_OUT:-/tmp/ab-adoption}"
+
+command -v claude >/dev/null || { echo "claude CLI not on PATH"; exit 1; }
+[ -d "$TARGET/.homegraph" ] || { echo "target not indexed: run 'homegraph init $TARGET' first"; exit 1; }
+git -C "$ENGINE" diff --quiet && git -C "$ENGINE" diff --cached --quiet || { echo "engine has uncommitted changes — commit/stash first"; exit 1; }
+CHANGED=$(git -C "$ENGINE" diff --name-only "$BASE_REF" HEAD -- src 2>/dev/null)
+[ -n "$CHANGED" ] || { echo "no src/ changes between $BASE_REF and HEAD"; exit 1; }
+
+cleanup() {
+  pkill -9 -f "serve --mcp --path $OUT/" 2>/dev/null
+  git -C "$ENGINE" checkout HEAD -- $CHANGED 2>/dev/null
+  ( cd "$ENGINE" && npm run build >/dev/null 2>&1 )
+}
+trap cleanup EXIT
+mkdir -p "$OUT"
+echo "###### target=$TARGET  runs/arm=$RUNS  baseline=$BASE_REF"
+echo "###### changed: $(echo "$CHANGED" | tr '\n' ' ')"
+echo "###### task=$TASK"; echo
+
+prewarm() {
+  pkill -9 -f "serve --mcp --path $1" 2>/dev/null
+  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" >/dev/null 2>&1
+}
+
+# Per-run tool-choice counts: Read vs homegraph_node[file] vs [symbol].
+count() {
+  node -e '
+    const fs=require("fs");
+    const lines=fs.readFileSync(process.argv[1],"utf8").split("\n").filter(Boolean);
+    let read=0,cgFile=0,cgSym=0,cgOther=0,exposed="?";
+    for(const l of lines){try{const o=JSON.parse(l);
+      if(o.type==="system"&&o.subtype==="init"){exposed=(o.tools||[]).filter(t=>/homegraph/.test(t)).length;}
+      const blocks=o.message?.content||[];
+      for(const b of (Array.isArray(blocks)?blocks:[])){
+        if(b.type!=="tool_use")continue;
+        if(b.name==="Read")read++;
+        else if(b.name==="mcp__homegraph__homegraph_node"){ if(b.input&&b.input.symbol)cgSym++; else cgFile++; }
+        else if(/mcp__homegraph__/.test(b.name))cgOther++;
+      }
+    }catch{}}
+    console.log(`    Read=${read}  homegraph_node[file]=${cgFile}  homegraph_node[symbol]=${cgSym}  other_cg=${cgOther}  (cg exposed=${exposed})`);
+  ' "$1"
+}
+
+run_arm() { # label, N
+  local label="$1" n="$2"
+  local c="$OUT/mcp-$label.json"
+  for i in $(seq 1 "$n"); do
+    local tgt="$OUT/t-$label-$i"
+    rm -rf "$tgt"
+    rsync -a --exclude node_modules --exclude .git --exclude dist --exclude .homegraph "$TARGET/" "$tgt/"
+    node "$BIN" init "$tgt" >/dev/null 2>&1
+    printf '{"mcpServers":{"homegraph":{"command":"env","args":["HOMEGRAPH_WASM_RELAUNCHED=1","node","%s","serve","--mcp","--path","%s"]}}}' "$BIN" "$tgt" > "$c"
+    prewarm "$tgt"
+    echo "----- [$label] run $i -----"
+    ( cd "$tgt" && claude -p "$TASK" \
+        --output-format stream-json --verbose --permission-mode bypassPermissions \
+        --model "${MODEL:-sonnet}" --effort "${EFFORT:-high}" --max-budget-usd 4 --strict-mcp-config --mcp-config "$c" \
+        </dev/null > "$OUT/run-$label-$i.jsonl" 2>"$OUT/run-$label-$i.err" )
+    count "$OUT/run-$label-$i.jsonl"
+    pkill -9 -f "serve --mcp --path $tgt" 2>/dev/null
+  done
+  echo
+}
+
+echo "== NEW build (HEAD: homegraph_node has Read parity) =="
+( cd "$ENGINE" && npm run build >/dev/null 2>&1 ) && echo "built"
+run_arm new "$RUNS"
+
+echo "== BASELINE build ($BASE_REF) =="
+git -C "$ENGINE" checkout "$BASE_REF" -- $CHANGED
+( cd "$ENGINE" && npm run build >/dev/null 2>&1 ) && echo "built"
+run_arm baseline "$RUNS"
+
+echo "###### DONE — compare [new] vs [baseline]: does homegraph_node[file] rise / Read fall? Logs: $OUT"

package/scripts/agent-eval/ab-hook.sh

@@ -1,86 +1,86 @@
-#!/usr/bin/env bash
-# A/B the PreToolUse(Read) REDIRECT hook (P1): does steering Read → homegraph_node
-# file-view actually move the agent off Read during implementation? BOTH arms use
-# the CURRENT build with homegraph attached and pre-warmed; the only difference is
-# the hook. Isolates the hook's behavioral effect from the build/file-view change
-# (use ab-new-vs-baseline.sh for the build A/B).
-#
-#   arm [nohook] — homegraph on, no hook   (does the better file-view get picked on its own?)
-#   arm [hook]   — homegraph on, + redirect hook   (does routing close it?)
-#
-# Reliable attach (works nested): each arm pre-warms a persistent daemon and skips
-# the startup re-exec (HOMEGRAPH_WASM_RELAUNCHED=1), so claude connects before the
-# agent's first turn. Judge by ACTUAL homegraph usage in parse-run.mjs's "by type",
-# not claude's init snapshot (which can read pending even when it then connects).
-#
-# Usage: ab-hook.sh <indexed-repo> "<implementation task>" [runs-per-arm]
-#   <indexed-repo>  a repo with a .homegraph index (copied per arm; never mutated)
-#   "<task>"        a GENUINELY-NEW implementation task (verify it isn't already done)
-#   [runs-per-arm]  default 2 (n=1 is noisy — the doctrine says >=2)
-# Env: AGENT_EVAL_OUT (default: /tmp/ab-hook)
-set -uo pipefail
-
-TARGET="${1:?usage: ab-hook.sh <indexed-repo> \"<task>\" [runs-per-arm]}"
-TASK="${2:?task required}"
-RUNS="${3:-2}"
-ENGINE="$(cd "$(dirname "$0")/../.." && pwd)"
-BIN="$ENGINE/dist/bin/homegraph.js"
-HOOK="$ENGINE/scripts/agent-eval/redirect-read-hook.sh"
-OUT="${AGENT_EVAL_OUT:-/tmp/ab-hook}"
-PARSE="$ENGINE/scripts/agent-eval/parse-run.mjs"
-
-command -v claude >/dev/null || { echo "claude CLI not on PATH"; exit 1; }
-command -v jq >/dev/null || { echo "jq not on PATH (the hook needs it)"; exit 1; }
-[ -d "$TARGET/.homegraph" ] || { echo "target not indexed: run 'homegraph init $TARGET' first"; exit 1; }
-chmod +x "$HOOK"
-
-cleanup() { pkill -9 -f "serve --mcp --path $OUT/" 2>/dev/null; }
-trap cleanup EXIT
-
-mkdir -p "$OUT"
-echo "###### engine=$ENGINE"
-echo "###### target=$TARGET   runs/arm=$RUNS"
-echo "###### task=$TASK"
-echo
-
-( cd "$ENGINE" && npm run build >/dev/null 2>&1 ) && echo "built"
-
-# A settings file carrying ONLY the PreToolUse(Read) redirect hook.
-HOOK_SETTINGS="$OUT/hook-settings.json"
-jq -n --arg cmd "bash $HOOK" \
-  '{hooks:{PreToolUse:[{matcher:"Read",hooks:[{type:"command",command:$cmd}]}]}}' > "$HOOK_SETTINGS"
-
-prewarm() { # target — spawn a persistent daemon and wait for its socket
-  pkill -9 -f "serve --mcp --path $1" 2>/dev/null
-  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: $1" || echo "  WARN: daemon never bound for $1"
-}
-
-run_one() { # arm-label, run-index, use-hook(0|1)
-  local label="$1" idx="$2" hook="$3"
-  local tgt="$OUT/t-$label-$idx" c="$OUT/mcp-$label.json"
-  rm -rf "$tgt"
-  rsync -a --exclude node_modules --exclude .git --exclude dist --exclude .homegraph "$TARGET/" "$tgt/"
-  node "$BIN" init "$tgt" >/dev/null 2>&1
-  printf '{"mcpServers":{"homegraph":{"command":"env","args":["HOMEGRAPH_WASM_RELAUNCHED=1","node","%s","serve","--mcp","--path","%s"]}}}' "$BIN" "$tgt" > "$c"
-  prewarm "$tgt"
-  local extra=()
-  [ "$hook" = "1" ] && extra=(--settings "$HOOK_SETTINGS")
-  echo "----- [$label] run $idx -----"
-  # ${extra[@]+...} guard: bash 3.2 (macOS) under `set -u` errors on an empty
-  # array expansion otherwise, which would skip the no-hook arm's claude run.
-  ( cd "$tgt" && claude -p "$TASK" \
-      --output-format stream-json --verbose --permission-mode bypassPermissions \
-      --model "${MODEL:-sonnet}" --effort "${EFFORT:-high}" --max-budget-usd 4 --strict-mcp-config --mcp-config "$c" ${extra[@]+"${extra[@]}"} \
-      </dev/null > "$OUT/run-$label-$idx.jsonl" 2>"$OUT/run-$label-$idx.err" )
-  node "$PARSE" "$OUT/run-$label-$idx.jsonl" 2>&1 | grep -E "by type|Result" || echo "  (parse failed — see $OUT/run-$label-$idx.jsonl)"
-  pkill -9 -f "serve --mcp --path $tgt" 2>/dev/null
-  echo
-}
-
-for i in $(seq 1 "$RUNS"); do run_one nohook "$i" 0; done
-for i in $(seq 1 "$RUNS"); do run_one hook   "$i" 1; done
-
-echo "###### DONE. Compare [nohook] vs [hook] 'by type' — Read should fall and"
-echo "###### mcp__homegraph__homegraph_node should rise in the [hook] arm. Logs: $OUT"
+#!/usr/bin/env bash
+# A/B the PreToolUse(Read) REDIRECT hook (P1): does steering Read → homegraph_node
+# file-view actually move the agent off Read during implementation? BOTH arms use
+# the CURRENT build with homegraph attached and pre-warmed; the only difference is
+# the hook. Isolates the hook's behavioral effect from the build/file-view change
+# (use ab-new-vs-baseline.sh for the build A/B).
+#
+#   arm [nohook] — homegraph on, no hook   (does the better file-view get picked on its own?)
+#   arm [hook]   — homegraph on, + redirect hook   (does routing close it?)
+#
+# Reliable attach (works nested): each arm pre-warms a persistent daemon and skips
+# the startup re-exec (HOMEGRAPH_WASM_RELAUNCHED=1), so claude connects before the
+# agent's first turn. Judge by ACTUAL homegraph usage in parse-run.mjs's "by type",
+# not claude's init snapshot (which can read pending even when it then connects).
+#
+# Usage: ab-hook.sh <indexed-repo> "<implementation task>" [runs-per-arm]
+#   <indexed-repo>  a repo with a .homegraph index (copied per arm; never mutated)
+#   "<task>"        a GENUINELY-NEW implementation task (verify it isn't already done)
+#   [runs-per-arm]  default 2 (n=1 is noisy — the doctrine says >=2)
+# Env: AGENT_EVAL_OUT (default: /tmp/ab-hook)
+set -uo pipefail
+
+TARGET="${1:?usage: ab-hook.sh <indexed-repo> \"<task>\" [runs-per-arm]}"
+TASK="${2:?task required}"
+RUNS="${3:-2}"
+ENGINE="$(cd "$(dirname "$0")/../.." && pwd)"
+BIN="$ENGINE/dist/bin/homegraph.js"
+HOOK="$ENGINE/scripts/agent-eval/redirect-read-hook.sh"
+OUT="${AGENT_EVAL_OUT:-/tmp/ab-hook}"
+PARSE="$ENGINE/scripts/agent-eval/parse-run.mjs"
+
+command -v claude >/dev/null || { echo "claude CLI not on PATH"; exit 1; }
+command -v jq >/dev/null || { echo "jq not on PATH (the hook needs it)"; exit 1; }
+[ -d "$TARGET/.homegraph" ] || { echo "target not indexed: run 'homegraph init $TARGET' first"; exit 1; }
+chmod +x "$HOOK"
+
+cleanup() { pkill -9 -f "serve --mcp --path $OUT/" 2>/dev/null; }
+trap cleanup EXIT
+
+mkdir -p "$OUT"
+echo "###### engine=$ENGINE"
+echo "###### target=$TARGET   runs/arm=$RUNS"
+echo "###### task=$TASK"
+echo
+
+( cd "$ENGINE" && npm run build >/dev/null 2>&1 ) && echo "built"
+
+# A settings file carrying ONLY the PreToolUse(Read) redirect hook.
+HOOK_SETTINGS="$OUT/hook-settings.json"
+jq -n --arg cmd "bash $HOOK" \
+  '{hooks:{PreToolUse:[{matcher:"Read",hooks:[{type:"command",command:$cmd}]}]}}' > "$HOOK_SETTINGS"
+
+prewarm() { # target — spawn a persistent daemon and wait for its socket
+  pkill -9 -f "serve --mcp --path $1" 2>/dev/null
+  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: $1" || echo "  WARN: daemon never bound for $1"
+}
+
+run_one() { # arm-label, run-index, use-hook(0|1)
+  local label="$1" idx="$2" hook="$3"
+  local tgt="$OUT/t-$label-$idx" c="$OUT/mcp-$label.json"
+  rm -rf "$tgt"
+  rsync -a --exclude node_modules --exclude .git --exclude dist --exclude .homegraph "$TARGET/" "$tgt/"
+  node "$BIN" init "$tgt" >/dev/null 2>&1
+  printf '{"mcpServers":{"homegraph":{"command":"env","args":["HOMEGRAPH_WASM_RELAUNCHED=1","node","%s","serve","--mcp","--path","%s"]}}}' "$BIN" "$tgt" > "$c"
+  prewarm "$tgt"
+  local extra=()
+  [ "$hook" = "1" ] && extra=(--settings "$HOOK_SETTINGS")
+  echo "----- [$label] run $idx -----"
+  # ${extra[@]+...} guard: bash 3.2 (macOS) under `set -u` errors on an empty
+  # array expansion otherwise, which would skip the no-hook arm's claude run.
+  ( cd "$tgt" && claude -p "$TASK" \
+      --output-format stream-json --verbose --permission-mode bypassPermissions \
+      --model "${MODEL:-sonnet}" --effort "${EFFORT:-high}" --max-budget-usd 4 --strict-mcp-config --mcp-config "$c" ${extra[@]+"${extra[@]}"} \
+      </dev/null > "$OUT/run-$label-$idx.jsonl" 2>"$OUT/run-$label-$idx.err" )
+  node "$PARSE" "$OUT/run-$label-$idx.jsonl" 2>&1 | grep -E "by type|Result" || echo "  (parse failed — see $OUT/run-$label-$idx.jsonl)"
+  pkill -9 -f "serve --mcp --path $tgt" 2>/dev/null
+  echo
+}
+
+for i in $(seq 1 "$RUNS"); do run_one nohook "$i" 0; done
+for i in $(seq 1 "$RUNS"); do run_one hook   "$i" 1; done
+
+echo "###### DONE. Compare [nohook] vs [hook] 'by type' — Read should fall and"
+echo "###### mcp__homegraph__homegraph_node should rise in the [hook] arm. Logs: $OUT"