@claude-flow/cli 3.10.15 → 3.10.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.10.15",
+  "version": "3.10.17",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",

package/scripts/benchmark-pretrained-retrieval.mjs

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+// benchmark-pretrained-retrieval.mjs — proof that pretrained patterns are
+// retrievable, not just stored.
+//
+// Runs sample queries against the neural store (post-pretrain) and reports
+// the top-k matches. Demonstrates that after `pretrain-from-github.mjs`
+// runs, an agent can recall relevant past work by intent.
+//
+// Usage:
+//   1. node scripts/pretrain-from-github.mjs           # populate the store
+//   2. node scripts/benchmark-pretrained-retrieval.mjs # query + report
+
+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');
+
+// Real ruflo-history-shaped queries. Each one targets a concept that should
+// have been seen during pretrain (Opus 4.8 fix, self-learning wiring,
+// codemod engine, etc.).
+const QUERIES = [
+  'how was the Opus model alias fixed',
+  'self-learning wiring task-completed pretrain',
+  'deterministic codemod engine var-to-const',
+  'MCP server orphan leak parent-death',
+  'unified learning stats aggregator',
+  'structured distillation 4-field schema',
+  'SQL injection migrate.ts table identifier',
+  'recall@k HNSW benchmark harness',
+  'Q-learning encoder keyword block',
+  'security hardening crypto random IDs',
+];
+
+const TOP_K = 5;
+
+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'));
+
+  // §1 — snapshot the neural store + globalStats so we know what's there.
+  const unified = await intel.getUnifiedLearningStats();
+  const total = unified.neuralPatterns.patternCount;
+
+  if (total === 0) {
+    console.error('No patterns in neural store. Run scripts/pretrain-from-github.mjs first.');
+    process.exit(2);
+  }
+
+  // §2 — run each query through neural_patterns search. The tool's search
+  // action runs cosine similarity against the stored embeddings.
+  const listTool = neural.neuralTools.find((t) => t.name === 'neural_patterns');
+  const tQuery0 = performance.now();
+  const results = [];
+  for (const q of QUERIES) {
+    const r = await listTool.handler({ action: 'search', query: q });
+    const matches = (r.patterns || r.results || r.matches || []).slice(0, TOP_K);
+    results.push({
+      query: q,
+      matched: matches.length > 0,
+      topK: matches.map((m) => ({
+        id: m.id,
+        name: m.name?.slice(0, 100),
+        type: m.type,
+        score: m.score ?? m.similarity,
+      })),
+    });
+  }
+  const queryMs = performance.now() - tQuery0;
+
+  const matchedQueries = results.filter((r) => r.matched).length;
+  const summary = {
+    runAt: new Date().toISOString(),
+    benchmark: 'pretrained-retrieval',
+    storeSize: total,
+    queries: QUERIES.length,
+    matchedQueries,
+    matchRate: Number((matchedQueries / QUERIES.length).toFixed(4)),
+    avgQueryLatencyMs: Number((queryMs / QUERIES.length).toFixed(2)),
+    totalQueryMs: Number(queryMs.toFixed(2)),
+    results,
+    passed: matchedQueries === QUERIES.length,
+  };
+
+  if (process.env.BENCH_JSON) {
+    console.log(JSON.stringify(summary, null, 2));
+  } else {
+    console.log(`# Pretrained-retrieval benchmark — proof of learning`);
+    console.log(`Store size: ${total} patterns`);
+    console.log(`Queries: ${QUERIES.length}`);
+    console.log(`Match rate: ${(summary.matchRate * 100).toFixed(0)}% (${matchedQueries}/${QUERIES.length})`);
+    console.log(`Avg query latency: ${summary.avgQueryLatencyMs} ms`);
+    console.log('');
+    for (const r of results) {
+      console.log(`Q: "${r.query}"`);
+      if (r.topK.length === 0) {
+        console.log(`   → no matches`);
+      } else {
+        for (const m of r.topK.slice(0, 3)) {
+          console.log(`   → ${m.score?.toFixed?.(3) ?? '—'}  ${m.name}`);
+        }
+      }
+    }
+    console.log('');
+    console.log(`Overall: ${summary.passed ? '✅ PASSED' : '⚠️  partial'}`);
+  }
+
+  if (!process.env.BENCH_NO_WRITE) {
+    mkdirSync(RUNS_DIR, { recursive: true });
+    const stamp = summary.runAt.replace(/[:.]/g, '-');
+    writeFileSync(join(RUNS_DIR, `pretrained-retrieval-${stamp}.json`), JSON.stringify(summary, null, 2));
+    writeFileSync(join(RUNS_DIR, 'pretrained-retrieval-latest.json'), JSON.stringify(summary, null, 2));
+    if (!process.env.BENCH_JSON) console.log(`\nWrote ${join(RUNS_DIR, `pretrained-retrieval-${stamp}.json`)}`);
+  }
+
+  // ONNX runtime keeps a worker thread alive — force exit.
+  process.exit(summary.passed ? 0 : 1);
+}
+
+main().catch((err) => { console.error(err); process.exit(1); });

package/scripts/benchmark-trajectory-mrr.mjs

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+// benchmark-trajectory-mrr.mjs — proof harness for Structured Distillation
+// (#2241 §SOTA, arXiv:2603.13017).
+//
+// Measures retrieval MRR for raw vs structured-distilled trajectory content
+// against a paired corpus. The arXiv paper reports raw → distilled MRR
+// going from 0.745 to 0.759 on a 214 K-pair consensus-graded set; our corpus
+// is much smaller and hand-curated, so the absolute numbers won't match,
+// but the *direction* of the delta is what we're proving.
+//
+// Two embedders are supported:
+//   - Real ONNX (Xenova/all-MiniLM-L6-v2 384-dim) via @claude-flow/embeddings
+//     when available. Best signal.
+//   - Hash-based deterministic fallback when ONNX isn't installed. Lower
+//     signal; results still relative-comparable.
+//
+// Usage:
+//   node scripts/benchmark-trajectory-mrr.mjs            # default
+//   BENCH_JSON=1 node scripts/benchmark-trajectory-mrr.mjs
+//   BENCH_NO_WRITE=1 node scripts/benchmark-trajectory-mrr.mjs
+
+import { readFileSync, 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');
+
+const { distillAndSerialise, compressionRatio } = await import(
+  join(CLI_ROOT, 'dist/src/memory/structured-distill.js')
+);
+
+// ---------------------------------------------------------------------------
+// Embedder — prefers real ONNX, falls back to hash-based deterministic.
+// ---------------------------------------------------------------------------
+async function loadEmbedder() {
+  // Tier 1: AgentDB's bridge-loaded ONNX embedder (the path the live MCP
+  // server + vitest tests use, so we measure what users actually get).
+  try {
+    const mb = await import(join(CLI_ROOT, 'dist/src/memory/memory-bridge.js'));
+    const probe = await mb.bridgeGenerateEmbedding('warm-up').catch(() => null);
+    if (probe && probe.embedding && probe.embedding.length > 0 && probe.backend === 'onnx') {
+      return {
+        name: `bridge ONNX (${probe.model}, ${probe.dimensions}-dim)`,
+        embed: async (text) => {
+          const r = await mb.bridgeGenerateEmbedding(text);
+          if (!r) throw new Error('bridge embed returned null');
+          return r.embedding;
+        },
+      };
+    }
+  } catch { /* fall through */ }
+  // Tier 2: hash-based deterministic. Clearly degraded; produces only
+  // direction-of-effect signal, not absolute MRR numbers comparable to paper.
+  console.error('⚠️  Real ONNX embedder unavailable — using hash-based deterministic fallback. Absolute MRR numbers are NOT comparable to the arXiv paper in this mode; relative comparison is also weak.');
+  return {
+    name: 'hash-fallback (no semantic signal — degraded mode)',
+    embed: async (text) => hashEmbed(text, 384),
+  };
+}
+
+function hashEmbed(text, dims) {
+  const v = new Float32Array(dims);
+  let seed = 0;
+  for (let i = 0; i < text.length; i++) seed = (seed * 31 + text.charCodeAt(i)) | 0;
+  let s = Math.abs(seed) | 1;
+  for (let i = 0; i < dims; i++) {
+    s = (s * 1103515245 + 12345) & 0x7fffffff;
+    v[i] = (s / 0x7fffffff) * 2 - 1;
+  }
+  // L2 normalise
+  let n = 0;
+  for (let i = 0; i < dims; i++) n += v[i] * v[i];
+  n = Math.sqrt(n) || 1;
+  for (let i = 0; i < dims; i++) v[i] /= n;
+  return Array.from(v);
+}
+
+function cosine(a, b) {
+  let s = 0;
+  for (let i = 0; i < a.length; i++) s += a[i] * b[i];
+  return s;
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+async function main() {
+  const corpusPath = join(CLI_ROOT, 'bench', 'trajectory-mrr-corpus.json');
+  const corpus = JSON.parse(readFileSync(corpusPath, 'utf-8'));
+  const trajectories = corpus.trajectories;
+  const embedder = await loadEmbedder();
+
+  // Per-trajectory: embed both raw and distilled forms.
+  const tEmbed0 = performance.now();
+  const rawEmbs = [];
+  const distEmbs = [];
+  let totalRawBytes = 0;
+  let totalDistBytes = 0;
+  for (const t of trajectories) {
+    const distilled = distillAndSerialise(t.raw);
+    totalRawBytes += t.raw.length;
+    totalDistBytes += distilled.length;
+    rawEmbs.push(await embedder.embed(t.raw));
+    distEmbs.push(await embedder.embed(distilled));
+  }
+  const embedMs = performance.now() - tEmbed0;
+
+  // For each (query, gold) pair: rank all trajectories by cosine to the query
+  // embedding. MRR = mean of 1 / rank-of-gold across all queries.
+  const tQuery0 = performance.now();
+  let rrRaw = 0, rrDist = 0;
+  const perQuery = [];
+  for (let i = 0; i < trajectories.length; i++) {
+    const q = await embedder.embed(trajectories[i].query);
+    const rankRaw = rankOf(q, rawEmbs, i);
+    const rankDist = rankOf(q, distEmbs, i);
+    rrRaw += 1 / rankRaw;
+    rrDist += 1 / rankDist;
+    perQuery.push({ id: trajectories[i].id, rankRaw, rankDist });
+  }
+  const queryMs = performance.now() - tQuery0;
+
+  const N = trajectories.length;
+  const mrrRaw = rrRaw / N;
+  const mrrDist = rrDist / N;
+  const delta = mrrDist - mrrRaw;
+  const compression = totalRawBytes / Math.max(1, totalDistBytes);
+
+  const summary = {
+    runAt: new Date().toISOString(),
+    benchmark: 'trajectory-mrr',
+    embedder: embedder.name,
+    corpusVersion: corpus.version,
+    corpusSize: N,
+    mrr: {
+      raw: Number(mrrRaw.toFixed(4)),
+      distilled: Number(mrrDist.toFixed(4)),
+      delta: Number(delta.toFixed(4)),
+      paperReference: { raw: 0.745, distilled: 0.759, delta: 0.014, source: 'arXiv:2603.13017' },
+    },
+    compression: {
+      totalRawBytes,
+      totalDistBytes,
+      ratio: Number(compression.toFixed(2)),
+      paperReference: { tokensRaw: 371, tokensDistilled: 38, ratio: 9.76, source: 'arXiv:2603.13017' },
+    },
+    latencyMs: {
+      embedAll: Number(embedMs.toFixed(2)),
+      queryAll: Number(queryMs.toFixed(2)),
+      perDistill: Number((embedMs / (2 * N)).toFixed(4)),
+    },
+    distilledIsBetter: delta > 0,
+    perQueryRanks: perQuery,
+  };
+
+  if (process.env.BENCH_JSON) {
+    console.log(JSON.stringify(summary, null, 2));
+  } else {
+    console.log(`# Trajectory MRR benchmark (#2241 §Structured Distillation)`);
+    console.log(`Embedder: ${embedder.name}`);
+    console.log(`Corpus: N=${N} (v${corpus.version})`);
+    console.log('');
+    console.log('| Metric | Raw | Distilled | Δ |');
+    console.log('|---|---:|---:|---:|');
+    console.log(`| MRR | ${summary.mrr.raw} | ${summary.mrr.distilled} | ${summary.mrr.delta >= 0 ? '+' : ''}${summary.mrr.delta} |`);
+    console.log(`| Total bytes | ${totalRawBytes} | ${totalDistBytes} | ${compression.toFixed(2)}× compression |`);
+    console.log('');
+    console.log(`Distilled is ${summary.distilledIsBetter ? 'BETTER ✅' : 'WORSE ❌'} than raw on this corpus.`);
+    console.log(`Paper (arXiv:2603.13017): MRR raw 0.745 → distilled 0.759 (Δ +0.014); compression ~9.76× (371→38 tokens).`);
+  }
+
+  if (!process.env.BENCH_NO_WRITE) {
+    mkdirSync(RUNS_DIR, { recursive: true });
+    const stamp = summary.runAt.replace(/[:.]/g, '-');
+    writeFileSync(join(RUNS_DIR, `trajectory-mrr-${stamp}.json`), JSON.stringify(summary, null, 2));
+    writeFileSync(join(RUNS_DIR, 'trajectory-mrr-latest.json'), JSON.stringify(summary, null, 2));
+    if (!process.env.BENCH_JSON) console.log(`\nWrote ${join(RUNS_DIR, `trajectory-mrr-${stamp}.json`)}`);
+  }
+}
+
+function rankOf(query, embeddings, goldIndex) {
+  const scored = embeddings.map((e, i) => ({ i, score: cosine(query, e) }));
+  scored.sort((a, b) => b.score - a.score);
+  return scored.findIndex((s) => s.i === goldIndex) + 1;
+}
+
+main().catch((err) => { console.error(err); process.exit(1); });

package/scripts/pretrain-from-github.mjs

@@ -0,0 +1,254 @@
+#!/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 REPO_ROOT = resolve(SCRIPT_DIR, '../../../..');
+const RUNS_DIR = join(REPO_ROOT, 'docs', 'benchmarks', 'runs');
+
+const COMMITS = Number(process.env.COMMITS) || 50;
+const ISSUES  = Number(process.env.ISSUES)  || 30;
+const SOURCE  = process.env.SOURCE || 'all'; // 'all' | 'git' | 'issues'
+
+// ---------------------------------------------------------------------------
+// Harvesters
+// ---------------------------------------------------------------------------
+
+function harvestCommits(n) {
+  if (SOURCE === 'issues') return [];
+  const fmt = '%H%x00%s%x00%b%x01';
+  const raw = execSync(
+    `git log --pretty=format:'${fmt}' -n ${n} 2>/dev/null`,
+    { cwd: REPO_ROOT, encoding: 'utf-8', maxBuffer: 64 * 1024 * 1024 },
+  );
+  const entries = [];
+  for (const block of raw.split('\x01')) {
+    if (!block.trim()) continue;
+    const [sha, subject, body] = block.split('\x00');
+    if (!sha || !subject) continue;
+    entries.push({
+      source: 'commit',
+      id: `commit-${sha.slice(0, 12)}`,
+      subject: subject.trim(),
+      body: (body || '').trim(),
+      // The "verdict" of a commit isn't directly known. Treat all commits as
+      // success — we're learning from intent, not outcome. Failures are
+      // captured separately via the issue stream (closed issues are
+      // success; open issues are partial).
+      verdict: 'success',
+      content: `${subject.trim()}\n\n${(body || '').trim()}`.slice(0, 8192),
+    });
+  }
+  return entries;
+}
+
+function harvestIssues(n) {
+  if (SOURCE === 'git') return [];
+  try {
+    const raw = execSync(
+      `gh issue list --repo ruvnet/ruflo --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.
+  const tFeed0 = performance.now();
+  let trained = 0;
+  let failed = 0;
+  const failures = [];
+  for (const item of items) {
+    try {
+      const distilled = distillAndSerialise(item.content);
+      await intel.recordTrajectory(
+        [{
+          type: 'result',
+          content: distilled,
+          metadata: {
+            source: item.source,
+            id: item.id,
+            subject: item.subject.slice(0, 200),
+          },
+          timestamp: Date.now(),
+        }],
+        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,
+    },
+    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(`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); });