ultra-builder-pro-cli 0.14.0 → 0.16.0

package/orchestrator/tests/phase-8b-gate.test.cjs

@@ -1,183 +0,0 @@
-'use strict';
-
-// Phase 8B gate — end-to-end integration verifying the three PLAN gate clauses:
-//
-//   1. "10-task PRD run → auto-completion rate ≥ 80%"
-//   2. "5-slice worktree stress → no .git/config.lock contention"
-//   3. "merge-back conflicts correctly identified"
-//
-// All use the Test-Double command (`node -e '...'`) so there's no LLM cost;
-// Phase 8A.1 LLM-backed parse_prd is out of scope here.
-
-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');
-const wtmgr = require('../worktree-manager.cjs');
-
-const NODE = process.execPath;
-function commitScript(filename, content) {
-  // Create a file (with parent dirs) in the session's CWD and commit it —
-  // simulates an agent's session work.
-  return [
-    '-e',
-    `
-const fs = require('fs');
-const path = require('path');
-const { execFileSync } = require('child_process');
-const f = ${JSON.stringify(filename)};
-fs.mkdirSync(path.dirname(f) || '.', { recursive: true });
-fs.writeFileSync(f, ${JSON.stringify(content)});
-execFileSync('git', ['add', '-A']);
-execFileSync('git', ['-c', 'user.email=agent@ubp.dev', '-c', 'user.name=agent',
-                     'commit', '-q', '-m', 'agent change ' + f]);
-process.exit(0);
-`,
-  ];
-}
-
-function mkRepo() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-8b-gate-'));
-  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');
-  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 cleanup(repoRoot, db) {
-  try { if (db) closeStateDb(db); } catch (_) { /* best-effort */ }
-  try { fs.rmSync(repoRoot, { recursive: true, force: true }); } catch (_) { /* best-effort */ }
-}
-
-// ─── Gate clause 1 — 10-task end-to-end, auto-completion ≥ 80% ────────────
-
-test('gate 1: 10-task plan with independent files → completion ≥ 80%', async () => {
-  const repo = mkRepo();
-  const db = mkDb(repo);
-  try {
-    const tasks = [];
-    for (let i = 1; i <= 10; i++) {
-      const id = `T${String(i).padStart(2, '0')}`;
-      const file = `feat/${id}.txt`;
-      ops.createTask(db, {
-        id, title: `feature ${i}`,
-        type: 'feature', priority: 'P2',
-        complexity: 2, files_modified: [file],
-      });
-      tasks.push({ id, deps: [], complexity: 2, files_modified: [file] });
-    }
-    const plan = buildPlan(tasks);
-    // All files independent → single parallel wave.
-    assert.equal(plan.waves.length, 1);
-    assert.equal(plan.waves[0].parallel, true);
-
-    const { results } = await parallelOrch.runPlan({
-      db, repoRoot: repo, plan,
-      runtimes: ['claude'],
-      command: NODE,
-      commandArgsFor: (task) => commitScript(task.files_modified[0], `${task.id}\n`),
-      autoMerge: true,
-      mergeBaseBranch: 'main',
-    });
-
-    const completed = results.filter((r) => r.status === 'completed').length;
-    const completionRate = completed / tasks.length;
-    assert.ok(completionRate >= 0.8, `completion rate ${completionRate} below 0.8`);
-
-    // Independent files → all merges clean → main HEAD reflects each file.
-    const merged = results.filter((r) => r.merge && r.merge.merged).length;
-    assert.ok(merged >= 8, `expected ≥8 clean merges, got ${merged}`);
-    for (let i = 1; i <= 10; i++) {
-      const id = `T${String(i).padStart(2, '0')}`;
-      const file = path.join(repo, 'feat', `${id}.txt`);
-      if (fs.existsSync(file)) {
-        // if merged, the file must be present on main
-        const content = fs.readFileSync(file, 'utf8');
-        assert.equal(content, `${id}\n`);
-      }
-    }
-  } finally { cleanup(repo, db); }
-});
-
-// ─── Gate clause 2 — 5-slice stress, no .git/config.lock contention ───────
-
-test('gate 2: 5 rapid worktree allocations → no git lock errors, all tracked', () => {
-  const repo = mkRepo();
-  try {
-    const sids = ['g2-1', 'g2-2', 'g2-3', 'g2-4', 'g2-5'];
-    // Back-to-back — Node single-thread execFileSync serializes git calls.
-    for (const sid of sids) wtmgr.allocate({ repoRoot: repo, sid });
-    const active = wtmgr.listActive(repo);
-    assert.equal(active.length, 5);
-    const seenSids = new Set(active.map((a) => a.sid));
-    for (const sid of sids) assert.ok(seenSids.has(sid), `missing slice ${sid}`);
-    // Cleanup and re-check — releaseAll must fully drain.
-    wtmgr.releaseAll(repo);
-    assert.equal(wtmgr.listActive(repo).length, 0);
-  } finally { cleanup(repo); }
-});
-
-// ─── Gate clause 3 — merge-back conflict identification ───────────────────
-
-test('gate 3: 2 parallel tasks on same file → 1 merged, 1 conflict event captured', async () => {
-  const repo = mkRepo();
-  const db = mkDb(repo);
-  try {
-    ops.createTask(db, {
-      id: 'X1', title: 'conflict A', type: 'feature', priority: 'P2',
-      files_modified: ['battle.txt'],
-    });
-    ops.createTask(db, {
-      id: 'X2', title: 'conflict B', type: 'feature', priority: 'P2',
-      files_modified: ['battle.txt'],
-    });
-    // Force concurrent execution so both worktrees fork from the SAME base
-    // commit. (plan-builder normally serializes these, which would cause X2
-    // to fork from X1's merged HEAD and fast-forward cleanly.)
-    const manualPlan = {
-      waves: [{
-        id: 1, tasks: ['X1', 'X2'], parallel: true,
-        reason: 'forced concurrent for conflict repro',
-      }],
-      ownership_forecast: { X1: ['battle.txt'], X2: ['battle.txt'] },
-      conflict_surface: [{ files: ['battle.txt'], tasks: ['X1', 'X2'], recommend: 'sequentialize' }],
-      estimated_cost_usd: 0,
-      estimated_duration_min: 0,
-      cycles: [],
-    };
-
-    await parallelOrch.runPlan({
-      db, repoRoot: repo, plan: manualPlan,
-      runtimes: ['claude'],
-      command: NODE,
-      commandArgsFor: (task) => commitScript('battle.txt', `${task.id}-version\n`),
-      autoMerge: true,
-      mergeBaseBranch: 'main',
-    });
-
-    const { events } = ops.subscribeEventsSince(db, 0);
-    const merged = events.filter((e) => e.type === 'merged_back');
-    const conflict = events.filter((e) => e.type === 'merge_conflict');
-    assert.equal(merged.length, 1, 'exactly one task should merge');
-    assert.equal(conflict.length, 1, 'exactly one task should conflict');
-    assert.ok(conflict[0].payload.conflict_paths.includes('battle.txt'));
-  } finally { cleanup(repo, db); }
-});

package/orchestrator/tests/recovery.test.cjs

@@ -1,190 +0,0 @@
-'use strict';
-
-// Phase 5.1 — recoverOnBoot semantics:
-//   • running + fresh heartbeat           → untouched
-//   • running + lease/heartbeat expired   → orphan   (handled by 4.5 reaper)
-//   • orphan  + pid is dead               → crashed + task_failure event
-//   • orphan  + pid still alive           → stays orphan (might recover)
-//
-// "pid dead" is determined via process.kill(pid, 0) throwing ESRCH.
-
-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 runner = require('../session-runner.cjs');
-const recovery = require('../recovery.cjs');
-
-const LONG_SLEEP_CMD = process.execPath;
-const LONG_SLEEP_ARGS = ['-e', 'setInterval(() => {}, 60000);'];
-
-function mkRepo() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-recovery-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 dbPath = path.join(repoRoot, '.ultra', 'state.db');
-  const { db } = initStateDb(dbPath);
-  return { db, dbPath };
-}
-
-function seedTask(db, id) {
-  ops.createTask(db, { id, title: 'recovery target', type: 'feature', priority: 'P1' });
-  return id;
-}
-
-function cleanup(repoRoot, db) {
-  try { closeStateDb(db); } catch (_) { /* ignore */ }
-  try { fs.rmSync(repoRoot, { recursive: true, force: true }); } catch (_) { /* ignore */ }
-}
-
-// Create a session row bypassing real spawn — lets us control pid precisely.
-function insertRawSession(db, { sid, task_id, pid, status = 'orphan', worktree_path, artifact_dir }) {
-  const row = ops.createSession(db, {
-    sid, task_id, runtime: 'claude', pid,
-    worktree_path: worktree_path || `/tmp/ubp-fake-wt/${sid}`,
-    artifact_dir: artifact_dir || `/tmp/ubp-fake-art/${sid}`,
-  });
-  if (status !== 'running') ops.updateSession(db, sid, { status });
-  return row;
-}
-
-test('recoverOnBoot: orphan with dead pid → crashed + task_failure event', () => {
-  const repoRoot = mkRepo();
-  const { db } = mkDb(repoRoot);
-  try {
-    seedTask(db, 'rec-1');
-    // pid 0x7FFFFFFE is almost certainly not assigned; process.kill will ESRCH.
-    insertRawSession(db, { sid: 'sess-dead01', task_id: 'rec-1', pid: 0x7FFFFFFE, status: 'orphan' });
-
-    const { events: beforeEvents } = ops.subscribeEventsSince(db, { since_id: 0, limit: 500 });
-    const result = recovery.recoverOnBoot(db);
-
-    assert.equal(result.count, 1);
-    assert.equal(result.recovered[0].sid, 'sess-dead01');
-    assert.equal(result.recovered[0].task_id, 'rec-1');
-    assert.equal(result.recovered[0].pid_alive, false);
-
-    const row = ops.readSession(db, 'sess-dead01');
-    assert.equal(row.status, 'crashed');
-
-    const { events: afterEvents } = ops.subscribeEventsSince(db, { since_id: 0, limit: 500 });
-    const newEvents = afterEvents.slice(beforeEvents.length);
-    assert.ok(newEvents.some((e) => e.type === 'session_crashed' && e.session_id === 'sess-dead01'));
-    assert.ok(newEvents.some((e) => e.type === 'task_failure' && e.task_id === 'rec-1'));
-  } finally {
-    cleanup(repoRoot, db);
-  }
-});
-
-test('recoverOnBoot: orphan with alive pid → stays orphan', () => {
-  const repoRoot = mkRepo();
-  const { db } = mkDb(repoRoot);
-  try {
-    seedTask(db, 'rec-2');
-    // Current process is definitely alive.
-    insertRawSession(db, { sid: 'sess-alive01', task_id: 'rec-2', pid: process.pid, status: 'orphan' });
-
-    const result = recovery.recoverOnBoot(db);
-    assert.equal(result.count, 0);
-    const row = ops.readSession(db, 'sess-alive01');
-    assert.equal(row.status, 'orphan');
-  } finally {
-    cleanup(repoRoot, db);
-  }
-});
-
-test('recoverOnBoot: running with fresh heartbeat → unchanged', () => {
-  const repoRoot = mkRepo();
-  const { db } = mkDb(repoRoot);
-  try {
-    seedTask(db, 'rec-3');
-    // Running session that will NOT be reaped — fresh heartbeat + future lease.
-    ops.createSession(db, {
-      sid: 'sess-healthy',
-      task_id: 'rec-3',
-      runtime: 'claude',
-      pid: process.pid,
-      worktree_path: '/tmp/ubp-fake-wt/sess-healthy',
-      artifact_dir: '/tmp/ubp-fake-art/sess-healthy',
-    });
-    ops.heartbeatSession(db, 'sess-healthy');
-
-    recovery.recoverOnBoot(db);
-    const row = ops.readSession(db, 'sess-healthy');
-    assert.equal(row.status, 'running');
-  } finally {
-    cleanup(repoRoot, db);
-  }
-});
-
-test('recoverOnBoot: first reaps stale running → orphan, then upgrades dead ones to crashed', () => {
-  const repoRoot = mkRepo();
-  const { db } = mkDb(repoRoot);
-  try {
-    seedTask(db, 'rec-4');
-    // Running session with expired lease + dead pid.
-    ops.createSession(db, {
-      sid: 'sess-stale-dead',
-      task_id: 'rec-4',
-      runtime: 'claude',
-      pid: 0x7FFFFFFE,
-      worktree_path: '/tmp/ubp-fake-wt/sess-stale-dead',
-      artifact_dir: '/tmp/ubp-fake-art/sess-stale-dead',
-    });
-    ops.updateSession(db, 'sess-stale-dead', {
-      lease_expires_at: new Date(Date.now() - 60 * 1000).toISOString(),
-      heartbeat_at: new Date(Date.now() - 60 * 1000).toISOString(),
-    });
-
-    const result = recovery.recoverOnBoot(db, { graceSeconds: 30 });
-    // Should have reaped to orphan first, then crashed.
-    assert.equal(result.count, 1);
-    assert.equal(result.recovered[0].sid, 'sess-stale-dead');
-    const row = ops.readSession(db, 'sess-stale-dead');
-    assert.equal(row.status, 'crashed');
-  } finally {
-    cleanup(repoRoot, db);
-  }
-});
-
-test('integration: kill -9 real child → recoverOnBoot marks crashed', async () => {
-  const repoRoot = mkRepo();
-  const { db } = mkDb(repoRoot);
-  let handle;
-  try {
-    seedTask(db, 'rec-int');
-    handle = runner.spawnSession({
-      db, repoRoot,
-      task_id: 'rec-int', runtime: 'claude',
-      command: LONG_SLEEP_CMD, args: LONG_SLEEP_ARGS,
-    });
-    // Force lease/heartbeat into the past so reaper catches it.
-    ops.updateSession(db, handle.sid, {
-      lease_expires_at: new Date(Date.now() - 60 * 1000).toISOString(),
-      heartbeat_at: new Date(Date.now() - 60 * 1000).toISOString(),
-    });
-    process.kill(handle.pid, 'SIGKILL');
-    // Let the kernel reap the zombie.
-    await new Promise((r) => setTimeout(r, 80));
-
-    const result = recovery.recoverOnBoot(db, { graceSeconds: 30 });
-    assert.ok(result.recovered.some((r) => r.sid === handle.sid));
-    const row = ops.readSession(db, handle.sid);
-    assert.equal(row.status, 'crashed');
-  } finally {
-    cleanup(repoRoot, db);
-  }
-});

package/orchestrator/tests/session-runner.test.cjs

@@ -1,314 +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 { 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 runner = require('../session-runner.cjs');
-
-// Short-lived child: keep the process alive until killed.
-const LONG_SLEEP_CMD = process.execPath;
-const LONG_SLEEP_ARGS = ['-e', 'setInterval(() => {}, 60000);'];
-
-function mkRepo() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-runner-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 dbPath = path.join(repoRoot, '.ultra', 'state.db');
-  const { db } = initStateDb(dbPath);
-  return { db, dbPath };
-}
-
-function seedTask(db, id = 't-1') {
-  ops.createTask(db, { id, title: 'runner target', type: 'feature', priority: 'P1' });
-  return id;
-}
-
-function cleanup(repoRoot, db) {
-  try { closeStateDb(db); } catch (_) { /* ignore */ }
-  try { fs.rmSync(repoRoot, { recursive: true, force: true }); } catch (_) { /* ignore */ }
-}
-
-function isProcessAlive(pid) {
-  try { process.kill(pid, 0); return true; }
-  catch (_) { return false; }
-}
-
-test('spawnSession creates worktree, child process, and sessions row', () => {
-  const repoRoot = mkRepo();
-  const { db } = mkDb(repoRoot);
-  let handle;
-  try {
-    seedTask(db, 'r-1');
-    handle = runner.spawnSession({
-      db, repoRoot,
-      task_id: 'r-1', runtime: 'claude',
-      command: LONG_SLEEP_CMD, args: LONG_SLEEP_ARGS,
-    });
-    assert.match(handle.sid, /^sess-/);
-    assert.ok(fs.existsSync(handle.worktree_path));
-    assert.ok(fs.existsSync(handle.artifact_dir));
-    assert.ok(handle.pid);
-    assert.ok(isProcessAlive(handle.pid));
-
-    const row = ops.readSession(db, handle.sid);
-    assert.equal(row.task_id, 'r-1');
-    assert.equal(row.status, 'running');
-    assert.equal(row.pid, handle.pid);
-  } finally {
-    if (handle && handle.pid) { try { process.kill(handle.pid, 'SIGKILL'); } catch (_) { /* ignore */ } }
-    cleanup(repoRoot, db);
-  }
-});
-
-test('closeSession kills child, marks completed, removes worktree', async () => {
-  const repoRoot = mkRepo();
-  const { db } = mkDb(repoRoot);
-  let handle;
-  try {
-    seedTask(db, 'r-close');
-    handle = runner.spawnSession({
-      db, repoRoot,
-      task_id: 'r-close', runtime: 'claude',
-      command: LONG_SLEEP_CMD, args: LONG_SLEEP_ARGS,
-    });
-    const wt = handle.worktree_path;
-    runner.closeSession(
-      { db, repoRoot, sid: handle.sid },
-      { status: 'completed', kill_signal: 'SIGKILL' },
-    );
-
-    const row = ops.readSession(db, handle.sid);
-    assert.equal(row.status, 'completed');
-    // give the kernel a tick to reap the SIGKILL
-    await new Promise((r) => setTimeout(r, 50));
-    assert.ok(!isProcessAlive(handle.pid), `pid ${handle.pid} should be dead`);
-    assert.ok(!fs.existsSync(wt));
-  } finally {
-    cleanup(repoRoot, db);
-  }
-});
-
-test('spawnSession refuses second session without takeover (ADMISSION_DENIED)', () => {
-  const repoRoot = mkRepo();
-  const { db } = mkDb(repoRoot);
-  let first;
-  try {
-    seedTask(db, 'r-adm');
-    first = runner.spawnSession({
-      db, repoRoot,
-      task_id: 'r-adm', runtime: 'claude',
-      command: LONG_SLEEP_CMD, args: LONG_SLEEP_ARGS,
-    });
-    assert.throws(
-      () => runner.spawnSession({
-        db, repoRoot,
-        task_id: 'r-adm', runtime: 'codex',
-        command: LONG_SLEEP_CMD, args: LONG_SLEEP_ARGS,
-      }),
-      (err) => err instanceof runner.SessionRunnerError && err.code === 'ADMISSION_DENIED',
-    );
-  } finally {
-    if (first && first.pid) { try { process.kill(first.pid, 'SIGKILL'); } catch (_) { /* ignore */ } }
-    cleanup(repoRoot, db);
-  }
-});
-
-test('takeover=true crashes old session and spawns new one', () => {
-  const repoRoot = mkRepo();
-  const { db } = mkDb(repoRoot);
-  let first, second;
-  try {
-    seedTask(db, 'r-take');
-    first = runner.spawnSession({
-      db, repoRoot,
-      task_id: 'r-take', runtime: 'claude',
-      command: LONG_SLEEP_CMD, args: LONG_SLEEP_ARGS,
-    });
-    second = runner.spawnSession({
-      db, repoRoot,
-      task_id: 'r-take', runtime: 'codex',
-      command: LONG_SLEEP_CMD, args: LONG_SLEEP_ARGS,
-      takeover: true,
-    });
-    assert.notEqual(second.sid, first.sid);
-
-    const firstRow = ops.readSession(db, first.sid);
-    assert.equal(firstRow.status, 'crashed');
-    const secondRow = ops.readSession(db, second.sid);
-    assert.equal(secondRow.status, 'running');
-    assert.equal(secondRow.runtime, 'codex');
-  } finally {
-    for (const h of [first, second]) {
-      if (h && h.pid) { try { process.kill(h.pid, 'SIGKILL'); } catch (_) { /* ignore */ } }
-    }
-    cleanup(repoRoot, db);
-  }
-});
-
-test('attachHeartbeat updates heartbeat_at while running', async () => {
-  const repoRoot = mkRepo();
-  const { db } = mkDb(repoRoot);
-  let handle;
-  try {
-    seedTask(db, 'r-hb');
-    handle = runner.spawnSession({
-      db, repoRoot,
-      task_id: 'r-hb', runtime: 'claude',
-      command: LONG_SLEEP_CMD, args: LONG_SLEEP_ARGS,
-    });
-    const stop = runner.attachHeartbeat(db, handle.sid, { intervalMs: 20 });
-    await new Promise((r) => setTimeout(r, 80));
-    stop();
-
-    const row = ops.readSession(db, handle.sid);
-    assert.ok(row.heartbeat_at, 'heartbeat_at should be populated');
-    // lease extended beyond initial default of started_at + 1800s? compare against start
-    assert.ok(Date.parse(row.heartbeat_at) > 0);
-  } finally {
-    if (handle && handle.pid) { try { process.kill(handle.pid, 'SIGKILL'); } catch (_) { /* ignore */ } }
-    cleanup(repoRoot, db);
-  }
-});
-
-test('kill -9 child: reapOrphanSessions marks orphan after heartbeat grace expires', async () => {
-  const repoRoot = mkRepo();
-  const { db } = mkDb(repoRoot);
-  let handle;
-  try {
-    seedTask(db, 'r-orphan');
-    handle = runner.spawnSession({
-      db, repoRoot,
-      task_id: 'r-orphan', runtime: 'claude',
-      command: LONG_SLEEP_CMD, args: LONG_SLEEP_ARGS,
-    });
-    // force lease + heartbeat into the past so reaper has something to grab
-    ops.updateSession(db, handle.sid, {
-      lease_expires_at: new Date(Date.now() - 60 * 1000).toISOString(),
-      heartbeat_at: new Date(Date.now() - 60 * 1000).toISOString(),
-    });
-    process.kill(handle.pid, 'SIGKILL');
-
-    const reaped = ops.reapOrphanSessions(db, { graceSeconds: 30 });
-    assert.ok(reaped.reaped.includes(handle.sid));
-    const row = ops.readSession(db, handle.sid);
-    assert.equal(row.status, 'orphan');
-  } finally {
-    cleanup(repoRoot, db);
-  }
-});
-
-test('concurrent spawns on same task: only one succeeds (admission serialization)', async () => {
-  const repoRoot = mkRepo();
-  const { db } = mkDb(repoRoot);
-  let winner;
-  try {
-    seedTask(db, 'r-race');
-
-    const attempts = [0, 1, 2].map((i) =>
-      Promise.resolve().then(() => {
-        try {
-          return runner.spawnSession({
-            db, repoRoot,
-            task_id: 'r-race', runtime: ['claude', 'opencode', 'codex'][i],
-            command: LONG_SLEEP_CMD, args: LONG_SLEEP_ARGS,
-          });
-        } catch (err) {
-          return { error: err.code };
-        }
-      }),
-    );
-    const results = await Promise.all(attempts);
-    const winners = results.filter((r) => r && r.sid);
-    const denied = results.filter((r) => r && r.error === 'ADMISSION_DENIED');
-    assert.equal(winners.length, 1, `expected 1 winner, got ${winners.length}`);
-    assert.equal(denied.length, 2, `expected 2 denied, got ${denied.length}`);
-    winner = winners[0];
-  } finally {
-    if (winner && winner.pid) { try { process.kill(winner.pid, 'SIGKILL'); } catch (_) { /* ignore */ } }
-    cleanup(repoRoot, db);
-  }
-});
-
-test('spawnSession refuses tripped task (CIRCUIT_TRIPPED, takeover cannot override)', () => {
-  const repoRoot = mkRepo();
-  const { db } = mkDb(repoRoot);
-  try {
-    seedTask(db, 'r-cb');
-    for (let i = 0; i < 3; i += 1) ops.recordTaskFailure(db, 'r-cb', { reason: 'test' });
-    assert.equal(ops.isCircuitTripped(db, 'r-cb'), true);
-
-    const attempt = (takeover) => runner.spawnSession({
-      db, repoRoot,
-      task_id: 'r-cb', runtime: 'claude',
-      command: LONG_SLEEP_CMD, args: LONG_SLEEP_ARGS,
-      takeover,
-    });
-    assert.throws(() => attempt(false), (err) => err.code === 'CIRCUIT_TRIPPED');
-    assert.throws(() => attempt(true), (err) => err.code === 'CIRCUIT_TRIPPED');
-  } finally {
-    cleanup(repoRoot, db);
-  }
-});
-
-test('spawnSession works again after resetCircuitBreaker', () => {
-  const repoRoot = mkRepo();
-  const { db } = mkDb(repoRoot);
-  let handle;
-  try {
-    seedTask(db, 'r-cb-reset');
-    for (let i = 0; i < 3; i += 1) ops.recordTaskFailure(db, 'r-cb-reset', { reason: 'test' });
-    ops.resetCircuitBreaker(db, 'r-cb-reset');
-    handle = runner.spawnSession({
-      db, repoRoot,
-      task_id: 'r-cb-reset', runtime: 'claude',
-      command: LONG_SLEEP_CMD, args: LONG_SLEEP_ARGS,
-    });
-    assert.ok(handle.sid);
-  } finally {
-    if (handle && handle.pid) { try { process.kill(handle.pid, 'SIGKILL'); } catch (_) { /* ignore */ } }
-    cleanup(repoRoot, db);
-  }
-});
-
-test('two sessions on different tasks get independent worktrees', () => {
-  const repoRoot = mkRepo();
-  const { db } = mkDb(repoRoot);
-  let a, b;
-  try {
-    seedTask(db, 'r-multi-a');
-    seedTask(db, 'r-multi-b');
-    a = runner.spawnSession({
-      db, repoRoot,
-      task_id: 'r-multi-a', runtime: 'claude',
-      command: LONG_SLEEP_CMD, args: LONG_SLEEP_ARGS,
-    });
-    b = runner.spawnSession({
-      db, repoRoot,
-      task_id: 'r-multi-b', runtime: 'codex',
-      command: LONG_SLEEP_CMD, args: LONG_SLEEP_ARGS,
-    });
-    assert.notEqual(a.sid, b.sid);
-    assert.notEqual(a.worktree_path, b.worktree_path);
-    assert.notEqual(a.pid, b.pid);
-    assert.ok(isProcessAlive(a.pid) && isProcessAlive(b.pid));
-  } finally {
-    for (const h of [a, b]) {
-      if (h && h.pid) { try { process.kill(h.pid, 'SIGKILL'); } catch (_) { /* ignore */ } }
-    }
-    cleanup(repoRoot, db);
-  }
-});