ultra-builder-pro-cli 0.13.0 → 0.15.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/llm-client.cjs

@@ -1,157 +0,0 @@
-'use strict';
-
-// Phase 8A.1 — Unified LLM client over @anthropic-ai/sdk and openai.
-//
-// Provider is inferred from model prefix (claude/opus/sonnet/haiku → Anthropic,
-// gpt/o1/o3 → OpenAI). API keys come from env. The single surface the rest of
-// the code depends on is `client.completeJson({ system, user, maxTokens })`,
-// which returns `{ json, raw, usage, model, provider }` — the model's reply
-// already parsed as JSON (caller handles schema validation on `.json`).
-
-const Anthropic = require('@anthropic-ai/sdk');
-const OpenAI = require('openai');
-
-const PROVIDER_RULES = Object.freeze([
-  { pattern: /^(claude|opus|sonnet|haiku)/i, provider: 'anthropic' },
-  { pattern: /^(gpt|o1|o3)/i,                provider: 'openai'    },
-]);
-
-const DEFAULT_MODEL = 'claude-sonnet-4-6';
-const DEFAULT_MAX_TOKENS = 4096;
-
-class LlmClientError extends Error {
-  constructor(code, message, cause) {
-    super(message);
-    this.name = 'LlmClientError';
-    this.code = code;
-    if (cause) this.cause = cause;
-  }
-}
-
-function inferProvider(model) {
-  if (!model || typeof model !== 'string') return null;
-  for (const rule of PROVIDER_RULES) {
-    if (rule.pattern.test(model)) return rule.provider;
-  }
-  return null;
-}
-
-function resolveProviderKey(provider, apiKey) {
-  if (apiKey) return apiKey;
-  return provider === 'anthropic' ? process.env.ANTHROPIC_API_KEY : process.env.OPENAI_API_KEY;
-}
-
-function createLlmClient({ model, apiKey } = {}) {
-  const resolvedModel = model || process.env.UBP_PLANNER_MODEL || DEFAULT_MODEL;
-  const provider = inferProvider(resolvedModel);
-  if (!provider) {
-    throw new LlmClientError(
-      'LLM_UNSUPPORTED_MODEL',
-      `cannot infer provider from model "${resolvedModel}"`,
-    );
-  }
-  const key = resolveProviderKey(provider, apiKey);
-  if (!key) {
-    const envName = provider === 'anthropic' ? 'ANTHROPIC_API_KEY' : 'OPENAI_API_KEY';
-    throw new LlmClientError('NO_LLM_CREDENTIALS', `${envName} not set`);
-  }
-  return provider === 'anthropic'
-    ? buildAnthropicAdapter({ model: resolvedModel, apiKey: key })
-    : buildOpenAiAdapter({ model: resolvedModel, apiKey: key });
-}
-
-function buildAnthropicAdapter({ model, apiKey }) {
-  const sdk = new Anthropic({ apiKey });
-  return {
-    provider: 'anthropic',
-    model,
-    async completeJson({ system, user, maxTokens = DEFAULT_MAX_TOKENS }) {
-      let message;
-      try {
-        message = await sdk.messages.create({
-          model,
-          max_tokens: maxTokens,
-          system,
-          messages: [{ role: 'user', content: user }],
-        });
-      } catch (err) {
-        throw new LlmClientError('LLM_API_ERROR', `Anthropic API error: ${err.message}`, err);
-      }
-      const text = extractAnthropicText(message.content);
-      const usage = {
-        input_tokens: message.usage?.input_tokens ?? 0,
-        output_tokens: message.usage?.output_tokens ?? 0,
-      };
-      return parseCompletionJson({ raw: text, usage, model, provider: 'anthropic' });
-    },
-  };
-}
-
-function buildOpenAiAdapter({ model, apiKey }) {
-  const sdk = new OpenAI({ apiKey });
-  return {
-    provider: 'openai',
-    model,
-    async completeJson({ system, user, maxTokens = DEFAULT_MAX_TOKENS }) {
-      let completion;
-      try {
-        completion = await sdk.chat.completions.create({
-          model,
-          max_tokens: maxTokens,
-          response_format: { type: 'json_object' },
-          messages: [
-            { role: 'system', content: system },
-            { role: 'user',   content: user   },
-          ],
-        });
-      } catch (err) {
-        throw new LlmClientError('LLM_API_ERROR', `OpenAI API error: ${err.message}`, err);
-      }
-      const text = completion.choices?.[0]?.message?.content ?? '';
-      const usage = {
-        input_tokens:  completion.usage?.prompt_tokens     ?? 0,
-        output_tokens: completion.usage?.completion_tokens ?? 0,
-      };
-      return parseCompletionJson({ raw: text, usage, model, provider: 'openai' });
-    },
-  };
-}
-
-function extractAnthropicText(content) {
-  if (!Array.isArray(content)) return '';
-  return content.filter((b) => b && b.type === 'text').map((b) => b.text || '').join('');
-}
-
-function parseCompletionJson({ raw, usage, model, provider }) {
-  const trimmed = stripCodeFence(raw).trim();
-  if (!trimmed) {
-    throw new LlmClientError('LLM_INVALID_JSON', 'LLM returned empty content');
-  }
-  let json;
-  try {
-    json = JSON.parse(trimmed);
-  } catch (err) {
-    throw new LlmClientError(
-      'LLM_INVALID_JSON',
-      `failed to parse LLM response as JSON: ${err.message}`,
-      err,
-    );
-  }
-  return { json, raw, usage, model, provider };
-}
-
-function stripCodeFence(s) {
-  if (!s || typeof s !== 'string') return '';
-  const fenced = s.match(/^```(?:json)?\s*\n?([\s\S]*?)\n?```\s*$/);
-  return fenced ? fenced[1] : s;
-}
-
-module.exports = {
-  createLlmClient,
-  inferProvider,
-  LlmClientError,
-  parseCompletionJson,
-  stripCodeFence,
-  DEFAULT_MODEL,
-  DEFAULT_MAX_TOKENS,
-};

package/mcp-server/lib/llm-client.test.cjs

@@ -1,156 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-
-const {
-  createLlmClient,
-  inferProvider,
-  LlmClientError,
-  parseCompletionJson,
-  stripCodeFence,
-  DEFAULT_MODEL,
-} = require('./llm-client.cjs');
-
-test('inferProvider: claude family → anthropic', () => {
-  assert.equal(inferProvider('claude-sonnet-4-6'), 'anthropic');
-  assert.equal(inferProvider('claude-opus-4-7'), 'anthropic');
-  assert.equal(inferProvider('sonnet-legacy'), 'anthropic');
-  assert.equal(inferProvider('opus-anything'), 'anthropic');
-  assert.equal(inferProvider('haiku-4-5'), 'anthropic');
-});
-
-test('inferProvider: GPT / o1 / o3 → openai', () => {
-  assert.equal(inferProvider('gpt-4o'), 'openai');
-  assert.equal(inferProvider('gpt-5.4'), 'openai');
-  assert.equal(inferProvider('o1-preview'), 'openai');
-  assert.equal(inferProvider('o3-mini'), 'openai');
-});
-
-test('inferProvider: unknown prefix → null', () => {
-  assert.equal(inferProvider('llama-3'), null);
-  assert.equal(inferProvider(''), null);
-  assert.equal(inferProvider(null), null);
-  assert.equal(inferProvider(undefined), null);
-});
-
-test('stripCodeFence: removes ```json ... ``` fence', () => {
-  const input = '```json\n{"a":1}\n```';
-  assert.equal(stripCodeFence(input).trim(), '{"a":1}');
-});
-
-test('stripCodeFence: removes plain ``` ... ``` fence', () => {
-  const input = '```\n{"a":1}\n```';
-  assert.equal(stripCodeFence(input).trim(), '{"a":1}');
-});
-
-test('stripCodeFence: leaves unfenced content alone', () => {
-  assert.equal(stripCodeFence('{"a":1}'), '{"a":1}');
-  assert.equal(stripCodeFence('   '), '   ');
-});
-
-test('stripCodeFence: empty / nullish → empty string', () => {
-  assert.equal(stripCodeFence(''), '');
-  assert.equal(stripCodeFence(null), '');
-  assert.equal(stripCodeFence(undefined), '');
-});
-
-test('parseCompletionJson: valid JSON → parsed object', () => {
-  const r = parseCompletionJson({
-    raw: '{"ok":true,"n":2}',
-    usage: { input_tokens: 10, output_tokens: 5 },
-    model: 'claude-sonnet-4-6',
-    provider: 'anthropic',
-  });
-  assert.deepEqual(r.json, { ok: true, n: 2 });
-  assert.equal(r.usage.input_tokens, 10);
-  assert.equal(r.model, 'claude-sonnet-4-6');
-  assert.equal(r.provider, 'anthropic');
-});
-
-test('parseCompletionJson: fenced JSON → parsed object', () => {
-  const r = parseCompletionJson({
-    raw: '```json\n{"x":42}\n```',
-    usage: {},
-    model: 'gpt-5',
-    provider: 'openai',
-  });
-  assert.deepEqual(r.json, { x: 42 });
-});
-
-test('parseCompletionJson: empty content → LLM_INVALID_JSON', () => {
-  assert.throws(
-    () => parseCompletionJson({ raw: '', usage: {}, model: 'x', provider: 'anthropic' }),
-    (err) => err instanceof LlmClientError && err.code === 'LLM_INVALID_JSON',
-  );
-});
-
-test('parseCompletionJson: malformed JSON → LLM_INVALID_JSON', () => {
-  assert.throws(
-    () => parseCompletionJson({ raw: '{not json', usage: {}, model: 'x', provider: 'anthropic' }),
-    (err) => err instanceof LlmClientError && err.code === 'LLM_INVALID_JSON',
-  );
-});
-
-test('createLlmClient: unknown model → LLM_UNSUPPORTED_MODEL', () => {
-  assert.throws(
-    () => createLlmClient({ model: 'llama-3', apiKey: 'sk-test' }),
-    (err) => err instanceof LlmClientError && err.code === 'LLM_UNSUPPORTED_MODEL',
-  );
-});
-
-test('createLlmClient: missing key → NO_LLM_CREDENTIALS', () => {
-  const savedA = process.env.ANTHROPIC_API_KEY;
-  const savedO = process.env.OPENAI_API_KEY;
-  delete process.env.ANTHROPIC_API_KEY;
-  delete process.env.OPENAI_API_KEY;
-  try {
-    assert.throws(
-      () => createLlmClient({ model: 'claude-sonnet-4-6' }),
-      (err) => err instanceof LlmClientError && err.code === 'NO_LLM_CREDENTIALS',
-    );
-    assert.throws(
-      () => createLlmClient({ model: 'gpt-5' }),
-      (err) => err instanceof LlmClientError && err.code === 'NO_LLM_CREDENTIALS',
-    );
-  } finally {
-    if (savedA !== undefined) process.env.ANTHROPIC_API_KEY = savedA;
-    if (savedO !== undefined) process.env.OPENAI_API_KEY = savedO;
-  }
-});
-
-test('createLlmClient: explicit apiKey bypasses env check + returns adapter shape', () => {
-  const anthropicClient = createLlmClient({ model: 'claude-sonnet-4-6', apiKey: 'sk-test' });
-  assert.equal(anthropicClient.provider, 'anthropic');
-  assert.equal(anthropicClient.model, 'claude-sonnet-4-6');
-  assert.equal(typeof anthropicClient.completeJson, 'function');
-
-  const openaiClient = createLlmClient({ model: 'gpt-5', apiKey: 'sk-test' });
-  assert.equal(openaiClient.provider, 'openai');
-  assert.equal(openaiClient.model, 'gpt-5');
-  assert.equal(typeof openaiClient.completeJson, 'function');
-});
-
-test('createLlmClient: defaults model from env UBP_PLANNER_MODEL', () => {
-  const saved = process.env.UBP_PLANNER_MODEL;
-  process.env.UBP_PLANNER_MODEL = 'gpt-5.4';
-  try {
-    const c = createLlmClient({ apiKey: 'sk-test' });
-    assert.equal(c.model, 'gpt-5.4');
-    assert.equal(c.provider, 'openai');
-  } finally {
-    if (saved === undefined) delete process.env.UBP_PLANNER_MODEL;
-    else process.env.UBP_PLANNER_MODEL = saved;
-  }
-});
-
-test('createLlmClient: falls back to DEFAULT_MODEL when nothing supplied', () => {
-  const savedEnv = process.env.UBP_PLANNER_MODEL;
-  delete process.env.UBP_PLANNER_MODEL;
-  try {
-    const c = createLlmClient({ apiKey: 'sk-test' });
-    assert.equal(c.model, DEFAULT_MODEL);
-  } finally {
-    if (savedEnv !== undefined) process.env.UBP_PLANNER_MODEL = savedEnv;
-  }
-});

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