seer-mcp 0.1.0

package/tests/tracki-preflight.ts

@@ -0,0 +1,251 @@
+/**
+ * Track I — Feature 3: Preflight Context.
+ *
+ * Symbol mode:
+ *   - returns a packet for a known symbol containing risk, likely tests,
+ *     service impact, history, and warnings.
+ *   - missing symbol returns ok=false but command does not crash.
+ *
+ * Range mode (--from/--to):
+ *   - a fixture branch with a single function change has its symbol mapped
+ *     correctly into touchedSymbols.
+ *
+ * Run: npx tsx tests/tracki-preflight.ts
+ */
+
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { spawnSync } from 'child_process';
+import { Indexer } from '../src/indexer/index';
+import { Store } from '../src/db/store';
+import { preflight } from '../src/indexer/preflight';
+
+const TMP = path.join(os.tmpdir(), `seer-tracki-preflight-${Date.now()}`);
+const REPO = path.join(TMP, 'repo');
+const DB = path.join(TMP, 'graph.db');
+
+let passed = 0;
+let failed = 0;
+function assert(cond: boolean, msg: string): void {
+  if (cond) { console.log(`  ✓ ${msg}`); passed++; }
+  else { console.error(`  ✗ ${msg}`); failed++; }
+}
+function assertEq<T>(actual: T, expected: T, msg: string): void {
+  assert(actual === expected,
+    `${msg} (got ${JSON.stringify(actual)}, expected ${JSON.stringify(expected)})`);
+}
+function cleanup(): void {
+  try { fs.rmSync(TMP, { recursive: true, force: true }); } catch { /* */ }
+}
+
+function git(...args: string[]): { stdout: string; status: number; stderr: string } {
+  const r = spawnSync('git', ['-C', REPO, ...args], { encoding: 'utf8' });
+  return { stdout: r.stdout ?? '', status: r.status ?? 1, stderr: r.stderr ?? '' };
+}
+
+function commit(message: string, author = 'Alice <alice@example.com>'): string {
+  git('add', '.');
+  const r = spawnSync(
+    'git',
+    ['-C', REPO, '-c', `user.email=${author.replace(/^.* <(.+)>$/, '$1')}`,
+            '-c', `user.name=${author.replace(/ <.+>$/, '')}`,
+            'commit', '-m', message, '--no-gpg-sign'],
+    { encoding: 'utf8' },
+  );
+  if (r.status !== 0) throw new Error(`git commit failed: ${r.stderr}`);
+  return git('rev-parse', 'HEAD').stdout.trim();
+}
+
+function write(rel: string, content: string): void {
+  const full = path.join(REPO, rel);
+  fs.mkdirSync(path.dirname(full), { recursive: true });
+  fs.writeFileSync(full, content, 'utf8');
+}
+
+async function main(): Promise<void> {
+  console.log('\nSeer Track I — Feature 3: Preflight Context');
+  console.log('============================================\n');
+  cleanup();
+  fs.mkdirSync(REPO, { recursive: true });
+
+  spawnSync('git', ['-C', REPO, 'init', '-q', '-b', 'main'], { encoding: 'utf8' });
+  git('config', 'commit.gpgsign', 'false');
+
+  // Commit 1: initial files — `validateToken`, its caller, and a test for it.
+  write('src/auth.ts', `
+export function validateToken(token: string): boolean {
+  if (!token) return false;
+  return token.length > 8;
+}
+
+export function authenticate(req: { token: string }): boolean {
+  return validateToken(req.token);
+}
+`.trimStart());
+  write('src/api.ts', `
+import { authenticate } from './auth';
+declare const app: any;
+export function loginHandler(req: any, res: any) {
+  if (!authenticate(req)) return res.status(401).send();
+  return res.send({ ok: true });
+}
+app.post('/api/login', loginHandler);
+`.trimStart());
+  write('tests/auth.test.ts', `
+import { validateToken } from '../src/auth';
+
+function testValidateRejectsEmpty(): void {
+  const ok = validateToken('');
+  expect(ok).toBe(false);
+}
+
+function testValidateRejectsShort(): void {
+  const ok = validateToken('abc');
+  expect(ok).toBe(false);
+}
+
+function testValidateAcceptsLong(): void {
+  const ok = validateToken('abcdefghi');
+  expect(ok).toBe(true);
+}
+
+function expect(_v: unknown) {
+  return { toBe(_e: unknown): void { /* */ } };
+}
+`.trimStart());
+  const sha1 = commit('Initial: auth + api + tests');
+
+  // Index the repo.
+  const store = new Store(DB);
+  try {
+    const idx = new Indexer(store);
+    await idx.indexDirectory(REPO, { quiet: true });
+
+    // ── Symbol-mode preflight on validateToken ────────────────────────────
+    console.log('── Symbol-mode preflight ──');
+    const r = await preflight(store, { symbol: 'validateToken', workspace: REPO });
+    assertEq(r.ok, true, 'preflight ok=true for known symbol');
+    assertEq(r.mode, 'symbol', 'mode=symbol');
+    assert(r.symbol?.name === 'validateToken', 'symbol.name === "validateToken"');
+    assert(Array.isArray(r.touchedSymbols) && r.touchedSymbols.length === 1,
+      'touchedSymbols length === 1');
+    assert(['low', 'medium', 'high'].includes(r.risk.overall),
+      'risk.overall is one of low/medium/high');
+    assert(r.risk.perSymbol.length === 1, 'risk.perSymbol has one entry');
+    assert(r.risk.perSymbol[0].topContributors.length > 0,
+      'risk top contributors are listed');
+    assert(r.likelyTests.length >= 1,
+      `likelyTests includes at least one test (got ${r.likelyTests.length})`);
+    const validateTokenTest = r.likelyTests.find(t =>
+      t.testSymbol.file.includes('auth.test'));
+    assert(validateTokenTest != null,
+      'likelyTests references the validateToken test file');
+
+    // The symbol is not route-exposed, no service impact expected directly.
+    // (loginHandler exposes /api/login but validateToken is the leaf.)
+
+    // ── Symbol-mode service impact preserves the real protocol (regression) ─
+    // The ContextPacket preview drops protocol; symbol-mode preflight used to
+    // hardcode 'http', mislabeling tRPC/gRPC/Kafka links. Inject a gRPC link
+    // into loginHandler and assert the protocol survives.
+    console.log('\n── Symbol-mode service impact protocol fidelity ──');
+    {
+      const raw = store.rawDb();
+      const handler = store.getDefinition('loginHandler')[0];
+      const caller = store.getDefinition('authenticate')[0];
+      assert(handler != null && caller != null, 'handler + caller symbols resolved');
+      const handlerFileId = store.getSymbolById(handler.id)!.fileId;
+      const callRes = raw.prepare(`
+        INSERT INTO service_calls
+          (file_id, symbol_id, protocol, method, raw_target, normalized_path,
+           framework, line, confidence, operation, service)
+        VALUES (?, ?, 'grpc', NULL, 'AuthService/Login', NULL, 'grpc', 0, 1.0, 'Login', 'AuthService')
+      `).run(handlerFileId, caller.id);
+      const callId = Number(callRes.lastInsertRowid);
+      // route_id NULL — serviceLinksForHandler LEFT-JOINs routes, and the
+      // protocol we assert on comes from service_links.protocol directly.
+      raw.prepare(`
+        INSERT INTO service_links
+          (call_id, route_id, caller_symbol_id, handler_symbol_id, protocol,
+           match_kind, confidence, evidence_json)
+        VALUES (?, NULL, ?, ?, 'grpc', 'manual', 0.9, '{}')
+      `).run(callId, caller.id, handler.id);
+
+      const pf = await preflight(store, { symbol: 'loginHandler', workspace: REPO });
+      assertEq(pf.ok, true, 'preflight ok=true for loginHandler');
+      const grpcInbound = pf.serviceImpact.inbound.find(i => i.protocol === 'grpc');
+      assert(grpcInbound != null,
+        `inbound gRPC link reports protocol=grpc (got ${JSON.stringify(pf.serviceImpact.inbound.map(i => i.protocol))})`);
+      assert(!pf.serviceImpact.inbound.some(i => i.protocol === 'http'),
+        'no inbound link is mislabeled as http');
+    }
+
+    // ── Missing-symbol preflight does NOT crash ───────────────────────────
+    console.log('\n── Missing-symbol preflight ──');
+    const miss = await preflight(store, { symbol: 'doesNotExist', workspace: REPO });
+    assertEq(miss.ok, false, 'preflight ok=false when symbol is missing');
+    assert(miss.warnings.length >= 1, 'preflight returns a warning when symbol is missing');
+    assertEq(miss.mode, 'symbol', 'mode=symbol on missing-symbol path');
+
+    // ── Range-mode preflight (uncommitted changes touching validateToken) ─
+    console.log('\n── Range-mode preflight ──');
+    // Edit validateToken (uncommitted change).
+    write('src/auth.ts', `
+export function validateToken(token: string): boolean {
+  // tightened: require non-empty AND minimum length of 12
+  if (!token) return false;
+  return token.length >= 12;
+}
+
+export function authenticate(req: { token: string }): boolean {
+  return validateToken(req.token);
+}
+`.trimStart());
+
+    const rr = await preflight(store, {
+      range: true, workspace: REPO,
+    });
+    assertEq(rr.ok, true, 'range preflight ok=true');
+    assertEq(rr.mode, 'range', 'mode=range');
+    assert(rr.range != null, 'range metadata is present');
+    assert(rr.touchedSymbols.length >= 1,
+      `touchedSymbols contains the changed function (got ${rr.touchedSymbols.length})`);
+    const touchedNames = rr.touchedSymbols.map(s => s.name);
+    assert(touchedNames.includes('validateToken'),
+      `touchedSymbols includes validateToken (got ${touchedNames.join(',')})`);
+    assert(rr.likelyTests.length >= 1,
+      'range preflight aggregates likelyTests from touched symbols');
+    // The risk.perSymbol entry for validateToken must exist.
+    const vt = rr.risk.perSymbol.find(p => p.symbol.name === 'validateToken');
+    assert(vt != null, 'risk.perSymbol contains validateToken');
+
+    // ── Output is bounded by maxSymbols / maxTests / maxHistory ───────────
+    const bounded = await preflight(store, {
+      range: true, workspace: REPO,
+      maxSymbols: 1, maxTests: 1, maxHistory: 1,
+    });
+    assert(bounded.touchedSymbols.length <= 1, 'bounded touchedSymbols ≤ 1');
+    assert(bounded.likelyTests.length <= 1, 'bounded likelyTests ≤ 1');
+    assert(bounded.history.length <= 1, 'bounded history ≤ 1');
+
+    // ── No-source-mutation invariant ─────────────────────────────────────
+    // preflight should never call into write helpers — the simplest check is
+    // that the on-disk auth.ts is still our (modified) content.
+    const onDisk = fs.readFileSync(path.join(REPO, 'src/auth.ts'), 'utf8');
+    assert(onDisk.includes('length >= 12'),
+      'preflight did not mutate the source under test');
+  } finally { store.close(); }
+  void sha1;
+
+  console.log('\n────────────────────────────');
+  console.log(`Passed: ${passed}   Failed: ${failed}`);
+  cleanup();
+  if (failed > 0) process.exit(1);
+}
+
+main().catch(err => {
+  console.error(err);
+  cleanup();
+  process.exit(1);
+});

package/tests/verify-roles.ts

@@ -0,0 +1,51 @@
+/**
+ * Post-scale verification: walk every produced DB and print
+ *   - schema_version
+ *   - file role breakdown
+ *   - top-3 symbols (and whether any are in a vendored path)
+ *
+ * This catches regressions in classification / project-first ranking
+ * that the scale-test invariants don't quite cover.
+ */
+
+import path from 'path';
+import fs from 'fs';
+import { Store } from '../src/db/store';
+
+const NAMES = ['helix', 'client-go', 'react', 'godot', 'linux', 'typescript', 'unreal', 'cbm'];
+
+function vendoredLooking(filePath: string): boolean {
+  const norm = filePath.replace(/\\/g, '/');
+  return /(^|\/)(vendor|vendored|thirdparty|third_party|external|node_modules)\//i.test(norm);
+}
+
+async function main(): Promise<void> {
+  console.log('\nSeer DB Role Verification\n===========================\n');
+  for (const name of NAMES) {
+    const dbPath = path.join(__dirname, 'outputs', 'dbs', `${name}.db`);
+    if (!fs.existsSync(dbPath)) { console.log(`  ${name.padEnd(12)} (no DB)`); continue; }
+    const s = Store.openReadOnly(dbPath);
+    try {
+      const schema = s.schemaInfo();
+      const stats = s.getStats();
+      const top3 = s.getTopSymbols(3);
+      const vendored = top3.filter(t => vendoredLooking(t.filePath));
+      const status = vendored.length === 0 ? 'OK' : `WARN ${vendored.length} top-3 vendored`;
+      console.log(`  ${name.padEnd(12)}`);
+      console.log(`    schema=${schema.dbVersion}/${schema.buildVersion}${schema.current ? ' ✓' : ' ⚠'}`);
+      console.log(`    files=${stats.files.toLocaleString()}  symbols=${stats.symbols.toLocaleString()}  edges=${stats.edges.toLocaleString()}`);
+      console.log(`    roles: project=${stats.roles?.project} vendor=${stats.roles?.vendor} generated=${stats.roles?.generated} test=${stats.roles?.test}`);
+      console.log(`    top3:`);
+      for (const t of top3) {
+        const rel = t.filePath.replace(/\\/g, '/').split('/').slice(-3).join('/');
+        const flag = vendoredLooking(t.filePath) ? ' ← VENDORED' : '';
+        console.log(`      ${t.name.padEnd(28)} pagerank=${t.pagerank.toFixed(5)}  ${rel}${flag}`);
+      }
+      console.log(`    => ${status}\n`);
+    } finally {
+      s.close();
+    }
+  }
+}
+
+main().catch(err => { console.error(err); process.exit(1); });

package/tests/worker-parity.ts

@@ -0,0 +1,286 @@
+/**
+ * Worker-parity test (Step 2 of parallel parsing).
+ *
+ * Verifies that parsing a file inside a worker_threads `Worker` produces
+ * byte-identical results to parsing the same file in-process via
+ * `parseFile()`. Also exercises the cached / too-large / io-error result
+ * kinds and clean shutdown.
+ *
+ * The worker is the compiled `dist/parser/worker.js` artifact — this test
+ * requires `npm run build` to have run first (the `test:worker-parity`
+ * package script chains them).
+ *
+ * Run with: npm run test:worker-parity
+ */
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+import { Worker } from 'worker_threads';
+import { parseFile, detectLanguage } from '../src/parser/index';
+import type { Language, FileExtraction } from '../src/types';
+import type { WorkerInput, WorkerOutput } from '../src/parser/worker';
+
+const FIXTURES_DIR        = path.join(__dirname, 'fixtures');
+const FIXTURES_TRACKCD    = path.join(__dirname, 'fixtures-trackcd');
+const WORKER_PATH         = path.join(__dirname, '..', 'dist', 'parser', 'worker.js');
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition: boolean, message: string): void {
+  if (condition) {
+    console.log(`  ✓ ${message}`);
+    passed++;
+  } else {
+    console.error(`  ✗ ${message}`);
+    failed++;
+  }
+}
+
+function sha256Short(content: string): string {
+  return crypto.createHash('sha256').update(content, 'utf8').digest('hex').slice(0, 16);
+}
+
+/** Walk a directory and collect all files (recursive). */
+function listFiles(dir: string): string[] {
+  const out: string[] = [];
+  if (!fs.existsSync(dir)) return out;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const p = path.join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...listFiles(p));
+    else out.push(p);
+  }
+  return out;
+}
+
+/**
+ * Canonicalize a FileExtraction for byte-equal comparison. JSON.stringify
+ * with sorted keys is enough here — the walker emits arrays in a
+ * deterministic traversal order so we don't need to sort them.
+ */
+function canon(obj: unknown): string {
+  return JSON.stringify(obj, (_k, v) => {
+    if (v && typeof v === 'object' && !Array.isArray(v)) {
+      const sorted: Record<string, unknown> = {};
+      for (const k of Object.keys(v as Record<string, unknown>).sort()) {
+        sorted[k] = (v as Record<string, unknown>)[k];
+      }
+      return sorted;
+    }
+    return v;
+  });
+}
+
+// ── Worker controller ────────────────────────────────────────────────────────
+
+interface PendingResolver {
+  resolve: (out: WorkerOutput) => void;
+  reject: (err: Error) => void;
+}
+
+class WorkerController {
+  private worker: Worker;
+  private pending = new Map<number, PendingResolver>();
+  private ready: Promise<void>;
+  private exitPromise: Promise<number>;
+  private exitCode: number | null = null;
+
+  constructor(workerPath: string) {
+    this.worker = new Worker(workerPath);
+    let readyResolve: () => void = () => {};
+    this.ready = new Promise<void>(r => { readyResolve = r; });
+    let exitResolve: (code: number) => void = () => {};
+    this.exitPromise = new Promise<number>(r => { exitResolve = r; });
+
+    this.worker.on('message', (msg: WorkerOutput) => {
+      if (msg.kind === 'ready') { readyResolve(); return; }
+      if (msg.kind === 'shutdown-ack') return; // we observe via 'exit'
+      const seq = (msg as { seq: number }).seq;
+      const pending = this.pending.get(seq);
+      if (!pending) {
+        console.error(`unexpected result for seq=${seq}: ${msg.kind}`);
+        return;
+      }
+      this.pending.delete(seq);
+      pending.resolve(msg);
+    });
+
+    this.worker.on('error', err => {
+      for (const [, p] of this.pending) p.reject(err);
+      this.pending.clear();
+    });
+
+    this.worker.on('exit', code => {
+      this.exitCode = code;
+      exitResolve(code);
+      const reason = new Error(`worker exited with code ${code}`);
+      for (const [, p] of this.pending) p.reject(reason);
+      this.pending.clear();
+    });
+  }
+
+  awaitReady(): Promise<void> { return this.ready; }
+  awaitExit(): Promise<number> { return this.exitPromise; }
+  getExitCode(): number | null { return this.exitCode; }
+
+  send(job: Extract<WorkerInput, { kind: 'parse' }>): Promise<WorkerOutput> {
+    return new Promise<WorkerOutput>((resolve, reject) => {
+      this.pending.set(job.seq, { resolve, reject });
+      this.worker.postMessage(job);
+    });
+  }
+
+  shutdown(): void {
+    this.worker.postMessage({ kind: 'shutdown' } satisfies WorkerInput);
+  }
+
+  terminate(): Promise<number> {
+    return this.worker.terminate();
+  }
+}
+
+// ── Run ──────────────────────────────────────────────────────────────────────
+
+async function run(): Promise<void> {
+  console.log('\nWorker Parity Test (Step 2)');
+  console.log('============================\n');
+
+  if (!fs.existsSync(WORKER_PATH)) {
+    console.error(`  ✗ ${WORKER_PATH} not found — run \`npm run build\` first.`);
+    process.exit(1);
+  }
+  console.log(`  worker: ${WORKER_PATH}`);
+
+  const ctrl = new WorkerController(WORKER_PATH);
+  await ctrl.awaitReady();
+  console.log('  worker ready\n');
+
+  // ── 1. Parity over every fixture ───────────────────────────────────────────
+  console.log('── Per-fixture parity (worker vs in-process parseFile) ──');
+
+  const all = [...listFiles(FIXTURES_DIR), ...listFiles(FIXTURES_TRACKCD)];
+  let seq = 0;
+  let perFixtureChecks = 0;
+  for (const abs of all) {
+    const lang = detectLanguage(abs);
+    if (!lang) continue;
+    perFixtureChecks++;
+    seq++;
+    const content = fs.readFileSync(abs, 'utf8');
+    const reference = await parseFile(content, abs, lang);
+    const result = await ctrl.send({
+      kind: 'parse', seq, abs, lang, expectedHash: null, maxFileBytes: 0,
+    });
+
+    const ok = reference !== null
+      && result.kind === 'parsed'
+      && canon((result as Extract<WorkerOutput, { kind: 'parsed' }>).extraction) === canon(reference);
+    if (!ok) {
+      console.error(`    seq=${seq} file=${path.relative(__dirname, abs)} kind=${result.kind}`);
+      if (result.kind === 'parsed' && reference !== null) {
+        // Print first 200 chars of diff for forensic value
+        const r = canon((result as Extract<WorkerOutput, { kind: 'parsed' }>).extraction);
+        const ref = canon(reference);
+        for (let i = 0; i < Math.min(r.length, ref.length); i++) {
+          if (r[i] !== ref[i]) {
+            console.error(`    first diff at char ${i}:`);
+            console.error(`      ref: …${ref.slice(Math.max(0, i - 40), i + 40)}…`);
+            console.error(`      got: …${r.slice(Math.max(0, i - 40), i + 40)}…`);
+            break;
+          }
+        }
+      }
+    }
+    assert(ok, `parity ${path.relative(__dirname, abs)}`);
+  }
+  console.log(`  (checked ${perFixtureChecks} fixtures)\n`);
+
+  // ── 2. Cached branch ───────────────────────────────────────────────────────
+  console.log('── Cached branch (expectedHash === actual hash → skip parse) ──');
+
+  // Pick a known fixture and exercise both cache-hit and cache-miss.
+  const tsFixture = path.join(FIXTURES_DIR, 'sample.ts');
+  if (fs.existsSync(tsFixture)) {
+    const content = fs.readFileSync(tsFixture, 'utf8');
+    const knownHash = sha256Short(content);
+
+    seq++;
+    const hit = await ctrl.send({
+      kind: 'parse', seq, abs: tsFixture, lang: 'typescript',
+      expectedHash: knownHash, maxFileBytes: 0,
+    });
+    assert(hit.kind === 'cached', `expectedHash matches → result.kind === 'cached'`);
+    if (hit.kind === 'cached') {
+      assert(hit.hash === knownHash, `cached result echoes the computed hash`);
+      assert(hit.lines > 0, `cached result reports line count`);
+      assert(hit.size > 0, `cached result reports byte size`);
+    }
+
+    seq++;
+    const miss = await ctrl.send({
+      kind: 'parse', seq, abs: tsFixture, lang: 'typescript',
+      expectedHash: 'deadbeefdeadbeef', maxFileBytes: 0,
+    });
+    assert(miss.kind === 'parsed', `expectedHash mismatch → result.kind === 'parsed'`);
+  }
+
+  // ── 3. Too-large branch ────────────────────────────────────────────────────
+  console.log('\n── Too-large branch (maxFileBytes < size) ──');
+
+  if (fs.existsSync(tsFixture)) {
+    seq++;
+    const big = await ctrl.send({
+      kind: 'parse', seq, abs: tsFixture, lang: 'typescript',
+      expectedHash: null, maxFileBytes: 1,
+    });
+    assert(big.kind === 'too-large', `maxFileBytes=1 → 'too-large'`);
+    if (big.kind === 'too-large') {
+      assert(big.size > 1, `too-large reports the actual size (${big.size}B > 1B cap)`);
+    }
+  }
+
+  // ── 4. IO-error branch ─────────────────────────────────────────────────────
+  console.log('\n── IO-error branch (path does not exist) ──');
+
+  seq++;
+  const ghost = await ctrl.send({
+    kind: 'parse', seq,
+    abs: path.join(os.tmpdir(), 'seer-worker-parity-nonexistent-' + Date.now() + '.ts'),
+    lang: 'typescript', expectedHash: null, maxFileBytes: 0,
+  });
+  assert(ghost.kind === 'io-error', `nonexistent path → 'io-error'`);
+
+  // ── 5. Worker is still alive after an io-error ─────────────────────────────
+  console.log('\n── Worker recovers from io-error (still parses next job) ──');
+
+  if (fs.existsSync(tsFixture)) {
+    seq++;
+    const after = await ctrl.send({
+      kind: 'parse', seq, abs: tsFixture, lang: 'typescript',
+      expectedHash: null, maxFileBytes: 0,
+    });
+    assert(after.kind === 'parsed', `worker still parses after an io-error`);
+  }
+
+  // ── 6. Clean shutdown ──────────────────────────────────────────────────────
+  console.log('\n── Clean shutdown ──');
+  ctrl.shutdown();
+  const code = await ctrl.awaitExit();
+  assert(code === 0, `worker exits with code 0 after shutdown (got ${code})`);
+
+  // ── Done ───────────────────────────────────────────────────────────────────
+  console.log('\n══════════════════════════════════════════════════════════════');
+  console.log(`  Worker-parity results: ${passed} passed, ${failed} failed`);
+  if (failed > 0) {
+    console.error('\n  WORKER-PARITY TESTS FAILED\n');
+    process.exit(1);
+  } else {
+    console.log('\n  All worker-parity tests passed! ✓\n');
+  }
+}
+
+run().catch(err => {
+  console.error('worker-parity test threw:', err);
+  process.exit(1);
+});