cgraphx 1.4.3 → 2.0.1

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

@@ -1,108 +0,0 @@
-#!/usr/bin/env node
-// Effort A/B — does CGRAPHX_OFFLOAD_EFFORT=high improve offload SYNTHESIS FIDELITY vs low?
-// Probe-based (no agent): for each repo × effort × rep, run codegraph_explore with the offload
-// ON on the canonical question, capture the synthesized answer + AI tokens/cost/latency, then
-// Sonnet-judge that answer's fidelity vs source-verified ground truth. Isolates the synthesis
-// from agent/adoption noise. Requires `cgraphx login` (managed offload) + indexed repos.
-//
-// Env: REPS (default 3) · CG_ENGINE (engine repo) · AGENT_EVAL_OUT (repos under /repos) · CONC (judge concurrency)
-import { pathToFileURL, fileURLToPath } from 'node:url';
-import { resolve, dirname, join } from 'node:path';
-import { readFileSync, writeFileSync, existsSync, rmSync } from 'node:fs';
-import { execFile } from 'node:child_process';
-import { tmpdir } from 'node:os';
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const ENGINE = process.env.CG_ENGINE || resolve(HERE, '..', '..');
-const OUT = process.env.AGENT_EVAL_OUT || '/tmp/cg-offload-eval';
-const REPOS = join(OUT, 'repos');
-const GT = JSON.parse(readFileSync(resolve(HERE, 'offload-eval-ground-truth.json'), 'utf8'));
-const REPS = Number(process.env.REPS || 3);
-const CONC = Number(process.env.CONC || 4);
-const EFFORTS = (process.env.EFFORTS_FILTER || 'low,high').split(',');
-const ONLY = process.env.REPOS_FILTER ? new Set(process.env.REPOS_FILTER.split(',')) : null;
-const TIER = { mtkruto: 'small', postybirb: 'medium', shapeshift: 'complex', trezor: 'large' };
-
-const load = async (rel) => import(pathToFileURL(resolve(ENGINE, rel)).href);
-const idx = await load('dist/index.js');
-const toolsMod = await load('dist/mcp/tools.js');
-const CodeGraph = idx.default?.default ?? idx.default ?? idx.CodeGraph;
-const ToolHandler = toolsMod.ToolHandler ?? toolsMod.default?.ToolHandler;
-if (typeof CodeGraph?.openSync !== 'function' || typeof ToolHandler !== 'function') {
-  console.error('could not load engine from', ENGINE); process.exit(2);
-}
-
-const fidPrompt = (gt, ans) => `You are scoring the FIDELITY of a machine-synthesized code-exploration answer against verified ground truth. Do NOT use any tools.
-
-QUESTION: ${gt.question}
-
-VERIFIED GROUND TRUTH (the actual call path + files):
-${gt.truth}
-
-SYNTHESIZED ANSWER (to score):
-${ans || '(empty)'}
-
-Judge: (1) is the traced call path correct vs ground truth? (2) are the cited files/symbols correct (not fabricated)? (3) if it gave a "Coverage:" verdict, was it honest? A confident WRONG trace is the worst outcome — penalize it harder than an honest partial.
-Output ONLY minified JSON: {"verdict":"pass|partial|fail","score":<0-100>,"fabrication":<true|false>,"coverageHonest":<true|false>,"note":"<=20 words"}`;
-
-const askJudge = (prompt) => new Promise((res) => {
-  execFile('claude', ['-p', prompt, '--model', 'sonnet', '--effort', 'high', '--max-budget-usd', '0.5',
-    '--strict-mcp-config', '--mcp-config', '{"mcpServers":{}}'],
-    { cwd: OUT, maxBuffer: 1 << 24, timeout: 120000 }, (err, stdout) => {
-      const m = (stdout || '').match(/\{[\s\S]*\}/);
-      if (!m) return res({ verdict: 'error', score: null, note: (err ? err.message : 'no json').slice(0, 60) });
-      try { res(JSON.parse(m[0])); } catch { res({ verdict: 'error', score: null }); }
-    });
-});
-
-// ---- 1. Probe: collect synthesized answers at each effort -------------------
-const records = [];
-for (const repo of Object.keys(GT)) {
-  if (ONLY && !ONLY.has(repo)) continue;
-  const dir = join(REPOS, repo);
-  if (!existsSync(join(dir, '.cgraphx'))) { console.error('skip (not indexed):', repo); continue; }
-  const cg = CodeGraph.openSync(dir);
-  const h = new ToolHandler(cg);
-  for (const effort of EFFORTS) {
-    for (let rep = 1; rep <= REPS; rep++) {
-      process.env.CGRAPHX_OFFLOAD_EFFORT = effort;
-      const usageLog = join(tmpdir(), `effort-${repo}-${effort}-${rep}.jsonl`);
-      try { rmSync(usageLog); } catch { /* none */ }
-      process.env.CGRAPHX_OFFLOAD_USAGE_LOG = usageLog;
-      let answer = '';
-      try { answer = (await h.execute('codegraph_explore', { query: GT[repo].question }))?.content?.[0]?.text ?? ''; }
-      catch (e) { console.error(`  ${repo}/${effort}#${rep} explore failed: ${e?.message}`); }
-      const fired = /Synthesized by CodeGraph/.test(answer);
-      const ai = { tokens: 0, cost: 0, ms: 0 };
-      if (existsSync(usageLog)) for (const e of readFileSync(usageLog, 'utf8').split('\n').filter(Boolean).map(JSON.parse)) {
-        ai.tokens += e.totalTokens || 0; ai.cost += e.costUsd || 0; ai.ms += e.ms || 0;
-      }
-      records.push({ repo, tier: TIER[repo], effort, rep, fired, ai, answer });
-      console.error(`  ${repo}/${effort}#${rep}: fired=${fired} ${ai.tokens}tok $${ai.cost.toFixed(4)} ${ai.ms}ms`);
-    }
-  }
-  try { cg.close?.(); } catch { /* none */ }
-}
-
-// ---- 2. Judge fidelity (concurrency) ---------------------------------------
-console.error(`\njudging ${records.length} answers (concurrency ${CONC})...`);
-let done = 0;
-const q = [...records];
-async function worker() { while (q.length) { const r = q.shift(); r.fid = await askJudge(fidPrompt(GT[r.repo], r.answer)); console.error(`  [${++done}/${records.length}] ${r.repo}/${r.effort}#${r.rep}: ${r.fid.verdict} ${r.fid.score ?? ''}`); } }
-await Promise.all(Array.from({ length: CONC }, worker));
-writeFileSync(join(OUT, 'effort-results.jsonl'), records.map((r) => JSON.stringify(r)).join('\n') + '\n');
-
-// ---- 3. Aggregate: low vs high per repo ------------------------------------
-const med = (a) => { a = a.filter((x) => x != null).sort((x, y) => x - y); return a.length ? (a.length % 2 ? a[(a.length - 1) / 2] : (a[a.length / 2 - 1] + a[a.length / 2]) / 2) : null; };
-console.log(`\n${'='.repeat(80)}\nEFFORT A/B — offload synthesis fidelity (probe, n=${REPS}/cell)\n${'='.repeat(80)}`);
-console.log(`${'repo'.padEnd(11)} ${'tier'.padEnd(8)} ${'effort'.padEnd(6)} fired  ${'fid(med)'.padStart(8)} ${'fab%'.padStart(5)} ${'AItok'.padStart(7)} ${'AIcost'.padStart(8)} ${'ms(med)'.padStart(8)}`);
-for (const repo of Object.keys(GT)) {
-  for (const effort of EFFORTS) {
-    const rs = records.filter((r) => r.repo === repo && r.effort === effort);
-    if (!rs.length) continue;
-    const fids = rs.map((r) => r.fid?.score).filter((x) => x != null);
-    const fab = rs.filter((r) => r.fid?.fabrication === true).length;
-    console.log(`${repo.padEnd(11)} ${TIER[repo].padEnd(8)} ${effort.padEnd(6)} ${rs.filter((r) => r.fired).length}/${rs.length}   ${String(med(fids) ?? '—').padStart(8)} ${String(Math.round(100 * fab / rs.length) + '%').padStart(5)} ${String(Math.round(med(rs.map((r) => r.ai.tokens)) / 1000) + 'k').padStart(7)} ${('$' + (med(rs.map((r) => r.ai.cost)) ?? 0).toFixed(4)).padStart(8)} ${String(med(rs.map((r) => r.ai.ms)) ?? '—').padStart(8)}`);
-  }
-}
-console.log('');

package/scripts/agent-eval/offload-eval-frontload-matrix.sh

@@ -1,25 +0,0 @@
-#!/usr/bin/env bash
-# Run the FRONTLOAD arm across all 4 tiers (n reps), then judge + merge with the existing
-# matrix (offload/raw/nocg in $OUT/judged.jsonl, if present) + emit a combined summary.
-# Env: REPS (default 3)  AGENT_EVAL_OUT=<scratch dir>
-set -uo pipefail
-HERE="$(cd "$(dirname "$0")" && pwd)"
-OUT="${AGENT_EVAL_OUT:-/tmp/cg-offload-eval}"
-GT="$HERE/offload-eval-ground-truth.json"
-REPS="${REPS:-3}"
-export RESULTS="$OUT/results-fl.jsonl"
-: > "$RESULTS"; rm -f "$OUT/runs/hook-debug.log"
-for repo in mtkruto postybirb shapeshift trezor; do
-  case "$repo" in mtkruto) tier=small;; postybirb) tier=medium;; shapeshift) tier=complex;; trezor) tier=large;; esac
-  Q=$(node -e "console.log(JSON.parse(require('fs').readFileSync(process.argv[1],'utf8'))[process.argv[2]].question)" "$GT" "$repo")
-  echo ""; echo "### $repo ($tier)  $(date +%H:%M:%S)"
-  bash "$HERE/offload-eval-frontload.sh" "$OUT/repos/$repo" "$tier" "$REPS" "$Q"
-done
-echo ""
-echo "frontload: $(wc -l < "$RESULTS") runs | hook injections: $(grep -c INJECTED "$OUT/runs/hook-debug.log" 2>/dev/null) | errors: $(grep -c ERROR "$OUT/runs/hook-debug.log" 2>/dev/null)"
-echo "=== JUDGE frontload ==="
-node "$HERE/offload-eval-judge.mjs" --results "$RESULTS" --truth "$GT" --out "$OUT/judged-fl.jsonl" --concurrency 4 2>&1 | tail -4
-if [ -f "$OUT/judged.jsonl" ]; then cat "$OUT/judged.jsonl" "$OUT/judged-fl.jsonl" > "$OUT/judged-all.jsonl"; else cp "$OUT/judged-fl.jsonl" "$OUT/judged-all.jsonl"; fi
-echo "=== COMBINED SUMMARY ==="
-node "$HERE/offload-eval-summarize.mjs" "$OUT/judged-all.jsonl"
-echo "###### FRONTLOAD MATRIX DONE"

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

@@ -1,47 +0,0 @@
-#!/usr/bin/env bash
-# FRONTLOAD arm (approach 1): cgraphx attached (offload-disabled) + the front-load
-# UserPromptSubmit hook (offload-eval-hook.mjs), n reps, appended to $RESULTS. Compare against
-# the matrix's raw/nocg baselines. Usage: offload-eval-frontload.sh <indexed-repo> <tier> <reps> "<Q>"
-# Env: MODEL=sonnet EFFORT=high  RESULTS=<file>  AGENT_EVAL_OUT=<scratch dir>
-set -uo pipefail
-HERE="$(cd "$(dirname "$0")" && pwd)"
-ENGINE="$(cd "$HERE/../.." && pwd)"
-BIN="$ENGINE/dist/bin/codegraph.js"
-OUT="${AGENT_EVAL_OUT:-/tmp/cg-offload-eval}"
-TARGET="${1:?repo}"; TIER="${2:?tier}"; REPS="${3:?reps}"; Q="${4:?question}"
-RUNS="$OUT/runs"
-EXTRACT="$HERE/offload-eval-metrics.mjs"
-RESULTS="${RESULTS:-$OUT/results-fl.jsonl}"
-REPO=$(basename "$TARGET")
-mkdir -p "$RUNS"
-[ -d "$TARGET/.cgraphx" ] || { echo "not indexed: $TARGET"; exit 1; }
-TARGET=$(cd "$TARGET" && pwd -P)
-
-CFG="$RUNS/mcp-fl-$REPO.json"
-printf '{"mcpServers":{"cgraphx":{"command":"env","args":["CGRAPHX_WASM_RELAUNCHED=1","CGRAPHX_OFFLOAD_DISABLE=1","node","%s","serve","--mcp","--path","%s"]}}}' "$BIN" "$TARGET" > "$CFG"
-# Generate the hook settings pointing at the persisted hook; enable its debug log so we can
-# count injections (claude passes this env down to the spawned hook process).
-HOOKCFG="$RUNS/frontload-settings.json"
-printf '{"hooks":{"UserPromptSubmit":[{"hooks":[{"type":"command","command":"node %s/offload-eval-hook.mjs"}]}]}}' "$HERE" > "$HOOKCFG"
-export CG_FRONTLOAD_DEBUG="$RUNS/hook-debug.log"
-
-prewarm() {
-  pkill -9 -f "serve --mcp --path $1" 2>/dev/null; rm -f "$1/.cgraphx/daemon.sock" 2>/dev/null; sleep 0.6
-  env CGRAPHX_OFFLOAD_DISABLE=1 CGRAPHX_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]+"/.cgraphx/daemon.sock")){clearInterval(t);process.exit(0)}if(n++>150){clearInterval(t);process.exit(1)}},100)' "$1" \
-    && echo "  daemon warm" || echo "  WARN no daemon"
-}
-
-echo "###### FRONTLOAD repo=$REPO tier=$TIER reps=$REPS"
-prewarm "$TARGET"
-for r in $(seq 1 "$REPS"); do
-  tag="$REPO-frontload-$r"
-  ( cd "$TARGET" && claude -p "$Q" --output-format stream-json --verbose --permission-mode bypassPermissions \
-      --model "${MODEL:-sonnet}" --effort "${EFFORT:-high}" --max-budget-usd 4 \
-      --strict-mcp-config --mcp-config "$CFG" --settings "$HOOKCFG" \
-      </dev/null > "$RUNS/$tag.jsonl" 2>"$RUNS/$tag.err" )
-  node "$EXTRACT" --run "$RUNS/$tag.jsonl" --usage "-" --arm frontload --rep "$r" --repo "$REPO" --tier "$TIER" --q "$Q" >> "$RESULTS"
-  node -e 'const o=JSON.parse(require("fs").readFileSync(process.argv[1],"utf8").trim().split("\n").pop());console.log(`  [frontload #${o.rep}] ${o.durationSec}s | main $${o.costUsdMain} ${o.tokBillable}tok | read=${o.read} grep=${o.grep} agentExplore=${o.explore} | ok=${o.ok}`)' "$RESULTS"
-done
-pkill -9 -f "serve --mcp --path $TARGET" 2>/dev/null; rm -f "$TARGET/.cgraphx/daemon.sock" 2>/dev/null
-echo "###### FRONTLOAD DONE $REPO (cumulative hook injections: $(grep -c INJECTED "$CG_FRONTLOAD_DEBUG" 2>/dev/null))"

package/scripts/agent-eval/offload-eval-ground-truth.json

@@ -1,18 +0,0 @@
-{
-  "mtkruto": {
-    "question": "How does calling the high-level client.sendMessage() method get the message serialized into a TL/MTProto request and sent over the network transport to Telegram's servers? Trace the call path.",
-    "truth": "Verified call path (small TS Telegram-client lib):\n1. Client.sendMessage — client/6_client.ts:1852 → calls this.#messageManager.sendMessage(...) (1853)\n2. MessageManager.sendMessage — client/3_message_manager.ts:330 → builds the TL function {_:\"messages.sendMessage\", peer, message,...} and calls this.#c.invoke(...) (~377)\n3. c.invoke closure / Client.#invoke — client/6_client.ts:279/887 → resolves a ClientEncrypted and calls client.invoke(function_) (897)\n4. ClientEncrypted.invoke — client/2_client_encrypted.ts:324 → this.#send(function_) (325)\n5. ClientEncrypted.#send — client/2_client_encrypted.ts:261 → SERIALIZES via Api.serializeObject(function_) (290), then this.session.send(body) (296)\n   - Serialization: Api.serializeObject (tl/2_telegram.ts:38) → new TLWriter().writeObject(...) (tl/1_tl_writer.ts) writes constructor id + fields\n6. SessionEncrypted.send — session/2_session_encrypted.ts:193 → ENQUEUES a PendingMessage and wakes the send loop (#awakeSendLoop) [DYNAMIC: async queue, not a direct call]\n7. SessionEncrypted.#sendLoopBody (AbortableLoop) — session/2_session_encrypted.ts:282 → #encryptMessage (serializeMessage tl/2_message.ts + IGE-256 AES) then this.transport.transport.send(payload) (339)\n8. Transport.send — TransportAbridged.send (transport/1_transport_abridged.ts:71) or TransportIntermediate → this.#connection.write(encrypt(framed))\n9. ConnectionTCP.write (connection/1_connection_tcp.ts:96) or ConnectionWebSocket.write — bytes exit the process.\nKEY SYMBOLS a correct answer must hit: sendMessage → MessageManager.sendMessage → invoke (ClientEncrypted.invoke/#send) → Api.serializeObject/TLWriter → SessionEncrypted.send (queue) → #sendLoopBody/#encryptMessage → Transport.send → Connection.write.\nDYNAMIC BOUNDARIES: the invoke indirection (closure→#invoke→ClientEncrypted), and the send-loop QUEUE between SessionEncrypted.send and #sendLoopBody (async, no direct edge)."
-  },
-  "postybirb": {
-    "question": "How does submitting/queueing a post reach the website-specific code that actually uploads to a target website? Trace the path from the submission entry point in the NestJS server to a concrete website service's post implementation.",
-    "truth": "Verified call path (NestJS+Electron, server under electron-app/src/server/):\n1. Entry: PostController.queue (submission/post/post.controller.ts:33, POST queue/:id) OR SubmissionService.queueScheduledSubmissions (submission/submission.service.ts, @Interval(60000) scheduler) — both call PostService.queue\n2. PostService.queue — submission/post/post.service.ts:68 → this.post(submission)\n3. PostService.post (private) — post.service.ts:206 → this.createPoster(...) for each non-default SubmissionPart\n4. PostService.createPoster — post.service.ts:373 → website = this.websites.getWebsiteModule(part.website) [part.website is a STRING]\n5. WebsiteProvider.getWebsiteModule — websites/website-provider.service.ts:86 → websiteModulesMap[name.toLowerCase()] [DYNAMIC: string-keyed registry of DI-injected Website singletons]; then new Poster(..., website, ...)\n6. Poster constructor — submission/post/poster.ts:117 → setTimeout(this.post.bind(this), delay) [DYNAMIC: async timer, min ~5s]\n7. Poster.post (poster.ts:131) → performPost (171) → attemptPost (217)\n8. Poster.attemptPost — poster.ts:217 → this.website.postFileSubmission(token, data, accountData) [DYNAMIC: polymorphic dispatch on abstract Website] (or postNotificationSubmission)\n9. Website.postFileSubmission (abstract) — websites/website.base.ts:102\n10. Concrete e.g. FurAffinity.postFileSubmission — websites/fur-affinity/fur-affinity.service.ts:231 → multi-step HTTP upload (GET /submit, POST /submit/upload multipart, POST /submit/finalize)\nKEY SYMBOLS: PostService.queue → PostService.post → createPoster → WebsiteProvider.getWebsiteModule (registry) → Poster (setTimeout) → Poster.attemptPost → Website.postFileSubmission (abstract base) → a concrete website service (e.g. FurAffinity).\nDYNAMIC BOUNDARIES: NestJS DI builds the website registry; string-keyed map lookup; setTimeout defers Poster.post; polymorphic dispatch on the abstract Website base. A correct answer must reach a concrete website's post via the registry + base class, not stop at PostService."
-  },
-  "shapeshift": {
-    "question": "How does executing a swap work in ShapeShift — from the code that fetches quotes and selects a swapper down to a specific swapper's execute/trade? Name the swapper interface, the registry, and one concrete swapper, and trace the path.",
-    "truth": "Verified call path (large multi-package monorepo; swap logic in packages/swapper + execution in src/lib):\nQUOTE/REGISTRY layer:\n- Swapper interface = the `Swapper` type (execute methods) + `SwapperApi` type (getTradeQuote/getUnsignedTx) — packages/swapper/src/types.ts (~846/897)\n- Registry = `swappers: Record<SwapperName,(SwapperApi & Swapper)>` — packages/swapper/src/constants.ts:52 (merges e.g. thorchainSwapper + thorchainApi)\n- Aggregator: swapperApi RTK endpoint getTradeQuote/getTradeRates (src/state/apis/swapper/swapperApi.ts:78/156) → getTradeQuotes (packages/swapper/src/swapper.ts:18/26): swapper = swappers[swapperName]; swapper.getTradeQuote(...) [DYNAMIC interface dispatch]\n- Concrete (THORChain): thorchainApi.getTradeQuote (swappers/ThorchainSwapper/endpoints.ts → getTradeQuote/getTradeQuote.ts:15) → getL1RateOrQuote → getQuote (thorService HTTP)\nSELECTION: tradeQuoteSlice selectors rank quotes (selectSortedTradeQuotes / selectActiveSwapperName) [DYNAMIC: winner chosen by ranking/user]\nEXECUTION layer:\n- useTradeExecution (src/components/MultiHopTrade/.../hooks/useTradeExecution.tsx:200/476) → new TradeExecution(); execution.execEvmTransaction(...) (CowSwap: execEvmMessage)\n- TradeExecution.execEvmTransaction — src/lib/tradeExecution.ts:326 → _execWalletAgnostic(...) (372)\n- TradeExecution._execWalletAgnostic — tradeExecution.ts:136 → swapper = swappers[swapperName] (149) [DYNAMIC registry]; buildSignBroadcast → swapper.getUnsignedEvmTransaction(...) (355) then swapper.executeEvmTransaction(unsignedTx, {signAndBroadcastTransaction}) (367) [DYNAMIC SwapperApi/Swapper interface]\n- Concrete (THORChain): thorchainSwapper.executeEvmTransaction (swappers/ThorchainSwapper/ThorchainSwapper.ts → utils.ts:181) delegates to callbacks.signAndBroadcastTransaction (wallet). CowSwap alt: cowSwapper.executeEvmMessage → signCowOrder + cowService.post.\nKEY SYMBOLS: Swapper/SwapperApi types, swappers registry (constants.ts), getTradeQuotes (swapper.ts), TradeExecution._execWalletAgnostic, swapper.getUnsignedEvmTransaction/executeEvmTransaction, one concrete swapper (thorchainSwapper/zrxSwapper/cowSwapper).\nDYNAMIC BOUNDARIES: swappers[name] registry lookup (2 sites); all hops into a concrete swapper are via the Swapper/SwapperApi interface, never a direct function. A correct answer must name the interface + registry and reach a concrete swapper through interface dispatch."
-  },
-  "trezor": {
-    "question": "How does sending a crypto transaction flow from the send form's review/sign action through to signing it via @trezor/connect (TrezorConnect.signTransaction)? Trace the call path.",
-    "truth": "Verified call path (trezor-suite monorepo; app in packages/suite, shared logic in suite-common/wallet-core, device API in packages/connect):\n1. ReviewButton.handleButtonReviewClick — packages/suite/src/views/wallet/send/TotalSent/ReviewButton.tsx:120 → signTransaction() (= useSendForm's sign)\n2. useSendForm.sign (exported as signTransaction) — packages/suite/src/hooks/wallet/useSendForm.ts:278 → dispatch(signAndPushSendFormTransactionThunk({formState, precomposedTransaction, selectedAccount})) [DYNAMIC: redux thunk]\n3. signAndPushSendFormTransactionThunk — packages/suite/src/actions/wallet/send/sendFormThunks.ts:237 → (first enhancePrecomposedTransactionThunk) then dispatch(signTransactionThunk({...})) [cross-package: thunk from suite-common/wallet-core]\n4. signTransactionThunk (coin-routing hub) — suite-common/wallet-core/src/send/sendFormThunks.ts:532/573 → networkType branch → dispatch(signBitcoinSendFormTransactionThunk) (ethereum→signEthereumSendFormTransactionThunk, etc.) [DYNAMIC: runtime coin dispatch]\n5. signBitcoinSendFormTransactionThunk — suite-common/wallet-core/src/send/sendFormBitcoinThunks.ts:394 → await TrezorConnect.signTransaction(signPayload)\n6. TrezorConnect.signTransaction (facade) — packages/connect-common/src/factory.ts → closure calls impl.call({method:'signTransaction',...}) [DYNAMIC: facade / iframe-or-module boundary]\n7. CoreInModule.call — packages/connect/src/impl/core-in-module.ts:171 → posts CORE_CALL to core (deferred promise)\n8. Core.onCall → getMethod — packages/connect/src/core/index.ts → getMethod resolves 'signTransaction' → new SignTransaction(message) [DYNAMIC: name→class]\n9. SignTransaction.run — packages/connect/src/api/signTransaction.ts:317 → signTx via device.getCommands().typedCall (protobuf to device). After signing, signAndPushSendFormTransactionThunk → pushSendFormTransactionThunk → TrezorConnect.pushTransaction.\nKEY SYMBOLS: ReviewButton → useSendForm.sign → signAndPushSendFormTransactionThunk (suite) → signTransactionThunk (wallet-core, coin hub) → signBitcoinSendFormTransactionThunk → TrezorConnect.signTransaction → connect factory/CoreInModule.call → SignTransaction.run.\nDYNAMIC BOUNDARIES: every suite→wallet-core hop is a redux thunk dispatch; signTransactionThunk branches by networkType at runtime; TrezorConnect is a dynamically-built facade crossing an iframe/module boundary; the SignTransaction class is resolved by name. A correct answer must cross suite→wallet-core→connect and reach TrezorConnect.signTransaction / SignTransaction.run, not stop at the UI."
-  }
-}

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

@@ -1,84 +0,0 @@
-#!/usr/bin/env node
-// UserPromptSubmit hook — APPROACH 1: additive context-injection.
-// Front-loads cgraphx's structural answer for flow/impact/"how/where" prompts so the
-// agent's reflex grep/read has nothing left to find. Strictly additive (never blocks),
-// gated to structural prompts (no cost otherwise), and uses RAW explore (offload disabled)
-// so the injected context is accurate — never the (currently low-fidelity) synthesis.
-//
-// Reads {prompt, cwd} as JSON on stdin; prints the explore result to stdout (which Claude
-// Code injects into the agent's context). Any failure -> silent exit 0 (degradable).
-import { pathToFileURL, fileURLToPath } from 'node:url';
-import { resolve, join, dirname } from 'node:path';
-import { existsSync, readFileSync, appendFileSync } from 'node:fs';
-
-// Resolve the engine repo from this script's own location (scripts/agent-eval/ -> ../..),
-// overridable with CG_ENGINE. The hook ships inside the repo, so it finds its own dist.
-const HERE = dirname(fileURLToPath(import.meta.url));
-const ENGINE = process.env.CG_ENGINE || resolve(HERE, '..', '..');
-const BUDGET = Number(process.env.CG_FRONTLOAD_BUDGET || 16000);
-
-// Debug log only when CG_FRONTLOAD_DEBUG is set to a file path (the harness points it at a
-// log to count injections); off by default so the shipped hook writes nothing extra.
-const DBG = process.env.CG_FRONTLOAD_DEBUG;
-const dbg = (m) => { if (!DBG) return; try { appendFileSync(DBG, `[${new Date().toISOString()}] ${m}\n`); } catch { /* ignore */ } };
-
-let input = {};
-try { input = JSON.parse(readFileSync(0, 'utf8')); } catch (e) { dbg('stdin parse fail: ' + e.message); }
-const prompt = String(input.prompt || '');
-const cwd = String(input.cwd || process.cwd());
-dbg(`invoked: promptLen=${prompt.length} cwd=${cwd}`);
-
-// Gate: only structural / flow / impact / where-how questions. Cheap regex; silent no-op
-// otherwise so non-structural prompts ("fix this typo") cost nothing.
-const STRUCTURAL = /\b(how|where|trace|flow|path|reach(es|ed)?|call(s|ed|er|ers|ee)?|depend|impact|affect|wire[ds]?|connect|implement|architect|structure|breaks?|what calls|why does)\b/i;
-if (!prompt || !STRUCTURAL.test(prompt)) { dbg('gate: non-structural, no-op'); process.exit(0); }
-dbg('gate: structural PASS');
-
-// Find the index: cwd, then walk up a few levels.
-let root = cwd, found = null;
-for (let i = 0; i < 6 && root; i++) {
-  if (existsSync(join(root, '.cgraphx'))) { found = root; break; }
-  const parent = resolve(root, '..'); if (parent === root) break; root = parent;
-}
-if (!found) { dbg(`no .cgraphx found from cwd=${cwd}`); process.exit(0); }
-dbg(`found index at ${found}`);
-
-try {
-  process.env.CGRAPHX_OFFLOAD_DISABLE = '1'; // raw, accurate — never the unfixed offload
-  process.env.CGRAPHX_TELEMETRY = '0'; process.env.DO_NOT_TRACK = '1';
-  const load = async (rel) => import(pathToFileURL(resolve(ENGINE, 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;
-  if (typeof CodeGraph?.openSync !== 'function' || typeof ToolHandler !== 'function') process.exit(0);
-
-  // Retry once on a transient busy/locked index (the hook's openSync can race a
-  // freshly-warming daemon on the first prompt of a session).
-  let text = '';
-  for (let attempt = 1; attempt <= 2; attempt++) {
-    try {
-      const cg = CodeGraph.openSync(found);
-      const h = new ToolHandler(cg);
-      const res = await h.execute('codegraph_explore', { query: prompt });
-      text = res?.content?.[0]?.text ?? '';
-      try { cg.close?.(); } catch { /* ignore */ }
-      dbg(`explore attempt ${attempt} returned ${text.length} chars`);
-      break;
-    } catch (e) {
-      dbg(`explore attempt ${attempt} failed: ${e?.message || e}`);
-      if (attempt === 2) throw e;
-      await new Promise((r) => setTimeout(r, 800));
-    }
-  }
-  if (!text.trim()) { dbg('empty explore result, no-op'); process.exit(0); }
-  if (text.length > BUDGET) text = text.slice(0, BUDGET) + '\n…[front-load truncated to budget]';
-
-  process.stdout.write(
-    `## CodeGraph structural context (auto-retrieved for this question)\n` +
-    `The code graph was queried for your question; the relevant symbols, source, and call flow are below. ` +
-    `Treat the quoted source as already read. If you need more, call codegraph_explore with specific symbol names rather than grepping or reading files.\n\n` +
-    text + '\n'
-  );
-  dbg(`INJECTED ${text.length} chars`);
-} catch (e) { dbg('ERROR: ' + (e?.stack || e?.message || e)); process.exit(0); } // degradable

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

@@ -1,103 +0,0 @@
-#!/usr/bin/env node
-// Accuracy judge. For each run in results.jsonl:
-//   - end-to-end: agent finalAnswer vs verified ground truth (all arms)
-//   - fidelity:   offload synthesized answer vs ground truth (offload arm only)
-// Judge = claude -p sonnet --effort high, no tools, run from a neutral cwd,
-// JSON-only verdicts. Writes judged.jsonl (one line per run, verdicts merged).
-//
-// Usage: judge.mjs --results <f> --truth <f> --out <f> [--concurrency 4]
-import { readFileSync, writeFileSync, existsSync } from 'fs';
-import { execFile } from 'child_process';
-
-const A = {};
-for (let i = 2; i < process.argv.length; i += 2) A[process.argv[i].replace(/^--/, '')] = process.argv[i + 1];
-const results = readFileSync(A.results, 'utf8').split('\n').filter(Boolean).map(l => JSON.parse(l));
-const truth = JSON.parse(readFileSync(A.truth, 'utf8'));
-const OUT = A.out || '/tmp/cg-offload-eval/judged.jsonl';
-const CONC = Number(A.concurrency || 4);
-
-function askJudge(prompt) {
-  return new Promise((resolve) => {
-    execFile('claude', ['-p', prompt, '--model', 'sonnet', '--effort', 'high',
-      '--max-budget-usd', '0.5', '--strict-mcp-config', '--mcp-config', '{"mcpServers":{}}'],
-      // Run from a neutral dir with no repo files so the judge can't "cheat" by reading source.
-      { cwd: process.env.AGENT_EVAL_OUT || '/tmp', maxBuffer: 1 << 24, timeout: 120000 },
-      (err, stdout) => {
-        const raw = (stdout || '').trim();
-        const m = raw.match(/\{[\s\S]*\}/);
-        if (!m) return resolve({ verdict: 'error', score: null, note: (err ? 'exec ' + err.message : 'no json').slice(0, 80) });
-        try { resolve(JSON.parse(m[0])); } catch { resolve({ verdict: 'error', score: null, note: 'parse fail' }); }
-      });
-  });
-}
-
-const e2ePrompt = (gt, ans) => `You are scoring whether an AI coding agent correctly answered a code-flow question about a repository. Judge ONLY against the verified ground truth. Do NOT use any tools.
-
-QUESTION: ${gt.question}
-
-VERIFIED GROUND TRUTH (the actual call path + files):
-${gt.truth}
-
-AGENT'S ANSWER:
-${ans || '(empty)'}
-
-Score how correct the agent's answer is vs the ground truth. A "pass" means it identifies the core mechanism and the major hops with the right files/symbols and makes no materially wrong claim. "partial" = right area but misses major hops or has notable errors. "fail" = wrong layer, fabricated, or misses the mechanism.
-Output ONLY minified JSON, no prose, no code fences:
-{"verdict":"pass|partial|fail","score":<0-100>,"missedHops":["..."],"wrongClaims":["..."],"note":"<=20 words"}`;
-
-const fidPrompt = (gt, ans) => `You are scoring the FIDELITY of a machine-synthesized code-exploration answer against verified ground truth. The synthesized answer claims to trace a flow and cite file:line locations. Do NOT use any tools.
-
-QUESTION: ${gt.question}
-
-VERIFIED GROUND TRUTH (the actual call path + files):
-${gt.truth}
-
-SYNTHESIZED ANSWER (to score):
-${ans || '(empty)'}
-
-Judge: (1) is the traced call path correct vs ground truth? (2) are the cited files/symbols correct (not fabricated)? (3) if it gave a "Coverage:" verdict, was that verdict honest about what it actually covered? A confident WRONG trace is the worst outcome — penalize it harder than an honest "partial/not found".
-Output ONLY minified JSON, no prose, no code fences:
-{"verdict":"pass|partial|fail","score":<0-100>,"fabrication":<true|false>,"coverageHonest":<true|false>,"missedHops":["..."],"note":"<=20 words"}`;
-
-// Build the job list
-const jobs = [];
-for (const r of results) {
-  const gt = truth[r.repo];
-  if (!gt) { r._nojudge = true; continue; }
-  jobs.push({ r, kind: 'e2e', prompt: e2ePrompt(gt, r.finalAnswer) });
-  if (r.arm === 'offload' && Array.isArray(r.offloadAnswers))
-    r.offloadAnswers.forEach((ans, i) => { if (ans && ans.trim()) jobs.push({ r, kind: 'fid', idx: i, prompt: fidPrompt(gt, ans) }); });
-}
-console.error(`judging ${jobs.length} verdicts across ${results.length} runs (concurrency ${CONC})...`);
-
-let done = 0;
-async function worker(queue) {
-  while (queue.length) {
-    const job = queue.shift();
-    const v = await askJudge(job.prompt);
-    if (job.kind === 'e2e') job.r.e2e = v; else (job.r._fid ??= []).push(v);
-    console.error(`  [${++done}/${jobs.length}] ${job.r.repo}/${job.r.arm}#${job.r.rep} ${job.kind}: ${v.verdict}${v.score != null ? ' ' + v.score : ''}`);
-  }
-}
-const q = [...jobs];
-await Promise.all(Array.from({ length: CONC }, () => worker(q)));
-
-// Aggregate per-answer fidelity verdicts into one fidelity object per offload run.
-const medOf = (a) => { a = [...a].sort((x, y) => x - y); return a.length ? (a.length % 2 ? a[(a.length - 1) / 2] : (a[a.length / 2 - 1] + a[a.length / 2]) / 2) : null; };
-for (const r of results) {
-  if (r._fid?.length) {
-    const scores = r._fid.map(v => v.score).filter(x => x != null);
-    r.fidelity = {
-      n: r._fid.length, scores,
-      max: scores.length ? Math.max(...scores) : null,
-      min: scores.length ? Math.min(...scores) : null,
-      median: medOf(scores),
-      anyFabrication: r._fid.some(v => v.fabrication === true),
-      allCoverageHonest: r._fid.every(v => v.coverageHonest !== false),
-      verdicts: r._fid.map(v => v.verdict),
-    };
-  }
-  delete r._fid;
-}
-writeFileSync(OUT, results.map(r => JSON.stringify(r)).join('\n') + '\n');
-console.error(`wrote ${OUT}`);

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

@@ -1,20 +0,0 @@
-#!/usr/bin/env bash
-# Drive the 3-arm campaign (offload/raw/nocg) across all 4 tiers, n reps each, into one
-# results.jsonl. Reads the canonical question per repo from offload-eval-ground-truth.json.
-# Env: REPS (default 3)  AGENT_EVAL_OUT=<scratch dir>
-set -uo pipefail
-HERE="$(cd "$(dirname "$0")" && pwd)"
-OUT="${AGENT_EVAL_OUT:-/tmp/cg-offload-eval}"
-GT="$HERE/offload-eval-ground-truth.json"
-REPS="${REPS:-3}"
-export RESULTS="$OUT/results.jsonl"
-: > "$RESULTS"
-for repo in mtkruto postybirb shapeshift trezor; do
-  case "$repo" in mtkruto) tier=small;; postybirb) tier=medium;; shapeshift) tier=complex;; trezor) tier=large;; esac
-  Q=$(node -e "console.log(JSON.parse(require('fs').readFileSync(process.argv[1],'utf8'))[process.argv[2]].question)" "$GT" "$repo")
-  echo ""; echo "### $repo ($tier)  $(date +%H:%M:%S)"
-  bash "$HERE/offload-eval-3arm.sh" "$OUT/repos/$repo" "$tier" "$REPS" "$Q"
-done
-echo ""; echo "###### MATRIX DONE -> $RESULTS ($(wc -l < "$RESULTS") runs).  Judge + summarize with:"
-echo "  node $HERE/offload-eval-judge.mjs --results $RESULTS --truth $GT --out $OUT/judged.jsonl"
-echo "  node $HERE/offload-eval-summarize.mjs $OUT/judged.jsonl"

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

@@ -1,94 +0,0 @@
-#!/usr/bin/env node
-// Extract one eval run's metrics from its Claude stream-json transcript + the
-// offload usage sidecar log, emit ONE merged JSON line.
-//
-// Usage: extract-metrics.mjs --run <run.jsonl> --usage <usage.jsonl|-> \
-//          --arm <a> --rep <n> --repo <r> --tier <t> --q <question>
-import { readFileSync, existsSync } from 'fs';
-
-const args = {};
-for (let i = 2; i < process.argv.length; i += 2) args[process.argv[i].replace(/^--/, '')] = process.argv[i + 1];
-
-const runFile = args.run;
-const lines = existsSync(runFile) ? readFileSync(runFile, 'utf8').split('\n').filter(Boolean) : [];
-
-const toolCounts = {};
-let result = null;
-const tok = { gen: 0, fresh: 0, cached: 0 };
-const offloadAnswers = [];
-let exploreResults = 0; // tool_results from explore (offload or raw)
-let lastAssistantText = '';
-
-for (const line of lines) {
-  let ev; try { ev = JSON.parse(line); } catch { continue; }
-
-  // per-turn token usage (authoritative token measure; result.usage is last-turn only)
-  const u = ev.message?.usage;
-  if (u) {
-    tok.gen += u.output_tokens || 0;
-    tok.fresh += (u.input_tokens || 0) + (u.cache_creation_input_tokens || 0);
-    tok.cached += u.cache_read_input_tokens || 0;
-  }
-
-  if (ev.type === 'assistant' && Array.isArray(ev.message?.content)) {
-    for (const b of ev.message.content) {
-      if (b.type === 'tool_use') toolCounts[b.name] = (toolCounts[b.name] || 0) + 1;
-      if (b.type === 'text' && b.text?.trim()) lastAssistantText = b.text.trim();
-    }
-  }
-  // tool_results arrive in user messages
-  if (ev.type === 'user' && Array.isArray(ev.message?.content)) {
-    for (const b of ev.message.content) {
-      if (b.type !== 'tool_result') continue;
-      const text = Array.isArray(b.content)
-        ? b.content.map(c => (typeof c === 'string' ? c : c.text || '')).join('')
-        : (typeof b.content === 'string' ? b.content : '');
-      // An offload answer is either the 'plain'/'report' synthesis (carries the
-      // "Synthesized by CodeGraph" footer) or a 'refs' answer (carries the re-expanded
-      // "### Referenced source — verbatim" appendix). A refs call that cited nothing
-      // valid falls back to RAW source, which is correctly counted as a raw explore below.
-      if (/Synthesized by CodeGraph|### Referenced source — verbatim/.test(text)) { offloadAnswers.push(text); exploreResults++; }
-      else if (/Found \d+ symbols? across|\*\*Exploration:/.test(text)) exploreResults++;
-    }
-  }
-  if (ev.type === 'result') result = ev;
-}
-
-// offload usage sidecar (CodeGraph AI tokens + cost) — one JSON line per offload call
-const ai = { calls: 0, promptTokens: 0, completionTokens: 0, totalTokens: 0, credits: 0, costUsd: 0, ms: 0 };
-if (args.usage && args.usage !== '-' && existsSync(args.usage)) {
-  for (const line of readFileSync(args.usage, 'utf8').split('\n').filter(Boolean)) {
-    let e; try { e = JSON.parse(line); } catch { continue; }
-    ai.calls++;
-    ai.promptTokens += e.promptTokens || 0;
-    ai.completionTokens += e.completionTokens || 0;
-    ai.totalTokens += e.totalTokens || 0;
-    ai.credits += e.creditsCharged || 0;
-    ai.costUsd += e.costUsd || 0;
-    ai.ms += e.ms || 0;
-  }
-}
-
-// front-load hook fired iff its injected header appears in the transcript
-const frontload = lines.some(l => l.includes('auto-retrieved for this question'));
-const get = (n) => toolCounts[n] || 0;
-const read = get('Read');
-const grep = get('Grep') + get('Bash') + get('Glob');
-const explore = get('mcp__cgraphx__codegraph_explore');
-const cgAny = Object.keys(toolCounts).filter(k => /mcp__cgraphx__/.test(k)).reduce((s, k) => s + toolCounts[k], 0);
-
-const out = {
-  repo: args.repo, tier: args.tier, arm: args.arm, rep: Number(args.rep), question: args.q,
-  ok: result?.subtype === 'success',
-  durationSec: result ? +(result.duration_ms / 1000).toFixed(1) : null,
-  numTurns: result?.num_turns ?? null,
-  costUsdMain: result ? +(result.total_cost_usd || 0).toFixed(4) : null,
-  tokGen: tok.gen, tokFresh: tok.fresh, tokCached: tok.cached, tokBillable: tok.gen + tok.fresh,
-  read, grep, explore, cgAny, frontload,
-  offloadFired: offloadAnswers.length,
-  ai,
-  // text payloads for the accuracy judge (kept separate; large)
-  finalAnswer: (result?.result || lastAssistantText || '').slice(0, 8000),
-  offloadAnswers: offloadAnswers.map(a => a.slice(0, 6000)),
-};
-process.stdout.write(JSON.stringify(out) + '\n');

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

@@ -1,50 +0,0 @@
-#!/usr/bin/env bash
-# ONE offload run on ONE indexed repo at a given offload STYLE (plain|refs), so we can
-# watch a single agent transcript at a time (the user's one-run-at-a-time methodology).
-# The OFFLOAD reasoning runs in the prewarmed DAEMON process, so the style env must be
-# set on BOTH the daemon and the client MCP config. Writes one metrics line to RESULTS
-# and leaves the raw stream-json at $RUNS/<repo>-<style>-<n>.jsonl for inspection.
-#
-# Usage: offload-eval-refs1.sh <indexed-repo> <style> <n> "<question>"
-set -uo pipefail
-HERE="$(cd "$(dirname "$0")" && pwd)"; ENGINE="$(cd "$HERE/../.." && pwd)"; BIN="$ENGINE/dist/bin/codegraph.js"
-OUT="${AGENT_EVAL_OUT:-/tmp/cg-offload-eval}"; RUNS="$OUT/runs"; EXTRACT="$HERE/offload-eval-metrics.mjs"
-TARGET="${1:?repo}"; STYLE="${2:?style}"; N="${3:?run-tag}"; Q="${4:?question}"
-RESULTS="${RESULTS:-$OUT/results-refs.jsonl}"; REPO=$(basename "$TARGET"); TARGET=$(cd "$TARGET" && pwd -P)
-mkdir -p "$RUNS"; command -v claude >/dev/null || { echo "no claude"; exit 1; }
-USAGE="$RUNS/$REPO-$STYLE-usage.jsonl"; : > "$USAGE"
-CFG="$RUNS/mcp-$REPO-$STYLE.json"
-# `raw` is a pseudo-style: cgraphx attached but the offload DISABLED (the ceiling —
-# verbatim source, no reasoning model). Any other value is an offload style (plain|refs).
-if [ "$STYLE" = "raw" ]; then
-  DAEMON_ENV="CGRAPHX_OFFLOAD_DISABLE=1"
-  printf '{"mcpServers":{"cgraphx":{"command":"env","args":["CGRAPHX_WASM_RELAUNCHED=1","CGRAPHX_OFFLOAD_DISABLE=1","node","%s","serve","--mcp","--path","%s"]}}}' \
-    "$BIN" "$TARGET" > "$CFG"
-  USAGE="-"
-else
-  DAEMON_ENV="CGRAPHX_OFFLOAD_STYLE=$STYLE CGRAPHX_OFFLOAD_USAGE_LOG=$USAGE"
-  printf '{"mcpServers":{"cgraphx":{"command":"env","args":["CGRAPHX_WASM_RELAUNCHED=1","CGRAPHX_OFFLOAD_STYLE=%s","CGRAPHX_OFFLOAD_USAGE_LOG=%s","node","%s","serve","--mcp","--path","%s"]}}}' \
-    "$STYLE" "$USAGE" "$BIN" "$TARGET" > "$CFG"
-fi
-
-# Prewarm a persistent daemon carrying the SAME offload config (it does the reasoning).
-pkill -9 -f "serve --mcp --path $TARGET" 2>/dev/null; rm -f "$TARGET/.cgraphx/daemon.sock" 2>/dev/null; sleep 0.6
-env $DAEMON_ENV CGRAPHX_DAEMON_IDLE_TIMEOUT_MS=1800000 \
-  node "$BIN" serve --mcp --path "$TARGET" </dev/null >/dev/null 2>&1 &
-node -e 'const fs=require("fs");let n=0;const t=setInterval(()=>{if(fs.existsSync(process.argv[1]+"/.cgraphx/daemon.sock")){clearInterval(t);process.exit(0)}if(n++>150){clearInterval(t);process.exit(1)}},100)' "$TARGET" \
-  && echo "daemon warm ($STYLE)" || echo "WARN daemon never bound"
-
-tag="$REPO-$STYLE-$N"
-echo "== run $tag =="
-# DISALLOW (optional): block tools that confound the offload-sufficiency signal —
-# chiefly "Agent" (sub-agent delegation: the spawned Explore subagent has low MCP
-# salience, ignores cgraphx, and thrashes via Bash+Read, making the A/B noise).
-( 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 "offload-$STYLE" --rep "$N" \
-    --repo "$REPO" --tier "complex" --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 | main $${o.costUsdMain} ${o.tokBillable} tok | read=${o.read} grep=${o.grep} explore=${o.explore} offload=${o.offloadFired} | AI ${o.ai.calls}call/${o.ai.totalTokens}tok/$${o.ai.costUsd.toFixed(4)} | ok=${o.ok}`)' "$RESULTS"
-pkill -9 -f "serve --mcp --path $TARGET" 2>/dev/null; rm -f "$TARGET/.cgraphx/daemon.sock" 2>/dev/null
-echo "raw transcript: $RUNS/$tag.jsonl"

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

@@ -1,24 +0,0 @@
-#!/usr/bin/env bash
-# Clone + index the 4 "not-trained-on" eval repos into $AGENT_EVAL_OUT/repos. These were
-# selected via a no-tools memory-probe gate (Sonnet cannot answer their flow questions from
-# memory — so the no-cgraphx baseline is honest). Env: AGENT_EVAL_OUT=<scratch dir>
-set -uo pipefail
-HERE="$(cd "$(dirname "$0")" && pwd)"
-ENGINE="$(cd "$HERE/../.." && pwd)"
-BIN="$ENGINE/dist/bin/codegraph.js"
-OUT="${AGENT_EVAL_OUT:-/tmp/cg-offload-eval}"
-ROOT="$OUT/repos"; mkdir -p "$ROOT"
-export CGRAPHX_TELEMETRY=0 DO_NOT_TRACK=1
-[ -f "$BIN" ] || { echo "engine not built: run 'npm run build' in $ENGINE first"; exit 1; }
-
-clone_index() { # url name
-  echo "=== $2: clone ==="; rm -rf "$ROOT/$2"
-  git clone --quiet --depth 1 "$1" "$ROOT/$2" || { echo "  clone FAILED"; return 1; }
-  echo "=== $2: index ==="
-  node "$BIN" init "$ROOT/$2" 2>&1 | grep -iE 'indexed|nodes|edges|error' | tail -2
-}
-clone_index https://github.com/MTKruto/MTKruto.git mtkruto          # small  (~322 TS)
-clone_index https://github.com/mvdicarlo/postybirb-plus.git postybirb  # medium (~608 TS)
-clone_index https://github.com/shapeshift/web.git shapeshift        # complex (~3.2k TS, 35-pkg monorepo)
-clone_index https://github.com/trezor/trezor-suite.git trezor       # large  (~8k TS monorepo)
-echo "###### SETUP DONE -> $ROOT"