ultra-builder-pro-cli 0.13.0 → 0.15.0

package/mcp-server/lib/prd-parser.test.cjs

@@ -1,171 +0,0 @@
-'use strict';
-
-// Test Double rationale: external LLM API — deterministic fixtures prove
-// parsing logic (prompt assembly, schema validation, id normalization)
-// without egress cost or key dependence. Integration coverage against a
-// real LLM lives behind an env gate and is exercised separately.
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-
-const { parsePrd, PrdParseError, TASK_LIST_SCHEMA } = require('./prd-parser.cjs');
-
-function fakeClient(jsonFn, { usage = { input_tokens: 100, output_tokens: 50 }, model = 'claude-sonnet-4-6', provider = 'anthropic' } = {}) {
-  return {
-    provider,
-    model,
-    async completeJson({ system, user }) {
-      const json = typeof jsonFn === 'function' ? await jsonFn({ system, user }) : jsonFn;
-      return { json, raw: JSON.stringify(json), usage, model, provider };
-    },
-  };
-}
-
-const HAPPY_TASKS = {
-  tasks: [
-    {
-      id: 'task-1',
-      title: 'Design auth schema',
-      type: 'architecture',
-      priority: 'P1',
-      complexity: 5,
-      deps: [],
-      files_modified: ['src/auth/schema.ts'],
-    },
-    {
-      id: 'task-2',
-      title: 'Implement login endpoint',
-      type: 'feature',
-      priority: 'P1',
-      complexity: 6,
-      deps: ['task-1'],
-      files_modified: ['src/auth/login.ts'],
-    },
-  ],
-};
-
-test('parsePrd: happy path normalizes tasks and returns usage metadata', async () => {
-  const client = fakeClient(HAPPY_TASKS);
-  const result = await parsePrd('Build login', { llmClient: client, tag: 'feat-auth' });
-  assert.equal(result.tasks.length, 2);
-  assert.equal(result.tasks[0].id, 'task-1');
-  assert.equal(result.tasks[0].tag, 'feat-auth');
-  assert.deepEqual(result.tasks[1].deps, ['task-1']);
-  assert.equal(result.model, 'claude-sonnet-4-6');
-  assert.equal(result.provider, 'anthropic');
-  assert.equal(result.usage.input_tokens, 100);
-});
-
-test('parsePrd: empty text → NO_INPUT', async () => {
-  await assert.rejects(
-    parsePrd('', { llmClient: fakeClient(HAPPY_TASKS) }),
-    (err) => err instanceof PrdParseError && err.code === 'NO_INPUT',
-  );
-  await assert.rejects(
-    parsePrd('   ', { llmClient: fakeClient(HAPPY_TASKS) }),
-    (err) => err instanceof PrdParseError && err.code === 'NO_INPUT',
-  );
-});
-
-test('parsePrd: missing llmClient → NO_LLM_CLIENT', async () => {
-  await assert.rejects(
-    parsePrd('Build something', {}),
-    (err) => err instanceof PrdParseError && err.code === 'NO_LLM_CLIENT',
-  );
-});
-
-test('parsePrd: llmClient error bubbles up as PARSE_FAILED', async () => {
-  const brokenClient = {
-    provider: 'anthropic',
-    model: 'claude-sonnet-4-6',
-    async completeJson() { throw new Error('upstream LLM 500'); },
-  };
-  await assert.rejects(
-    parsePrd('Build something', { llmClient: brokenClient }),
-    (err) => err instanceof PrdParseError && err.code === 'PARSE_FAILED' && /upstream LLM 500/.test(err.message),
-  );
-});
-
-test('parsePrd: invalid JSON shape rejected — missing required "priority"', async () => {
-  const bad = {
-    tasks: [{
-      id: 'task-1', title: 'Foo', type: 'feature', // priority missing
-      complexity: 3, deps: [], files_modified: [],
-    }],
-  };
-  await assert.rejects(
-    parsePrd('Build Foo', { llmClient: fakeClient(bad) }),
-    (err) => err instanceof PrdParseError && err.code === 'PARSE_FAILED' && /priority/.test(err.message),
-  );
-});
-
-test('parsePrd: invalid enum value rejected — bad type', async () => {
-  const bad = {
-    tasks: [{
-      id: 'task-1', title: 'Foo', type: 'chore', priority: 'P1',
-    }],
-  };
-  await assert.rejects(
-    parsePrd('Build Foo', { llmClient: fakeClient(bad) }),
-    (err) => err instanceof PrdParseError && err.code === 'PARSE_FAILED',
-  );
-});
-
-test('parsePrd: duplicate task id rejected', async () => {
-  const dup = {
-    tasks: [
-      { id: 'task-1', title: 'First copy', type: 'feature', priority: 'P2' },
-      { id: 'task-1', title: 'Second copy', type: 'feature', priority: 'P2' },
-    ],
-  };
-  await assert.rejects(
-    parsePrd('Build dupes', { llmClient: fakeClient(dup) }),
-    (err) => err instanceof PrdParseError && err.code === 'PARSE_FAILED' && /duplicate/i.test(err.message),
-  );
-});
-
-test('parsePrd: missing optional fields are normalized to defaults', async () => {
-  const minimal = {
-    tasks: [{
-      id: 'task-1', title: 'Minimal task', type: 'feature', priority: 'P3',
-    }],
-  };
-  const result = await parsePrd('anything', { llmClient: fakeClient(minimal) });
-  assert.equal(result.tasks[0].complexity, null);
-  assert.deepEqual(result.tasks[0].deps, []);
-  assert.deepEqual(result.tasks[0].files_modified, []);
-  assert.equal(result.tasks[0].tag, null);
-});
-
-test('parsePrd: prompt contains PRD text passed to llmClient', async () => {
-  let captured;
-  const client = {
-    provider: 'anthropic',
-    model: 'claude-sonnet-4-6',
-    async completeJson({ system, user }) {
-      captured = { system, user };
-      return {
-        json: HAPPY_TASKS,
-        raw: '',
-        usage: {},
-        model: 'claude-sonnet-4-6',
-        provider: 'anthropic',
-      };
-    },
-  };
-  await parsePrd('Build the thing with acceptance criteria X', { llmClient: client });
-  assert.match(captured.system, /engineering planner/i);
-  assert.match(captured.user, /Build the thing with acceptance criteria X/);
-});
-
-test('parsePrd: empty tasks array rejected (schema requires minItems:1)', async () => {
-  await assert.rejects(
-    parsePrd('Build nothing', { llmClient: fakeClient({ tasks: [] }) }),
-    (err) => err instanceof PrdParseError && err.code === 'PARSE_FAILED',
-  );
-});
-
-test('TASK_LIST_SCHEMA: exported for downstream consumers', () => {
-  assert.equal(TASK_LIST_SCHEMA.required[0], 'tasks');
-  assert.equal(TASK_LIST_SCHEMA.properties.tasks.minItems, 1);
-});

package/mcp-server/lib/runtime-state.test.cjs

@@ -1,92 +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 { initStateDb, closeStateDb } = require('./state-db.cjs');
-const runtime = require('./runtime-state.cjs');
-
-function fixture() {
-  const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-runtime-state-'));
-  const { db } = initStateDb(path.join(rootDir, '.ultra', 'state.db'));
-  return { rootDir, db };
-}
-
-function cleanup({ rootDir, db }) {
-  closeStateDb(db);
-  fs.rmSync(rootDir, { recursive: true, force: true });
-}
-
-test('projection jobs complete and retain their event cursor', () => {
-  const fx = fixture();
-  try {
-    const job = runtime.enqueueProjection(fx.db, { tool_name: 'task.create', event_cursor: 7 });
-    const result = runtime.processProjectionJobs(fx.db, {
-      rootDir: fx.rootDir,
-      project: () => ({ tasks_json: { count: 0 }, contexts: [] }),
-    });
-    assert.equal(result.processed, 1);
-    assert.equal(result.jobs[0].status, 'completed');
-    const stored = runtime.readProjectionJob(fx.db, job.id);
-    assert.equal(stored.status, 'completed');
-    assert.equal(stored.event_cursor, 7);
-  } finally {
-    cleanup(fx);
-  }
-});
-
-test('projection failures are explicit, retryable incidents rather than swallowed warnings', () => {
-  const fx = fixture();
-  try {
-    runtime.enqueueProjection(fx.db, { tool_name: 'task.update', event_cursor: 4, max_attempts: 1 });
-    // Test Double rationale: deterministic projector failure is required; filesystem permission failures vary by host.
-    const result = runtime.processProjectionJobs(fx.db, {
-      rootDir: fx.rootDir,
-      project: () => { throw new Error('projection disk unavailable'); },
-    });
-    assert.equal(result.jobs[0].status, 'failed');
-    assert.match(result.jobs[0].error, /projection disk unavailable/);
-    const incidents = runtime.listIncidents(fx.db, { status: 'open' });
-    assert.equal(incidents.length, 1);
-    assert.equal(incidents[0].code, 'PROJECTION_FAILED');
-    assert.equal(incidents[0].retryable, true);
-  } finally {
-    cleanup(fx);
-  }
-});
-
-test('event consumer cursors are durable and monotonic', () => {
-  const fx = fixture();
-  try {
-    assert.equal(runtime.readConsumerCursor(fx.db, 'spec-staleness'), 0);
-    runtime.writeConsumerCursor(fx.db, 'spec-staleness', 12);
-    runtime.writeConsumerCursor(fx.db, 'spec-staleness', 9);
-    assert.equal(runtime.readConsumerCursor(fx.db, 'spec-staleness'), 12);
-  } finally {
-    cleanup(fx);
-  }
-});
-
-test('interrupted running projections are requeued only after the stale cutoff', () => {
-  const fx = fixture();
-  try {
-    const stale = runtime.enqueueProjection(fx.db, { tool_name: 'task.update', event_cursor: 3 });
-    const fresh = runtime.enqueueProjection(fx.db, { tool_name: 'task.create', event_cursor: 4 });
-    fx.db.prepare("UPDATE projection_jobs SET status = 'running', updated_at = ? WHERE id = ?")
-      .run('2000-01-01T00:00:00.000Z', stale.id);
-    fx.db.prepare("UPDATE projection_jobs SET status = 'running', updated_at = ? WHERE id = ?")
-      .run('2999-01-01T00:00:00.000Z', fresh.id);
-
-    const result = runtime.requeueInterruptedProjections(fx.db, {
-      staleBefore: '2026-01-01T00:00:00.000Z',
-    });
-    assert.equal(result.requeued, 1);
-    assert.equal(runtime.readProjectionJob(fx.db, stale.id).status, 'pending');
-    assert.equal(runtime.readProjectionJob(fx.db, fresh.id).status, 'running');
-  } finally {
-    cleanup(fx);
-  }
-});

package/mcp-server/lib/spec-learning.test.cjs

@@ -1,67 +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('./state-db.cjs');
-const changes = require('./change-workflow.cjs');
-const learning = require('./spec-learning.cjs');
-
-function fixture() {
-  const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-learning-'));
-  execFileSync('git', ['init', '-q'], { cwd: rootDir });
-  execFileSync('git', ['config', 'user.email', 'test@ubp.dev'], { cwd: rootDir });
-  execFileSync('git', ['config', 'user.name', 'ubp-test'], { cwd: rootDir });
-  fs.writeFileSync(path.join(rootDir, 'README.md'), '# Fixture\n');
-  execFileSync('git', ['add', 'README.md'], { cwd: rootDir });
-  execFileSync('git', ['commit', '-q', '-m', 'seed'], { cwd: rootDir });
-  const { db } = initStateDb(path.join(rootDir, '.ultra', 'state.db'));
-  db.prepare(
-    `INSERT INTO baselines
-     (id, project_name, mode, status, approved_by, approval_note, converged_at)
-     VALUES ('test-baseline', 'fixture', 'greenfield', 'ready', 'test', 'accepted fixture', ?)`,
-  ).run(new Date().toISOString());
-  changes.createChange(db, {
-    id: 'learning-change', title: 'Learning change', kind: 'quick',
-    intent: 'Exercise guarded specification-learning transitions.',
-  }, { rootDir });
-  return { rootDir, db };
-}
-
-test('spec learning cannot skip approval or mutate after apply', () => {
-  const fx = fixture();
-  try {
-    learning.proposeSpecLearning(fx.db, {
-      id: 'candidate-1', change_id: 'learning-change', target_ref: 'README.md',
-      summary: 'A stable public contract was discovered.',
-    }, { rootDir: fx.rootDir });
-    assert.throws(
-      () => learning.resolveSpecLearning(fx.db, {
-        change_id: 'learning-change', candidate_id: 'candidate-1', decision: 'apply',
-        resolution: 'Applied.',
-      }, { rootDir: fx.rootDir }),
-      (error) => error.code === 'ILLEGAL_LEARNING_TRANSITION',
-    );
-    learning.resolveSpecLearning(fx.db, {
-      change_id: 'learning-change', candidate_id: 'candidate-1', decision: 'approve',
-    }, { rootDir: fx.rootDir });
-    learning.resolveSpecLearning(fx.db, {
-      change_id: 'learning-change', candidate_id: 'candidate-1', decision: 'apply',
-      resolution: 'Applied to README.md.',
-    }, { rootDir: fx.rootDir });
-    assert.throws(
-      () => learning.resolveSpecLearning(fx.db, {
-        change_id: 'learning-change', candidate_id: 'candidate-1', decision: 'reject',
-        resolution: 'Too late.',
-      }, { rootDir: fx.rootDir }),
-      (error) => error.code === 'ILLEGAL_LEARNING_TRANSITION',
-    );
-  } finally {
-    closeStateDb(fx.db);
-    fs.rmSync(fx.rootDir, { recursive: true, force: true });
-  }
-});

package/mcp-server/lib/state-db.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 {
-  EXPECTED_VERSION,
-  REQUIRED_TABLES,
-  SCHEMA_FILE,
-  initStateDb,
-  closeStateDb,
-  openStateDb,
-  tableNames,
-} = require('./state-db.cjs');
-const stateOps = require('./state-ops.cjs');
-
-function tmpDbPath(prefix = 'ubp-state') {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), `${prefix}-`));
-  return { dir, file: path.join(dir, 'state.db') };
-}
-
-test('initStateDb creates workflow tables without an Ultra memory store', () => {
-  const { dir, file } = tmpDbPath();
-  try {
-    const init = initStateDb(file);
-    assert.equal(init.created, true);
-    assert.equal(init.schema_version, EXPECTED_VERSION);
-    for (const t of REQUIRED_TABLES) {
-      assert.ok(init.tables.includes(t), `missing table ${t}`);
-    }
-    assert.ok(!init.tables.includes('memory_entries'));
-    assert.ok(!init.tables.includes('memory_fts'));
-    closeStateDb(init.db);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('initStateDb applies WAL + busy_timeout + foreign_keys pragmas', () => {
-  const { dir, file } = tmpDbPath();
-  try {
-    const { db } = initStateDb(file);
-    assert.equal(db.pragma('journal_mode', { simple: true }), 'wal');
-    assert.equal(db.pragma('busy_timeout', { simple: true }), 5000);
-    assert.equal(db.pragma('foreign_keys', { simple: true }), 1);
-    closeStateDb(db);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('initStateDb is idempotent — second call does not duplicate seed rows', () => {
-  const { dir, file } = tmpDbPath();
-  try {
-    const first = initStateDb(file);
-    const firstRows = first.db.prepare('SELECT COUNT(*) AS n FROM schema_version').get().n;
-    closeStateDb(first.db);
-
-    const second = initStateDb(file);
-    assert.equal(second.created, false, 'second init should not recreate schema');
-    assert.equal(second.schema_version, EXPECTED_VERSION);
-
-    const secondRows = second.db.prepare('SELECT COUNT(*) AS n FROM schema_version').get().n;
-    assert.equal(secondRows, firstRows, 'schema_version row count must not grow on re-init');
-    closeStateDb(second.db);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('openStateDb on an empty file produces no tables until schema is applied', () => {
-  const { dir, file } = tmpDbPath();
-  try {
-    const db = openStateDb(file);
-    assert.deepEqual(tableNames(db), []);
-    closeStateDb(db);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('initStateDb upgrades an exact schema 11 project without replacing its approved baseline', () => {
-  const { dir, file } = tmpDbPath('ubp-schema-11-upgrade');
-  try {
-    const legacy = openStateDb(file);
-    legacy.exec(`
-      CREATE TABLE schema_version (
-        version TEXT PRIMARY KEY,
-        applied_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
-        description TEXT
-      );
-      CREATE TABLE migration_history (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        from_version TEXT NOT NULL,
-        to_version TEXT NOT NULL,
-        direction TEXT NOT NULL CHECK (direction IN ('forward', 'rollback')),
-        ts TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
-        status TEXT NOT NULL CHECK (status IN ('success', 'failed', 'dry_run')),
-        notes TEXT
-      );
-      CREATE TABLE baselines (
-        id TEXT PRIMARY KEY,
-        project_name TEXT NOT NULL,
-        project_type TEXT,
-        stack TEXT,
-        mode TEXT NOT NULL CHECK (mode IN ('greenfield', 'brownfield', 'migrated')),
-        status TEXT NOT NULL CHECK (status IN ('draft', 'adopting', 'blocked', 'ready', 'superseded')),
-        repository_root TEXT NOT NULL DEFAULT '.',
-        scope_json TEXT NOT NULL DEFAULT '["."]',
-        repository_revision TEXT,
-        spec_refs_json TEXT NOT NULL DEFAULT '[]',
-        evidence_json TEXT NOT NULL DEFAULT '[]',
-        verification_json TEXT NOT NULL DEFAULT '[]',
-        unknowns_json TEXT NOT NULL DEFAULT '[]',
-        provider_refs_json TEXT NOT NULL DEFAULT '{}',
-        approved_by TEXT,
-        approval_note TEXT,
-        started_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
-        converged_at TEXT,
-        updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
-      );
-      CREATE TABLE changes (
-        id TEXT PRIMARY KEY,
-        title TEXT NOT NULL,
-        kind TEXT NOT NULL CHECK (kind IN ('quick', 'standard', 'major', 'incident')),
-        status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'blocked', 'ready', 'archived', 'cancelled')),
-        intent TEXT NOT NULL,
-        docs_impact_json TEXT NOT NULL DEFAULT '{}',
-        provider_refs_json TEXT NOT NULL DEFAULT '{}',
-        base_commit TEXT,
-        artifact_root TEXT,
-        created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
-        updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
-        closed_at TEXT
-      );
-      INSERT INTO schema_version (version, description) VALUES ('11.0', 'baseline authority');
-      INSERT INTO baselines
-        (id, project_name, mode, status, approved_by, approval_note, converged_at)
-      VALUES
-        ('approved-baseline', 'legacy-project', 'brownfield', 'ready', 'owner', 'approved',
-         '2026-07-01T00:00:00.000Z');
-    `);
-    closeStateDb(legacy);
-
-    let upgraded;
-    try {
-      upgraded = initStateDb(file);
-    } catch (error) {
-      assert.fail(`schema 11 upgrade failed: ${error.message}\n${error.stack || ''}`);
-    }
-    try {
-      assert.equal(upgraded.schema_version, '12.0');
-      assert.ok(fs.existsSync(upgraded.backup_path));
-      const baseline = upgraded.db.prepare(
-        'SELECT id, mode, status, worktree_state, gaps_json FROM baselines',
-      ).get();
-      assert.deepEqual(baseline, {
-        id: 'approved-baseline', mode: 'brownfield', status: 'ready',
-        worktree_state: 'unavailable', gaps_json: '[]',
-      });
-      assert.equal(
-        upgraded.db.prepare("SELECT COUNT(*) AS count FROM baselines WHERE mode = 'migrated'").get().count,
-        0,
-      );
-      const changeColumns = upgraded.db.prepare('PRAGMA table_info(changes)').all().map((row) => row.name);
-      assert.ok(changeColumns.includes('baseline_bypass_json'));
-    } finally { closeStateDb(upgraded.db); }
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('initStateDb exposes its pre-migration backup when an incompatible legacy schema fails', () => {
-  const { dir, file } = tmpDbPath('ubp-schema-upgrade-failure');
-  try {
-    const legacy = openStateDb(file);
-    legacy.exec(`
-      CREATE TABLE schema_version (
-        version TEXT PRIMARY KEY,
-        applied_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
-        description TEXT
-      );
-      CREATE TABLE migration_history (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        from_version TEXT NOT NULL,
-        to_version TEXT NOT NULL,
-        direction TEXT NOT NULL,
-        applied_at TEXT NOT NULL,
-        status TEXT NOT NULL,
-        notes TEXT
-      );
-      INSERT INTO schema_version (version, description) VALUES ('11.0', 'incompatible fixture');
-    `);
-    closeStateDb(legacy);
-
-    let failure;
-    try {
-      initStateDb(file);
-    } catch (error) {
-      failure = error;
-    }
-    assert.ok(failure, 'the incompatible migration_history table must fail schema application');
-    assert.match(failure.message, /no such column: ts/);
-    assert.ok(failure.migration_backup_path, 'failure must retain the backup location for recovery');
-    assert.ok(fs.existsSync(failure.migration_backup_path));
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('Phase 8A.1 schema: tasks.parent_id column + tasks_parent partial index + seed row', () => {
-  const { dir, file } = tmpDbPath();
-  try {
-    const { db } = initStateDb(file);
-
-    const cols = db.prepare("PRAGMA table_info(tasks)").all();
-    const parentCol = cols.find((c) => c.name === 'parent_id');
-    assert.ok(parentCol, 'tasks.parent_id column must exist');
-    assert.equal(parentCol.type, 'TEXT');
-    assert.equal(parentCol.notnull, 0, 'parent_id must be nullable (top-level tasks)');
-
-    const indexRow = db
-      .prepare("SELECT name FROM sqlite_master WHERE type = 'index' AND name = 'tasks_parent'")
-      .get();
-    assert.ok(indexRow, 'tasks_parent index must exist');
-
-    const seedRow = db
-      .prepare("SELECT version, description FROM schema_version WHERE version = '8A.1'")
-      .get();
-    assert.ok(seedRow, 'schema_version row for 8A.1 must be seeded');
-    assert.match(seedRow.description, /parent_id/);
-
-    const fkInfo = db.prepare("PRAGMA foreign_key_list(tasks)").all();
-    const parentFk = fkInfo.find((fk) => fk.from === 'parent_id');
-    assert.ok(parentFk, 'parent_id must declare a foreign key to tasks(id)');
-    assert.equal(parentFk.table, 'tasks');
-    assert.equal(parentFk.to, 'id');
-    assert.equal(parentFk.on_delete, 'SET NULL');
-
-    closeStateDb(db);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('initStateDb migrates existing runtime constraints to Kimi without losing references', () => {
-  const { dir, file } = tmpDbPath('ubp-kimi-runtime-upgrade');
-  try {
-    const legacy = openStateDb(file);
-    const legacySchema = fs.readFileSync(SCHEMA_FILE, 'utf8').replaceAll(", 'kimi'", '');
-    legacy.exec(legacySchema);
-    legacy.prepare("DELETE FROM schema_version WHERE version IN ('9.1', '10.0', '11.0', '12.0')").run();
-    legacy.prepare(
-      "INSERT INTO tasks (id, title, type, priority) VALUES ('task-old', 'Old', 'feature', 'P1')",
-    ).run();
-    legacy.prepare(
-      `INSERT INTO sessions
-       (sid, task_id, runtime, worktree_path, artifact_dir, lease_expires_at)
-       VALUES ('session-old', 'task-old', 'codex', '/tmp/worktree', '/tmp/artifacts', '2099-01-01T00:00:00.000Z')`,
-    ).run();
-    legacy.prepare(
-      "INSERT INTO telemetry (session_id, event_type, tool_name) VALUES ('session-old', 'tool_call', 'task.list')",
-    ).run();
-    legacy.prepare(
-      `INSERT INTO incidents
-       (id, code, severity, message, session_id)
-       VALUES ('incident-old', 'OLD', 'warning', 'preserve me', 'session-old')`,
-    ).run();
-    legacy.prepare(
-      "INSERT INTO events (type, session_id, runtime) VALUES ('session_spawned', 'session-old', 'codex')",
-    ).run();
-    closeStateDb(legacy);
-
-    const upgraded = initStateDb(file);
-    assert.equal(upgraded.schema_version, '12.0');
-    assert.ok(upgraded.backup_path);
-    assert.ok(fs.existsSync(upgraded.backup_path));
-    assert.equal(upgraded.db.prepare("SELECT runtime FROM sessions WHERE sid = 'session-old'").get().runtime, 'codex');
-    assert.equal(upgraded.db.prepare("SELECT COUNT(*) AS n FROM telemetry WHERE session_id = 'session-old'").get().n, 1);
-    assert.equal(upgraded.db.prepare("SELECT COUNT(*) AS n FROM incidents WHERE session_id = 'session-old'").get().n, 1);
-    assert.deepEqual(upgraded.db.pragma('foreign_key_check'), []);
-    const migrations = upgraded.db.prepare(
-      "SELECT to_version, notes FROM migration_history WHERE to_version IN ('9.1', '10.0', '11.0', '12.0') ORDER BY id",
-    ).all();
-    assert.ok(migrations.some((row) => row.to_version === '9.1' && /Kimi/.test(row.notes)));
-    assert.ok(migrations.some((row) => row.to_version === '10.0' && /Context Spine/.test(row.notes)));
-    assert.ok(migrations.some((row) => row.to_version === '11.0' && /baseline adoption/i.test(row.notes)));
-    assert.ok(migrations.some((row) => row.to_version === '12.0' && /gap ledger|re-adoption/i.test(row.notes)));
-    assert.deepEqual(
-      upgraded.db.prepare("SELECT mode, status FROM baselines WHERE id = 'migrated-baseline'").get(),
-      { mode: 'migrated', status: 'adopting' },
-    );
-
-    upgraded.db.prepare(
-      "INSERT INTO tasks (id, title, type, priority) VALUES ('task-kimi', 'Kimi', 'feature', 'P1')",
-    ).run();
-    const session = stateOps.createSession(upgraded.db, {
-      sid: 'session-kimi',
-      task_id: 'task-kimi',
-      runtime: 'kimi',
-      worktree_path: '/tmp/kimi-worktree',
-      artifact_dir: '/tmp/kimi-artifacts',
-    });
-    assert.equal(session.runtime, 'kimi');
-    const event = stateOps.appendEvent(upgraded.db, { type: 'kimi-ready', runtime: 'kimi' });
-    assert.ok(event.event_id > 0);
-    closeStateDb(upgraded.db);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});