ultra-builder-pro-cli 0.14.0 → 0.16.0

package/mcp-server/tests/telemetry.test.cjs

@@ -1,219 +0,0 @@
-'use strict';
-
-// Phase 6.2 — Telemetry collectors:
-//   • appendTelemetry writes to state.db.telemetry AND .ultra/telemetry/
-//     {YYYY-MM-DD}.jsonl (double-write; jsonl keeps full payload the table
-//     can't hold).
-//   • computeCost(runtime, model, ti, to) returns USD from 2026-04 pricing.
-//   • aggregateTelemetryByRuntime / byTask / bySession drive /ultra-status.
-
-const { test } = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-const { initStateDb, closeStateDb } = require('../lib/state-db.cjs');
-const ops = require('../lib/state-ops.cjs');
-const telemetry = require('../lib/telemetry.cjs');
-const pricing = require('../lib/pricing.cjs');
-
-function freshFixture() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-tele-'));
-  const file = path.join(dir, '.ultra', 'state.db');
-  const init = initStateDb(file);
-  return { dir, db: init.db };
-}
-
-function teardown(dir, db) {
-  try { closeStateDb(db); } catch (_) { /* ignore */ }
-  try { fs.rmSync(dir, { recursive: true, force: true }); } catch (_) { /* ignore */ }
-}
-
-function seedSession(db, { sid = 's-1', task_id = 't-1', runtime = 'claude' } = {}) {
-  ops.createTask(db, { id: task_id, title: 'tele target', type: 'feature', priority: 'P1' });
-  ops.createSession(db, {
-    sid, task_id, runtime, pid: null,
-    worktree_path: `/tmp/${sid}/wt`,
-    artifact_dir: `/tmp/${sid}/art`,
-  });
-  return { sid, task_id, runtime };
-}
-
-// ─── pricing ──────────────────────────────────────────────────────────────
-
-test('computeCost: claude opus produces non-zero USD for realistic tokens', () => {
-  const cost = pricing.computeCost('claude', 'claude-opus-4-7', 1000, 500);
-  assert.ok(cost > 0 && cost < 1, `expected reasonable cost, got ${cost}`);
-});
-
-test('computeCost: unknown runtime → null', () => {
-  assert.equal(pricing.computeCost('madeup', 'model-x', 100, 100), null);
-});
-
-test('computeCost: zero tokens → zero', () => {
-  assert.equal(pricing.computeCost('claude', 'claude-sonnet-4-6', 0, 0), 0);
-});
-
-// ─── appendTelemetry ─────────────────────────────────────────────────────
-
-test('appendTelemetry writes to telemetry table', () => {
-  const { dir, db } = freshFixture();
-  try {
-    seedSession(db, { sid: 's-t1' });
-    const out = telemetry.appendTelemetry(db, {
-      event_type: 'tool_call',
-      tool_name: 'task.list',
-      session_id: 's-t1',
-      rootDir: dir,
-    });
-    assert.ok(out.id > 0);
-    const row = db.prepare('SELECT * FROM telemetry WHERE id = ?').get(out.id);
-    assert.equal(row.event_type, 'tool_call');
-    assert.equal(row.tool_name, 'task.list');
-    assert.equal(row.session_id, 's-t1');
-  } finally { teardown(dir, db); }
-});
-
-test('appendTelemetry writes a jsonl line under .ultra/telemetry/YYYY-MM-DD.jsonl', () => {
-  const { dir, db } = freshFixture();
-  try {
-    seedSession(db, { sid: 's-t2' });
-    telemetry.appendTelemetry(db, {
-      event_type: 'tool_call',
-      tool_name: 'task.create',
-      session_id: 's-t2',
-      rootDir: dir,
-      payload: { duration_ms: 42 },
-    });
-    const today = new Date().toISOString().slice(0, 10);
-    const jsonl = path.join(dir, '.ultra', 'telemetry', `${today}.jsonl`);
-    assert.ok(fs.existsSync(jsonl), `expected jsonl at ${jsonl}`);
-    const lines = fs.readFileSync(jsonl, 'utf8').trim().split('\n');
-    assert.equal(lines.length, 1);
-    const parsed = JSON.parse(lines[0]);
-    assert.equal(parsed.tool_name, 'task.create');
-    assert.equal(parsed.payload.duration_ms, 42);
-  } finally { teardown(dir, db); }
-});
-
-test('appendTelemetry auto-computes cost_usd when runtime + tokens supplied', () => {
-  const { dir, db } = freshFixture();
-  try {
-    seedSession(db, { sid: 's-t3' });
-    const out = telemetry.appendTelemetry(db, {
-      event_type: 'token_usage',
-      tool_name: 'session.close',
-      session_id: 's-t3',
-      runtime: 'claude',
-      tokens_input: 2000,
-      tokens_output: 500,
-      rootDir: dir,
-      payload: { model: 'claude-sonnet-4-6' },
-    });
-    const row = db.prepare('SELECT cost_usd FROM telemetry WHERE id = ?').get(out.id);
-    assert.ok(row.cost_usd > 0, 'cost should be computed from tokens');
-  } finally { teardown(dir, db); }
-});
-
-test('appendTelemetry tolerates null session_id (pre-session CLI calls)', () => {
-  const { dir, db } = freshFixture();
-  try {
-    const out = telemetry.appendTelemetry(db, {
-      event_type: 'tool_call',
-      tool_name: 'cli.task.list',
-      session_id: null,
-      rootDir: dir,
-    });
-    const row = db.prepare('SELECT * FROM telemetry WHERE id = ?').get(out.id);
-    assert.equal(row.session_id, null);
-  } finally { teardown(dir, db); }
-});
-
-test('appendTelemetry event_type constraint: invalid value rejected', () => {
-  const { dir, db } = freshFixture();
-  try {
-    assert.throws(
-      () => telemetry.appendTelemetry(db, { event_type: 'bogus', rootDir: dir }),
-      /CHECK|constraint|event_type/,
-    );
-  } finally { teardown(dir, db); }
-});
-
-test('appendTelemetry rejects unsupported runtime labels', () => {
-  const { dir, db } = freshFixture();
-  const retiredRuntime = ['gem', 'ini'].join('');
-  try {
-    assert.throws(
-      () => telemetry.appendTelemetry(db, {
-        event_type: 'tool_call', runtime: retiredRuntime, rootDir: dir,
-      }),
-      /unsupported runtime/,
-    );
-    assert.equal(db.prepare('SELECT COUNT(*) AS n FROM telemetry').get().n, 0);
-  } finally { teardown(dir, db); }
-});
-
-// ─── aggregation ─────────────────────────────────────────────────────────
-
-test('aggregateTelemetryByRuntime: groups calls + sums tokens/cost', () => {
-  const { dir, db } = freshFixture();
-  try {
-    seedSession(db, { sid: 's-a1', task_id: 't-a1', runtime: 'claude' });
-    seedSession(db, { sid: 's-a2', task_id: 't-a2', runtime: 'codex' });
-    telemetry.appendTelemetry(db, { event_type: 'token_usage', tool_name: 'x', session_id: 's-a1', runtime: 'claude', tokens_input: 1000, tokens_output: 200, rootDir: dir, payload: { model: 'claude-sonnet-4-6' } });
-    telemetry.appendTelemetry(db, { event_type: 'token_usage', tool_name: 'y', session_id: 's-a1', runtime: 'claude', tokens_input: 500, tokens_output: 100, rootDir: dir, payload: { model: 'claude-sonnet-4-6' } });
-    telemetry.appendTelemetry(db, { event_type: 'token_usage', tool_name: 'z', session_id: 's-a2', runtime: 'codex', tokens_input: 800, tokens_output: 300, rootDir: dir, payload: { model: 'gpt-5.4' } });
-
-    const summary = ops.aggregateTelemetryByRuntime(db);
-    const byRuntime = Object.fromEntries(summary.map((r) => [r.runtime, r]));
-    assert.equal(byRuntime.claude.calls, 2);
-    assert.equal(byRuntime.codex.calls, 1);
-    assert.equal(byRuntime.claude.tokens_in, 1500);
-    assert.equal(byRuntime.codex.tokens_in, 800);
-    assert.ok(byRuntime.claude.cost_usd > 0);
-  } finally { teardown(dir, db); }
-});
-
-test('aggregateTelemetryByTask: top N tasks by cost', () => {
-  const { dir, db } = freshFixture();
-  try {
-    seedSession(db, { sid: 's-b1', task_id: 't-cheap', runtime: 'claude' });
-    seedSession(db, { sid: 's-b2', task_id: 't-expensive', runtime: 'claude' });
-    telemetry.appendTelemetry(db, { event_type: 'token_usage', tool_name: 'x', session_id: 's-b1', runtime: 'claude', tokens_input: 100, tokens_output: 50, rootDir: dir, payload: { model: 'claude-sonnet-4-6' } });
-    telemetry.appendTelemetry(db, { event_type: 'token_usage', tool_name: 'y', session_id: 's-b2', runtime: 'claude', tokens_input: 10000, tokens_output: 5000, rootDir: dir, payload: { model: 'claude-opus-4-7' } });
-
-    const top = ops.aggregateTelemetryByTask(db, { limit: 1 });
-    assert.equal(top.length, 1);
-    assert.equal(top[0].task_id, 't-expensive');
-    assert.ok(top[0].cost_usd > 0);
-  } finally { teardown(dir, db); }
-});
-
-test('aggregateTelemetryBySession: per-session roll-up', () => {
-  const { dir, db } = freshFixture();
-  try {
-    seedSession(db, { sid: 's-c1', task_id: 't-c1', runtime: 'claude' });
-    telemetry.appendTelemetry(db, { event_type: 'tool_call', tool_name: 'task.list', session_id: 's-c1', rootDir: dir });
-    telemetry.appendTelemetry(db, { event_type: 'tool_call', tool_name: 'task.get', session_id: 's-c1', rootDir: dir });
-    telemetry.appendTelemetry(db, { event_type: 'token_usage', tool_name: 'session.close', session_id: 's-c1', runtime: 'claude', tokens_input: 500, tokens_output: 100, rootDir: dir, payload: { model: 'claude-haiku-4-5' } });
-
-    const summary = ops.aggregateTelemetryBySession(db, 's-c1');
-    assert.equal(summary.tool_calls, 3);
-    assert.equal(summary.tokens_in, 500);
-    assert.equal(summary.tokens_out, 100);
-    assert.ok(summary.cost_usd > 0);
-  } finally { teardown(dir, db); }
-});
-
-test('aggregate filter: since cutoff excludes older rows', () => {
-  const { dir, db } = freshFixture();
-  try {
-    seedSession(db, { sid: 's-d1', task_id: 't-d1', runtime: 'claude' });
-    // Insert one row; then a cutoff in the future filters it out.
-    telemetry.appendTelemetry(db, { event_type: 'tool_call', tool_name: 'x', session_id: 's-d1', rootDir: dir });
-    const futureCutoff = new Date(Date.now() + 60 * 1000).toISOString();
-    const summary = ops.aggregateTelemetryByRuntime(db, { since: futureCutoff });
-    assert.equal(summary.length, 0);
-  } finally { teardown(dir, db); }
-});

package/orchestrator/planner/plan-builder.test.cjs

@@ -1,165 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-
-const { buildPlan, listWaveConflicts } = require('./plan-builder.cjs');
-
-function mk(id, deps = [], files = [], complexity = 3) {
-  return { id, deps, files_modified: files, complexity };
-}
-
-test('buildPlan fixture 1: 5 tasks, no file overlap → 2 waves, no conflicts', () => {
-  const tasks = [
-    mk('a', [], ['src/a.ts'], 2),
-    mk('b', ['a'], ['src/b.ts'], 3),
-    mk('c', ['a'], ['src/c.ts'], 4),
-    mk('d', ['b', 'c'], ['src/d.ts'], 5),
-    mk('e', [], ['src/e.ts'], 2),
-  ];
-  const plan = buildPlan(tasks);
-  assert.equal(plan.waves.length, 3);
-  assert.equal(plan.conflict_surface.length, 0);
-  // wave 1 should contain a+e, both parallel-safe
-  assert.deepEqual(new Set(plan.waves[0].tasks), new Set(['a', 'e']));
-  assert.equal(plan.waves[0].parallel, true);
-  assert.deepEqual(plan.cycles, []);
-  assert.ok(plan.estimated_cost_usd > 0);
-  assert.ok(plan.estimated_duration_min > 0);
-});
-
-test('buildPlan fixture 2: same wave, shared file → conflict_surface + parallel=false', () => {
-  const tasks = [
-    mk('a', []),
-    mk('b', ['a'], ['src/utils.ts']),
-    mk('c', ['a'], ['src/utils.ts']),
-  ];
-  const plan = buildPlan(tasks);
-  assert.equal(plan.waves.length, 2);
-  const w2 = plan.waves[1];
-  assert.equal(w2.parallel, false);
-  assert.match(w2.reason, /shared files: src\/utils\.ts/);
-
-  assert.equal(plan.conflict_surface.length, 1);
-  const c = plan.conflict_surface[0];
-  assert.deepEqual(c.files, ['src/utils.ts']);
-  assert.deepEqual(new Set(c.tasks), new Set(['b', 'c']));
-  assert.equal(c.recommend, 'sequentialize');
-});
-
-test('buildPlan fixture 3: cross-wave same file → NOT a conflict', () => {
-  const tasks = [
-    mk('a', [], ['src/shared.ts']),
-    mk('b', ['a'], ['src/shared.ts']),
-  ];
-  const plan = buildPlan(tasks);
-  assert.equal(plan.conflict_surface.length, 0);
-  // wave 1 has only `a`, not parallel; wave 2 has only `b`, not parallel
-  for (const w of plan.waves) {
-    assert.equal(w.parallel, false);
-    assert.ok(!w.reason);
-  }
-});
-
-test('buildPlan fixture 4: empty tasks → empty plan, non-negative numbers', () => {
-  const plan = buildPlan([]);
-  assert.deepEqual(plan.waves, []);
-  assert.deepEqual(plan.conflict_surface, []);
-  assert.deepEqual(plan.ownership_forecast, {});
-  assert.equal(plan.estimated_cost_usd, 0);
-  assert.equal(plan.estimated_duration_min, 0);
-  assert.deepEqual(plan.cycles, []);
-});
-
-test('buildPlan fixture 5: cost + duration math (parallel vs serial waves)', () => {
-  // wave 1 (parallel): a complexity=2, b complexity=4 → max = 4 * 5 = 20 min
-  // wave 2 (1 task, not parallel): c complexity=6 → 6 * 5 = 30 min
-  // total duration = 50 min
-  const tasks = [
-    mk('a', [], ['src/a.ts'], 2),
-    mk('b', [], ['src/b.ts'], 4),
-    mk('c', ['a', 'b'], ['src/c.ts'], 6),
-  ];
-  const plan = buildPlan(tasks);
-  assert.equal(plan.estimated_duration_min, 50);
-  // cost: 3 tasks × sum(complexity)=12 × (5000*3e-6 + 2000*15e-6) per complexity unit
-  //     = 12 × (0.015 + 0.030) = 12 × 0.045 = 0.54 usd
-  assert.ok(Math.abs(plan.estimated_cost_usd - 0.54) < 0.001);
-});
-
-test('buildPlan: serial wave (with conflict) sums complexities instead of max', () => {
-  // both tasks in same wave share a file → wave is serial
-  // wave 1: a(complexity=3), b(complexity=3) → (3+3) * 5 = 30 min
-  const tasks = [
-    mk('a', [], ['src/utils.ts'], 3),
-    mk('b', [], ['src/utils.ts'], 3),
-  ];
-  const plan = buildPlan(tasks);
-  assert.equal(plan.waves[0].parallel, false);
-  assert.equal(plan.estimated_duration_min, 30);
-});
-
-test('buildPlan: ownership_forecast captures per-task files_modified verbatim', () => {
-  const tasks = [
-    mk('a', [], ['src/a.ts', 'src/a.util.ts']),
-    mk('b', [], ['src/b.ts']),
-  ];
-  const plan = buildPlan(tasks);
-  assert.deepEqual(plan.ownership_forecast, {
-    a: ['src/a.ts', 'src/a.util.ts'],
-    b: ['src/b.ts'],
-  });
-});
-
-test('buildPlan: cycle in task graph surfaced in plan.cycles', () => {
-  const tasks = [
-    mk('x', ['y']),
-    mk('y', ['x']),
-  ];
-  const plan = buildPlan(tasks);
-  assert.deepEqual(plan.waves, []);
-  assert.equal(plan.cycles.length, 1);
-  assert.deepEqual(new Set(plan.cycles[0]), new Set(['x', 'y']));
-});
-
-test('buildPlan: missing complexity defaults to DEFAULT_COMPLEXITY for cost calc', () => {
-  const tasks = [{ id: 'a', deps: [], files_modified: [] }];
-  const plan = buildPlan(tasks);
-  // complexity 3 → 15k in, 6k out → cost > 0
-  assert.ok(plan.estimated_cost_usd > 0);
-  assert.equal(plan.estimated_duration_min, 15); // 3 * 5 (single-task wave, not parallel)
-});
-
-test('buildPlan: non-array input → TypeError', () => {
-  assert.throws(() => buildPlan(null), TypeError);
-  assert.throws(() => buildPlan({}), TypeError);
-});
-
-test('listWaveConflicts: no overlap → empty', () => {
-  const byId = new Map([
-    ['a', { id: 'a', files_modified: ['x.ts'] }],
-    ['b', { id: 'b', files_modified: ['y.ts'] }],
-  ]);
-  assert.deepEqual(listWaveConflicts(['a', 'b'], byId), []);
-});
-
-test('listWaveConflicts: pair overlap reported once', () => {
-  const byId = new Map([
-    ['a', { id: 'a', files_modified: ['shared.ts', 'x.ts'] }],
-    ['b', { id: 'b', files_modified: ['shared.ts'] }],
-  ]);
-  const out = listWaveConflicts(['a', 'b'], byId);
-  assert.equal(out.length, 1);
-  assert.deepEqual(out[0].files, ['shared.ts']);
-  assert.deepEqual(out[0].tasks, ['a', 'b']);
-});
-
-test('listWaveConflicts: three-way overlap yields C(3,2)=3 pairs', () => {
-  const byId = new Map([
-    ['a', { id: 'a', files_modified: ['x.ts'] }],
-    ['b', { id: 'b', files_modified: ['x.ts'] }],
-    ['c', { id: 'c', files_modified: ['x.ts'] }],
-  ]);
-  const out = listWaveConflicts(['a', 'b', 'c'], byId);
-  assert.equal(out.length, 3);
-});

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