ultra-builder-pro-cli 0.14.0 → 0.16.0

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

package/mcp-server/lib/task-expander.test.cjs

@@ -1,169 +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 ops = require('./state-ops.cjs');
-const changes = require('./change-workflow.cjs');
-const { expandTask, TaskExpandError } = require('./task-expander.cjs');
-
-function tmpDb() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-expand-'));
-  const { db } = initStateDb(path.join(dir, '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', 'fixture', ?)`,
-  ).run(new Date().toISOString());
-  return { dir, db };
-}
-
-function cleanup({ dir, db }) {
-  closeStateDb(db);
-  fs.rmSync(dir, { recursive: true, force: true });
-}
-
-function seedParent(db, overrides = {}) {
-  return ops.createTask(db, {
-    id: 'parent-1',
-    title: 'Build authentication module',
-    type: 'feature',
-    priority: 'P1',
-    complexity: 9,
-    files_modified: ['src/auth/index.ts'],
-    ...overrides,
-  });
-}
-
-const HAPPY_CHILDREN = [
-  { id: 'child-1', title: 'Design auth schema', type: 'architecture', priority: 'P1', complexity: 4, deps: [], files_modified: ['src/auth/schema.ts'] },
-  { id: 'child-2', title: 'Implement login endpoint', type: 'feature', priority: 'P1', complexity: 5, deps: ['child-1'], files_modified: ['src/auth/login.ts'] },
-  { id: 'child-3', title: 'Add signup endpoint', type: 'feature', priority: 'P2', complexity: 3, deps: ['child-1'], files_modified: ['src/auth/signup.ts'] },
-];
-
-test('expandTask atomically persists host-derived children without a provider client', () => {
-  const ctx = tmpDb();
-  try {
-    seedParent(ctx.db);
-    const result = expandTask(ctx.db, { id: 'parent-1', children: HAPPY_CHILDREN });
-    assert.equal(result.parent_id, 'parent-1');
-    assert.equal(result.children.length, 3);
-    assert.equal(ops.readTask(ctx.db, 'parent-1').status, 'expanded');
-    for (const child of HAPPY_CHILDREN) {
-      const row = ops.readTask(ctx.db, child.id);
-      assert.equal(row.parent_id, 'parent-1');
-      assert.equal(row.status, 'pending');
-    }
-    const events = ops.subscribeEventsSince(ctx.db, { since_id: 0, limit: 100 }).events;
-    assert.equal(events.filter((event) => event.type === 'task_expanded').length, 1);
-  } finally { cleanup(ctx); }
-});
-
-test('expandTask rejects missing and already expanded parents', () => {
-  const ctx = tmpDb();
-  try {
-    assert.throws(
-      () => expandTask(ctx.db, { id: 'missing', children: HAPPY_CHILDREN }),
-      (err) => err instanceof TaskExpandError && err.code === 'TASK_NOT_FOUND',
-    );
-    seedParent(ctx.db);
-    expandTask(ctx.db, { id: 'parent-1', children: HAPPY_CHILDREN });
-    assert.throws(
-      () => expandTask(ctx.db, { id: 'parent-1', children: [{ ...HAPPY_CHILDREN[0], id: 'other' }] }),
-      (err) => err instanceof TaskExpandError && err.code === 'ALREADY_EXPANDED',
-    );
-  } finally { cleanup(ctx); }
-});
-
-test('expandTask requires valid host-derived children and leaves the parent untouched on failure', () => {
-  const ctx = tmpDb();
-  try {
-    seedParent(ctx.db);
-    for (const children of [undefined, [], [{
-      id: 'child-1', title: 'x', type: 'feature', priority: 'P1',
-    }]]) {
-      assert.throws(
-        () => expandTask(ctx.db, { id: 'parent-1', children }),
-        (err) => err instanceof TaskExpandError && err.code === 'INVALID_OUTPUT',
-      );
-      assert.equal(ops.readTask(ctx.db, 'parent-1').status, 'pending');
-    }
-  } finally { cleanup(ctx); }
-});
-
-test('expandTask rejects duplicate child ids', () => {
-  const ctx = tmpDb();
-  try {
-    seedParent(ctx.db);
-    assert.throws(
-      () => expandTask(ctx.db, { id: 'parent-1', children: [
-        { id: 'same', title: 'First child', type: 'feature', priority: 'P2' },
-        { id: 'same', title: 'Second child', type: 'feature', priority: 'P2' },
-      ] }),
-      (err) => err instanceof TaskExpandError && err.code === 'INVALID_OUTPUT',
-    );
-  } finally { cleanup(ctx); }
-});
-
-test('expandTask rolls back every child when one id collides', () => {
-  const ctx = tmpDb();
-  try {
-    seedParent(ctx.db);
-    ops.createTask(ctx.db, {
-      id: 'child-1', title: 'Pre-existing task', type: 'bugfix', priority: 'P3',
-    });
-    assert.throws(() => expandTask(ctx.db, { id: 'parent-1', children: HAPPY_CHILDREN }));
-    assert.equal(ops.readTask(ctx.db, 'parent-1').status, 'pending');
-    assert.equal(ops.readTask(ctx.db, 'child-2'), null);
-    assert.equal(ops.readTask(ctx.db, 'child-3'), null);
-  } finally { cleanup(ctx); }
-});
-
-test('expandTask children inherit parent tag and change ownership', () => {
-  const ctx = tmpDb();
-  try {
-    const { change } = changes.createChange(ctx.db, {
-      id: 'expand-change', title: 'Expand one task', kind: 'quick',
-      intent: 'Keep child ownership inside the active change.',
-      docs_impact: { status: 'none', rationale: 'test fixture' },
-    }, { rootDir: ctx.dir });
-    seedParent(ctx.db, { tag: 'feat-auth', change_id: change.id });
-    const result = expandTask(ctx.db, {
-      id: 'parent-1', children: HAPPY_CHILDREN, rootDir: ctx.dir,
-    });
-    for (const child of result.children) {
-      const row = ops.readTask(ctx.db, child.id);
-      assert.equal(row.tag, 'feat-auth');
-      assert.equal(row.change_id, change.id);
-    }
-  } finally { cleanup(ctx); }
-});
-
-test('expandTask enforces baseline authority before writing children', () => {
-  for (const baseline of ['missing', 'draft', 'migrated']) {
-    const ctx = tmpDb();
-    try {
-      seedParent(ctx.db);
-      if (baseline === 'missing') ctx.db.prepare('DELETE FROM baselines').run();
-      else if (baseline === 'draft') {
-        ctx.db.prepare("UPDATE baselines SET status = 'draft' WHERE id = 'test-baseline'").run();
-      } else {
-        ctx.db.prepare(
-          "UPDATE baselines SET mode = 'migrated', status = 'adopting' WHERE id = 'test-baseline'",
-        ).run();
-      }
-      assert.throws(
-        () => expandTask(ctx.db, {
-          id: 'parent-1', children: HAPPY_CHILDREN, rootDir: ctx.dir,
-        }),
-        (error) => error.code === 'BASELINE_NOT_READY',
-      );
-      assert.equal(ops.readTask(ctx.db, 'child-1'), null);
-      assert.equal(ops.readTask(ctx.db, 'parent-1').status, 'pending');
-    } finally { cleanup(ctx); }
-  }
-});