ultra-builder-pro-cli 0.5.0

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

@@ -0,0 +1,125 @@
+'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

@@ -0,0 +1,117 @@
+'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

@@ -0,0 +1,96 @@
+'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

@@ -0,0 +1,112 @@
+'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 });
+    }
+  });
+}

package/mcp-server/tests/db-ops.test.cjs

@@ -0,0 +1,117 @@
+'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 Database = require('better-sqlite3');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const CLI = path.join(REPO_ROOT, 'ultra-tools', 'cli.cjs');
+const { initStateDb, closeStateDb } = require('../lib/state-db.cjs');
+const ops = require('../lib/state-ops.cjs');
+
+function tmpDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-db-ops-'));
+}
+
+function runCli(args) {
+  const r = spawnSync(process.execPath, [CLI, 'db', ...args], { encoding: 'utf8' });
+  const lines = r.stdout.trim().split('\n').filter(Boolean);
+  const last = lines[lines.length - 1] || '{}';
+  return { code: r.status, envelope: JSON.parse(last), stderr: r.stderr };
+}
+
+test('db checkpoint runs PRAGMA wal_checkpoint(TRUNCATE) and reports counters', () => {
+  const dir = tmpDir();
+  const dbPath = path.join(dir, 'state.db');
+  try {
+    closeStateDb(initStateDb(dbPath).db);
+    const { code, envelope } = runCli(['checkpoint', '--path', dbPath]);
+    assert.equal(code, 0);
+    assert.equal(envelope.ok, true);
+    assert.equal(typeof envelope.data.busy, 'number');
+    assert.equal(typeof envelope.data.checkpointed, 'number');
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('db vacuum reports reclaimed bytes after deleting rows', () => {
+  const dir = tmpDir();
+  const dbPath = path.join(dir, 'state.db');
+  try {
+    const init = initStateDb(dbPath);
+    for (let i = 0; i < 50; i++) {
+      ops.appendEvent(init.db, { type: 'task_created', task_id: `t-${i}` });
+    }
+    init.db.prepare('DELETE FROM events').run();
+    closeStateDb(init.db);
+
+    const { code, envelope } = runCli(['vacuum', '--path', dbPath]);
+    assert.equal(code, 0);
+    assert.equal(envelope.ok, true);
+    assert.ok(envelope.data.bytes_after <= envelope.data.bytes_before);
+    assert.equal(typeof envelope.data.reclaimed_bytes, 'number');
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('db integrity returns ok on a healthy database', () => {
+  const dir = tmpDir();
+  const dbPath = path.join(dir, 'state.db');
+  try {
+    closeStateDb(initStateDb(dbPath).db);
+    const { code, envelope } = runCli(['integrity', '--path', dbPath]);
+    assert.equal(code, 0);
+    assert.equal(envelope.ok, true);
+    assert.equal(envelope.data.integrity_ok, true);
+    assert.deepEqual(envelope.data.messages, ['ok']);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('db backup writes a file that opens independently with the same schema', () => {
+  const dir = tmpDir();
+  const dbPath = path.join(dir, 'state.db');
+  const backupPath = path.join(dir, 'snap.db');
+  try {
+    const init = initStateDb(dbPath);
+    ops.createTask(init.db, { id: 'b-1', title: 'backup', type: 'feature', priority: 'P1' });
+    closeStateDb(init.db);
+
+    const { code, envelope } = runCli(['backup', '--path', dbPath, '--to', backupPath]);
+    assert.equal(code, 0);
+    assert.equal(envelope.ok, true);
+    assert.equal(envelope.data.target, path.resolve(backupPath));
+    assert.ok(envelope.data.size_bytes > 0);
+
+    // Independently open the backup with a fresh connection
+    const snap = new Database(backupPath);
+    const v = snap.prepare("SELECT version FROM schema_version").get();
+    assert.equal(v.version, '4.5');
+    const t = snap.prepare("SELECT id FROM tasks WHERE id = 'b-1'").get();
+    assert.equal(t.id, 'b-1');
+    snap.close();
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('db <verb> on a missing database returns DB_NOT_FOUND with exit 2', () => {
+  const dir = tmpDir();
+  try {
+    const missing = path.join(dir, 'missing.db');
+    const { code, envelope } = runCli(['integrity', '--path', missing]);
+    assert.equal(code, 2);
+    assert.equal(envelope.ok, false);
+    assert.equal(envelope.error.code, 'DB_NOT_FOUND');
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});