@claude-flow/cli 3.21.1 → 3.22.0

package/scripts/grid-search-retrieval.mjs

@@ -1,216 +0,0 @@
-#!/usr/bin/env node
-// grid-search-retrieval.mjs — sweep retrieval hyperparameters against the
-// ADR-081 labelled corpus. Reports label nDCG@3, top-1, top-3, precision@3,
-// MRR@3 per configuration. Identifies the best non-rerank and best rerank
-// configs by nDCG@3.
-//
-// Run prerequisites: scripts/pretrain-from-github.mjs first.
-//
-// Usage:
-//   node scripts/grid-search-retrieval.mjs                 # default grid
-//   node scripts/grid-search-retrieval.mjs --quick         # smaller grid
-//   BENCH_JSON=1 node scripts/grid-search-retrieval.mjs    # machine-readable
-//
-// Output also goes to docs/benchmarks/runs/grid-search-retrieval-<ts>.json
-
-import { writeFileSync, mkdirSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join, resolve } from 'node:path';
-import { performance } from 'node:perf_hooks';
-
-const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
-const CLI_ROOT = resolve(SCRIPT_DIR, '..');
-const REPO_ROOT = resolve(SCRIPT_DIR, '../../../..');
-const RUNS_DIR = join(REPO_ROOT, 'docs', 'benchmarks', 'runs');
-
-// Same labelled corpus as benchmark-pretrained-retrieval.mjs (ADR-081).
-const QUERIES = [
-  { q: 'how was the Opus model alias fixed',
-    labels: ['opus 4.8', 'opus alias', 'opus model alias', '#2232'] },
-  { q: 'self-learning wiring task-completed pretrain',
-    labels: ['self-learning', 'adr-074', 'self learning', '#2245', 'task-completed'] },
-  { q: 'deterministic codemod engine var-to-const',
-    labels: ['deterministic tier-1 codemod', 'adr-143', 'codemod', 'var-to-const'] },
-  { q: 'MCP server orphan leak parent-death',
-    labels: ['mcp orphan', 'mcp servers orphan', 'parent-death', '#2234', 'orphan on every claude'] },
-  { q: 'unified learning stats aggregator',
-    labels: ['unified learning-stats', 'adr-075', 'unified learning stats'] },
-  { q: 'structured distillation 4-field schema',
-    labels: ['structured distillation', 'adr-076', '4-field schema'] },
-  { q: 'SQL injection migrate.ts table identifier',
-    labels: ['sql injection', 'shell injection', 'migrate.ts', 'agentdb', 'cve'] },
-  { q: 'recall@k HNSW benchmark harness',
-    labels: ['hnsw', 'memory-recall', 'benchmark suite', 'recall@k', 'benchmark intelligence'] },
-  { q: 'Q-learning encoder keyword block',
-    labels: ['q-state encoder', 'route q-state', 'keyword block', '#2239', 'q-encoder'] },
-  { q: 'security hardening crypto random IDs',
-    labels: ['cwe-347', 'crypto.randomuuid', 'security fix', 'random id', 'crypto random'] },
-];
-
-function isRelevant(name, labels) {
-  if (!name || !labels?.length) return false;
-  const lower = String(name).toLowerCase();
-  return labels.some((s) => lower.includes(s.toLowerCase()));
-}
-
-function ndcgAtK(rankedRel, k) {
-  const arr = rankedRel.slice(0, k);
-  const dcg = arr.reduce((acc, rel, i) => acc + (rel ? 1 / Math.log2(i + 2) : 0), 0);
-  const numRelevant = arr.filter(Boolean).length;
-  if (numRelevant === 0) return 0;
-  let idcg = 0;
-  for (let i = 0; i < numRelevant; i++) idcg += 1 / Math.log2(i + 2);
-  return idcg > 0 ? dcg / idcg : 0;
-}
-
-// ---------------------------------------------------------------------------
-// Grid definitions
-// ---------------------------------------------------------------------------
-
-const QUICK = process.argv.includes('--quick');
-
-// Non-rerank grid: alpha × subjectWeight × mmrLambda
-const ALPHA_GRID = QUICK ? [0.5, 0.7] : [0.3, 0.5, 0.7];
-const SUBJ_GRID = QUICK ? [3.0, 5.0] : [2.0, 3.0, 5.0];
-const MMR_GRID = QUICK ? [0.5] : [0.3, 0.5, 0.7];
-
-// Rerank grid: hybridWeight × ceWeight (sum to 1).
-const RERANK_GRID = QUICK
-  ? [[0.5, 0.5]]
-  : [[0.2, 0.8], [0.3, 0.7], [0.4, 0.6], [0.5, 0.5], [0.6, 0.4], [0.7, 0.3], [0.8, 0.2]];
-
-// ADR-083: when re-gridding rerank, sweep BOTH the hybrid sub-params (alpha, sw)
-// AND the rerank weights. This catches joint-optima the per-axis grids miss.
-const RERANK_HYBRID_ALPHA = QUICK ? [0.5] : [0.3, 0.5];
-const RERANK_HYBRID_SW    = QUICK ? [2.0] : [2.0, 3.0];
-
-// ---------------------------------------------------------------------------
-// Eval
-// ---------------------------------------------------------------------------
-
-async function evalConfig(tool, params) {
-  let top1Hits = 0, top3HitsBin = 0, ranks = [], ndcg3Sum = 0, prec3Sum = 0;
-  const tStart = performance.now();
-  for (const { q, labels } of QUERIES) {
-    const r = await tool.handler({ action: 'search', query: q, mode: 'hybrid', limit: 5, ...params });
-    const matches = (r.results || []).slice(0, 5);
-    const rel = matches.map((m) => isRelevant(m?.name, labels));
-    if (rel[0]) top1Hits++;
-    if (rel.slice(0, 3).some(Boolean)) top3HitsBin++;
-    const firstRank = rel.findIndex(Boolean);
-    if (firstRank >= 0) ranks.push(firstRank + 1);
-    ndcg3Sum += ndcgAtK(rel, 3);
-    prec3Sum += rel.slice(0, 3).filter(Boolean).length / 3;
-  }
-  const elapsed = performance.now() - tStart;
-  return {
-    label_top1HitRate: top1Hits / QUERIES.length,
-    label_top3HitRate: top3HitsBin / QUERIES.length,
-    label_mrr3: ranks.reduce((s, r) => s + 1 / r, 0) / QUERIES.length,
-    label_precision3: prec3Sum / QUERIES.length,
-    label_ndcg3: ndcg3Sum / QUERIES.length,
-    avgLatencyMs: elapsed / QUERIES.length,
-  };
-}
-
-async function main() {
-  const neural = await import(join(CLI_ROOT, 'dist/src/mcp-tools/neural-tools.js'));
-  const tool = neural.neuralTools.find((t) => t.name === 'neural_patterns');
-  if (!tool) throw new Error('neural_patterns tool not found');
-
-  const configs = [];
-
-  // §A — non-rerank grid (fast, ~3*3*3 = 27 configs at default)
-  for (const alpha of ALPHA_GRID) {
-    for (const subjectWeight of SUBJ_GRID) {
-      for (const mmrLambda of MMR_GRID) {
-        configs.push({
-          name: `hybrid α=${alpha} sw=${subjectWeight} mmr=${mmrLambda}`,
-          rerank: false,
-          params: { rerank: false, alpha, subjectWeight, mmrLambda, bodyWeight: 1.0, typePenaltyFactor: 1.0 },
-        });
-      }
-    }
-  }
-
-  // §B — rerank joint grid (ADR-083): hybridWeight × ceWeight × alpha × subjectWeight.
-  // Each query takes ~1s with cross-encoder, so default full grid = 28 configs × 10
-  // queries × 1s ≈ 5 minutes. Use --quick for 1 config (smoke).
-  for (const [hybridWeight, ceWeight] of RERANK_GRID) {
-    for (const alpha of RERANK_HYBRID_ALPHA) {
-      for (const subjectWeight of RERANK_HYBRID_SW) {
-        configs.push({
-          name: `rerank hw=${hybridWeight} cw=${ceWeight} α=${alpha} sw=${subjectWeight}`,
-          rerank: true,
-          params: { rerank: true, alpha, subjectWeight, mmrLambda: 0.7, hybridWeight, ceWeight },
-        });
-      }
-    }
-  }
-
-  console.log(`Grid-search: ${configs.length} configs across ${QUERIES.length} queries\n`);
-  const results = [];
-  for (const cfg of configs) {
-    process.stdout.write(`  ${cfg.name.padEnd(40)} … `);
-    const m = await evalConfig(tool, cfg.params);
-    results.push({ ...cfg, metrics: m });
-    console.log(`top1=${(m.label_top1HitRate * 100).toFixed(0)}% top3=${(m.label_top3HitRate * 100).toFixed(0)}% nDCG3=${m.label_ndcg3.toFixed(3)} P3=${m.label_precision3.toFixed(3)} MRR3=${m.label_mrr3.toFixed(3)} ${m.avgLatencyMs.toFixed(0)}ms`);
-  }
-
-  // Rank by label nDCG@3 (the canonical relevance metric).
-  const byNdcg = [...results].sort((a, b) => b.metrics.label_ndcg3 - a.metrics.label_ndcg3);
-  const byTop1 = [...results].sort((a, b) => b.metrics.label_top1HitRate - a.metrics.label_top1HitRate || b.metrics.label_ndcg3 - a.metrics.label_ndcg3);
-  const byPrec3 = [...results].sort((a, b) => b.metrics.label_precision3 - a.metrics.label_precision3 || b.metrics.label_ndcg3 - a.metrics.label_ndcg3);
-
-  const bestNonRerankByNdcg = byNdcg.find((r) => !r.rerank);
-  const bestRerankByNdcg = byNdcg.find((r) => r.rerank);
-
-  console.log('\n=== Top 5 by label nDCG@3 ===');
-  for (const r of byNdcg.slice(0, 5)) {
-    console.log(`  nDCG=${r.metrics.label_ndcg3.toFixed(3)}  top1=${(r.metrics.label_top1HitRate * 100).toFixed(0)}%  P3=${r.metrics.label_precision3.toFixed(3)}  ${r.name}`);
-  }
-
-  console.log('\n=== Top 5 by label top-1 (ties broken by nDCG) ===');
-  for (const r of byTop1.slice(0, 5)) {
-    console.log(`  top1=${(r.metrics.label_top1HitRate * 100).toFixed(0)}%  nDCG=${r.metrics.label_ndcg3.toFixed(3)}  P3=${r.metrics.label_precision3.toFixed(3)}  ${r.name}`);
-  }
-
-  console.log('\n=== Top 5 by label precision@3 ===');
-  for (const r of byPrec3.slice(0, 5)) {
-    console.log(`  P3=${r.metrics.label_precision3.toFixed(3)}  top1=${(r.metrics.label_top1HitRate * 100).toFixed(0)}%  nDCG=${r.metrics.label_ndcg3.toFixed(3)}  ${r.name}`);
-  }
-
-  console.log(`\n=== WINNERS ===`);
-  console.log(`Best non-rerank (by nDCG@3):   ${bestNonRerankByNdcg.name}  → top1=${(bestNonRerankByNdcg.metrics.label_top1HitRate * 100).toFixed(0)}% nDCG=${bestNonRerankByNdcg.metrics.label_ndcg3.toFixed(3)}`);
-  console.log(`Best rerank (by nDCG@3):       ${bestRerankByNdcg.name}  → top1=${(bestRerankByNdcg.metrics.label_top1HitRate * 100).toFixed(0)}% nDCG=${bestRerankByNdcg.metrics.label_ndcg3.toFixed(3)}`);
-
-  const summary = {
-    runAt: new Date().toISOString(),
-    benchmark: 'grid-search-retrieval',
-    queries: QUERIES.length,
-    configsEvaluated: configs.length,
-    grid: { ALPHA_GRID, SUBJ_GRID, MMR_GRID, RERANK_GRID },
-    results: results.map((r) => ({ name: r.name, rerank: r.rerank, params: r.params, metrics: r.metrics })),
-    winners: {
-      nDcg3: byNdcg[0].name,
-      top1: byTop1[0].name,
-      precision3: byPrec3[0].name,
-      bestNonRerank: bestNonRerankByNdcg.name,
-      bestRerank: bestRerankByNdcg.name,
-    },
-  };
-
-  if (process.env.BENCH_JSON) {
-    console.log(JSON.stringify(summary, null, 2));
-  } else {
-    mkdirSync(RUNS_DIR, { recursive: true });
-    const stamp = summary.runAt.replace(/[:.]/g, '-');
-    writeFileSync(join(RUNS_DIR, `grid-search-retrieval-${stamp}.json`), JSON.stringify(summary, null, 2));
-    writeFileSync(join(RUNS_DIR, 'grid-search-retrieval-latest.json'), JSON.stringify(summary, null, 2));
-    console.log(`\nWrote ${join(RUNS_DIR, `grid-search-retrieval-${stamp}.json`)}`);
-  }
-
-  process.exit(0);
-}
-
-main().catch((err) => { console.error(err); process.exit(1); });

package/scripts/pretrain-from-github.mjs

@@ -1,358 +0,0 @@
-#!/usr/bin/env node
-// pretrain-from-github.mjs — pretrain ruflo's self-learning system from its
-// own GitHub history (commits + issues). Each commit/issue becomes one
-// trajectory through the SONA + EWC++ pipeline; Structured Distillation
-// (ADR-076) compresses each into the 4-field schema before embedding.
-//
-// What this proves:
-//   - globalStats.{trajectoriesRecorded, patternsLearned, signalsProcessed}
-//     all move from a measured before to a measured after.
-//   - neural_patterns.patternCount grows.
-//   - memory-bridge entries grow.
-//   - The unified-stats aggregator's consistency block stays clean.
-//   - Every item gets a learningPath of 'trajectory-pipeline' (not 'recorded-only').
-//
-// Usage:
-//   node scripts/pretrain-from-github.mjs                   # 50 commits + 30 issues
-//   COMMITS=200 ISSUES=100 node scripts/pretrain-from-github.mjs
-//   SOURCE=git node scripts/pretrain-from-github.mjs        # git only, skip gh
-//   BENCH_JSON=1 node scripts/pretrain-from-github.mjs      # machine-readable
-//   BENCH_NO_WRITE=1 node scripts/pretrain-from-github.mjs  # don't write a run JSON
-//
-// Repro from a fresh checkout:
-//   git clone https://github.com/ruvnet/ruflo && cd ruflo
-//   npm install && ( cd v3/@claude-flow/cli && npx tsc -b )
-//   node v3/@claude-flow/cli/scripts/pretrain-from-github.mjs
-
-import { execSync } from 'node:child_process';
-import { writeFileSync, mkdirSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join, resolve } from 'node:path';
-import { performance } from 'node:perf_hooks';
-
-const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
-const CLI_ROOT = resolve(SCRIPT_DIR, '..');
-const RUFLO_ROOT = resolve(SCRIPT_DIR, '../../../..');
-const RUNS_DIR = join(RUFLO_ROOT, 'docs', 'benchmarks', 'runs');
-
-// ADR-084 cross-repo support — REPO_ROOT and GH_REPO env-overridable so the
-// same script can pretrain on agentdb / agentic-flow / any other repo for
-// generalisation testing. Defaults preserve ruflo behaviour.
-const REPO_ROOT = process.env.REPO_ROOT ? resolve(process.env.REPO_ROOT) : RUFLO_ROOT;
-const GH_REPO   = process.env.GH_REPO   || 'ruvnet/ruflo';
-
-const COMMITS = Number(process.env.COMMITS) || 50;
-const ISSUES  = Number(process.env.ISSUES)  || 30;
-const SOURCE  = process.env.SOURCE || 'all'; // 'all' | 'git' | 'issues'
-
-// ---------------------------------------------------------------------------
-// Harvesters
-// ---------------------------------------------------------------------------
-
-// ADR-078 outcome signal — classify each commit by whether it was reverted,
-// hotfix-followed, or stuck. Operates on the harvested-commits window plus a
-// wider lookahead window for revert/hotfix detection.
-//
-// Verdicts emitted:
-//   success — landed cleanly, no later commit reverted or fixed it
-//   reverted — a later commit subject starts with `Revert "<this subject>"`
-//   hotfixed — a later commit (within HOTFIX_WINDOW_COMMITS) shares >=50%
-//              of the same touched files AND subject contains fix|hotfix|patch
-//
-// The "later" direction is git-log order (newest first → we look at older
-// indices in the lookahead, which are NEWER commits chronologically).
-const HOTFIX_WINDOW_COMMITS = Number(process.env.HOTFIX_WINDOW_COMMITS) || 20;
-const HOTFIX_FILE_OVERLAP = Number(process.env.HOTFIX_FILE_OVERLAP) || 0.5;
-const HOTFIX_KEYWORDS = /\b(fix|hotfix|patch|revert|bugfix|fixup)\b/i;
-
-function harvestCommits(n) {
-  if (SOURCE === 'issues') return [];
-  const fmt = '%H%x00%s%x00%b%x01';
-  // Pull a wider window so we have lookahead for revert/hotfix detection
-  // without changing the trained set size n.
-  const lookahead = HOTFIX_WINDOW_COMMITS;
-  const raw = execSync(
-    `git log --pretty=format:'${fmt}' -n ${n + lookahead} 2>/dev/null`,
-    { cwd: REPO_ROOT, encoding: 'utf-8', maxBuffer: 64 * 1024 * 1024 },
-  );
-
-  // Parse all blocks (window + lookahead).
-  const all = [];
-  for (const block of raw.split('\x01')) {
-    if (!block.trim()) continue;
-    const [sha, subject, body] = block.split('\x00');
-    if (!sha || !subject) continue;
-    all.push({ sha, subject: subject.trim(), body: (body || '').trim() });
-  }
-
-  // For each commit in the trained slice, get its touched files.
-  const filesCache = new Map();
-  const filesOf = (sha) => {
-    if (filesCache.has(sha)) return filesCache.get(sha);
-    try {
-      const out = execSync(
-        `git show --pretty=format: --name-only ${sha} 2>/dev/null`,
-        { cwd: REPO_ROOT, encoding: 'utf-8', maxBuffer: 8 * 1024 * 1024 },
-      ).trim().split('\n').filter(Boolean);
-      filesCache.set(sha, new Set(out));
-      return filesCache.get(sha);
-    } catch {
-      filesCache.set(sha, new Set());
-      return filesCache.get(sha);
-    }
-  };
-
-  // Build a revert-target map: any commit whose subject starts with
-  // `Revert "<X>"` flags X as reverted.
-  const revertedSubjects = new Set();
-  for (const c of all) {
-    const m = c.subject.match(/^Revert\s+"(.+?)"/);
-    if (m) revertedSubjects.add(m[1].trim());
-  }
-
-  const trained = all.slice(0, n);
-  const entries = [];
-  for (let i = 0; i < trained.length; i++) {
-    const c = trained[i];
-    const myFiles = filesOf(c.sha);
-
-    let verdict = 'success';
-    let outcomeNote = null;
-
-    // Reverted? Check if any later (lower-index = newer) commit reverted us.
-    if (revertedSubjects.has(c.subject)) {
-      verdict = 'reverted';
-      outcomeNote = 'subject reverted by a later commit';
-    } else {
-      // Hotfixed? A later commit within HOTFIX_WINDOW_COMMITS shares files
-      // AND has fix/hotfix in its subject.
-      const start = Math.max(0, i - HOTFIX_WINDOW_COMMITS);
-      for (let j = start; j < i; j++) {
-        const later = trained[j];
-        if (!HOTFIX_KEYWORDS.test(later.subject)) continue;
-        const laterFiles = filesOf(later.sha);
-        if (laterFiles.size === 0 || myFiles.size === 0) continue;
-        let overlap = 0;
-        for (const f of laterFiles) if (myFiles.has(f)) overlap++;
-        // Use min() so a small targeted fix on a big change still triggers
-        // (semantic: "≥half of the smaller commit's files overlap").
-        const overlapFrac = overlap / Math.min(laterFiles.size, myFiles.size);
-        if (overlapFrac >= HOTFIX_FILE_OVERLAP) {
-          verdict = 'hotfixed';
-          outcomeNote = `${(overlapFrac * 100).toFixed(0)}% file overlap with later fix ${later.sha.slice(0, 8)}`;
-          break;
-        }
-      }
-    }
-
-    entries.push({
-      source: 'commit',
-      id: `commit-${c.sha.slice(0, 12)}`,
-      subject: c.subject,
-      body: c.body,
-      verdict,
-      outcomeNote,
-      content: `${c.subject}\n\n${c.body}`.slice(0, 8192),
-    });
-  }
-  return entries;
-}
-
-function harvestIssues(n) {
-  if (SOURCE === 'git') return [];
-  try {
-    const raw = execSync(
-      `gh issue list --repo ${GH_REPO} --state all --limit ${n} --json number,title,body,state,closedAt 2>/dev/null`,
-      { cwd: REPO_ROOT, encoding: 'utf-8', maxBuffer: 64 * 1024 * 1024 },
-    );
-    const items = JSON.parse(raw);
-    return items.map((i) => ({
-      source: 'issue',
-      id: `issue-${i.number}`,
-      subject: i.title,
-      body: (i.body || '').slice(0, 8192),
-      // closed = success outcome; open = partial (in-progress).
-      verdict: i.state === 'CLOSED' ? 'success' : 'partial',
-      content: `${i.title}\n\n${(i.body || '').slice(0, 8192)}`,
-    }));
-  } catch (err) {
-    console.error(`gh issue harvest skipped (${err.message?.slice(0, 60)}). Set SOURCE=git to silence.`);
-    return [];
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Main
-// ---------------------------------------------------------------------------
-
-async function main() {
-  const intel = await import(join(CLI_ROOT, 'dist/src/memory/intelligence.js'));
-  const neural = await import(join(CLI_ROOT, 'dist/src/mcp-tools/neural-tools.js'));
-  const { distillAndSerialise } = await import(join(CLI_ROOT, 'dist/src/memory/structured-distill.js'));
-
-  // §1 — record the baseline (no clear; we want to learn ON TOP of whatever
-  // history the user already has).
-  const unified0 = await intel.getUnifiedLearningStats();
-  const before = {
-    trajectoriesRecorded: unified0.global.trajectoriesRecorded,
-    patternsLearned: unified0.global.patternsLearned,
-    signalsProcessed: unified0.global.signalsProcessed,
-    neuralPatternCount: unified0.neuralPatterns.patternCount,
-    memoryBridgeTotal: unified0.memoryBridge.totalEntries,
-  };
-
-  // §2 — harvest
-  const tHarvest0 = performance.now();
-  const commits = harvestCommits(COMMITS);
-  const issues = harvestIssues(ISSUES);
-  const items = [...commits, ...issues];
-  const harvestMs = performance.now() - tHarvest0;
-
-  if (!process.env.BENCH_JSON) {
-    console.log(`# Pretrain from ruflo GitHub history`);
-    console.log(`Harvested: ${commits.length} commits + ${issues.length} issues = ${items.length} trajectories (${harvestMs.toFixed(0)} ms)`);
-  }
-
-  // §3 — feed each item through the trajectory pipeline. The harvester
-  // emits one of: success | partial | reverted | hotfixed. We map this to
-  // the trajectory pipeline's binary verdict {success, partial} since the
-  // pipeline doesn't accept arbitrary strings — but we preserve the original
-  // outcome in metadata + the summary's verdictMix so the signal isn't lost.
-  const verdictToPipeline = (v) => {
-    if (v === 'success') return 'success';
-    if (v === 'partial') return 'partial';
-    if (v === 'reverted') return 'partial';   // a revert is the strongest "this was wrong" signal we have
-    if (v === 'hotfixed') return 'partial';   // a same-files fix-followup is "needs adjustment"
-    return 'success';
-  };
-  const verdictMix = { success: 0, partial: 0, reverted: 0, hotfixed: 0 };
-  const tFeed0 = performance.now();
-  let trained = 0;
-  let failed = 0;
-  const failures = [];
-  for (const item of items) {
-    try {
-      const distilled = distillAndSerialise(item.content);
-      verdictMix[item.verdict] = (verdictMix[item.verdict] ?? 0) + 1;
-      await intel.recordTrajectory(
-        [{
-          type: 'result',
-          content: distilled,
-          metadata: {
-            source: item.source,
-            id: item.id,
-            subject: item.subject.slice(0, 200),
-            outcomeVerdict: item.verdict,
-            outcomeNote: item.outcomeNote ?? null,
-          },
-          timestamp: Date.now(),
-        }],
-        verdictToPipeline(item.verdict),
-      );
-      trained++;
-    } catch (err) {
-      failed++;
-      if (failures.length < 5) failures.push({ id: item.id, error: String(err.message).slice(0, 120) });
-    }
-  }
-  const feedMs = performance.now() - tFeed0;
-  intel.flushIntelligenceStats();
-
-  // §4 — also seed the neural store directly from the same items so
-  // `neural_patterns list` reflects them (closes the "globalStats moved but
-  // neural_patterns didn't" consistency note from ADR-075).
-  const tSeed0 = performance.now();
-  const neuralItems = items.map((item) => ({
-    name: item.subject.slice(0, 200),
-    type: item.source === 'commit' ? 'history-commit' : 'history-issue',
-    content: distillAndSerialise(item.content),
-    metadata: { source: item.source, id: item.id, verdict: item.verdict },
-  }));
-  const seedResult = await neural.storeNeuralPatterns(neuralItems);
-  const seedMs = performance.now() - tSeed0;
-
-  // §5 — read the after-counters via the unified aggregator (this is what
-  // hooks_intelligence_unified-stats would return for a live caller).
-  const unified1 = await intel.getUnifiedLearningStats();
-  const after = {
-    trajectoriesRecorded: unified1.global.trajectoriesRecorded,
-    patternsLearned: unified1.global.patternsLearned,
-    signalsProcessed: unified1.global.signalsProcessed,
-    neuralPatternCount: unified1.neuralPatterns.patternCount,
-    memoryBridgeTotal: unified1.memoryBridge.totalEntries,
-  };
-
-  const deltas = Object.fromEntries(
-    Object.keys(after).map((k) => [k, after[k] - before[k]]),
-  );
-
-  const summary = {
-    runAt: new Date().toISOString(),
-    benchmark: 'pretrain-from-github',
-    source: SOURCE,
-    config: { COMMITS, ISSUES },
-    harvest: {
-      commits: commits.length,
-      issues: issues.length,
-      total: items.length,
-      harvestMs: Number(harvestMs.toFixed(2)),
-    },
-    feed: {
-      trained,
-      failed,
-      avgLatencyMs: items.length > 0 ? Number((feedMs / items.length).toFixed(2)) : 0,
-      totalMs: Number(feedMs.toFixed(2)),
-      sampleFailures: failures,
-      verdictMix,   // ADR-078 outcome signal — counts per harvested verdict
-    },
-    seedNeuralStore: {
-      stored: seedResult.stored,
-      total: seedResult.total,
-      seedMs: Number(seedMs.toFixed(2)),
-    },
-    before,
-    after,
-    deltas,
-    consistency: unified1.consistency,
-    passed:
-      trained === items.length &&
-      deltas.trajectoriesRecorded >= items.length &&
-      deltas.neuralPatternCount >= items.length,
-  };
-
-  if (process.env.BENCH_JSON) {
-    console.log(JSON.stringify(summary, null, 2));
-  } else {
-    console.log('');
-    console.log('| Counter | Before | After | Δ |');
-    console.log('|---|---:|---:|---:|');
-    for (const k of Object.keys(after)) {
-      console.log(`| ${k} | ${before[k]} | ${after[k]} | +${deltas[k]} |`);
-    }
-    console.log('');
-    console.log(`Trained via trajectory pipeline: ${trained}/${items.length}`);
-    console.log(`Failed: ${failed}`);
-    console.log(`Avg latency per trajectory: ${summary.feed.avgLatencyMs} ms`);
-    console.log(`Neural store seeded: ${seedResult.stored}/${seedResult.total}`);
-    console.log(`Verdict mix: success=${verdictMix.success} partial=${verdictMix.partial} reverted=${verdictMix.reverted} hotfixed=${verdictMix.hotfixed}`);
-    console.log(`Overall: ${summary.passed ? '✅ PASSED' : '⚠️  partial'}`);
-    if (unified1.consistency.notes.length > 0) {
-      console.log(`\nConsistency notes:`);
-      for (const n of unified1.consistency.notes) console.log(`  • ${n}`);
-    }
-  }
-
-  if (!process.env.BENCH_NO_WRITE) {
-    mkdirSync(RUNS_DIR, { recursive: true });
-    const stamp = summary.runAt.replace(/[:.]/g, '-');
-    writeFileSync(join(RUNS_DIR, `pretrain-from-github-${stamp}.json`), JSON.stringify(summary, null, 2));
-    writeFileSync(join(RUNS_DIR, 'pretrain-from-github-latest.json'), JSON.stringify(summary, null, 2));
-    if (!process.env.BENCH_JSON) console.log(`\nWrote ${join(RUNS_DIR, `pretrain-from-github-${stamp}.json`)}`);
-  }
-
-  // ONNX runtime keeps a worker thread alive — force exit so this can be used
-  // as a CI step or chained with other scripts.
-  process.exit(summary.passed ? 0 : 1);
-}
-
-main().catch((err) => { console.error(err); process.exit(1); });