ultra-builder-pro-cli 0.13.0 → 0.15.0

package/mcp-server/tests/init-project.test.cjs

@@ -1,393 +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 Database = require('better-sqlite3');
-
-const {
-  initProject, InitProjectError, DEFAULT_TEMPLATE, classifyRepository,
-} = require('../lib/init-project.cjs');
-const { EXPECTED_VERSION } = require('../lib/state-db.cjs');
-
-function mkTempDir(prefix = 'ubp-init-test-') {
-  return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-}
-
-function cleanup(dir) {
-  try { fs.rmSync(dir, { recursive: true, force: true }); } catch (_) { /* best effort */ }
-}
-
-test('initProject copies bundled template into .ultra/', () => {
-  const target = mkTempDir();
-  try {
-    const r = initProject({
-      target_dir: target,
-      project_name: 'demo',
-      project_type: 'cli',
-      stack: 'node',
-    });
-    assert.equal(r.status, 'created');
-    assert.equal(r.mode, 'greenfield');
-    assert.equal(r.created_path, path.join(target, '.ultra'));
-    assert.ok(r.copied_files.includes('tasks/tasks.json'));
-    assert.ok(r.copied_files.includes('specs/product.md'));
-    assert.ok(r.copied_files.includes('changes/active/.gitkeep'));
-    assert.ok(r.copied_files.includes('changes/archive/.gitkeep'));
-    assert.equal(r.state_db_path, path.join(target, '.ultra', 'state.db'));
-    assert.ok(fs.existsSync(r.state_db_path));
-    const db = new Database(r.state_db_path, { readonly: true });
-    try {
-      const version = db.prepare('SELECT version FROM schema_version WHERE version = ?').get(EXPECTED_VERSION);
-      assert.equal(version.version, EXPECTED_VERSION);
-      assert.ok(db.prepare("SELECT name FROM sqlite_master WHERE name = 'changes'").get());
-      const baseline = db.prepare('SELECT mode, status, project_name FROM baselines').get();
-      assert.deepEqual(baseline, { mode: 'greenfield', status: 'draft', project_name: 'demo' });
-    } finally {
-      db.close();
-    }
-    assert.ok(!r.copied_files.some((f) => f.endsWith('.DS_Store')));
-  } finally { cleanup(target); }
-});
-
-test('initProject auto-detects existing source as brownfield and starts adoption', () => {
-  const target = mkTempDir();
-  try {
-    fs.mkdirSync(path.join(target, 'src'));
-    fs.writeFileSync(path.join(target, 'package.json'), '{"name":"legacy-app"}\n');
-    fs.writeFileSync(path.join(target, 'src', 'index.js'), 'module.exports = true;\n');
-    const result = initProject({ target_dir: target, project_name: 'legacy-app' });
-    assert.equal(result.mode, 'brownfield');
-    const db = new Database(result.state_db_path, { readonly: true });
-    try {
-      const baseline = db.prepare('SELECT mode, status, scope_json FROM baselines').get();
-      assert.equal(baseline.mode, 'brownfield');
-      assert.equal(baseline.status, 'adopting');
-      assert.deepEqual(JSON.parse(baseline.scope_json), ['.']);
-    } finally {
-      db.close();
-    }
-  } finally { cleanup(target); }
-});
-
-test('auto classification keeps a documentation-and-manifest-only skeleton greenfield', () => {
-  const target = mkTempDir();
-  try {
-    fs.writeFileSync(path.join(target, 'README.md'), '# New service skeleton\n');
-    fs.writeFileSync(path.join(target, 'package.json'), JSON.stringify({
-      name: 'new-service', private: true, scripts: { test: 'node --test' },
-    }));
-    const profile = classifyRepository(target);
-    assert.equal(profile.mode, 'greenfield');
-    assert.equal(profile.repository_kind, 'single');
-    assert.deepEqual(profile.source_signals, []);
-
-    const result = initProject({ target_dir: target, project_name: 'new-service' });
-    assert.equal(result.mode, 'greenfield');
-    assert.deepEqual(result.repository_profile.verification_commands, ['npm test']);
-  } finally { cleanup(target); }
-});
-
-test('auto classification records bounded monorepo evidence for brownfield adoption', () => {
-  const target = mkTempDir();
-  try {
-    fs.mkdirSync(path.join(target, 'packages', 'api', 'src'), { recursive: true });
-    fs.writeFileSync(path.join(target, 'package.json'), JSON.stringify({
-      name: 'legacy-suite', private: true, workspaces: ['packages/*'],
-      scripts: { build: 'turbo build', test: 'turbo test', lint: 'turbo lint' },
-    }));
-    fs.writeFileSync(path.join(target, 'packages', 'api', 'package.json'), '{"name":"api"}\n');
-    fs.writeFileSync(path.join(target, 'packages', 'api', 'src', 'index.js'), 'module.exports = true;\n');
-    fs.writeFileSync(path.join(target, 'Dockerfile'), 'FROM node:22\n');
-
-    const result = initProject({ target_dir: target, project_name: 'legacy-suite' });
-    assert.equal(result.mode, 'brownfield');
-    assert.equal(result.repository_profile.repository_kind, 'monorepo');
-    assert.deepEqual(result.repository_profile.workspace_roots, ['packages/api']);
-    assert.ok(result.repository_profile.source_signals.includes('packages/api/src/index.js'));
-    assert.ok(result.repository_profile.deployment_signals.includes('Dockerfile'));
-    assert.deepEqual(
-      result.repository_profile.verification_commands,
-      ['npm run build', 'npm test', 'npm run lint'],
-    );
-
-    const db = new Database(result.state_db_path, { readonly: true });
-    try {
-      const row = db.prepare(
-        'SELECT repository_branch, worktree_state, classification_json FROM baselines',
-      ).get();
-      assert.equal(row.repository_branch, null);
-      assert.equal(row.worktree_state, 'unavailable');
-      assert.equal(JSON.parse(row.classification_json).repository_kind, 'monorepo');
-    } finally { db.close(); }
-  } finally { cleanup(target); }
-});
-
-test('brownfield initialization persists an explicitly selected monorepo scope', () => {
-  const target = mkTempDir();
-  try {
-    fs.mkdirSync(path.join(target, 'packages', 'api', 'src'), { recursive: true });
-    fs.mkdirSync(path.join(target, 'packages', 'web', 'src'), { recursive: true });
-    fs.writeFileSync(path.join(target, 'package.json'), JSON.stringify({
-      name: 'legacy-suite', private: true, workspaces: ['packages/*'],
-    }));
-    fs.writeFileSync(path.join(target, 'packages', 'api', 'src', 'index.js'), 'module.exports = true;\n');
-    fs.writeFileSync(path.join(target, 'packages', 'web', 'src', 'index.js'), 'module.exports = true;\n');
-
-    const result = initProject({
-      target_dir: target,
-      project_name: 'legacy-suite',
-      scope: ['packages/api'],
-    });
-
-    const db = new Database(result.state_db_path, { readonly: true });
-    try {
-      const baseline = db.prepare('SELECT scope_json FROM baselines').get();
-      assert.deepEqual(JSON.parse(baseline.scope_json), ['packages/api']);
-      assert.deepEqual(result.baseline.scope, ['packages/api']);
-    } finally { db.close(); }
-  } finally { cleanup(target); }
-});
-
-test('maintenance CLI forwards an explicit initialization mode', () => {
-  const target = mkTempDir();
-  try {
-    fs.writeFileSync(path.join(target, 'README.md'), '# Intentional greenfield notes\n');
-    const output = execFileSync(process.execPath, [
-      path.resolve(__dirname, '..', '..', 'ultra-tools', 'cli.cjs'),
-      'task', 'init-project', '--target-dir', target, '--project-name', 'explicit-mode',
-      '--mode', 'greenfield',
-    ], { encoding: 'utf8' });
-    const envelope = JSON.parse(output);
-    assert.equal(envelope.ok, true);
-    assert.equal(envelope.data.mode, 'greenfield');
-  } finally { cleanup(target); }
-});
-
-test('initProject keeps project metadata in authoritative baseline state and tasks.json as a projection', () => {
-  const target = mkTempDir();
-  try {
-    initProject({
-      target_dir: target,
-      project_name: 'meta-demo',
-      project_type: 'web',
-      stack: 'next',
-    });
-    const tasksJson = JSON.parse(fs.readFileSync(path.join(target, '.ultra', 'tasks', 'tasks.json'), 'utf8'));
-    assert.equal(tasksJson.schema_version, '4.5');
-    assert.equal(tasksJson.source, '.ultra/state.db');
-    assert.deepEqual(tasksJson.tasks, []);
-    assert.equal('project' in tasksJson, false);
-    const db = new Database(path.join(target, '.ultra', 'state.db'), { readonly: true });
-    try {
-      const baseline = db.prepare('SELECT project_name, project_type, stack FROM baselines').get();
-      assert.deepEqual(baseline, { project_name: 'meta-demo', project_type: 'web', stack: 'next' });
-    } finally {
-      db.close();
-    }
-  } finally { cleanup(target); }
-});
-
-test('initProject records the declared project_initialized lifecycle event', () => {
-  const rootDir = mkTempDir();
-  try {
-    const result = initProject({ target_dir: rootDir, project_name: 'events-fixture' });
-    const db = new Database(result.state_db_path, { readonly: true });
-    try {
-      const events = db.prepare('SELECT type, payload_json FROM events ORDER BY id').all();
-      assert.deepEqual(events.map((row) => row.type), ['baseline_started', 'project_initialized']);
-      assert.deepEqual(JSON.parse(events[1].payload_json), {
-        project_name: 'events-fixture', mode: 'greenfield', baseline_id: 'project-baseline',
-      });
-    } finally {
-      db.close();
-    }
-  } finally {
-    fs.rmSync(rootDir, { recursive: true, force: true });
-  }
-});
-
-test('initProject refuses when .ultra/ already exists and overwrite=false', () => {
-  const target = mkTempDir();
-  try {
-    initProject({ target_dir: target, project_name: 'first' });
-    assert.throws(
-      () => initProject({ target_dir: target, project_name: 'again' }),
-      (err) => err instanceof InitProjectError && err.code === 'ULTRA_DIR_EXISTS',
-    );
-  } finally { cleanup(target); }
-});
-
-test('initProject resume preserves existing artifacts and installs only missing current scaffold files', () => {
-  const target = mkTempDir();
-  try {
-    fs.mkdirSync(path.join(target, '.ultra', 'specs'), { recursive: true });
-    fs.writeFileSync(path.join(target, '.ultra', 'specs', 'product.md'), '# Existing product contract\n');
-
-    const result = initProject({
-      target_dir: target, project_name: 'existing-project', mode: 'brownfield', resume: true,
-    });
-    assert.equal(result.status, 'resumed');
-    assert.equal(
-      fs.readFileSync(path.join(target, '.ultra', 'specs', 'product.md'), 'utf8'),
-      '# Existing product contract\n',
-    );
-    assert.ok(fs.existsSync(path.join(target, '.ultra', 'specs', 'architecture.md')));
-    assert.ok(result.copied_files.includes('specs/architecture.md'));
-    assert.equal(result.copied_files.includes('specs/product.md'), false);
-
-    const second = initProject({
-      target_dir: target, project_name: 'existing-project', resume: true,
-    });
-    assert.equal(second.status, 'resumed');
-    assert.deepEqual(second.copied_files, []);
-    const db = new Database(result.state_db_path, { readonly: true });
-    try {
-      assert.equal(db.prepare('SELECT COUNT(*) AS count FROM baselines').get().count, 1);
-    } finally { db.close(); }
-  } finally { cleanup(target); }
-});
-
-test('initProject resume refuses projection-only tasks until the supported import runs', () => {
-  const target = mkTempDir();
-  try {
-    fs.mkdirSync(path.join(target, '.ultra', 'tasks'), { recursive: true });
-    fs.writeFileSync(path.join(target, '.ultra', 'tasks', 'tasks.json'), JSON.stringify({
-      schema_version: '4.5', source: '.ultra/state.db',
-      tasks: [{ id: 'legacy', title: 'Legacy task', type: 'feature', priority: 'P1', status: 'pending' }],
-    }));
-    assert.throws(
-      () => initProject({ target_dir: target, project_name: 'legacy', resume: true }),
-      (error) => error.code === 'LEGACY_STATE_MIGRATION_REQUIRED'
-        && /--from=4\.5 --to=12\.0/.test(error.message),
-    );
-    assert.equal(fs.existsSync(path.join(target, '.ultra', 'state.db')), false);
-    assert.equal(fs.existsSync(path.join(target, '.ultra', 'specs', 'product.md')), false);
-  } finally { cleanup(target); }
-});
-
-test('initProject rejects conflicting resume and overwrite modes', () => {
-  const target = mkTempDir();
-  try {
-    fs.mkdirSync(path.join(target, '.ultra'));
-    assert.throws(
-      () => initProject({
-        target_dir: target, project_name: 'conflict', resume: true, overwrite: true,
-      }),
-      (error) => error.code === 'VALIDATION_ERROR' && /resume.*overwrite/i.test(error.message),
-    );
-  } finally { cleanup(target); }
-});
-
-test('initProject with overwrite=true backs up existing .ultra/', () => {
-  const target = mkTempDir();
-  try {
-    initProject({ target_dir: target, project_name: 'first' });
-    const sentinel = path.join(target, '.ultra', 'sentinel.txt');
-    fs.writeFileSync(sentinel, 'before-backup');
-
-    const r = initProject({ target_dir: target, project_name: 'second', overwrite: true });
-    assert.equal(r.status, 'overwritten');
-    assert.ok(r.backup_path);
-    assert.ok(fs.existsSync(path.join(r.backup_path, 'sentinel.txt')));
-    assert.equal(
-      fs.readFileSync(path.join(r.backup_path, 'sentinel.txt'), 'utf8'),
-      'before-backup',
-    );
-    assert.ok(!fs.existsSync(sentinel));
-  } finally { cleanup(target); }
-});
-
-test('initProject restores the prior .ultra when overwrite initialization fails', () => {
-  const target = mkTempDir();
-  const badTemplate = mkTempDir('ubp-bad-template-');
-  try {
-    initProject({ target_dir: target, project_name: 'first' });
-    fs.writeFileSync(path.join(target, '.ultra', 'sentinel.txt'), 'restore-me');
-    fs.cpSync(DEFAULT_TEMPLATE, badTemplate, { recursive: true });
-    fs.writeFileSync(path.join(badTemplate, 'tasks', 'tasks.json'), '{not-json\n');
-
-    assert.throws(
-      () => initProject({
-        target_dir: target,
-        project_name: 'broken-overwrite',
-        overwrite: true,
-        source_template: badTemplate,
-      }),
-      (error) => error instanceof InitProjectError && error.code === 'IO_ERROR',
-    );
-    assert.equal(
-      fs.readFileSync(path.join(target, '.ultra', 'sentinel.txt'), 'utf8'),
-      'restore-me',
-    );
-    assert.equal(
-      fs.readdirSync(target).some((name) => name.startsWith('.ultra.backup.')),
-      false,
-    );
-  } finally {
-    cleanup(target);
-    cleanup(badTemplate);
-  }
-});
-
-test('initProject rejects empty project_name', () => {
-  const target = mkTempDir();
-  try {
-    assert.throws(
-      () => initProject({ target_dir: target, project_name: '' }),
-      (err) => err instanceof InitProjectError && err.code === 'VALIDATION_ERROR',
-    );
-  } finally { cleanup(target); }
-});
-
-test('initProject rejects missing source_template', () => {
-  const target = mkTempDir();
-  try {
-    assert.throws(
-      () => initProject({
-        target_dir: target,
-        project_name: 'demo',
-        source_template: '/tmp/does-not-exist-ubp-init',
-      }),
-      (err) => err instanceof InitProjectError && err.code === 'TEMPLATE_MISSING',
-    );
-  } finally { cleanup(target); }
-});
-
-test('initProject surface TARGET_NOT_DIR when target_dir is a file', () => {
-  const parent = mkTempDir();
-  const filePath = path.join(parent, 'not-a-dir.txt');
-  fs.writeFileSync(filePath, 'x');
-  try {
-    assert.throws(
-      () => initProject({ target_dir: filePath, project_name: 'demo' }),
-      (err) => err instanceof InitProjectError && err.code === 'TARGET_NOT_DIR',
-    );
-  } finally { cleanup(parent); }
-});
-
-test('copied tree matches bundled templates/.ultra/ (diff-equal excluding .DS_Store)', () => {
-  const target = mkTempDir();
-  try {
-    const r = initProject({ target_dir: target, project_name: 'diff-equal' });
-    const templateFiles = [];
-    (function walk(dir, prefix = '') {
-      for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
-        if (e.name === '.DS_Store') continue;
-        const rel = prefix ? path.join(prefix, e.name) : e.name;
-        if (e.isDirectory()) walk(path.join(dir, e.name), rel);
-        else if (e.isFile()) templateFiles.push(rel);
-      }
-    })(DEFAULT_TEMPLATE);
-    assert.deepEqual(r.copied_files.sort(), templateFiles.sort());
-    for (const rel of templateFiles) {
-      if (rel === 'tasks/tasks.json') continue; // metadata injected by design
-      const src = fs.readFileSync(path.join(DEFAULT_TEMPLATE, rel));
-      const dst = fs.readFileSync(path.join(r.created_path, rel));
-      assert.deepEqual(dst, src, `content diff in ${rel}`);
-    }
-  } finally { cleanup(target); }
-});

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

@@ -1,232 +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 { spawnSync } = require('node:child_process');
-
-const REPO_ROOT = path.resolve(__dirname, '..', '..');
-const CLI = path.join(REPO_ROOT, 'ultra-tools', 'cli.cjs');
-const FIXTURE = path.join(REPO_ROOT, 'spec', 'fixtures', 'v4.4-project');
-
-const { openStateDb, closeStateDb } = require('../lib/state-db.cjs');
-
-function tmpProject() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-mig-'));
-  copyRecursive(FIXTURE, dir);
-  return dir;
-}
-
-function copyRecursive(src, dst) {
-  fs.mkdirSync(dst, { recursive: true });
-  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
-    const s = path.join(src, entry.name);
-    const d = path.join(dst, entry.name);
-    if (entry.isDirectory()) copyRecursive(s, d);
-    else fs.copyFileSync(s, d);
-  }
-}
-
-function runCli(args, opts = {}) {
-  const r = spawnSync(process.execPath, [CLI, ...args], { encoding: 'utf8', ...opts });
-  const lines = r.stdout.trim().split('\n').filter(Boolean);
-  const last = lines[lines.length - 1] || '{}';
-  return { code: r.status, envelope: JSON.parse(last), stderr: r.stderr };
-}
-
-test('migrate --dry prints the plan without writing state.db or backups', () => {
-  const dir = tmpProject();
-  try {
-    const dbPath = path.join(dir, '.ultra', 'state.db');
-    const r = runCli(['migrate', '--from=4.4', '--to=4.5', '--dry', '--source-dir', dir]);
-    assert.equal(r.code, 0);
-    assert.equal(r.envelope.ok, true);
-    assert.equal(r.envelope.data.mode, 'dry');
-    assert.equal(r.envelope.data.tasks_to_insert, 3);
-    assert.equal(r.envelope.data.events_to_insert, 6);
-    assert.equal(r.envelope.data.warnings.length, 1, 'task-3 status mismatch must be flagged');
-    assert.equal(r.envelope.data.warnings[0].task_id, 'task-3');
-    assert.equal(fs.existsSync(dbPath), false, 'dry must not create state.db');
-    const ultraEntries = fs.readdirSync(path.join(dir, '.ultra'));
-    assert.equal(ultraEntries.some((n) => n.startsWith('backup-v4.4-')), false, 'dry must not create a backup');
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('migrate forward inserts tasks + events, records migration_history, creates backup', () => {
-  const dir = tmpProject();
-  try {
-    const dbPath = path.join(dir, '.ultra', 'state.db');
-    const r = runCli(['migrate', '--from=4.4', '--to=4.5', '--source-dir', dir]);
-    assert.equal(r.code, 0);
-    assert.equal(r.envelope.ok, true);
-    assert.equal(r.envelope.data.mode, 'apply');
-    assert.equal(r.envelope.data.tasks_inserted, 3);
-    assert.equal(r.envelope.data.events_inserted, 6);
-    assert.ok(fs.existsSync(r.envelope.data.backup_dir), 'backup dir must exist');
-    assert.ok(fs.existsSync(dbPath), 'state.db must be written');
-
-    const db = openStateDb(dbPath);
-    const taskIds = db.prepare('SELECT id FROM tasks ORDER BY id').all().map((r) => r.id);
-    assert.deepEqual(taskIds, ['task-1', 'task-2', 'task-3']);
-
-    const migrated = db.prepare(
-      'SELECT id, deps, estimated_days, context_file, created_at, updated_at FROM tasks ORDER BY id',
-    ).all();
-    assert.deepEqual(JSON.parse(migrated[1].deps), ['task-1']);
-    assert.equal(migrated[1].estimated_days, 1.5);
-    assert.equal(migrated[1].context_file, '.ultra/tasks/contexts/task-2.md');
-    for (const task of migrated) {
-      assert.match(task.created_at, /^2026-04-15T00:00:00\.000Z$/);
-      assert.match(task.updated_at, /^2026-04-16T00:00:00\.000Z$/);
-    }
-
-    // Status comes from tasks.json (task-3 = pending), not the context md (blocked)
-    const t3 = db.prepare("SELECT status FROM tasks WHERE id = 'task-3'").get();
-    assert.equal(t3.status, 'pending');
-
-    const eventCount = db.prepare('SELECT COUNT(*) AS n FROM events').get().n;
-    assert.equal(eventCount, 6);
-
-    const mig = db.prepare("SELECT direction, status FROM migration_history ORDER BY id").all();
-    assert.equal(mig.length, 1);
-    assert.equal(mig[0].direction, 'forward');
-    assert.equal(mig[0].status, 'success');
-    closeStateDb(db);
-
-    const projected = JSON.parse(fs.readFileSync(
-      path.join(dir, '.ultra', 'tasks', 'tasks.json'),
-      'utf8',
-    ));
-    assert.equal(projected.schema_version, '4.5');
-    assert.equal(projected.source, '.ultra/state.db');
-    assert.equal(projected.tasks.length, 3);
-    assert.equal(projected.tasks[1].estimated_days, 1.5);
-    assert.deepEqual(projected.tasks[1].deps, ['task-1']);
-    assert.match(
-      fs.readFileSync(path.join(dir, '.ultra', 'tasks', 'contexts', 'task-2.md'), 'utf8'),
-      /Wire JWT validation into the request pipeline/,
-    );
-    const contextTemplate = fs.readFileSync(
-      path.join(dir, '.ultra', 'tasks', 'contexts', 'TEMPLATE.md'),
-      'utf8',
-    );
-    assert.doesNotMatch(contextTemplate, /> \*\*Status\*\*:/);
-    assert.doesNotMatch(contextTemplate, /mid_workflow_recall|session_context/);
-    assert.match(contextTemplate, /Preserve this acceptance item/);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('migrate imports a v4.5 projection into schema 12 authority and requires evidence-backed re-adoption', () => {
-  const dir = tmpProject();
-  try {
-    const tasksPath = path.join(dir, '.ultra', 'tasks', 'tasks.json');
-    const projection = JSON.parse(fs.readFileSync(tasksPath, 'utf8'));
-    delete projection.version;
-    projection.schema_version = '4.5';
-    projection.source = '.ultra/state.db';
-    fs.writeFileSync(tasksPath, `${JSON.stringify(projection, null, 2)}\n`);
-
-    const r = runCli(['migrate', '--from=4.5', '--to=12.0', '--source-dir', dir]);
-    assert.equal(r.code, 0);
-    assert.equal(r.envelope.data.from, '4.5');
-    assert.equal(r.envelope.data.to, '12.0');
-    assert.match(path.basename(r.envelope.data.backup_dir), /^backup-v4\.5-/);
-
-    const db = openStateDb(path.join(dir, '.ultra', 'state.db'));
-    try {
-      assert.equal(db.prepare('SELECT COUNT(*) AS count FROM tasks').get().count, 3);
-      const baseline = db.prepare(
-        "SELECT mode, status, gaps_json FROM baselines WHERE id = 'migrated-baseline'",
-      ).get();
-      assert.deepEqual(
-        { mode: baseline.mode, status: baseline.status },
-        { mode: 'migrated', status: 'adopting' },
-      );
-      assert.equal(JSON.parse(baseline.gaps_json)[0].id, 'legacy-rebaseline-required');
-    } finally { closeStateDb(db); }
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('migrate --rollback restores .ultra contents and writes a rollback row', () => {
-  const dir = tmpProject();
-  try {
-    const dbPath = path.join(dir, '.ultra', 'state.db');
-    const fwd = runCli(['migrate', '--from=4.4', '--to=4.5', '--source-dir', dir]);
-    assert.equal(fwd.code, 0);
-
-    // Capture rollback audit BEFORE the db file is removed by reading from the
-    // backup snapshot we'll restore from.
-    const backupDir = fwd.envelope.data.backup_dir;
-
-    const back = runCli(['migrate', '--from=4.4', '--to=4.5', '--rollback', '--source-dir', dir]);
-    assert.equal(back.code, 0);
-    assert.equal(back.envelope.ok, true);
-    assert.equal(back.envelope.data.mode, 'rollback');
-    assert.equal(back.envelope.data.backup_dir, backupDir);
-
-    // state.db is gone
-    assert.equal(fs.existsSync(dbPath), false);
-
-    // .ultra/tasks/tasks.json restored to original v4.4 content
-    const tasksJson = JSON.parse(fs.readFileSync(path.join(dir, '.ultra', 'tasks', 'tasks.json'), 'utf8'));
-    assert.equal(tasksJson.version, '4.4');
-    assert.equal(tasksJson.tasks.length, 3);
-    closeStateDb(undefined);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('migrate refuses to merge a v4.4 projection into a non-empty state.db', () => {
-  const dir = tmpProject();
-  try {
-    const dbPath = path.join(dir, '.ultra', 'state.db');
-    const init = require('../lib/state-db.cjs').initStateDb(dbPath);
-    require('../lib/state-ops.cjs').createTask(init.db, {
-      id: 'existing', title: 'existing task', type: 'feature', priority: 'P1',
-    });
-    closeStateDb(init.db);
-
-    const r = runCli(['migrate', '--from=4.4', '--to=4.5', '--source-dir', dir]);
-    assert.equal(r.code, 2);
-    assert.equal(r.envelope.error.code, 'MIGRATE_FAILED');
-    assert.match(r.envelope.error.message, /non-empty state\.db/);
-
-    const db = openStateDb(dbPath);
-    assert.deepEqual(db.prepare('SELECT id FROM tasks ORDER BY id').all(), [{ id: 'existing' }]);
-    closeStateDb(db);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('migrate rejects unsupported --from / --to versions', () => {
-  const r1 = runCli(['migrate', '--from=3.0', '--to=4.5', '--dry', '--source-dir', FIXTURE]);
-  assert.equal(r1.code, 1);
-  assert.equal(r1.envelope.error.code, 'UNSUPPORTED_VERSION');
-
-  const r2 = runCli(['migrate', '--from=4.4', '--to=5.0', '--dry', '--source-dir', FIXTURE]);
-  assert.equal(r2.code, 1);
-  assert.equal(r2.envelope.error.code, 'UNSUPPORTED_VERSION');
-});
-
-test('migrate forward fails cleanly when tasks.json is missing', () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-mig-empty-'));
-  fs.mkdirSync(path.join(dir, '.ultra'), { recursive: true });
-  try {
-    const r = runCli(['migrate', '--from=4.4', '--to=4.5', '--source-dir', dir]);
-    assert.equal(r.code, 2);
-    assert.equal(r.envelope.error.code, 'MIGRATE_FAILED');
-    assert.match(r.envelope.error.message, /tasks\.json missing/);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});