ultra-builder-pro-cli 0.14.0 → 0.16.0

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');
-});

package/orchestrator/tests/parallel-orchestrator.test.cjs

@@ -1,233 +0,0 @@
-'use strict';
-
-// Phase 8B.2 — Parallel orchestrator: consumes execution-plan.json waves,
-// spawns sessions via session-runner, respects parallel vs serial per wave,
-// and emits wave/plan events.
-//
-// AC (PLAN §6 Phase 8B.2):
-//   - 10 independent-file tasks run in parallel
-//   - 2 tasks sharing a file serialize (plan-builder flips wave.parallel=false)
-//   - wave boundary strict: wave N+1 waits on wave N close
-//   - Phase 5.4 daemon tests stay green (no shared state)
-
-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 { buildPlan } = require('../planner/plan-builder.cjs');
-const parallelOrch = require('../parallel-orchestrator.cjs');
-
-// Test-Double rationale: we don't invoke real LLM runtimes; a short-lived
-// Node subprocess is enough to exercise spawn → exit → session.close flow.
-const NODE = process.execPath;
-function exitOk(delayMs = 20) { return ['-e', `setTimeout(() => process.exit(0), ${delayMs})`]; }
-function exitFail() { return ['-e', 'process.exit(1)']; }
-
-function mkRepo() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-parorch-'));
-  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, 'seed.md'), '# seed\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 seedTask(db, id, files_modified = [], deps = []) {
-  ops.createTask(db, {
-    id, title: `task ${id}`, type: 'feature', priority: 'P2',
-    complexity: 2, files_modified, deps,
-  });
-}
-
-function cleanup(repoRoot, db) {
-  try { closeStateDb(db); } catch (_) { /* best-effort */ }
-  try { fs.rmSync(repoRoot, { recursive: true, force: true }); } catch (_) { /* best-effort */ }
-}
-
-// ─── happy path ───────────────────────────────────────────────────────────
-
-test('runPlan: 1 wave 1 task → task.status=completed + plan_completed event', async () => {
-  const repo = mkRepo();
-  const db = mkDb(repo);
-  try {
-    seedTask(db, 't1');
-    const plan = buildPlan([{ id: 't1', deps: [], complexity: 2 }]);
-    await parallelOrch.runPlan({
-      db, repoRoot: repo, plan,
-      runtimes: ['claude'],
-      command: NODE, commandArgs: exitOk(),
-    });
-    const t = ops.readTask(db, 't1');
-    assert.equal(t.status, 'completed');
-    const { events } = ops.subscribeEventsSince(db, 0);
-    const types = events.map((e) => e.type);
-    assert.ok(types.includes('wave_started'));
-    assert.ok(types.includes('wave_completed'));
-    assert.ok(types.includes('plan_completed'));
-  } finally { cleanup(repo, db); }
-});
-
-test('runPlan: 2-wave 6-task independent files → all parallel, all completed', async () => {
-  const repo = mkRepo();
-  const db = mkDb(repo);
-  try {
-    const tasks = [];
-    for (let i = 1; i <= 3; i++) {
-      seedTask(db, `a${i}`, [`dir/a${i}.js`]);
-      tasks.push({ id: `a${i}`, deps: [], complexity: 1, files_modified: [`dir/a${i}.js`] });
-    }
-    for (let i = 1; i <= 3; i++) {
-      seedTask(db, `b${i}`, [`dir/b${i}.js`], [`a${i}`]);
-      tasks.push({ id: `b${i}`, deps: [`a${i}`], complexity: 1, files_modified: [`dir/b${i}.js`] });
-    }
-    const plan = buildPlan(tasks);
-    assert.equal(plan.waves.length, 2, 'topo should yield 2 waves');
-    assert.equal(plan.waves[0].parallel, true);
-    assert.equal(plan.waves[1].parallel, true);
-
-    await parallelOrch.runPlan({
-      db, repoRoot: repo, plan,
-      runtimes: ['claude'],
-      command: NODE, commandArgs: exitOk(30),
-    });
-    for (const t of tasks) {
-      assert.equal(ops.readTask(db, t.id).status, 'completed', `${t.id} should complete`);
-    }
-  } finally { cleanup(repo, db); }
-});
-
-test('runPlan: 2 tasks sharing one file → plan-builder flips parallel=false → serial exec', async () => {
-  const repo = mkRepo();
-  const db = mkDb(repo);
-  try {
-    seedTask(db, 'c1', ['shared.js']);
-    seedTask(db, 'c2', ['shared.js']);
-    const plan = buildPlan([
-      { id: 'c1', deps: [], complexity: 1, files_modified: ['shared.js'] },
-      { id: 'c2', deps: [], complexity: 1, files_modified: ['shared.js'] },
-    ]);
-    assert.equal(plan.waves[0].parallel, false, 'plan-builder should detect conflict');
-
-    await parallelOrch.runPlan({
-      db, repoRoot: repo, plan,
-      runtimes: ['claude'],
-      command: NODE, commandArgs: exitOk(30),
-    });
-    assert.equal(ops.readTask(db, 'c1').status, 'completed');
-    assert.equal(ops.readTask(db, 'c2').status, 'completed');
-  } finally { cleanup(repo, db); }
-});
-
-test('runPlan: wave boundary — wave 2 does not start until wave 1 closes', async () => {
-  const repo = mkRepo();
-  const db = mkDb(repo);
-  try {
-    seedTask(db, 'w1');
-    seedTask(db, 'w2', [], ['w1']);
-    const plan = buildPlan([
-      { id: 'w1', deps: [] },
-      { id: 'w2', deps: ['w1'] },
-    ]);
-    assert.equal(plan.waves.length, 2);
-
-    await parallelOrch.runPlan({
-      db, repoRoot: repo, plan,
-      runtimes: ['claude'],
-      command: NODE, commandArgs: exitOk(40),
-    });
-
-    const { events } = ops.subscribeEventsSince(db, 0);
-    const spawns = events.filter((e) => e.type === 'session_spawned');
-    const closes = events.filter((e) => e.type === 'session_closed');
-    const w2SpawnIdx = events.findIndex((e) => e.type === 'session_spawned' && e.task_id === 'w2');
-    const w1CloseIdx = events.findIndex((e) => e.type === 'session_closed' && e.task_id === 'w1');
-    assert.ok(w1CloseIdx > -1 && w2SpawnIdx > -1, 'both events should exist');
-    assert.ok(w1CloseIdx < w2SpawnIdx, 'w1 must close before w2 spawns');
-    assert.equal(spawns.length, 2);
-    assert.equal(closes.length, 2);
-  } finally { cleanup(repo, db); }
-});
-
-// ─── failure path ─────────────────────────────────────────────────────────
-
-test('runPlan: task exits non-zero → session crashed, task stays pending', async () => {
-  const repo = mkRepo();
-  const db = mkDb(repo);
-  try {
-    seedTask(db, 'fail1');
-    const plan = buildPlan([{ id: 'fail1', deps: [] }]);
-    await parallelOrch.runPlan({
-      db, repoRoot: repo, plan,
-      runtimes: ['claude'],
-      command: NODE, commandArgs: exitFail(),
-    });
-    const t = ops.readTask(db, 'fail1');
-    assert.equal(t.status, 'pending', 'failed task stays pending for recovery');
-    const { events } = ops.subscribeEventsSince(db, 0);
-    const crashed = events.find((e) => e.type === 'session_crashed');
-    assert.ok(crashed, 'session_crashed event expected');
-  } finally { cleanup(repo, db); }
-});
-
-test('runPlan: one task fails in wave, others still complete (no short-circuit)', async () => {
-  const repo = mkRepo();
-  const db = mkDb(repo);
-  try {
-    seedTask(db, 'ok1', ['f1.js']);
-    seedTask(db, 'bad1', ['f2.js']);
-    seedTask(db, 'ok2', ['f3.js']);
-    const plan = buildPlan([
-      { id: 'ok1', deps: [], files_modified: ['f1.js'] },
-      { id: 'bad1', deps: [], files_modified: ['f2.js'] },
-      { id: 'ok2', deps: [], files_modified: ['f3.js'] },
-    ]);
-    await parallelOrch.runPlan({
-      db, repoRoot: repo, plan,
-      runtimes: ['claude'],
-      command: NODE,
-      commandArgsFor: (task) => (task.id === 'bad1' ? exitFail() : exitOk(20)),
-    });
-    assert.equal(ops.readTask(db, 'ok1').status, 'completed');
-    assert.equal(ops.readTask(db, 'ok2').status, 'completed');
-    assert.equal(ops.readTask(db, 'bad1').status, 'pending');
-  } finally { cleanup(repo, db); }
-});
-
-test('runPlan: emits wave_started/wave_completed per wave + one plan_completed', async () => {
-  const repo = mkRepo();
-  const db = mkDb(repo);
-  try {
-    seedTask(db, 'e1');
-    seedTask(db, 'e2', [], ['e1']);
-    const plan = buildPlan([
-      { id: 'e1', deps: [] },
-      { id: 'e2', deps: ['e1'] },
-    ]);
-    await parallelOrch.runPlan({
-      db, repoRoot: repo, plan,
-      runtimes: ['claude'],
-      command: NODE, commandArgs: exitOk(20),
-    });
-    const { events } = ops.subscribeEventsSince(db, 0);
-    const waveStarts = events.filter((e) => e.type === 'wave_started');
-    const waveCloses = events.filter((e) => e.type === 'wave_completed');
-    const planCloses = events.filter((e) => e.type === 'plan_completed');
-    assert.equal(waveStarts.length, 2);
-    assert.equal(waveCloses.length, 2);
-    assert.equal(planCloses.length, 1);
-  } finally { cleanup(repo, db); }
-});