ultra-builder-pro-cli 0.13.0 → 0.15.0

package/orchestrator/tests/auto-merge.test.cjs

@@ -1,216 +0,0 @@
-'use strict';
-
-// Phase 8B.4 — Auto-merge back.
-//
-// autoMerge({ repoRoot, worktreePath, baseBranch, sid, task_id, db }):
-//   • no changes (session_sha === base_sha)        → { merged:false, reason:'no_changes' }
-//   • clean merge                                   → { merged:true }  + merged_back event
-//   • conflict                                      → { merged:false, reason:'conflict', conflict_paths[] }
-//                                                     + merge_conflict event + merge --abort
-// closeSession({ autoMerge:true }) integration:
-//   • autoMerge=true + conflict → worktree kept on disk (for human to resolve)
-//   • autoMerge=false (default) → behavior unchanged (Phase 4.5 / 5 / 7 tests)
-
-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 { execFileSync } = require('node:child_process');
-
-const { initStateDb, closeStateDb } = require('../../mcp-server/lib/state-db.cjs');
-const ops = require('../../mcp-server/lib/state-ops.cjs');
-const wtmgr = require('../worktree-manager.cjs');
-const autoMerge = require('../auto-merge.cjs');
-const runner = require('../session-runner.cjs');
-
-function mkRepo() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-automerge-'));
-  execFileSync('git', ['init', '-q', '-b', 'main'], { cwd: dir });
-  execFileSync('git', ['config', 'user.email', 'test@ubp.dev'], { cwd: dir });
-  execFileSync('git', ['config', 'user.name', 'ubp-test'], { cwd: dir });
-  fs.writeFileSync(path.join(dir, 'seed.md'), '# seed\n');
-  // The DB and worktree dirs live under .ultra/ — keep them out of git so
-  // `git status` in conflict tests isn't polluted by untracked test artifacts.
-  fs.writeFileSync(path.join(dir, '.gitignore'), '.ultra/\n');
-  execFileSync('git', ['add', '-A'], { cwd: dir });
-  execFileSync('git', ['commit', '-q', '-m', 'seed'], { cwd: dir });
-  return dir;
-}
-
-function mkDb(repoRoot) {
-  const dbPath = path.join(repoRoot, '.ultra', 'state.db');
-  fs.mkdirSync(path.dirname(dbPath), { recursive: true });
-  const { db } = initStateDb(dbPath);
-  return db;
-}
-
-function commitInWorktree(wtPath, filename, content, msg = 'session change') {
-  fs.writeFileSync(path.join(wtPath, filename), content);
-  execFileSync('git', ['add', '-A'], { cwd: wtPath });
-  execFileSync('git', ['-c', 'user.email=s@ubp.dev', '-c', 'user.name=s-ubp',
-    'commit', '-q', '-m', msg], { cwd: wtPath });
-  return execFileSync('git', ['rev-parse', 'HEAD'], { cwd: wtPath, stdio: ['ignore', 'pipe', 'pipe'] })
-    .toString().trim();
-}
-
-function cleanup(repoRoot, db) {
-  try { if (db) closeStateDb(db); } catch (_) { /* best-effort */ }
-  try { fs.rmSync(repoRoot, { recursive: true, force: true }); } catch (_) { /* best-effort */ }
-}
-
-// ─── autoMerge pure function ──────────────────────────────────────────────
-
-test('autoMerge: no session commits → merged:false reason:no_changes', () => {
-  const repo = mkRepo();
-  try {
-    const { worktree_path } = wtmgr.allocate({ repoRoot: repo, sid: 's-noop' });
-    const r = autoMerge.autoMerge({
-      repoRoot: repo, worktreePath: worktree_path,
-      baseBranch: 'main', sid: 's-noop',
-    });
-    assert.equal(r.merged, false);
-    assert.equal(r.reason, 'no_changes');
-  } finally { cleanup(repo); }
-});
-
-test('autoMerge: 3 slices with independent files → all merged back to main', () => {
-  const repo = mkRepo();
-  const db = mkDb(repo);
-  try {
-    for (const sid of ['s1', 's2', 's3']) {
-      ops.createTask(db, { id: sid, title: sid, type: 'feature', priority: 'P2' });
-    }
-    const shas = {};
-    for (const [sid, file] of [['s1', 'a.txt'], ['s2', 'b.txt'], ['s3', 'c.txt']]) {
-      const { worktree_path } = wtmgr.allocate({ repoRoot: repo, sid });
-      shas[sid] = commitInWorktree(worktree_path, file, `${file}\n`);
-      const r = autoMerge.autoMerge({
-        repoRoot: repo, worktreePath: worktree_path,
-        baseBranch: 'main', sid, task_id: sid, db,
-      });
-      assert.equal(r.merged, true, `${sid} should merge`);
-      assert.equal(r.session_sha, shas[sid]);
-    }
-    assert.ok(fs.existsSync(path.join(repo, 'a.txt')));
-    assert.ok(fs.existsSync(path.join(repo, 'b.txt')));
-    assert.ok(fs.existsSync(path.join(repo, 'c.txt')));
-    const { events } = ops.subscribeEventsSince(db, 0);
-    const merged = events.filter((e) => e.type === 'merged_back');
-    assert.equal(merged.length, 3);
-  } finally { cleanup(repo, db); }
-});
-
-test('autoMerge: 2 slices on same file → first merges, second conflict + event', () => {
-  const repo = mkRepo();
-  const db = mkDb(repo);
-  try {
-    ops.createTask(db, { id: 'cf1', title: 'cf1', type: 'feature', priority: 'P2' });
-    ops.createTask(db, { id: 'cf2', title: 'cf2', type: 'feature', priority: 'P2' });
-    const { worktree_path: w1 } = wtmgr.allocate({ repoRoot: repo, sid: 'cf1' });
-    const { worktree_path: w2 } = wtmgr.allocate({ repoRoot: repo, sid: 'cf2' });
-    commitInWorktree(w1, 'conflict.txt', 'version-A\n');
-    commitInWorktree(w2, 'conflict.txt', 'version-B\n');
-
-    const r1 = autoMerge.autoMerge({
-      repoRoot: repo, worktreePath: w1, baseBranch: 'main', sid: 'cf1', task_id: 'cf1', db,
-    });
-    assert.equal(r1.merged, true);
-    const r2 = autoMerge.autoMerge({
-      repoRoot: repo, worktreePath: w2, baseBranch: 'main', sid: 'cf2', task_id: 'cf2', db,
-    });
-    assert.equal(r2.merged, false);
-    assert.equal(r2.reason, 'conflict');
-    assert.ok(Array.isArray(r2.conflict_paths));
-    assert.ok(r2.conflict_paths.includes('conflict.txt'));
-
-    // main HEAD rolled back to r1's merge commit, not mid-conflict
-    const status = execFileSync('git', ['status', '--porcelain'], {
-      cwd: repo, stdio: ['ignore', 'pipe', 'pipe'],
-    }).toString();
-    assert.equal(status.trim(), '', 'working tree must be clean after abort');
-
-    const { events } = ops.subscribeEventsSince(db, 0);
-    const conflict = events.find((e) => e.type === 'merge_conflict');
-    assert.ok(conflict, 'merge_conflict event expected');
-    assert.deepEqual(conflict.payload.conflict_paths, ['conflict.txt']);
-  } finally { cleanup(repo, db); }
-});
-
-// ─── closeSession integration ─────────────────────────────────────────────
-
-test('closeSession autoMerge=true + clean merge → worktree removed', () => {
-  const repo = mkRepo();
-  const db = mkDb(repo);
-  try {
-    ops.createTask(db, { id: 'cs-clean', title: 'x', type: 'feature', priority: 'P2' });
-    const handle = runner.spawnSession({
-      db, repoRoot: repo,
-      task_id: 'cs-clean', runtime: 'claude',
-      command: process.execPath, args: ['-e', 'process.exit(0)'],
-    });
-    // Simulate agent commit inside worktree
-    commitInWorktree(handle.worktree_path, 'new.txt', 'hi\n');
-    // Wait for child to exit so closeSession can kill cleanly (it already did)
-    if (handle.process) { try { handle.process.kill('SIGTERM'); } catch (_) { /* noop */ } }
-
-    const result = runner.closeSession(
-      { db, repoRoot: repo, sid: handle.sid },
-      { autoMerge: true, mergeBaseBranch: 'main' },
-    );
-    assert.equal(result.merge && result.merge.merged, true);
-    assert.equal(fs.existsSync(handle.worktree_path), false, 'clean merge → worktree removed');
-  } finally { cleanup(repo, db); }
-});
-
-test('closeSession autoMerge=true + conflict → worktree kept', () => {
-  const repo = mkRepo();
-  const db = mkDb(repo);
-  try {
-    ops.createTask(db, { id: 'cs-cflict', title: 'x', type: 'feature', priority: 'P2' });
-
-    // Spawn FIRST so the worktree forks at seed commit (before main diverges).
-    const handle = runner.spawnSession({
-      db, repoRoot: repo,
-      task_id: 'cs-cflict', runtime: 'claude',
-      command: process.execPath, args: ['-e', 'process.exit(0)'],
-    });
-    // Advance main with a conflicting version of shared.txt.
-    fs.writeFileSync(path.join(repo, 'shared.txt'), 'main-version\n');
-    execFileSync('git', ['add', '-A'], { cwd: repo });
-    execFileSync('git', ['commit', '-q', '-m', 'main change'], { cwd: repo });
-    // Session worktree forks off seed and writes its own version of the same file.
-    commitInWorktree(handle.worktree_path, 'shared.txt', 'session-version\n');
-
-    const result = runner.closeSession(
-      { db, repoRoot: repo, sid: handle.sid },
-      { autoMerge: true, mergeBaseBranch: 'main' },
-    );
-    assert.equal(result.merge && result.merge.merged, false);
-    assert.equal(result.merge.reason, 'conflict');
-    assert.ok(fs.existsSync(handle.worktree_path), 'conflict → worktree preserved for resolution');
-  } finally { cleanup(repo, db); }
-});
-
-test('closeSession autoMerge=false (default) → no merge, legacy behavior', () => {
-  const repo = mkRepo();
-  const db = mkDb(repo);
-  try {
-    ops.createTask(db, { id: 'cs-off', title: 'x', type: 'feature', priority: 'P2' });
-    const handle = runner.spawnSession({
-      db, repoRoot: repo,
-      task_id: 'cs-off', runtime: 'claude',
-      command: process.execPath, args: ['-e', 'process.exit(0)'],
-    });
-    commitInWorktree(handle.worktree_path, 'n.txt', 'x\n');
-
-    const result = runner.closeSession(
-      { db, repoRoot: repo, sid: handle.sid },
-      {}, // autoMerge not set
-    );
-    assert.equal(result.merge, undefined, 'no merge when opt-in disabled');
-    assert.equal(fs.existsSync(handle.worktree_path), false, 'worktree removed normally');
-    // main must still be at seed (no merge happened)
-    assert.equal(fs.existsSync(path.join(repo, 'n.txt')), false);
-  } finally { cleanup(repo, db); }
-});

package/orchestrator/tests/daemon.test.cjs

@@ -1,311 +0,0 @@
-'use strict';
-
-// Phase 5.4 — Orchestrator daemon:
-//   • routeTask: pure function — complexity_hint + availableRuntimes → runtime
-//   • runDaemon: poll loop that spawns pending tasks, respects admission +
-//     circuit breaker, and shuts down gracefully via stop().
-
-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 { execFileSync } = require('node:child_process');
-
-const { initStateDb, closeStateDb } = require('../../mcp-server/lib/state-db.cjs');
-const ops = require('../../mcp-server/lib/state-ops.cjs');
-const daemon = require('../daemon.cjs');
-const RETIRED_RUNTIME = ['gem', 'ini'].join('');
-
-const LONG_SLEEP_CMD = process.execPath;
-const LONG_SLEEP_ARGS = ['-e', 'setInterval(() => {}, 60000);'];
-
-function mkRepo() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-daemon-repo-'));
-  execFileSync('git', ['init', '-q'], { cwd: dir });
-  execFileSync('git', ['config', 'user.email', 'test@ubp.dev'], { cwd: dir });
-  execFileSync('git', ['config', 'user.name', 'ubp-test'], { cwd: dir });
-  fs.writeFileSync(path.join(dir, 'README.md'), '# test\n');
-  execFileSync('git', ['add', '-A'], { cwd: dir });
-  execFileSync('git', ['commit', '-q', '-m', 'seed'], { cwd: dir });
-  return dir;
-}
-
-function mkDb(repoRoot) {
-  const { db } = initStateDb(path.join(repoRoot, '.ultra', 'state.db'));
-  return db;
-}
-
-function cleanup(repoRoot, db, handle) {
-  if (handle) {
-    try { handle.stop(); } catch (_) { /* ignore */ }
-  }
-  // Kill any stray children spawned by the daemon.
-  try {
-    const rows = db.prepare("SELECT pid FROM sessions WHERE pid IS NOT NULL AND status = 'running'").all();
-    for (const r of rows) {
-      try { process.kill(r.pid, 'SIGKILL'); } catch (_) { /* ignore */ }
-    }
-  } catch (_) { /* ignore */ }
-  try { closeStateDb(db); } catch (_) { /* ignore */ }
-  try { fs.rmSync(repoRoot, { recursive: true, force: true }); } catch (_) { /* ignore */ }
-}
-
-// ─── routeTask ────────────────────────────────────────────────────────────
-
-test('routeTask: haiku hint prefers cheap runtimes', () => {
-  const runtime = daemon.routeTask(
-    { id: 't', complexity_hint: 'haiku' },
-    ['claude', 'opencode', 'codex'],
-  );
-  assert.equal(runtime, 'opencode');
-});
-
-test('routeTask: opus hint prefers strong runtimes', () => {
-  const runtime = daemon.routeTask(
-    { id: 't', complexity_hint: 'opus' },
-    ['claude', 'opencode', 'codex'],
-  );
-  assert.ok(['claude', 'codex'].includes(runtime), `got ${runtime}`);
-});
-
-test('routeTask: sonnet hint middle-ground', () => {
-  const runtime = daemon.routeTask(
-    { id: 't', complexity_hint: 'sonnet' },
-    ['claude', 'opencode', 'codex'],
-  );
-  assert.ok(['claude', 'codex', 'opencode'].includes(runtime));
-});
-
-test('routeTask: respects availability constraint', () => {
-  const runtime = daemon.routeTask(
-    { id: 't', complexity_hint: 'opus' },
-    ['opencode'],
-  );
-  // Prefers claude/codex but those aren't available → fall back to any.
-  assert.equal(runtime, 'opencode');
-});
-
-test('routeTask: no hint skips unsupported runtimes', () => {
-  const runtime = daemon.routeTask({ id: 't' }, [RETIRED_RUNTIME, 'claude']);
-  assert.equal(runtime, 'claude');
-});
-
-test('routeTask: no runtimes available → null', () => {
-  assert.equal(daemon.routeTask({ id: 't' }, []), null);
-});
-
-// ─── runDaemon ────────────────────────────────────────────────────────────
-
-test('runDaemon spawns pending task within pollMs window', async () => {
-  const repoRoot = mkRepo();
-  const db = mkDb(repoRoot);
-  let handle;
-  try {
-    ops.createTask(db, { id: 'd-1', title: 'pending target', type: 'feature', priority: 'P1' });
-    handle = daemon.runDaemon({
-      db, repoRoot,
-      runtimes: ['claude'],
-      pollMs: 50,
-      command: LONG_SLEEP_CMD,
-      commandArgs: LONG_SLEEP_ARGS,
-    });
-
-    // Wait up to 500ms for the daemon to pick up the task.
-    const start = Date.now();
-    let spawned = null;
-    while (Date.now() - start < 500) {
-      const sessions = db.prepare("SELECT * FROM sessions WHERE task_id = 'd-1'").all();
-      if (sessions.length > 0) { spawned = sessions[0]; break; }
-      await new Promise((r) => setTimeout(r, 25));
-    }
-    assert.ok(spawned, 'daemon should have spawned a session within 500ms');
-    assert.equal(spawned.status, 'running');
-    assert.equal(spawned.runtime, 'claude');
-  } finally {
-    cleanup(repoRoot, db, handle);
-  }
-});
-
-test('runDaemon skips tripped tasks', async () => {
-  const repoRoot = mkRepo();
-  const db = mkDb(repoRoot);
-  let handle;
-  try {
-    ops.createTask(db, { id: 'd-trip', title: 'tripped', type: 'feature', priority: 'P1' });
-    for (let i = 0; i < 3; i += 1) ops.recordTaskFailure(db, 'd-trip', { reason: 'x' });
-    assert.equal(ops.isCircuitTripped(db, 'd-trip'), true);
-
-    handle = daemon.runDaemon({
-      db, repoRoot,
-      runtimes: ['claude'],
-      pollMs: 50,
-      command: LONG_SLEEP_CMD,
-      commandArgs: LONG_SLEEP_ARGS,
-    });
-    await new Promise((r) => setTimeout(r, 300));
-    const sessions = db.prepare("SELECT * FROM sessions WHERE task_id = 'd-trip'").all();
-    assert.equal(sessions.length, 0, 'tripped task must not be spawned');
-  } finally {
-    cleanup(repoRoot, db, handle);
-  }
-});
-
-test('runDaemon does not double-spawn same task', async () => {
-  const repoRoot = mkRepo();
-  const db = mkDb(repoRoot);
-  let handle;
-  try {
-    ops.createTask(db, { id: 'd-once', title: 'single', type: 'feature', priority: 'P1' });
-    handle = daemon.runDaemon({
-      db, repoRoot,
-      runtimes: ['claude'],
-      pollMs: 30,
-      command: LONG_SLEEP_CMD,
-      commandArgs: LONG_SLEEP_ARGS,
-    });
-    await new Promise((r) => setTimeout(r, 400));
-    const sessions = db.prepare("SELECT * FROM sessions WHERE task_id = 'd-once'").all();
-    assert.equal(sessions.length, 1, 'daemon should not double-spawn');
-  } finally {
-    cleanup(repoRoot, db, handle);
-  }
-});
-
-test('runDaemon.stop() halts polling; existing children stay alive', async () => {
-  const repoRoot = mkRepo();
-  const db = mkDb(repoRoot);
-  let handle;
-  try {
-    ops.createTask(db, { id: 'd-stop', title: 'stop test', type: 'feature', priority: 'P1' });
-    handle = daemon.runDaemon({
-      db, repoRoot,
-      runtimes: ['claude'],
-      pollMs: 30,
-      command: LONG_SLEEP_CMD,
-      commandArgs: LONG_SLEEP_ARGS,
-    });
-    // Wait for spawn.
-    await new Promise((r) => setTimeout(r, 200));
-    const before = db.prepare("SELECT pid FROM sessions WHERE task_id = 'd-stop'").all();
-    assert.equal(before.length, 1);
-    const childPid = before[0].pid;
-
-    handle.stop();
-    // After stop: child still alive, no new spawn for a fresh task.
-    ops.createTask(db, { id: 'd-after-stop', title: 'after stop', type: 'feature', priority: 'P1' });
-    await new Promise((r) => setTimeout(r, 200));
-    const afterStop = db.prepare("SELECT * FROM sessions WHERE task_id = 'd-after-stop'").all();
-    assert.equal(afterStop.length, 0, 'no new spawns after stop');
-
-    try { process.kill(childPid, 0); } catch (err) {
-      assert.fail(`child ${childPid} should still be alive after daemon stop: ${err.message}`);
-    }
-  } finally {
-    cleanup(repoRoot, db, handle);
-  }
-});
-
-test('runDaemon branchScoped=true only spawns tasks matching cwd branch tag', async () => {
-  const repoRoot = mkRepo();
-  const db = mkDb(repoRoot);
-  let handle;
-  try {
-    // Normalize to a known branch name so the test doesn't depend on
-    // the dev machine's git init.defaultBranch config.
-    execFileSync('git', ['checkout', '-q', '-B', 'main'], { cwd: repoRoot });
-    ops.createTask(db, { id: 'd-branch-match', title: 'main task', type: 'feature', priority: 'P1', tag: 'main' });
-    ops.createTask(db, { id: 'd-branch-other', title: 'other task', type: 'feature', priority: 'P1', tag: 'feat-other' });
-    handle = daemon.runDaemon({
-      db, repoRoot,
-      runtimes: ['claude'],
-      pollMs: 50,
-      command: LONG_SLEEP_CMD,
-      commandArgs: LONG_SLEEP_ARGS,
-      branchScoped: true,
-    });
-    await new Promise((r) => setTimeout(r, 300));
-    const match = db.prepare("SELECT * FROM sessions WHERE task_id = 'd-branch-match'").all();
-    const other = db.prepare("SELECT * FROM sessions WHERE task_id = 'd-branch-other'").all();
-    assert.equal(match.length, 1, 'current-branch task must spawn');
-    assert.equal(other.length, 0, 'other-branch task must stay pending');
-  } finally {
-    cleanup(repoRoot, db, handle);
-  }
-});
-
-test('runDaemon applies complexity_hint route', async () => {
-  const repoRoot = mkRepo();
-  const db = mkDb(repoRoot);
-  let handle;
-  try {
-    ops.createTask(db, {
-      id: 'd-opus', title: 'opus task', type: 'architecture', priority: 'P0',
-      complexity_hint: 'opus',
-    });
-    handle = daemon.runDaemon({
-      db, repoRoot,
-      runtimes: ['claude', 'opencode'],
-      pollMs: 50,
-      command: LONG_SLEEP_CMD,
-      commandArgs: LONG_SLEEP_ARGS,
-    });
-    await new Promise((r) => setTimeout(r, 300));
-    const sessions = db.prepare("SELECT * FROM sessions WHERE task_id = 'd-opus'").all();
-    assert.equal(sessions.length, 1);
-    // opus should prefer claude over opencode.
-    assert.equal(sessions[0].runtime, 'claude');
-  } finally {
-    cleanup(repoRoot, db, handle);
-  }
-});
-
-test('maintainState consumes spec changes with a durable cursor', () => {
-  const repoRoot = mkRepo();
-  const db = mkDb(repoRoot);
-  try {
-    ops.createTask(db, {
-      id: 'maintain-stale', title: 'stale target', type: 'feature', priority: 'P1',
-      trace_to: '.ultra/specs/product.md#daily-change',
-    });
-    ops.appendEvent(db, {
-      type: 'spec_changed', payload: { sections: ['.ultra/specs/product.md#daily-change'] },
-    });
-    const first = daemon.maintainState({ db, repoRoot });
-    assert.equal(first.staleness.processed, 1);
-    assert.equal(ops.readTask(db, 'maintain-stale').stale, true);
-    const second = daemon.maintainState({ db, repoRoot });
-    assert.equal(second.staleness.processed, 0);
-  } finally {
-    cleanup(repoRoot, db);
-  }
-});
-
-test('runDaemon performs crash recovery before dispatch polling', async () => {
-  const repoRoot = mkRepo();
-  const db = mkDb(repoRoot);
-  let handle;
-  try {
-    ops.createTask(db, { id: 'recover-boot', title: 'recover boot', type: 'bugfix', priority: 'P0' });
-    ops.updateTaskStatus(db, 'recover-boot', 'in_progress');
-    ops.createSession(db, {
-      sid: 'dead-session', task_id: 'recover-boot', runtime: 'claude', pid: 999999,
-      worktree_path: '/tmp/dead-worktree', artifact_dir: '/tmp/dead-artifact', lease_seconds: 1,
-    });
-    db.prepare(
-      "UPDATE sessions SET heartbeat_at = '2000-01-01T00:00:00.000Z', lease_expires_at = '2000-01-01T00:00:00.000Z' WHERE sid = 'dead-session'",
-    ).run();
-
-    handle = daemon.runDaemon({
-      db, repoRoot, runtimes: ['claude'], pollMs: 50,
-      command: LONG_SLEEP_CMD, commandArgs: LONG_SLEEP_ARGS,
-    });
-    await new Promise((resolve) => setTimeout(resolve, 100));
-    const session = ops.readSession(db, 'dead-session');
-    assert.equal(session.status, 'crashed');
-    const failure = db.prepare("SELECT * FROM circuit_breaker WHERE task_id = 'recover-boot'").get();
-    assert.equal(failure.failure_count, 1);
-  } finally {
-    cleanup(repoRoot, db, handle);
-  }
-});

package/orchestrator/tests/dispatch-rules.test.cjs

@@ -1,124 +0,0 @@
-'use strict';
-
-// Phase 8B.1 — Dispatch rules declarative table.
-//
-// evaluate(ctx, rules) → { rule_id, action, runtime }.
-// DEFAULT_RULES must reproduce Phase 5.4 routeTask behavior (ROUTE_PREFERENCES
-// by complexity_hint, fall back to first available) so daemon.cjs keeps green.
-// New dimensions: breaker_state / deps_ready / wave conflict / custom rules.
-
-const { test } = require('node:test');
-const assert = require('node:assert/strict');
-
-const { evaluate, DEFAULT_RULES, ROUTE_PREFERENCES } = require('../dispatch-rules.cjs');
-const RETIRED_RUNTIME = ['gem', 'ini'].join('');
-
-function baseCtx(overrides = {}) {
-  return {
-    task: { id: 't1' },
-    deps_ready: true,
-    available_runtimes: ['claude', 'opencode', 'codex'],
-    breaker_state: 'ok',
-    wave: null,
-    ...overrides,
-  };
-}
-
-// ─── spawn_agent path (preference routing, 6 cases mirror routeTask) ──────
-
-test('evaluate: opus hint + all available → claude (preference head)', () => {
-  const d = evaluate(baseCtx({ task: { id: 't', complexity_hint: 'opus' } }));
-  assert.equal(d.action, 'spawn_agent');
-  assert.equal(d.runtime, 'claude');
-});
-
-test('evaluate: opus hint + only codex available → codex', () => {
-  const d = evaluate(baseCtx({
-    task: { id: 't', complexity_hint: 'opus' },
-    available_runtimes: ['codex', 'opencode'],
-  }));
-  assert.equal(d.runtime, 'codex');
-});
-
-test('evaluate: opus hint + preference exhausted → first available fallback', () => {
-  const d = evaluate(baseCtx({
-    task: { id: 't', complexity_hint: 'opus' },
-    available_runtimes: ['opencode'],
-  }));
-  assert.equal(d.action, 'spawn_agent');
-  assert.equal(d.runtime, 'opencode');
-});
-
-test('evaluate: haiku hint + all available → opencode (cheapest preference)', () => {
-  const d = evaluate(baseCtx({ task: { id: 't', complexity_hint: 'haiku' } }));
-  assert.equal(d.runtime, 'opencode');
-});
-
-test('evaluate: sonnet hint + all available → claude', () => {
-  const d = evaluate(baseCtx({ task: { id: 't', complexity_hint: 'sonnet' } }));
-  assert.equal(d.runtime, 'claude');
-});
-
-test('evaluate: retired runtimes are discarded before fallback routing', () => {
-  const d = evaluate(baseCtx({
-    task: { id: 't' },
-    available_runtimes: [RETIRED_RUNTIME, 'claude'],
-  }));
-  assert.equal(d.action, 'spawn_agent');
-  assert.equal(d.runtime, 'claude');
-});
-
-// ─── block / defer paths (new in 8B.1) ────────────────────────────────────
-
-test('evaluate: empty runtimes → block', () => {
-  const d = evaluate(baseCtx({ available_runtimes: [] }));
-  assert.equal(d.action, 'block');
-  assert.equal(d.runtime, null);
-});
-
-test('evaluate: breaker tripped → block (wins over spawn rules)', () => {
-  const d = evaluate(baseCtx({ breaker_state: 'tripped' }));
-  assert.equal(d.action, 'block');
-  assert.equal(d.rule_id, 'breaker-blocked');
-});
-
-test('evaluate: deps_ready=false → defer', () => {
-  const d = evaluate(baseCtx({ deps_ready: false }));
-  assert.equal(d.action, 'defer');
-  assert.equal(d.rule_id, 'deps-not-ready');
-});
-
-test('evaluate: serial wave already has running task → defer', () => {
-  const d = evaluate(baseCtx({
-    wave: { parallel: false, running_count: 1 },
-  }));
-  assert.equal(d.action, 'defer');
-  assert.equal(d.rule_id, 'wave-conflict');
-});
-
-// ─── composability: custom rules override defaults ────────────────────────
-
-test('evaluate: custom rules cannot select an unsupported runtime', () => {
-  const customRules = [
-    ...DEFAULT_RULES,
-    {
-      id: 'force-retired-runtime',
-      priority: 999,
-      when: () => true,
-      action: 'spawn_agent',
-      resolve: () => RETIRED_RUNTIME,
-    },
-  ];
-  const d = evaluate(baseCtx({ task: { id: 't', complexity_hint: 'opus' } }), customRules);
-  assert.equal(d.action, 'block');
-  assert.equal(d.runtime, null);
-  assert.equal(d.rule_id, 'force-retired-runtime');
-});
-
-// ─── ROUTE_PREFERENCES shape guard (regression: don't drift from Phase 5.4) ─
-
-test('DEFAULT_RULES preserves ROUTE_PREFERENCES shape', () => {
-  assert.deepEqual(Object.keys(ROUTE_PREFERENCES).sort(), ['haiku', 'opus', 'sonnet']);
-  assert.equal(ROUTE_PREFERENCES.opus[0], 'claude');
-  assert.equal(ROUTE_PREFERENCES.haiku[0], 'opencode');
-});