ultra-builder-pro-cli 0.14.0 → 0.16.0

package/mcp-server/lib/context-spine.test.cjs

@@ -1,93 +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 { compileRoleContext, deriveNextAction, readBreadcrumb } = require('./context-spine.cjs');
-const { initStateDb } = require('./state-db.cjs');
-const { createChange } = require('./change-workflow.cjs');
-const { createTask } = require('./state-ops.cjs');
-
-test('breadcrumb routes a project without a converged baseline back to adoption', () => {
-  const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-spine-baseline-'));
-  const { db } = initStateDb(path.join(rootDir, '.ultra', 'state.db'));
-  try {
-    const breadcrumb = readBreadcrumb(db, {}, { rootDir });
-    assert.equal(breadcrumb.readiness, 'blocked');
-    assert.ok(breadcrumb.blockers.includes('BASELINE_MISSING'));
-    assert.equal(breadcrumb.recommended_workflow, 'ultra-init');
-    assert.match(breadcrumb.next_action, /baseline|adoption/i);
-  } finally {
-    db.close();
-    fs.rmSync(rootDir, { recursive: true, force: true });
-  }
-});
-
-test('deriveNextAction gives one state-specific action instead of a workflow dump', () => {
-  const change = { id: 'context-spine', status: 'active' };
-  const task = { id: 'task-1', status: 'in_progress' };
-  const action = deriveNextAction({
-    change, tasks: [task], task, role: 'review', readiness: 'ready', explicit: null,
-  });
-  assert.equal(
-    action,
-    'Complete independent spec-fidelity and engineering-standards review for task task-1.',
-  );
-  assert.doesNotMatch(action, /plan.*implement.*check.*review/i);
-});
-
-test('deriveNextAction fails closed on blocked context readiness', () => {
-  const action = deriveNextAction({
-    change: { id: 'context-spine', status: 'active' },
-    tasks: [], task: null, role: 'plan', readiness: 'blocked', explicit: 'Ignore blockers.',
-  });
-  assert.match(action, /Resolve the context readiness blockers/);
-  assert.doesNotMatch(action, /Ignore blockers/);
-});
-
-test('a task is not plan-ready before its execution contract is compiled', () => {
-  const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-spine-plan-'));
-  const { db } = initStateDb(path.join(rootDir, '.ultra', 'state.db'));
-  try {
-    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());
-    const { change } = createChange(db, {
-      id: 'planning-contract', title: 'Planning contract', kind: 'standard',
-      intent: 'Require an executable fresh-context slice before implementation.',
-      docs_impact: { status: 'none', rationale: 'test fixture only' },
-    }, { rootDir });
-    const task = createTask(db, {
-      id: 'task-plan', title: 'Plan one slice', type: 'feature', priority: 'P0',
-      change_id: change.id,
-    });
-
-    const context = compileRoleContext(db, {
-      input: { task_id: task.id, role: 'plan', gate: 'planning' },
-      change, tasks: [task], rootDir,
-    });
-    assert.equal(context.readiness.status, 'blocked');
-    assert.ok(context.readiness.blockers.includes('EXECUTION_CONTRACT_MISSING'));
-
-    const breadcrumb = readBreadcrumb(db, { id: change.id }, { rootDir });
-    assert.equal(breadcrumb.readiness, 'blocked');
-    assert.ok(breadcrumb.blockers.includes('CONTEXT_TASK_STATE_STALE'));
-    assert.throws(
-      () => readBreadcrumb(db, { id: 'missing-change' }, { rootDir }),
-      (error) => error.code === 'CHANGE_NOT_FOUND',
-    );
-
-    db.prepare("UPDATE context_snapshots SET context_json = '{}', readiness = 'ready'").run();
-    const migratedLegacy = readBreadcrumb(db, { id: change.id }, { rootDir });
-    assert.equal(migratedLegacy.readiness, 'blocked');
-    assert.ok(migratedLegacy.blockers.includes('CONTEXT_SNAPSHOT_UPGRADE_REQUIRED'));
-  } finally {
-    db.close();
-    fs.rmSync(rootDir, { recursive: true, force: true });
-  }
-});

package/mcp-server/lib/doctor.test.cjs

@@ -1,148 +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 runtime = require('./runtime-state.cjs');
-const doctor = require('./doctor.cjs');
-const baselines = require('./baseline-workflow.cjs');
-const changes = require('./change-workflow.cjs');
-const archiveJournal = require('./archive-journal.cjs');
-
-function fixture({ baseline = true } = {}) {
-  const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-doctor-'));
-  const { db } = initStateDb(path.join(rootDir, '.ultra', 'state.db'));
-  if (baseline) {
-    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());
-  }
-  return { rootDir, db };
-}
-
-function cleanup({ rootDir, db }) {
-  closeStateDb(db);
-  fs.rmSync(rootDir, { recursive: true, force: true });
-}
-
-test('doctor reports structured health for an initialized Ultra project', async () => {
-  const fx = fixture();
-  try {
-    const report = await doctor.runDoctor(fx.db, { rootDir: fx.rootDir });
-    assert.equal(report.status, 'healthy');
-    assert.equal(report.repair_performed, false);
-    assert.equal(report.checks.state_db.status, 'pass');
-    assert.equal(report.checks.external_providers.ownership, 'external');
-  } finally {
-    cleanup(fx);
-  }
-});
-
-test('doctor reports incomplete brownfield adoption as advisory rather than authority failure', async () => {
-  const fx = fixture({ baseline: false });
-  try {
-    baselines.startBaseline(fx.db, {
-      id: 'adoption', project_name: 'legacy', mode: 'brownfield', scope: ['.'],
-    }, { rootDir: fx.rootDir, emitEvent: false });
-    const report = await doctor.runDoctor(fx.db, { rootDir: fx.rootDir });
-    assert.equal(report.status, 'healthy');
-    assert.equal(report.checks.baseline.status, 'warning');
-    assert.equal(report.checks.baseline.mode, 'brownfield');
-    assert.deepEqual(report.checks.baseline.gaps, {
-      total: 0, open: 0, blocking: 0, by_category: {},
-    });
-    assert.ok(report.checks.baseline.blockers.includes('BASELINE_NOT_READY:adopting'));
-  } finally {
-    cleanup(fx);
-  }
-});
-
-test('doctor repair is backup-first and drains projection/spec-event recovery work', async () => {
-  const fx = fixture();
-  try {
-    ops.createTask(fx.db, {
-      id: 'stale-target', title: 'Refresh context', type: 'feature', priority: 'P1',
-      trace_to: '.ultra/specs/product.md#continuous-change',
-    });
-    ops.appendEvent(fx.db, {
-      type: 'spec_changed',
-      payload: { sections: ['.ultra/specs/product.md#continuous-change'] },
-    });
-    runtime.enqueueProjection(fx.db, { tool_name: 'task.append_event', event_cursor: 2 });
-
-    const report = await doctor.runDoctor(fx.db, { rootDir: fx.rootDir, repair: true });
-    assert.equal(report.repair_performed, true);
-    assert.ok(fs.existsSync(report.backup_path));
-    assert.equal(ops.readTask(fx.db, 'stale-target').stale, true);
-    assert.equal(runtime.readConsumerCursor(fx.db, 'spec-staleness'), 2);
-    assert.equal(runtime.listProjectionJobs(fx.db, { status: 'pending' }).length, 0);
-    assert.equal(report.status, 'healthy');
-  } finally {
-    cleanup(fx);
-  }
-});
-
-test('doctor reports running projection work and repairs only stale interrupted jobs', async () => {
-  const fx = fixture();
-  try {
-    ops.appendEvent(fx.db, { type: 'spec_changed', payload: { sections: [] } });
-    const job = runtime.enqueueProjection(fx.db, { tool_name: 'task.append_event', event_cursor: 1 });
-    fx.db.prepare("UPDATE projection_jobs SET status = 'running', updated_at = ? WHERE id = ?")
-      .run('2000-01-01T00:00:00.000Z', job.id);
-
-    const before = await doctor.runDoctor(fx.db, { rootDir: fx.rootDir });
-    assert.equal(before.status, 'degraded');
-    assert.equal(before.checks.projections.running, 1);
-
-    const after = await doctor.runDoctor(fx.db, {
-      rootDir: fx.rootDir,
-      repair: true,
-      projectionStaleAfterMs: 0,
-    });
-    assert.equal(after.repair.interrupted.requeued, 1);
-    assert.equal(after.checks.projections.running, 0);
-    assert.equal(after.status, 'healthy');
-  } finally {
-    cleanup(fx);
-  }
-});
-
-test('doctor repair resumes an archive journal left after a process crash', async () => {
-  const fx = fixture();
-  try {
-    const activeRoot = path.join(fx.rootDir, '.ultra', 'changes', 'active', 'doctor-archive');
-    fs.mkdirSync(activeRoot, { recursive: true });
-    fs.writeFileSync(path.join(activeRoot, 'intent.md'), '# Authorized archive\n');
-    fx.db.prepare(
-      `INSERT INTO changes
-       (id, title, kind, status, intent, docs_impact_json, provider_refs_json, artifact_root)
-       VALUES ('doctor-archive', 'Recover archive', 'quick', 'ready', 'Recover it',
-               '{"status":"none","files":[],"rationale":"recovery"}', '{}',
-               '.ultra/changes/active/doctor-archive')`,
-    ).run();
-    const prepared = archiveJournal.prepareArchiveMove({
-      rootDir: fx.rootDir, change: changes.readChange(fx.db, 'doctor-archive'),
-      summary: 'Resume the authorized archive.', baselineUpdates: [],
-      noBaselineChangeReason: 'No baseline content changed.',
-    });
-    assert.equal(fs.existsSync(prepared.source), false);
-    const before = doctor.inspectSystem(fx.db, { rootDir: fx.rootDir });
-    assert.equal(before.status, 'degraded');
-    assert.equal(before.checks.archive_recovery.pending, 1);
-
-    const after = await doctor.runDoctor(fx.db, { rootDir: fx.rootDir, repair: true });
-    assert.equal(after.repair.archives.resumed, 1);
-    assert.equal(changes.readChange(fx.db, 'doctor-archive').status, 'archived');
-    assert.equal(after.checks.archive_recovery.pending, 0);
-    assert.equal(fs.existsSync(path.join(prepared.destination, archiveJournal.INTENT_FILE)), false);
-  } finally {
-    cleanup(fx);
-  }
-});

package/mcp-server/lib/plan-store.test.cjs

@@ -1,132 +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 {
-  savePlanArtifact,
-  loadPlanArtifact,
-  selectSection,
-  renderPlanMd,
-  DEFAULT_ARTIFACT_RELPATH,
-} = require('./plan-store.cjs');
-
-function tmpRoot() {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-plan-'));
-}
-
-const SAMPLE_PLAN = Object.freeze({
-  waves: [
-    { id: 1, tasks: ['a', 'b'], parallel: true },
-    { id: 2, tasks: ['c'], parallel: false },
-  ],
-  ownership_forecast: { a: ['src/a.ts'], b: ['src/b.ts'], c: ['src/c.ts'] },
-  conflict_surface: [],
-  estimated_cost_usd: 0.12,
-  estimated_duration_min: 35,
-  cycles: [],
-});
-
-test('savePlanArtifact: json format writes a file we can JSON.parse back', () => {
-  const root = tmpRoot();
-  try {
-    const outPath = path.join(root, '.ultra', 'execution-plan.json');
-    const { plan_path } = savePlanArtifact(SAMPLE_PLAN, outPath, 'json');
-    assert.equal(plan_path, path.resolve(outPath));
-    assert.ok(fs.existsSync(plan_path));
-    const parsed = JSON.parse(fs.readFileSync(plan_path, 'utf8'));
-    assert.deepEqual(parsed.waves, SAMPLE_PLAN.waves);
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('savePlanArtifact: md format writes a human-readable report', () => {
-  const root = tmpRoot();
-  try {
-    const outPath = path.join(root, '.ultra', 'execution-plan.md');
-    savePlanArtifact(SAMPLE_PLAN, outPath, 'md');
-    const text = fs.readFileSync(outPath, 'utf8');
-    assert.match(text, /# Execution Plan/);
-    assert.match(text, /Wave 1/);
-    assert.match(text, /parallel/);
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('savePlanArtifact: missing out_path → WRITE_FAILED', () => {
-  assert.throws(
-    () => savePlanArtifact(SAMPLE_PLAN, '', 'json'),
-    (err) => err.code === 'WRITE_FAILED',
-  );
-});
-
-test('loadPlanArtifact: no file → null', () => {
-  const root = tmpRoot();
-  try {
-    assert.equal(loadPlanArtifact(root), null);
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('loadPlanArtifact: round-trip via DEFAULT_ARTIFACT_RELPATH', () => {
-  const root = tmpRoot();
-  try {
-    const target = path.join(root, DEFAULT_ARTIFACT_RELPATH);
-    savePlanArtifact(SAMPLE_PLAN, target, 'json');
-    const loaded = loadPlanArtifact(root);
-    assert.deepEqual(loaded.waves, SAMPLE_PLAN.waves);
-    assert.equal(loaded.estimated_cost_usd, 0.12);
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('loadPlanArtifact: corrupt file → null (no throw)', () => {
-  const root = tmpRoot();
-  try {
-    const target = path.join(root, DEFAULT_ARTIFACT_RELPATH);
-    fs.mkdirSync(path.dirname(target), { recursive: true });
-    fs.writeFileSync(target, '{not json');
-    assert.equal(loadPlanArtifact(root), null);
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('selectSection: tasks returns ownership_forecast only', () => {
-  const r = selectSection(SAMPLE_PLAN, 'tasks');
-  assert.deepEqual(Object.keys(r), ['ownership_forecast']);
-});
-
-test('selectSection: topo returns waves only', () => {
-  const r = selectSection(SAMPLE_PLAN, 'topo');
-  assert.deepEqual(Object.keys(r), ['waves']);
-});
-
-test('selectSection: conflicts returns conflict_surface only', () => {
-  const r = selectSection(SAMPLE_PLAN, 'conflicts');
-  assert.deepEqual(Object.keys(r), ['conflict_surface']);
-});
-
-test('selectSection: all (default) returns whole plan', () => {
-  assert.deepEqual(selectSection(SAMPLE_PLAN, 'all'), SAMPLE_PLAN);
-  assert.deepEqual(selectSection(SAMPLE_PLAN), SAMPLE_PLAN);
-});
-
-test('renderPlanMd: reports cycles + conflicts counts when present', () => {
-  const planWithConflicts = {
-    ...SAMPLE_PLAN,
-    conflict_surface: [{ files: ['x.ts'], tasks: ['a', 'b'], recommend: 'sequentialize' }],
-    cycles: [['z', 'y']],
-  };
-  const md = renderPlanMd(planWithConflicts);
-  assert.match(md, /Conflicts: 1/);
-  assert.match(md, /Cycles: 1/);
-  assert.match(md, /## Conflict Surface/);
-});

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

@@ -1,82 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-
-const { parsePrd, PrdParseError, TASK_LIST_SCHEMA } = require('./prd-parser.cjs');
-
-const HAPPY_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 validates and normalizes host-derived tasks without a provider client', () => {
-  const result = parsePrd(HAPPY_TASKS, { tag: 'feat-auth', changeId: 'auth-change' });
-  assert.equal(result.tasks.length, 2);
-  assert.equal(result.tasks[0].tag, 'feat-auth');
-  assert.equal(result.tasks[0].change_id, 'auth-change');
-  assert.deepEqual(result.tasks[1].deps, ['task-1']);
-  assert.equal(Object.hasOwn(result, 'model'), false);
-  assert.equal(Object.hasOwn(result, 'provider'), false);
-  assert.equal(Object.hasOwn(result, 'usage'), false);
-});
-
-test('parsePrd requires at least one host-derived task', () => {
-  for (const value of [undefined, null, [], 'not-an-array']) {
-    assert.throws(
-      () => parsePrd(value),
-      (err) => err instanceof PrdParseError && err.code === 'NO_INPUT',
-    );
-  }
-});
-
-test('parsePrd rejects an invalid task shape', () => {
-  assert.throws(
-    () => parsePrd([{
-      id: 'task-1', title: 'Missing priority', type: 'feature',
-    }]),
-    (err) => err instanceof PrdParseError && err.code === 'PARSE_FAILED' && /priority/.test(err.message),
-  );
-});
-
-test('parsePrd rejects duplicate task ids', () => {
-  assert.throws(
-    () => parsePrd([
-      { id: 'task-1', title: 'First copy', type: 'feature', priority: 'P2' },
-      { id: 'task-1', title: 'Second copy', type: 'feature', priority: 'P2' },
-    ]),
-    (err) => err instanceof PrdParseError && err.code === 'PARSE_FAILED' && /duplicate/i.test(err.message),
-  );
-});
-
-test('parsePrd normalizes optional fields', () => {
-  const result = parsePrd([{
-    id: 'task-1', title: 'Minimal task', type: 'feature', priority: 'P3',
-  }]);
-  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);
-  assert.equal(result.tasks[0].change_id, null);
-});
-
-test('TASK_LIST_SCHEMA remains available to MCP contract consumers', () => {
-  assert.equal(TASK_LIST_SCHEMA.required[0], 'tasks');
-  assert.equal(TASK_LIST_SCHEMA.properties.tasks.minItems, 1);
-});

package/mcp-server/lib/project-breadcrumb.test.cjs

@@ -1,112 +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 Database = require('better-sqlite3');
-
-const { initStateDb, closeStateDb } = require('./state-db.cjs');
-const { createChange } = require('./change-workflow.cjs');
-const { createTask } = require('./state-ops.cjs');
-const { compileRoleContext, readBreadcrumb } = require('./context-spine.cjs');
-const {
-  readProjectBreadcrumb,
-  renderProjectBreadcrumb,
-} = require('./project-breadcrumb.cjs');
-
-function tmpProject(prefix) {
-  const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-  fs.mkdirSync(path.join(rootDir, '.ultra'), { recursive: true });
-  return rootDir;
-}
-
-test('project reader returns the exact canonical breadcrumb from state.db', () => {
-  const rootDir = tmpProject('ubp-project-breadcrumb-');
-  const state = initStateDb(path.join(rootDir, '.ultra', 'state.db'));
-  try {
-    state.db.prepare(
-      `INSERT INTO baselines
-       (id, project_name, mode, status, approved_by, approval_note, converged_at)
-       VALUES ('baseline-1', 'fixture', 'greenfield', 'ready', 'test', 'fixture', ?)`,
-    ).run(new Date().toISOString());
-    const { change } = createChange(state.db, {
-      id: 'db-change', title: 'Database change', kind: 'quick',
-      intent: 'Prove every host consumes one breadcrumb.',
-      docs_impact: { status: 'none', rationale: 'test fixture' },
-    }, { rootDir });
-    const task = createTask(state.db, {
-      id: 'db-task', title: 'Use one breadcrumb', type: 'bugfix', priority: 'P0',
-      change_id: change.id,
-    });
-    compileRoleContext(state.db, {
-      input: {
-        task_id: task.id,
-        role: 'implement',
-        gate: 'implementation',
-        execution_contract: {
-          slice_kind: 'tracer_bullet',
-          public_seam: 'all host injections',
-          verification_command: 'npm test',
-        },
-        next_action: 'Run the cross-host breadcrumb regression test.',
-      },
-      change,
-      tasks: [task],
-      rootDir,
-    });
-
-    const expected = readBreadcrumb(state.db, {}, { rootDir });
-    const actual = readProjectBreadcrumb(rootDir);
-    assert.deepEqual(actual, expected);
-    const rendered = renderProjectBreadcrumb(rootDir, actual);
-    assert.match(rendered, /Change: db-change/);
-    assert.match(rendered, /Task: db-task/);
-    assert.ok(rendered.includes(actual.next_action));
-    assert.match(rendered, /Authority: \.ultra\/state\.db/);
-  } finally {
-    closeStateDb(state.db);
-    fs.rmSync(rootDir, { recursive: true, force: true });
-  }
-});
-
-test('project reader routes a missing authority to ultra-init', () => {
-  const rootDir = tmpProject('ubp-project-missing-db-');
-  try {
-    const breadcrumb = readProjectBreadcrumb(rootDir);
-    assert.equal(breadcrumb.readiness, 'blocked');
-    assert.deepEqual(breadcrumb.blockers, ['STATE_DB_MISSING']);
-    assert.equal(breadcrumb.recommended_workflow, 'ultra-init');
-  } finally {
-    fs.rmSync(rootDir, { recursive: true, force: true });
-  }
-});
-
-test('project reader routes an old schema to ultra-init without consulting projections', () => {
-  const rootDir = tmpProject('ubp-project-old-schema-');
-  const db = new Database(path.join(rootDir, '.ultra', 'state.db'));
-  try {
-    db.exec(`
-      CREATE TABLE schema_version (
-        version TEXT PRIMARY KEY,
-        applied_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
-      );
-      INSERT INTO schema_version(version) VALUES ('10.0');
-    `);
-  } finally {
-    db.close();
-  }
-  fs.writeFileSync(path.join(rootDir, '.ultra', 'workflow-state.json'), JSON.stringify({
-    command: 'ultra-dev', task_id: 'projection-task', status: 'active',
-  }));
-  try {
-    const breadcrumb = readProjectBreadcrumb(rootDir);
-    assert.equal(breadcrumb.readiness, 'blocked');
-    assert.ok(breadcrumb.blockers.includes('STATE_SCHEMA_MIGRATION_REQUIRED:10.0'));
-    assert.equal(breadcrumb.recommended_workflow, 'ultra-init');
-    assert.doesNotMatch(JSON.stringify(breadcrumb), /projection-task|ultra-dev/);
-  } finally {
-    fs.rmSync(rootDir, { recursive: true, force: true });
-  }
-});

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