homegraph 1.1.2 → 1.1.3

package/scripts/agent-eval/arms-matrix.sh

@@ -1,37 +1,37 @@
-#!/usr/bin/env bash
-# Drive the tool-surface ablation across the chosen repos × arms (A–E).
-# Arms A–D ask the canonical FLOW question; arm E asks a NON-flow survey
-# question (the control probe — should degrade without explore+context).
-# Output: /tmp/arms/<repo>/<arm>-r<n>.jsonl  (parse with parse-arms.mjs).
-set -uo pipefail
-HARNESS="$(cd "$(dirname "$0")" && pwd)"
-RUNS="${RUNS:-2}"
-C="${CORPUS:-/tmp/homegraph-corpus}"
-NFQ='What are the main modules/components of this codebase and what does each one do? Give an overview of how it is organized.'
-
-# repo-path|flow-question  (2 small, 2 medium, 2 large — spans the size range)
-ROWS=(
-"$C/flutter-samples/add_to_app/books/flutter_module_books|How does the books UI build and what child widgets does it show?"
-"$C/aspnet-realworld|How is creating an article handled? Trace the controller to the service."
-"$C/spring-mall|How is a product-list request handled? Trace the controller to the service."
-"$C/vapor-spi|How is a package-show request handled? Name the route and controller."
-"$C/excalidraw|How does updating an element re-render the canvas on screen? Trace the flow."
-"$C/spring-halo|How is publishing a post handled? Trace the controller to the service."
-)
-
-echo "### ARMS MATRIX START $(date) RUNS=$RUNS"
-for row in "${ROWS[@]}"; do
-  repo="${row%%|*}"; q="${row#*|}"
-  for arm in A B C D; do
-    for r in $(seq 1 "$RUNS"); do
-      bash "$HARNESS/run-arms.sh" "$repo" "$q" "$arm" "$r"
-    done
-  done
-done
-# E: non-flow control probe on two repos (must degrade without explore+context)
-for repo in "$C/excalidraw" "$C/spring-mall"; do
-  for r in $(seq 1 "$RUNS"); do
-    bash "$HARNESS/run-arms.sh" "$repo" "$NFQ" E "$r"
-  done
-done
-echo "### ARMS MATRIX COMPLETE $(date)"
+#!/usr/bin/env bash
+# Drive the tool-surface ablation across the chosen repos × arms (A–E).
+# Arms A–D ask the canonical FLOW question; arm E asks a NON-flow survey
+# question (the control probe — should degrade without explore+context).
+# Output: /tmp/arms/<repo>/<arm>-r<n>.jsonl  (parse with parse-arms.mjs).
+set -uo pipefail
+HARNESS="$(cd "$(dirname "$0")" && pwd)"
+RUNS="${RUNS:-2}"
+C="${CORPUS:-/tmp/homegraph-corpus}"
+NFQ='What are the main modules/components of this codebase and what does each one do? Give an overview of how it is organized.'
+
+# repo-path|flow-question  (2 small, 2 medium, 2 large — spans the size range)
+ROWS=(
+"$C/flutter-samples/add_to_app/books/flutter_module_books|How does the books UI build and what child widgets does it show?"
+"$C/aspnet-realworld|How is creating an article handled? Trace the controller to the service."
+"$C/spring-mall|How is a product-list request handled? Trace the controller to the service."
+"$C/vapor-spi|How is a package-show request handled? Name the route and controller."
+"$C/excalidraw|How does updating an element re-render the canvas on screen? Trace the flow."
+"$C/spring-halo|How is publishing a post handled? Trace the controller to the service."
+)
+
+echo "### ARMS MATRIX START $(date) RUNS=$RUNS"
+for row in "${ROWS[@]}"; do
+  repo="${row%%|*}"; q="${row#*|}"
+  for arm in A B C D; do
+    for r in $(seq 1 "$RUNS"); do
+      bash "$HARNESS/run-arms.sh" "$repo" "$q" "$arm" "$r"
+    done
+  done
+done
+# E: non-flow control probe on two repos (must degrade without explore+context)
+for repo in "$C/excalidraw" "$C/spring-mall"; do
+  for r in $(seq 1 "$RUNS"); do
+    bash "$HARNESS/run-arms.sh" "$repo" "$NFQ" E "$r"
+  done
+done
+echo "### ARMS MATRIX COMPLETE $(date)"

package/scripts/agent-eval/audit.sh

@@ -1,68 +1,68 @@
-#!/usr/bin/env bash
-# One-shot HomeGraph quality audit:
-#   set version -> ensure corpus repo -> wipe+reindex with that version ->
-#   run with/without A/B -> restore the local dev link.
-#
-# Usage: audit.sh <version> <repo-name> <repo-url> "<question>" [headless|all]
-#   <version>    "local" (build + npm link this repo) | "latest" | a version (e.g. 0.7.10)
-#   <repo-name>  dir name under the corpus dir
-#   <repo-url>   git URL (cloned --depth 1 when the repo dir is missing)
-#   [mode]       headless (default) | all (also the interactive tmux arms)
-# Env: CORPUS  corpus dir (default: /tmp/homegraph-corpus)
-set -uo pipefail
-
-VERSION="${1:?usage: audit.sh <version> <repo-name> <repo-url> \"<question>\" [mode]}"
-NAME="${2:?repo-name required}"
-URL="${3:?repo-url required}"
-Q="${4:?question required}"
-MODE="${5:-headless}"
-
-HARNESS="$(cd "$(dirname "$0")" && pwd)"
-REPO_ROOT="$(cd "$HARNESS/../.." && pwd)"     # homegraph repo root
-CORPUS="${CORPUS:-/tmp/homegraph-corpus}"
-REPO="$CORPUS/$NAME"
-PKG="homegraph"
-
-echo "==================== HomeGraph audit ===================="
-echo "version=$VERSION  repo=$NAME  mode=$MODE  corpus=$CORPUS"
-echo
-
-# 1. Set the homegraph version under test (mutates the global install).
-if [ "$VERSION" = local ]; then
-  echo "→ [1/4] building + linking local dev build (local-install.sh)"
-  ( cd "$REPO_ROOT" && ./scripts/local-install.sh ) || { echo "local-install.sh failed"; exit 1; }
-else
-  echo "→ [1/4] installing $PKG@$VERSION globally"
-  npm install -g "$PKG@$VERSION" || { echo "npm install -g $PKG@$VERSION failed"; exit 1; }
-fi
-ACTUAL="$(homegraph --version 2>/dev/null || echo '?')"
-echo "  homegraph on PATH: $(command -v homegraph) -> $ACTUAL"
-
-# 2. Ensure the corpus repo exists (clone shallow if missing, reuse if present).
-mkdir -p "$CORPUS"
-if [ -d "$REPO/.git" ]; then
-  echo "→ [2/4] reusing existing checkout: $REPO"
-else
-  echo "→ [2/4] cloning $URL"
-  git clone --depth 1 "$URL" "$REPO" || { echo "git clone failed"; exit 1; }
-fi
-
-# 3. Wipe + re-index with THIS version (the index must be built by the same
-#    binary that serves it — different versions extract differently).
-echo "→ [3/4] wiping .homegraph and re-indexing with $ACTUAL"
-rm -rf "$REPO/.homegraph"
-( cd "$REPO" && homegraph init -i ) || { echo "indexing failed"; exit 1; }
-
-# 4. Run the with/without A/B.
-echo "→ [4/4] running A/B harness (mode=$MODE)"
-bash "$HARNESS/run-all.sh" "$REPO" "$Q" "$MODE"
-
-# Restore the dev link (the normal working state in this repo).
-echo
-echo "→ restoring local dev link (local-install.sh)"
-if ( cd "$REPO_ROOT" && ./scripts/local-install.sh >/dev/null 2>&1 ); then
-  echo "  global homegraph restored to dev build"
-else
-  echo "  WARN: restore failed — run ./scripts/local-install.sh manually"
-fi
-echo "==================== audit complete ===================="
+#!/usr/bin/env bash
+# One-shot HomeGraph quality audit:
+#   set version -> ensure corpus repo -> wipe+reindex with that version ->
+#   run with/without A/B -> restore the local dev link.
+#
+# Usage: audit.sh <version> <repo-name> <repo-url> "<question>" [headless|all]
+#   <version>    "local" (build + npm link this repo) | "latest" | a version (e.g. 0.7.10)
+#   <repo-name>  dir name under the corpus dir
+#   <repo-url>   git URL (cloned --depth 1 when the repo dir is missing)
+#   [mode]       headless (default) | all (also the interactive tmux arms)
+# Env: CORPUS  corpus dir (default: /tmp/homegraph-corpus)
+set -uo pipefail
+
+VERSION="${1:?usage: audit.sh <version> <repo-name> <repo-url> \"<question>\" [mode]}"
+NAME="${2:?repo-name required}"
+URL="${3:?repo-url required}"
+Q="${4:?question required}"
+MODE="${5:-headless}"
+
+HARNESS="$(cd "$(dirname "$0")" && pwd)"
+REPO_ROOT="$(cd "$HARNESS/../.." && pwd)"     # homegraph repo root
+CORPUS="${CORPUS:-/tmp/homegraph-corpus}"
+REPO="$CORPUS/$NAME"
+PKG="homegraph"
+
+echo "==================== HomeGraph audit ===================="
+echo "version=$VERSION  repo=$NAME  mode=$MODE  corpus=$CORPUS"
+echo
+
+# 1. Set the homegraph version under test (mutates the global install).
+if [ "$VERSION" = local ]; then
+  echo "→ [1/4] building + linking local dev build (local-install.sh)"
+  ( cd "$REPO_ROOT" && ./scripts/local-install.sh ) || { echo "local-install.sh failed"; exit 1; }
+else
+  echo "→ [1/4] installing $PKG@$VERSION globally"
+  npm install -g "$PKG@$VERSION" || { echo "npm install -g $PKG@$VERSION failed"; exit 1; }
+fi
+ACTUAL="$(homegraph --version 2>/dev/null || echo '?')"
+echo "  homegraph on PATH: $(command -v homegraph) -> $ACTUAL"
+
+# 2. Ensure the corpus repo exists (clone shallow if missing, reuse if present).
+mkdir -p "$CORPUS"
+if [ -d "$REPO/.git" ]; then
+  echo "→ [2/4] reusing existing checkout: $REPO"
+else
+  echo "→ [2/4] cloning $URL"
+  git clone --depth 1 "$URL" "$REPO" || { echo "git clone failed"; exit 1; }
+fi
+
+# 3. Wipe + re-index with THIS version (the index must be built by the same
+#    binary that serves it — different versions extract differently).
+echo "→ [3/4] wiping .homegraph and re-indexing with $ACTUAL"
+rm -rf "$REPO/.homegraph"
+( cd "$REPO" && homegraph init -i ) || { echo "indexing failed"; exit 1; }
+
+# 4. Run the with/without A/B.
+echo "→ [4/4] running A/B harness (mode=$MODE)"
+bash "$HARNESS/run-all.sh" "$REPO" "$Q" "$MODE"
+
+# Restore the dev link (the normal working state in this repo).
+echo
+echo "→ restoring local dev link (local-install.sh)"
+if ( cd "$REPO_ROOT" && ./scripts/local-install.sh >/dev/null 2>&1 ); then
+  echo "  global homegraph restored to dev build"
+else
+  echo "  WARN: restore failed — run ./scripts/local-install.sh manually"
+fi
+echo "==================== audit complete ===================="

package/scripts/agent-eval/bench-readme.sh

@@ -1,28 +1,28 @@
-#!/usr/bin/env bash
-# Re-run the README "Benchmark Results" A/B (with vs without homegraph) on the
-# current build: the 7 README repos, same queries, RUNS per arm (default 4).
-# Output → /tmp/ab-readme/<repo>/run<n>/run-headless-{with,without}.jsonl
-# Aggregate with parse-bench-readme.mjs. Repos must be cloned + indexed under
-# $CORPUS (default /tmp/homegraph-corpus) by the build under test.
-set -uo pipefail
-H="$(cd "$(dirname "$0")" && pwd)"
-C="${CORPUS:-/tmp/homegraph-corpus}"
-RUNS="${RUNS:-4}"
-ROWS=(
-"vscode|How does the extension host communicate with the main process?"
-"excalidraw|How does Excalidraw render and update canvas elements?"
-"django|How does Django's ORM build and execute a query from a QuerySet?"
-"tokio|How does tokio schedule and run async tasks on its runtime?"
-"okhttp|How does OkHttp process a request through its interceptor chain?"
-"gin|How does gin route requests through its middleware chain?"
-"alamofire|How does Alamofire build, send, and validate a request?"
-)
-echo "### README A/B START $(date) RUNS=$RUNS"
-for row in "${ROWS[@]}"; do
-  repo="${row%%|*}"; q="${row#*|}"
-  echo "===== $repo ====="
-  for run in $(seq 1 "$RUNS"); do
-    AGENT_EVAL_OUT="/tmp/ab-readme/$repo/run$run" bash "$H/run-all.sh" "$C/$repo" "$q" headless 2>&1 | grep -E "exit [0-9]" || echo "  run$run: (no exit line)"
-  done
-done
-echo "### README A/B DONE $(date)"
+#!/usr/bin/env bash
+# Re-run the README "Benchmark Results" A/B (with vs without homegraph) on the
+# current build: the 7 README repos, same queries, RUNS per arm (default 4).
+# Output → /tmp/ab-readme/<repo>/run<n>/run-headless-{with,without}.jsonl
+# Aggregate with parse-bench-readme.mjs. Repos must be cloned + indexed under
+# $CORPUS (default /tmp/homegraph-corpus) by the build under test.
+set -uo pipefail
+H="$(cd "$(dirname "$0")" && pwd)"
+C="${CORPUS:-/tmp/homegraph-corpus}"
+RUNS="${RUNS:-4}"
+ROWS=(
+"vscode|How does the extension host communicate with the main process?"
+"excalidraw|How does Excalidraw render and update canvas elements?"
+"django|How does Django's ORM build and execute a query from a QuerySet?"
+"tokio|How does tokio schedule and run async tasks on its runtime?"
+"okhttp|How does OkHttp process a request through its interceptor chain?"
+"gin|How does gin route requests through its middleware chain?"
+"alamofire|How does Alamofire build, send, and validate a request?"
+)
+echo "### README A/B START $(date) RUNS=$RUNS"
+for row in "${ROWS[@]}"; do
+  repo="${row%%|*}"; q="${row#*|}"
+  echo "===== $repo ====="
+  for run in $(seq 1 "$RUNS"); do
+    AGENT_EVAL_OUT="/tmp/ab-readme/$repo/run$run" bash "$H/run-all.sh" "$C/$repo" "$q" headless 2>&1 | grep -E "exit [0-9]" || echo "  run$run: (no exit line)"
+  done
+done
+echo "### README A/B DONE $(date)"

package/scripts/agent-eval/bench-why-repo.sh

@@ -1,22 +1,22 @@
-#!/usr/bin/env bash
-# One README repo, WITH-homegraph only, N runs. Each run appends a why-Read
-# diagnostic so the agent explains any Read/Grep. (The WITHOUT baseline is
-# homegraph-independent and already in the README — no point re-running it.)
-# Output -> /tmp/ab-why/<repo>/with<n>.jsonl
-# Usage: bench-why-repo.sh <repo-path> "<query>" [N]
-set -uo pipefail
-REPO="$1"; Q="$2"; N="${3:-4}"
-NAME="$(basename "$REPO")"
-CG="/Users/colby/Development/Personal/homegraph/dist/bin/homegraph.js"
-OUT="/tmp/ab-why/$NAME"; mkdir -p "$OUT"
-WHY=$'\n\nIMPORTANT — diagnostic: if you use the Read or Grep tool at ANY point, for EACH such call explain why homegraph_explore / homegraph_node did not already give you what you needed. End your entire answer with a section titled exactly "## Why I read" listing every Read and Grep you made and the precise reason homegraph fell short for it. If you used neither, write "## Why I read" then "none — homegraph was sufficient."'
-printf '{"mcpServers":{"homegraph":{"command":"%s","args":["serve","--mcp","--path","%s"]}}}' "$CG" "$REPO" > "$OUT/cg.json"
-
-for i in $(seq 1 "$N"); do
-  pkill -f "serve --mcp" 2>/dev/null; sleep 1; rm -f "$REPO/.homegraph/daemon.sock"
-  ( cd "$REPO" && claude -p "$Q$WHY" --output-format stream-json --verbose \
-      --permission-mode bypassPermissions --model "${MODEL:-sonnet}" --effort "${EFFORT:-high}" --max-budget-usd 4 \
-      --strict-mcp-config --mcp-config "$OUT/cg.json" > "$OUT/with$i.jsonl" 2>"$OUT/with$i.err" )
-  echo "WITH run $i: exit $? ($(wc -l < "$OUT/with$i.jsonl" | tr -d ' ') lines)"
-done
-echo "DONE $NAME"
+#!/usr/bin/env bash
+# One README repo, WITH-homegraph only, N runs. Each run appends a why-Read
+# diagnostic so the agent explains any Read/Grep. (The WITHOUT baseline is
+# homegraph-independent and already in the README — no point re-running it.)
+# Output -> /tmp/ab-why/<repo>/with<n>.jsonl
+# Usage: bench-why-repo.sh <repo-path> "<query>" [N]
+set -uo pipefail
+REPO="$1"; Q="$2"; N="${3:-4}"
+NAME="$(basename "$REPO")"
+CG="/Users/colby/Development/Personal/homegraph/dist/bin/homegraph.js"
+OUT="/tmp/ab-why/$NAME"; mkdir -p "$OUT"
+WHY=$'\n\nIMPORTANT — diagnostic: if you use the Read or Grep tool at ANY point, for EACH such call explain why homegraph_explore / homegraph_node did not already give you what you needed. End your entire answer with a section titled exactly "## Why I read" listing every Read and Grep you made and the precise reason homegraph fell short for it. If you used neither, write "## Why I read" then "none — homegraph was sufficient."'
+printf '{"mcpServers":{"homegraph":{"command":"%s","args":["serve","--mcp","--path","%s"]}}}' "$CG" "$REPO" > "$OUT/cg.json"
+
+for i in $(seq 1 "$N"); do
+  pkill -f "serve --mcp" 2>/dev/null; sleep 1; rm -f "$REPO/.homegraph/daemon.sock"
+  ( cd "$REPO" && claude -p "$Q$WHY" --output-format stream-json --verbose \
+      --permission-mode bypassPermissions --model "${MODEL:-sonnet}" --effort "${EFFORT:-high}" --max-budget-usd 4 \
+      --strict-mcp-config --mcp-config "$OUT/cg.json" > "$OUT/with$i.jsonl" 2>"$OUT/with$i.err" )
+  echo "WITH run $i: exit $? ($(wc -l < "$OUT/with$i.jsonl" | tr -d ' ') lines)"
+done
+echo "DONE $NAME"

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

@@ -1,19 +1,19 @@
-#!/usr/bin/env bash
-# PreToolUse hook (experiment): deny Read of homegraph-indexed source files and
-# steer the agent to homegraph_explore/homegraph_node instead. Tests whether
-# homegraph can FULLY replace Read for code-understanding once the escape hatch
-# is removed. Non-source reads (config, .env, markdown, new files) pass through.
-#
-# Wire via:  claude ... --settings scripts/agent-eval/hook-settings.json
-set -uo pipefail
-input="$(cat)"
-fp="$(printf '%s' "$input" | jq -r '.tool_input.file_path // empty' 2>/dev/null)"
-
-case "$fp" in
-  *.ts|*.tsx|*.js|*.jsx|*.mjs|*.cjs|*.py|*.go|*.rs|*.java|*.rb|*.php|*.swift|*.kt|*.kts|*.c|*.cc|*.cpp|*.h|*.hpp|*.cs|*.lua|*.vue|*.svelte)
-    msg="Read is disabled for source files in this session — homegraph already has this file indexed (with line numbers, kept in sync on every change). Use homegraph_explore (several related symbols at once) or homegraph_node (one symbol's full source). If a symbol you need wasn't in a prior explore, run ANOTHER homegraph_explore with its exact name instead of reading the file."
-    jq -n --arg m "$msg" '{reason:$m, hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"deny",permissionDecisionReason:$m}}'
-    exit 0
-    ;;
-esac
-exit 0
+#!/usr/bin/env bash
+# PreToolUse hook (experiment): deny Read of homegraph-indexed source files and
+# steer the agent to homegraph_explore/homegraph_node instead. Tests whether
+# homegraph can FULLY replace Read for code-understanding once the escape hatch
+# is removed. Non-source reads (config, .env, markdown, new files) pass through.
+#
+# Wire via:  claude ... --settings scripts/agent-eval/hook-settings.json
+set -uo pipefail
+input="$(cat)"
+fp="$(printf '%s' "$input" | jq -r '.tool_input.file_path // empty' 2>/dev/null)"
+
+case "$fp" in
+  *.ts|*.tsx|*.js|*.jsx|*.mjs|*.cjs|*.py|*.go|*.rs|*.java|*.rb|*.php|*.swift|*.kt|*.kts|*.c|*.cc|*.cpp|*.h|*.hpp|*.cs|*.lua|*.vue|*.svelte)
+    msg="Read is disabled for source files in this session — homegraph already has this file indexed (with line numbers, kept in sync on every change). Use homegraph_explore (several related symbols at once) or homegraph_node (one symbol's full source). If a symbol you need wasn't in a prior explore, run ANOTHER homegraph_explore with its exact name instead of reading the file."
+    jq -n --arg m "$msg" '{reason:$m, hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"deny",permissionDecisionReason:$m}}'
+    exit 0
+    ;;
+esac
+exit 0

package/scripts/agent-eval/hook-settings.json

@@ -1,15 +1,15 @@
-{
-  "hooks": {
-    "PreToolUse": [
-      {
-        "matcher": "Read",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bash /Users/colby/Development/Personal/homegraph/scripts/agent-eval/block-read-hook.sh"
-          }
-        ]
-      }
-    ]
-  }
-}
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Read",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash /Users/colby/Development/Personal/homegraph/scripts/agent-eval/block-read-hook.sh"
+          }
+        ]
+      }
+    ]
+  }
+}

package/scripts/agent-eval/itrun.sh

@@ -1,120 +1,120 @@
-#!/usr/bin/env bash
-# Drive an INTERACTIVE Claude Code session in tmux, send a prompt, wait for the
-# agent to finish, then print the tool-call breakdown from the session logs.
-#
-# Why interactive (not `claude -p`): headless print-mode picks the
-# general-purpose subagent, while real interactive sessions delegate to the
-# Explore subagent (or drive homegraph from the main thread). Only the
-# interactive TUI reproduces the behavior users actually see. (Idle-detection
-# technique borrowed from devpit's WaitForIdle.)
-#
-# Usage: itrun.sh <repo-path> <label> "<prompt>"
-# Output dir: $AGENT_EVAL_OUT (default /tmp/agent-eval)
-# Requires: tmux 3.0+, a logged-in `claude` CLI, homegraph MCP configured.
-set -uo pipefail
-REPO="$1"; LABEL="$2"; PROMPT="$3"
-SESSION="cgt_${LABEL}"
-OUT_DIR="${AGENT_EVAL_OUT:-/tmp/agent-eval}"; mkdir -p "$OUT_DIR"
-OUT="$OUT_DIR/itrun-${LABEL}.txt"
-HERE="$(cd "$(dirname "$0")" && pwd)"
-
-cap() { tmux capture-pane -p -t "$SESSION" -S -40; }
-
-tmux kill-session -t "$SESSION" 2>/dev/null
-
-# Wide pane so the TUI doesn't hard-wrap tool lines.
-tmux new-session -d -s "$SESSION" -x 230 -y 60
-tmux send-keys -t "$SESSION" "cd $REPO && claude --dangerously-skip-permissions ${CLAUDE_EXTRA_ARGS:-}" Enter
-
-# Wait for the ❯ prompt (claude drew its UI), up to 60s. NOTE: ❯ appears on the
-# welcome screen seconds before the input actually accepts keystrokes, so this is
-# necessary but NOT sufficient — the type-and-verify loop below is what proves
-# the input is live.
-ready=0
-for _ in $(seq 1 120); do
-  cap | grep -q "❯" && { ready=1; break; }
-  sleep 0.5
-done
-[ "$ready" = 1 ] || { echo "claude never drew its UI"; cap; tmux kill-session -t "$SESSION" 2>/dev/null; exit 1; }
-
-# Accept the per-folder "Is this a project you trust?" dialog if it shows (first
-# time claude opens a given repo). Option 1 ("Yes, I trust this folder") is
-# pre-selected, so Enter accepts. This dialog also contains ❯, so it must be
-# cleared before the type-and-verify loop or keystrokes land on the menu.
-for _ in $(seq 1 20); do
-  cap | grep -q "trust this folder" || break
-  tmux send-keys -t "$SESSION" Enter
-  sleep 1
-done
-
-# Type-and-verify: send the prompt, confirm a distinctive chunk of it actually
-# landed in the input box, retry if it didn't (handles the early-❯ race where
-# the welcome screen shows the prompt glyph but MCP init is still eating keys).
-needle="${PROMPT:0:24}"
-typed=0
-for _ in $(seq 1 30); do
-  tmux send-keys -l -t "$SESSION" "$PROMPT"
-  sleep 1
-  if cap | grep -Fq "$needle"; then typed=1; break; fi
-  # Clear whatever partial text may have landed, then retry.
-  tmux send-keys -t "$SESSION" C-u
-  sleep 1
-done
-[ "$typed" = 1 ] || { echo "prompt never landed in the input box"; cap; tmux kill-session -t "$SESSION" 2>/dev/null; exit 1; }
-sleep 0.5
-tmux send-keys -t "$SESSION" Enter
-
-# Busy signals. The robust one is the spinner's elapsed-time-in-parens, which
-# EVERY working state shows — both the pre-stream thinking phase
-# "(8s · thinking with max effort)" and the streaming phase
-# "(24s · ↑ 2.5k tokens · …)", and it survives the 32s→"1m 3s" rollover. We OR
-# in the token arrows, "esc to interrupt", and "Initializing" as belt-and-braces
-# (some TUI versions/states show one but not the others).
-BUSY_RE='esc to interrupt|↓ [0-9]|↑ [0-9]|Initializing|\(([0-9]+m )?[0-9]+s ·'
-
-# Wait for work to START (busy indicator appears), up to 60s. If it never starts,
-# fail loudly rather than silently reporting an empty run.
-started=0
-for _ in $(seq 1 120); do
-  cap | grep -qE "$BUSY_RE" && { started=1; break; }
-  sleep 0.5
-done
-[ "$started" = 1 ] || { echo "agent never started working"; cap; tmux kill-session -t "$SESSION" 2>/dev/null; exit 1; }
-
-# Poll for idle. CRITICAL: Opus 4.8 (extended thinking) renders NO spinner /
-# "esc to interrupt" / timer while it STREAMS its final answer — those appear
-# only during the thinking + tool-use phases ("✻ Marinating… (32s · ↓ 1.3k
-# tokens · thinking with max effort)"). So BUSY_RE reads "not busy" for the whole
-# 10-30s answer stream, and any short not-busy threshold kills the run mid-answer
-# (the truncation bug). We therefore detect "done" by CONTENT STABILITY, not by a
-# spinner string: while the agent streams, the captured pane changes every poll,
-# so stability never accrues; it accrues only once the agent has finished and the
-# static "✻ Brewed for 1m 9s" summary is all that is left. BUSY_RE still hard-
-# resets stability (covers thinking/tool-use/live-timer, where text can briefly
-# sit still). Need STABLE_NEEDED polls (~8s) of zero pane change + ❯ present.
-# Content-stability is model-agnostic — it survives future spinner re-wordings.
-STABLE_NEEDED=16
-prev=""; stable=0
-for _ in $(seq 1 2400); do            # up to ~20 min
-  pane="$(cap)"
-  sig="$(printf '%s' "$pane" | tr -s '[:space:]' ' ')"
-  if printf '%s' "$pane" | grep -qE "$BUSY_RE"; then
-    stable=0                          # thinking / tool use / live timer → busy
-  elif [ -n "$sig" ] && [ "$sig" = "$prev" ] && printf '%s' "$pane" | grep -q "❯"; then
-    stable=$((stable+1)); [ "$stable" -ge "$STABLE_NEEDED" ] && break
-  else
-    stable=0                          # answer still streaming → pane changing
-  fi
-  prev="$sig"
-  sleep 0.5
-done
-sleep 1
-
-tmux capture-pane -p -t "$SESSION" -S - > "$OUT"
-echo "captured $(wc -l < "$OUT") lines -> $OUT"
-grep -oE "Done \([^)]*\)|[A-Z][a-z]+ for ([0-9]+m )?[0-9]+s" "$OUT" | tail -1
-grep -oE "[0-9.]+k?/[0-9.]+M" "$OUT" | tail -1 | sed 's/^/Context /'
-tmux kill-session -t "$SESSION" 2>/dev/null
-
-# Clean tool breakdown from the session logs (main + subagents).
-node "$HERE/parse-session.mjs" "$REPO" 2>/dev/null || true
+#!/usr/bin/env bash
+# Drive an INTERACTIVE Claude Code session in tmux, send a prompt, wait for the
+# agent to finish, then print the tool-call breakdown from the session logs.
+#
+# Why interactive (not `claude -p`): headless print-mode picks the
+# general-purpose subagent, while real interactive sessions delegate to the
+# Explore subagent (or drive homegraph from the main thread). Only the
+# interactive TUI reproduces the behavior users actually see. (Idle-detection
+# technique borrowed from devpit's WaitForIdle.)
+#
+# Usage: itrun.sh <repo-path> <label> "<prompt>"
+# Output dir: $AGENT_EVAL_OUT (default /tmp/agent-eval)
+# Requires: tmux 3.0+, a logged-in `claude` CLI, homegraph MCP configured.
+set -uo pipefail
+REPO="$1"; LABEL="$2"; PROMPT="$3"
+SESSION="cgt_${LABEL}"
+OUT_DIR="${AGENT_EVAL_OUT:-/tmp/agent-eval}"; mkdir -p "$OUT_DIR"
+OUT="$OUT_DIR/itrun-${LABEL}.txt"
+HERE="$(cd "$(dirname "$0")" && pwd)"
+
+cap() { tmux capture-pane -p -t "$SESSION" -S -40; }
+
+tmux kill-session -t "$SESSION" 2>/dev/null
+
+# Wide pane so the TUI doesn't hard-wrap tool lines.
+tmux new-session -d -s "$SESSION" -x 230 -y 60
+tmux send-keys -t "$SESSION" "cd $REPO && claude --dangerously-skip-permissions ${CLAUDE_EXTRA_ARGS:-}" Enter
+
+# Wait for the ❯ prompt (claude drew its UI), up to 60s. NOTE: ❯ appears on the
+# welcome screen seconds before the input actually accepts keystrokes, so this is
+# necessary but NOT sufficient — the type-and-verify loop below is what proves
+# the input is live.
+ready=0
+for _ in $(seq 1 120); do
+  cap | grep -q "❯" && { ready=1; break; }
+  sleep 0.5
+done
+[ "$ready" = 1 ] || { echo "claude never drew its UI"; cap; tmux kill-session -t "$SESSION" 2>/dev/null; exit 1; }
+
+# Accept the per-folder "Is this a project you trust?" dialog if it shows (first
+# time claude opens a given repo). Option 1 ("Yes, I trust this folder") is
+# pre-selected, so Enter accepts. This dialog also contains ❯, so it must be
+# cleared before the type-and-verify loop or keystrokes land on the menu.
+for _ in $(seq 1 20); do
+  cap | grep -q "trust this folder" || break
+  tmux send-keys -t "$SESSION" Enter
+  sleep 1
+done
+
+# Type-and-verify: send the prompt, confirm a distinctive chunk of it actually
+# landed in the input box, retry if it didn't (handles the early-❯ race where
+# the welcome screen shows the prompt glyph but MCP init is still eating keys).
+needle="${PROMPT:0:24}"
+typed=0
+for _ in $(seq 1 30); do
+  tmux send-keys -l -t "$SESSION" "$PROMPT"
+  sleep 1
+  if cap | grep -Fq "$needle"; then typed=1; break; fi
+  # Clear whatever partial text may have landed, then retry.
+  tmux send-keys -t "$SESSION" C-u
+  sleep 1
+done
+[ "$typed" = 1 ] || { echo "prompt never landed in the input box"; cap; tmux kill-session -t "$SESSION" 2>/dev/null; exit 1; }
+sleep 0.5
+tmux send-keys -t "$SESSION" Enter
+
+# Busy signals. The robust one is the spinner's elapsed-time-in-parens, which
+# EVERY working state shows — both the pre-stream thinking phase
+# "(8s · thinking with max effort)" and the streaming phase
+# "(24s · ↑ 2.5k tokens · …)", and it survives the 32s→"1m 3s" rollover. We OR
+# in the token arrows, "esc to interrupt", and "Initializing" as belt-and-braces
+# (some TUI versions/states show one but not the others).
+BUSY_RE='esc to interrupt|↓ [0-9]|↑ [0-9]|Initializing|\(([0-9]+m )?[0-9]+s ·'
+
+# Wait for work to START (busy indicator appears), up to 60s. If it never starts,
+# fail loudly rather than silently reporting an empty run.
+started=0
+for _ in $(seq 1 120); do
+  cap | grep -qE "$BUSY_RE" && { started=1; break; }
+  sleep 0.5
+done
+[ "$started" = 1 ] || { echo "agent never started working"; cap; tmux kill-session -t "$SESSION" 2>/dev/null; exit 1; }
+
+# Poll for idle. CRITICAL: Opus 4.8 (extended thinking) renders NO spinner /
+# "esc to interrupt" / timer while it STREAMS its final answer — those appear
+# only during the thinking + tool-use phases ("✻ Marinating… (32s · ↓ 1.3k
+# tokens · thinking with max effort)"). So BUSY_RE reads "not busy" for the whole
+# 10-30s answer stream, and any short not-busy threshold kills the run mid-answer
+# (the truncation bug). We therefore detect "done" by CONTENT STABILITY, not by a
+# spinner string: while the agent streams, the captured pane changes every poll,
+# so stability never accrues; it accrues only once the agent has finished and the
+# static "✻ Brewed for 1m 9s" summary is all that is left. BUSY_RE still hard-
+# resets stability (covers thinking/tool-use/live-timer, where text can briefly
+# sit still). Need STABLE_NEEDED polls (~8s) of zero pane change + ❯ present.
+# Content-stability is model-agnostic — it survives future spinner re-wordings.
+STABLE_NEEDED=16
+prev=""; stable=0
+for _ in $(seq 1 2400); do            # up to ~20 min
+  pane="$(cap)"
+  sig="$(printf '%s' "$pane" | tr -s '[:space:]' ' ')"
+  if printf '%s' "$pane" | grep -qE "$BUSY_RE"; then
+    stable=0                          # thinking / tool use / live timer → busy
+  elif [ -n "$sig" ] && [ "$sig" = "$prev" ] && printf '%s' "$pane" | grep -q "❯"; then
+    stable=$((stable+1)); [ "$stable" -ge "$STABLE_NEEDED" ] && break
+  else
+    stable=0                          # answer still streaming → pane changing
+  fi
+  prev="$sig"
+  sleep 0.5
+done
+sleep 1
+
+tmux capture-pane -p -t "$SESSION" -S - > "$OUT"
+echo "captured $(wc -l < "$OUT") lines -> $OUT"
+grep -oE "Done \([^)]*\)|[A-Z][a-z]+ for ([0-9]+m )?[0-9]+s" "$OUT" | tail -1
+grep -oE "[0-9.]+k?/[0-9.]+M" "$OUT" | tail -1 | sed 's/^/Context /'
+tmux kill-session -t "$SESSION" 2>/dev/null
+
+# Clean tool breakdown from the session logs (main + subagents).
+node "$HERE/parse-session.mjs" "$REPO" 2>/dev/null || true