ultra-builder-pro-cli 0.14.0 → 0.15.0

package/mcp-server/lib/topo.test.cjs

@@ -1,158 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-
-const { computeWaves } = require('./topo.cjs');
-
-function makeTask(id, deps = []) {
-  return { id, deps };
-}
-
-function idsSet(ids) {
-  return new Set(ids);
-}
-
-function asWaveSets(waves) {
-  return waves.map(idsSet);
-}
-
-test('topo: empty array → empty waves and cycles', () => {
-  const r = computeWaves([]);
-  assert.deepEqual(r.waves, []);
-  assert.deepEqual(r.cycles, []);
-});
-
-test('topo: single task with no deps → single wave', () => {
-  const r = computeWaves([makeTask('A')]);
-  assert.deepEqual(r.waves, [['A']]);
-  assert.deepEqual(r.cycles, []);
-});
-
-test('topo fixture 1: linear chain A, B(A), C(B) → three serial waves', () => {
-  const r = computeWaves([
-    makeTask('A'),
-    makeTask('B', ['A']),
-    makeTask('C', ['B']),
-  ]);
-  assert.deepEqual(asWaveSets(r.waves), [idsSet(['A']), idsSet(['B']), idsSet(['C'])]);
-  assert.deepEqual(r.cycles, []);
-});
-
-test('topo fixture 2: fan-out A→{B,C} + independent D→E → 2 waves', () => {
-  const r = computeWaves([
-    makeTask('A'),
-    makeTask('B', ['A']),
-    makeTask('C', ['A']),
-    makeTask('D'),
-    makeTask('E', ['D']),
-  ]);
-  assert.equal(r.waves.length, 2);
-  assert.deepEqual(asWaveSets(r.waves), [
-    idsSet(['A', 'D']),
-    idsSet(['B', 'C', 'E']),
-  ]);
-  assert.deepEqual(r.cycles, []);
-});
-
-test('topo fixture 3: double diamond merges waves correctly', () => {
-  const r = computeWaves([
-    makeTask('A'),
-    makeTask('B', ['A']),
-    makeTask('C', ['A']),
-    makeTask('D', ['B', 'C']),
-    makeTask('E'),
-    makeTask('F', ['E']),
-    makeTask('G', ['E']),
-    makeTask('H', ['F', 'G']),
-  ]);
-  assert.deepEqual(asWaveSets(r.waves), [
-    idsSet(['A', 'E']),
-    idsSet(['B', 'C', 'F', 'G']),
-    idsSet(['D', 'H']),
-  ]);
-  assert.deepEqual(r.cycles, []);
-});
-
-test('topo fixture 4: 2-node cycle A↔B → cycle reported, no waves', () => {
-  const r = computeWaves([
-    makeTask('A', ['B']),
-    makeTask('B', ['A']),
-  ]);
-  assert.deepEqual(r.waves, []);
-  assert.equal(r.cycles.length, 1);
-  assert.deepEqual(idsSet(r.cycles[0]), idsSet(['A', 'B']));
-});
-
-test('topo fixture 5: two independent cycles A↔B and C↔D → both reported', () => {
-  const r = computeWaves([
-    makeTask('A', ['B']),
-    makeTask('B', ['A']),
-    makeTask('C', ['D']),
-    makeTask('D', ['C']),
-  ]);
-  assert.deepEqual(r.waves, []);
-  assert.equal(r.cycles.length, 2);
-  const cycleSets = r.cycles.map((c) => idsSet(c));
-  const expected = [idsSet(['A', 'B']), idsSet(['C', 'D'])];
-  for (const exp of expected) {
-    const found = cycleSets.some(
-      (s) => s.size === exp.size && [...s].every((x) => exp.has(x)),
-    );
-    assert.ok(found, `cycle ${[...exp].join(',')} not reported`);
-  }
-});
-
-test('topo: self-loop counts as cycle', () => {
-  const r = computeWaves([makeTask('A', ['A'])]);
-  assert.deepEqual(r.waves, []);
-  assert.equal(r.cycles.length, 1);
-  assert.deepEqual(r.cycles[0], ['A']);
-});
-
-test('topo: cycle plus acyclic tail — tail is waved, cycle isolated', () => {
-  const r = computeWaves([
-    makeTask('A', ['B']),
-    makeTask('B', ['A']),
-    makeTask('X'),
-    makeTask('Y', ['X']),
-  ]);
-  assert.deepEqual(asWaveSets(r.waves), [idsSet(['X']), idsSet(['Y'])]);
-  assert.equal(r.cycles.length, 1);
-  assert.deepEqual(idsSet(r.cycles[0]), idsSet(['A', 'B']));
-});
-
-test('topo: external deps (ids not in task_ids) are treated as satisfied', () => {
-  const r = computeWaves([makeTask('A', ['X'])]);
-  assert.deepEqual(r.waves, [['A']]);
-  assert.deepEqual(r.cycles, []);
-});
-
-test('topo: input order does not change wave membership', () => {
-  const tasks = [
-    makeTask('A'),
-    makeTask('B', ['A']),
-    makeTask('C', ['A']),
-    makeTask('D', ['B', 'C']),
-  ];
-  const r1 = computeWaves(tasks);
-  const r2 = computeWaves([...tasks].reverse());
-  assert.deepEqual(asWaveSets(r1.waves), asWaveSets(r2.waves));
-  assert.deepEqual(r1.cycles, r2.cycles);
-});
-
-test('topo: rejects non-array input', () => {
-  assert.throws(() => computeWaves(null), TypeError);
-  assert.throws(() => computeWaves({}), TypeError);
-});
-
-test('topo: 3-node cycle A→B→C→A surfaced intact', () => {
-  const r = computeWaves([
-    makeTask('A', ['C']),
-    makeTask('B', ['A']),
-    makeTask('C', ['B']),
-  ]);
-  assert.deepEqual(r.waves, []);
-  assert.equal(r.cycles.length, 1);
-  assert.deepEqual(idsSet(r.cycles[0]), idsSet(['A', 'B', 'C']));
-});

package/mcp-server/tests/circuit-breaker.test.cjs

@@ -1,125 +0,0 @@
-'use strict';
-
-// Phase 5.2 — Circuit breaker:
-// per-task consecutive failures ≥3 → trip; tripped tasks refused spawn.
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-const { initStateDb, closeStateDb } = require('../lib/state-db.cjs');
-const ops = require('../lib/state-ops.cjs');
-
-function freshDb() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-cb-'));
-  const file = path.join(dir, 'state.db');
-  const init = initStateDb(file);
-  return { dir, db: init.db };
-}
-
-function teardown(dir, db) {
-  try { closeStateDb(db); } catch (_) { /* ignore */ }
-  try { fs.rmSync(dir, { recursive: true, force: true }); } catch (_) { /* ignore */ }
-}
-
-function seedTask(db, id) {
-  ops.createTask(db, { id, title: 'cb target', type: 'feature', priority: 'P1' });
-  return id;
-}
-
-test('isCircuitTripped: unrecorded task → false', () => {
-  const { dir, db } = freshDb();
-  try {
-    seedTask(db, 'cb-1');
-    assert.equal(ops.isCircuitTripped(db, 'cb-1'), false);
-  } finally { teardown(dir, db); }
-});
-
-test('recordTaskFailure: 3 consecutive → trips + task_circuit_broken event', () => {
-  const { dir, db } = freshDb();
-  try {
-    seedTask(db, 'cb-2');
-    ops.recordTaskFailure(db, 'cb-2', { reason: 'test1' });
-    assert.equal(ops.isCircuitTripped(db, 'cb-2'), false);
-    ops.recordTaskFailure(db, 'cb-2', { reason: 'test2' });
-    assert.equal(ops.isCircuitTripped(db, 'cb-2'), false);
-    ops.recordTaskFailure(db, 'cb-2', { reason: 'test3' });
-    assert.equal(ops.isCircuitTripped(db, 'cb-2'), true);
-
-    const { events } = ops.subscribeEventsSince(db, { since_id: 0, limit: 500 });
-    const brokenEvents = events.filter((e) => e.type === 'task_circuit_broken' && e.task_id === 'cb-2');
-    assert.equal(brokenEvents.length, 1, 'circuit broken event should fire exactly once');
-    const failures = events.filter((e) => e.type === 'task_failure' && e.task_id === 'cb-2');
-    assert.equal(failures.length, 3);
-  } finally { teardown(dir, db); }
-});
-
-test('recordTaskFailure: 4th + 5th failure does not re-emit task_circuit_broken', () => {
-  const { dir, db } = freshDb();
-  try {
-    seedTask(db, 'cb-3');
-    for (let i = 0; i < 5; i += 1) {
-      ops.recordTaskFailure(db, 'cb-3', { reason: `test${i}` });
-    }
-    assert.equal(ops.isCircuitTripped(db, 'cb-3'), true);
-    const { events } = ops.subscribeEventsSince(db, { since_id: 0, limit: 500 });
-    const brokenEvents = events.filter((e) => e.type === 'task_circuit_broken' && e.task_id === 'cb-3');
-    assert.equal(brokenEvents.length, 1, 'should only emit on the trip transition');
-  } finally { teardown(dir, db); }
-});
-
-test('resetCircuitBreaker: clears count and tripped_at', () => {
-  const { dir, db } = freshDb();
-  try {
-    seedTask(db, 'cb-4');
-    ops.recordTaskFailure(db, 'cb-4', { reason: 'x' });
-    ops.recordTaskFailure(db, 'cb-4', { reason: 'x' });
-    ops.recordTaskFailure(db, 'cb-4', { reason: 'x' });
-    assert.equal(ops.isCircuitTripped(db, 'cb-4'), true);
-
-    ops.resetCircuitBreaker(db, 'cb-4');
-    assert.equal(ops.isCircuitTripped(db, 'cb-4'), false);
-
-    // Next failure starts count at 1, not accumulating pre-reset.
-    ops.recordTaskFailure(db, 'cb-4', { reason: 'x' });
-    assert.equal(ops.isCircuitTripped(db, 'cb-4'), false);
-    ops.recordTaskFailure(db, 'cb-4', { reason: 'x' });
-    assert.equal(ops.isCircuitTripped(db, 'cb-4'), false);
-  } finally { teardown(dir, db); }
-});
-
-test('admissionCheck: tripped task → can_spawn=false, recommended=blocked_by_breaker', () => {
-  const { dir, db } = freshDb();
-  try {
-    seedTask(db, 'cb-5');
-    for (let i = 0; i < 3; i += 1) ops.recordTaskFailure(db, 'cb-5', { reason: 'x' });
-
-    const verdict = ops.admissionCheck(db, 'cb-5');
-    assert.equal(verdict.can_spawn, false);
-    assert.equal(verdict.recommended_action, 'blocked_by_breaker');
-  } finally { teardown(dir, db); }
-});
-
-test('admissionCheck: reset after trip → can_spawn=true', () => {
-  const { dir, db } = freshDb();
-  try {
-    seedTask(db, 'cb-6');
-    for (let i = 0; i < 3; i += 1) ops.recordTaskFailure(db, 'cb-6', { reason: 'x' });
-    ops.resetCircuitBreaker(db, 'cb-6');
-    const verdict = ops.admissionCheck(db, 'cb-6');
-    assert.equal(verdict.can_spawn, true);
-  } finally { teardown(dir, db); }
-});
-
-test('custom threshold: fail_threshold=2 trips on 2nd failure', () => {
-  const { dir, db } = freshDb();
-  try {
-    seedTask(db, 'cb-7');
-    ops.recordTaskFailure(db, 'cb-7', { reason: 'x', fail_threshold: 2 });
-    assert.equal(ops.isCircuitTripped(db, 'cb-7'), false);
-    ops.recordTaskFailure(db, 'cb-7', { reason: 'x', fail_threshold: 2 });
-    assert.equal(ops.isCircuitTripped(db, 'cb-7'), true);
-  } finally { teardown(dir, db); }
-});

package/mcp-server/tests/commit-hash-flow.test.cjs

@@ -1,117 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { spawnSync } = require('node:child_process');
-
-const { initStateDb, closeStateDb } = require('../lib/state-db.cjs');
-const ops = require('../lib/state-ops.cjs');
-const projector = require('../lib/projector.cjs');
-
-function gitRun(cwd, args, opts = {}) {
-  const env = {
-    ...process.env,
-    GIT_AUTHOR_NAME: 'ubp-test',
-    GIT_AUTHOR_EMAIL: 'ubp@example.com',
-    GIT_COMMITTER_NAME: 'ubp-test',
-    GIT_COMMITTER_EMAIL: 'ubp@example.com',
-  };
-  const r = spawnSync('git', args, { cwd, encoding: 'utf8', env, ...opts });
-  if (r.status !== 0 && !opts.allowFail) {
-    throw new Error(`git ${args.join(' ')} failed: ${r.stderr || r.stdout}`);
-  }
-  return { code: r.status, stdout: r.stdout.trim(), stderr: r.stderr };
-}
-
-function tmpRepo() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-hash-flow-'));
-  gitRun(dir, ['init', '-q', '-b', 'main']);
-  gitRun(dir, ['config', 'commit.gpgsign', 'false']);
-  // Ignore the SQLite WAL/SHM sidecars so they don't appear as modifications.
-  fs.writeFileSync(path.join(dir, '.gitignore'), '.ultra/state.db-shm\n.ultra/state.db-wal\n');
-  return dir;
-}
-
-test('two-commit flow lands feat then chore with the right SHA in context md', () => {
-  const dir = tmpRepo();
-  try {
-    const dbPath = path.join(dir, '.ultra', 'state.db');
-    const init = initStateDb(dbPath);
-    const db = init.db;
-
-    // Task starts pending, no completion_commit yet.
-    ops.createTask(db, { id: 'task-h1', title: 'commit hash flow', type: 'feature', priority: 'P1' });
-    projector.projectAll(db, { rootDir: dir });
-
-    // Stage initial state and land the feat commit.
-    fs.writeFileSync(path.join(dir, 'src.js'), '// implementation\n');
-    gitRun(dir, ['add', '-A']);
-    gitRun(dir, ['commit', '-q', '-m', 'feat: task-h1 — commit hash flow']);
-
-    const featSha = gitRun(dir, ['rev-parse', 'HEAD']).stdout;
-
-    // Step 3 — update state.db with the new SHA.
-    ops.patchTask(db, 'task-h1', { completion_commit: featSha });
-
-    // Step 4 — re-project the context so its YAML carries the hash.
-    projector.projectContext(db, 'task-h1', {}, { rootDir: dir });
-
-    // Step 5 — chore commit captures the projection update.
-    gitRun(dir, ['add', '-A']);
-    gitRun(dir, ['commit', '-q', '-m', 'chore: record task-h1 completion hash']);
-
-    const log = gitRun(dir, ['log', '--oneline', '-2']).stdout.split('\n');
-    assert.match(log[0], /chore: record task-h1 completion hash/);
-    assert.match(log[1], /feat: task-h1 — commit hash flow/);
-
-    const ctxFile = path.join(dir, '.ultra', 'tasks', 'contexts', 'task-task-h1.md');
-    const ctxText = fs.readFileSync(ctxFile, 'utf8');
-    // The chore commit's working tree must reflect the recorded SHA.
-    const dbRow = db.prepare("SELECT completion_commit FROM tasks WHERE id = 'task-h1'").get();
-    assert.equal(dbRow.completion_commit, featSha);
-    // Header is regenerated; ensure projector wrote v4.5 + the right task_id.
-    assert.match(ctxText, /^---/);
-    assert.match(ctxText, /schema_version: 4\.5/);
-    assert.match(ctxText, /task_id: task-h1/);
-    closeStateDb(db);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('rerunning steps 4–5 against the same SHA produces an empty chore commit attempt', () => {
-  const dir = tmpRepo();
-  try {
-    const dbPath = path.join(dir, '.ultra', 'state.db');
-    const init = initStateDb(dbPath);
-    const db = init.db;
-    ops.createTask(db, { id: 'task-h2', title: 'idempotent', type: 'feature', priority: 'P1' });
-    projector.projectAll(db, { rootDir: dir });
-
-    fs.writeFileSync(path.join(dir, 'a.js'), '// a\n');
-    gitRun(dir, ['add', '-A']);
-    gitRun(dir, ['commit', '-q', '-m', 'feat: task-h2 — idempotent']);
-    const sha = gitRun(dir, ['rev-parse', 'HEAD']).stdout;
-    ops.patchTask(db, 'task-h2', { completion_commit: sha });
-    projector.projectContext(db, 'task-h2', {}, { rootDir: dir });
-    gitRun(dir, ['add', '-A']);
-    gitRun(dir, ['commit', '-q', '-m', 'chore: record task-h2 completion hash']);
-
-    // Idempotency: re-projecting the same db state must produce byte-identical
-    // context md (generated_at is derived from tasks.updated_at, not now()).
-    projector.projectContext(db, 'task-h2', {}, { rootDir: dir });
-    gitRun(dir, ['add', '-A']);
-    const status = gitRun(dir, ['status', '--porcelain']).stdout;
-    assert.equal(status, '', 're-projection of unchanged state must leave nothing to commit');
-
-    // A retry chore commit on an empty diff must be refused by git.
-    const r = gitRun(dir, ['commit', '-q', '-m', 'chore: idempotent retry'], { allowFail: true });
-    assert.notEqual(r.code, 0, 'a follow-up empty chore commit must fail');
-    closeStateDb(db);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});

package/mcp-server/tests/concurrency-update.test.cjs

@@ -1,96 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { Worker, isMainThread, workerData, parentPort } = require('node:worker_threads');
-
-const { initStateDb, openStateDb, closeStateDb } = require('../lib/state-db.cjs');
-const ops = require('../lib/state-ops.cjs');
-
-const WORKER_COUNT = 20;
-const TASKS_PER_WORKER = 50;
-
-function tmpDb() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-conc-up-'));
-  return { dir, file: path.join(dir, 'state.db') };
-}
-
-if (!isMainThread) {
-  const { dbPath, workerIdx, count } = workerData;
-  const db = openStateDb(dbPath);
-  const completed = [];
-  for (let i = 0; i < count; i++) {
-    const id = `w${workerIdx}-t${i}`;
-    ops.updateTaskStatus(db, id, 'in_progress');
-    ops.updateTaskStatus(db, id, 'completed');
-    completed.push(id);
-  }
-  closeStateDb(db);
-  parentPort.postMessage({ workerIdx, completed });
-} else {
-  test(`${WORKER_COUNT} workers × ${TASKS_PER_WORKER} updateTaskStatus — no loss, monotonic events`, async () => {
-    const { dir, file } = tmpDb();
-    try {
-      const init = initStateDb(file);
-      const db = init.db;
-
-      // Pre-seed disjoint tasks so workers never contend on the same row.
-      for (let w = 0; w < WORKER_COUNT; w++) {
-        for (let t = 0; t < TASKS_PER_WORKER; t++) {
-          ops.createTask(db, {
-            id: `w${w}-t${t}`,
-            title: `seed w${w}t${t}`,
-            type: 'feature',
-            priority: 'P3',
-          });
-        }
-      }
-      closeStateDb(db);
-
-      const expectedTasks = WORKER_COUNT * TASKS_PER_WORKER;
-      const results = await Promise.all(
-        Array.from({ length: WORKER_COUNT }, (_, idx) =>
-          new Promise((resolve, reject) => {
-            const w = new Worker(__filename, {
-              workerData: { dbPath: file, workerIdx: idx, count: TASKS_PER_WORKER },
-            });
-            w.on('message', resolve);
-            w.on('error', reject);
-            w.on('exit', (code) => {
-              if (code !== 0) reject(new Error(`worker ${idx} exit ${code}`));
-            });
-          }),
-        ),
-      );
-
-      const completedClaims = results.flatMap((r) => r.completed);
-      assert.equal(completedClaims.length, expectedTasks);
-
-      const verify = openStateDb(file);
-      const completedRows = verify.prepare("SELECT id, status FROM tasks WHERE status = @status").all({ status: 'completed' });
-      assert.equal(completedRows.length, expectedTasks, 'every task must end in completed');
-
-      // Each task contributes 1 task_created + 1 task_started + 1 task_completed = 3 events.
-      const totalEvents = verify.prepare('SELECT COUNT(*) AS n FROM events').get().n;
-      assert.equal(totalEvents, expectedTasks * 3, 'every transition must record an event');
-
-      const ids = verify.prepare('SELECT id FROM events ORDER BY id ASC').all().map((r) => r.id);
-      assert.equal(new Set(ids).size, ids.length, 'event ids must be unique');
-      for (let i = 1; i < ids.length; i++) {
-        assert.ok(ids[i] > ids[i - 1], 'event ids must be strictly monotonic');
-      }
-
-      const startedCount = verify.prepare("SELECT COUNT(*) AS n FROM events WHERE type = @type").get({ type: 'task_started' }).n;
-      const completedCount = verify.prepare("SELECT COUNT(*) AS n FROM events WHERE type = @type").get({ type: 'task_completed' }).n;
-      assert.equal(startedCount, expectedTasks, 'every task got a task_started event');
-      assert.equal(completedCount, expectedTasks, 'every task got a task_completed event');
-
-      closeStateDb(verify);
-    } finally {
-      fs.rmSync(dir, { recursive: true, force: true });
-    }
-  });
-}

package/mcp-server/tests/concurrency.test.cjs

@@ -1,112 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { Worker, isMainThread, workerData, parentPort } = require('node:worker_threads');
-
-const { initStateDb, openStateDb, closeStateDb } = require('../lib/state-db.cjs');
-
-function tmpDb() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-conc-'));
-  return { dir, file: path.join(dir, 'state.db') };
-}
-
-function appendEventRaw(db, type, payload) {
-  const stmt = db.prepare(
-    `INSERT INTO events (type, runtime, payload_json) VALUES (?, ?, ?)`,
-  );
-  return stmt.run(type, 'claude', JSON.stringify(payload)).lastInsertRowid;
-}
-
-function withRetry(fn, attempts = 3, baseMs = 25) {
-  let lastErr;
-  for (let i = 0; i < attempts; i++) {
-    try {
-      return fn();
-    } catch (err) {
-      if (!String(err.code || err.message).includes('SQLITE_BUSY')) throw err;
-      lastErr = err;
-      const wait = baseMs * Math.pow(2, i);
-      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, wait);
-    }
-  }
-  throw lastErr;
-}
-
-if (!isMainThread) {
-  const { dbPath, role, count, baseId } = workerData;
-  const db = openStateDb(dbPath);
-  const written = [];
-  for (let i = 0; i < count; i++) {
-    const id = withRetry(() =>
-      appendEventRaw(db, 'task_created', { role, baseId, i }),
-    );
-    written.push(Number(id));
-  }
-  closeStateDb(db);
-  parentPort.postMessage({ role, written });
-} else {
-  test('three concurrent writers append to events with no loss and monotonic id', async () => {
-    const { dir, file } = tmpDb();
-    try {
-      const init = initStateDb(file);
-      closeStateDb(init.db);
-
-      const roles = ['mcp', 'cli', 'daemon'];
-      const COUNT_PER_WORKER = 100;
-      const expected = roles.length * COUNT_PER_WORKER;
-
-      const results = await Promise.all(
-        roles.map(
-          (role, idx) =>
-            new Promise((resolve, reject) => {
-              const w = new Worker(__filename, {
-                workerData: {
-                  dbPath: file,
-                  role,
-                  count: COUNT_PER_WORKER,
-                  baseId: idx * COUNT_PER_WORKER,
-                },
-              });
-              w.on('message', (m) => resolve(m));
-              w.on('error', reject);
-              w.on('exit', (code) => {
-                if (code !== 0) reject(new Error(`worker ${role} exit ${code}`));
-              });
-            }),
-        ),
-      );
-
-      const verify = openStateDb(file);
-      const total = verify.prepare('SELECT COUNT(*) AS n FROM events').get().n;
-      assert.equal(total, expected, 'total event count must match');
-
-      const ids = verify.prepare('SELECT id FROM events ORDER BY id ASC').all().map((r) => r.id);
-      assert.equal(new Set(ids).size, ids.length, 'event ids must be unique');
-      for (let i = 1; i < ids.length; i++) {
-        assert.ok(ids[i] > ids[i - 1], 'event ids must be strictly monotonic');
-      }
-      const minId = ids[0];
-      const maxId = ids[ids.length - 1];
-      assert.ok(maxId - minId + 1 >= ids.length, 'sequence must not have collisions');
-
-      const perRole = verify
-        .prepare("SELECT json_extract(payload_json, '$.role') AS role, COUNT(*) AS n FROM events GROUP BY role")
-        .all();
-      for (const row of perRole) {
-        assert.equal(row.n, COUNT_PER_WORKER, `role ${row.role} count`);
-      }
-      closeStateDb(verify);
-
-      // Workers should each have observed their own row ids returned cleanly.
-      const collected = results.flatMap((r) => r.written);
-      assert.equal(collected.length, expected);
-      assert.equal(new Set(collected).size, expected, 'no duplicate ids reported by workers');
-    } finally {
-      fs.rmSync(dir, { recursive: true, force: true });
-    }
-  });
-}