ultra-builder-pro-cli 0.13.0 → 0.15.0

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

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