ultra-builder-pro-cli 0.12.1 → 0.14.0

package/ultra-tools/system-command.test.cjs

@@ -17,7 +17,7 @@ function fixture() {
   db.prepare(
     `INSERT INTO baselines
      (id, project_name, mode, status, approved_by, approval_note, converged_at)
-     VALUES ('test-baseline', 'fixture', 'migrated', 'ready', 'test', 'legacy fixture', ?)`,
+     VALUES ('test-baseline', 'fixture', 'greenfield', 'ready', 'test', 'accepted fixture', ?)`,
   ).run(new Date().toISOString());
   closeStateDb(db);
   return rootDir;
@@ -56,3 +56,254 @@ test('system doctor --repair creates a backup before recovery', () => {
     fs.rmSync(rootDir, { recursive: true, force: true });
   }
 });
+
+test('system doctor --repair migrates an older schema only after preserving a pre-migration backup', () => {
+  const rootDir = fixture();
+  try {
+    const dbPath = path.join(rootDir, '.ultra', 'state.db');
+    const Database = require('better-sqlite3');
+    const db = new Database(dbPath);
+    db.prepare("DELETE FROM schema_version WHERE version = '12.0'").run();
+    db.close();
+
+    const result = invoke(rootDir, ['doctor', '--repair']);
+    assert.equal(result.status, 0, result.stderr);
+    const envelope = JSON.parse(result.stdout.trim().split('\n').at(-1));
+    assert.equal(envelope.ok, true);
+    assert.equal(envelope.data.schema_version, '12.0');
+    assert.ok(fs.existsSync(envelope.data.schema_migration_backup_path));
+    assert.ok(fs.existsSync(envelope.data.backup_path));
+  } finally {
+    fs.rmSync(rootDir, { recursive: true, force: true });
+  }
+});
+
+test('system doctor reports a corrupt database as structured recovery guidance', () => {
+  const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-system-corrupt-'));
+  try {
+    fs.mkdirSync(path.join(rootDir, '.ultra'), { recursive: true });
+    fs.writeFileSync(path.join(rootDir, '.ultra', 'state.db'), 'not a sqlite database');
+    const result = invoke(rootDir, ['doctor']);
+    assert.equal(result.status, 2);
+    const envelope = JSON.parse(result.stdout.trim().split('\n').at(-1));
+    assert.equal(envelope.ok, false);
+    assert.equal(envelope.error.code, 'STATE_DB_CORRUPT');
+    assert.match(envelope.error.message, /restore.*backup|rebaseline/i);
+  } finally {
+    fs.rmSync(rootDir, { recursive: true, force: true });
+  }
+});
+
+test('system restore replaces only a corrupt state database from a verified managed backup', () => {
+  const rootDir = fixture();
+  try {
+    const dbPath = path.join(rootDir, '.ultra', 'state.db');
+    const backupsDir = path.join(rootDir, '.ultra', 'backups');
+    fs.mkdirSync(backupsDir, { recursive: true });
+    const sourceBackup = path.join(backupsDir, 'verified.db');
+    fs.copyFileSync(dbPath, sourceBackup);
+    fs.writeFileSync(dbPath, 'not a sqlite database');
+
+    const refused = invoke(rootDir, ['restore', '--backup', sourceBackup]);
+    assert.equal(refused.status, 1);
+    assert.equal(JSON.parse(refused.stdout.trim()).error.code, 'CONFIRMATION_REQUIRED');
+    assert.equal(fs.readFileSync(dbPath, 'utf8'), 'not a sqlite database');
+
+    const restored = invoke(rootDir, [
+      'restore', '--backup', sourceBackup,
+      '--confirm', 'REPLACE_CORRUPT_ULTRA_STATE',
+    ]);
+    assert.equal(restored.status, 0, restored.stderr);
+    const envelope = JSON.parse(restored.stdout.trim());
+    assert.equal(envelope.ok, true);
+    assert.equal(envelope.data.schema_version, '12.0');
+    assert.equal(envelope.data.source_backup, fs.realpathSync(sourceBackup));
+    assert.ok(fs.existsSync(envelope.data.quarantined_state_path));
+    assert.equal(
+      fs.readFileSync(envelope.data.quarantined_state_path, 'utf8'),
+      'not a sqlite database',
+    );
+    const restoredDb = require('better-sqlite3')(dbPath, { readonly: true });
+    try {
+      assert.equal(restoredDb.prepare('SELECT COUNT(*) AS count FROM baselines').get().count, 1);
+    } finally { restoredDb.close(); }
+  } finally {
+    fs.rmSync(rootDir, { recursive: true, force: true });
+  }
+});
+
+test('system rebaseline preserves corrupt authority and legacy projection before starting brownfield adoption', () => {
+  const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-system-rebaseline-'));
+  try {
+    fs.mkdirSync(path.join(rootDir, 'src'), { recursive: true });
+    fs.mkdirSync(path.join(rootDir, '.ultra', 'tasks', 'contexts'), { recursive: true });
+    fs.writeFileSync(path.join(rootDir, 'src', 'index.js'), 'module.exports = true;\n');
+    fs.writeFileSync(path.join(rootDir, '.ultra', 'state.db'), 'broken authority');
+    const tasksPath = path.join(rootDir, '.ultra', 'tasks', 'tasks.json');
+    fs.writeFileSync(tasksPath, `${JSON.stringify({
+      schema_version: '4.5', source: '.ultra/state.db',
+      tasks: [{ id: 'legacy-task', title: 'Preserved task', type: 'feature', priority: 'P1', status: 'pending' }],
+    }, null, 2)}\n`);
+    fs.writeFileSync(
+      path.join(rootDir, '.ultra', 'tasks', 'contexts', 'legacy-task.md'),
+      '# Preserved task context\n',
+    );
+
+    const result = invoke(rootDir, [
+      'rebaseline', '--project-name', 'legacy-app',
+      '--confirm', 'REBASELINE_CORRUPT_ULTRA_STATE',
+    ]);
+    assert.equal(result.status, 0, result.stderr);
+    const envelope = JSON.parse(result.stdout.trim());
+    assert.equal(envelope.ok, true);
+    assert.equal(envelope.data.baseline.mode, 'brownfield');
+    assert.equal(envelope.data.baseline.status, 'adopting');
+    assert.ok(fs.existsSync(envelope.data.quarantined_state_path));
+    assert.ok(fs.existsSync(envelope.data.legacy_projection_path));
+    assert.equal(
+      JSON.parse(fs.readFileSync(envelope.data.legacy_projection_path, 'utf8')).tasks[0].id,
+      'legacy-task',
+    );
+    assert.ok(fs.existsSync(path.join(
+      envelope.data.recovery_backup_dir, 'tasks', 'contexts', 'legacy-task.md',
+    )));
+    assert.equal(
+      fs.existsSync(path.join(rootDir, '.ultra', 'tasks', 'contexts', 'legacy-task.md')),
+      false,
+    );
+    assert.deepEqual(JSON.parse(fs.readFileSync(tasksPath, 'utf8')).tasks, []);
+  } finally {
+    fs.rmSync(rootDir, { recursive: true, force: true });
+  }
+});
+
+test('system restore rolls back the corrupt database and sidecars when replacement initialization fails', () => {
+  const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-system-restore-rollback-'));
+  try {
+    const ultraDir = path.join(rootDir, '.ultra');
+    const backupsDir = path.join(ultraDir, 'backups');
+    fs.mkdirSync(backupsDir, { recursive: true });
+    const statePath = path.join(ultraDir, 'state.db');
+    const originals = {
+      '': Buffer.from('broken authority'),
+      '-wal': Buffer.from('broken wal'),
+      '-shm': Buffer.from('broken shm'),
+    };
+    for (const [suffix, content] of Object.entries(originals)) {
+      fs.writeFileSync(`${statePath}${suffix}`, content);
+    }
+
+    const incompatibleBackup = path.join(backupsDir, 'structurally-incompatible.db');
+    const backupDb = require('better-sqlite3')(incompatibleBackup);
+    backupDb.exec("CREATE TABLE schema_version (version TEXT NOT NULL); INSERT INTO schema_version VALUES ('11.0');");
+    backupDb.close();
+
+    const result = invoke(rootDir, [
+      'restore', '--backup', incompatibleBackup,
+      '--confirm', 'REPLACE_CORRUPT_ULTRA_STATE',
+    ]);
+    assert.notEqual(result.status, 0, result.stderr);
+    const envelope = JSON.parse(result.stdout.trim());
+    assert.equal(envelope.ok, false);
+    assert.equal(envelope.error.code, 'STATE_RESTORE_FAILED');
+    for (const [suffix, content] of Object.entries(originals)) {
+      assert.deepEqual(fs.readFileSync(`${statePath}${suffix}`), content);
+    }
+  } finally {
+    fs.rmSync(rootDir, { recursive: true, force: true });
+  }
+});
+
+test('system rebaseline rolls back authority, sidecars, and the full task projection when adoption fails', () => {
+  const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-system-rebaseline-rollback-'));
+  try {
+    const ultraDir = path.join(rootDir, '.ultra');
+    const tasksDir = path.join(ultraDir, 'tasks');
+    fs.mkdirSync(path.join(tasksDir, 'contexts'), { recursive: true });
+    fs.mkdirSync(path.join(rootDir, 'src'), { recursive: true });
+    fs.writeFileSync(path.join(rootDir, 'src', 'index.js'), 'module.exports = true;\n');
+    const statePath = path.join(ultraDir, 'state.db');
+    const originals = {
+      '': Buffer.from('broken authority'),
+      '-wal': Buffer.from('broken wal'),
+      '-shm': Buffer.from('broken shm'),
+    };
+    for (const [suffix, content] of Object.entries(originals)) {
+      fs.writeFileSync(`${statePath}${suffix}`, content);
+    }
+    const tasksPath = path.join(tasksDir, 'tasks.json');
+    const contextPath = path.join(tasksDir, 'contexts', 'legacy.md');
+    const tasksContent = Buffer.from('{"schema_version":"4.5","source":".ultra/state.db","tasks":[]}\n');
+    const contextContent = Buffer.from('# Legacy context\n');
+    fs.writeFileSync(tasksPath, tasksContent);
+    fs.writeFileSync(contextPath, contextContent);
+
+    const result = invoke(rootDir, [
+      'rebaseline', '--project-name', 'legacy-app', '--scope', 'missing-workspace',
+      '--confirm', 'REBASELINE_CORRUPT_ULTRA_STATE',
+    ]);
+    assert.notEqual(result.status, 0, result.stderr);
+    const envelope = JSON.parse(result.stdout.trim());
+    assert.equal(envelope.ok, false);
+    assert.equal(envelope.error.code, 'IO_ERROR');
+    for (const [suffix, content] of Object.entries(originals)) {
+      assert.deepEqual(fs.readFileSync(`${statePath}${suffix}`), content);
+    }
+    assert.deepEqual(fs.readFileSync(tasksPath), tasksContent);
+    assert.deepEqual(fs.readFileSync(contextPath), contextContent);
+  } finally {
+    fs.rmSync(rootDir, { recursive: true, force: true });
+  }
+});
+
+test('system restore rejects backups outside the managed project backup directory', () => {
+  const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-system-external-backup-'));
+  const externalDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-external-backup-'));
+  try {
+    fs.mkdirSync(path.join(rootDir, '.ultra'), { recursive: true });
+    fs.mkdirSync(path.join(rootDir, '.ultra', 'backups'), { recursive: true });
+    fs.writeFileSync(path.join(rootDir, '.ultra', 'state.db'), 'broken authority');
+    const external = path.join(externalDir, 'state.db');
+    fs.writeFileSync(external, 'not trusted');
+    const result = invoke(rootDir, [
+      'restore', '--backup', external,
+      '--confirm', 'REPLACE_CORRUPT_ULTRA_STATE',
+    ]);
+    assert.equal(result.status, 1);
+    assert.equal(JSON.parse(result.stdout.trim()).error.code, 'BACKUP_OUTSIDE_MANAGED_ROOT');
+  } finally {
+    fs.rmSync(rootDir, { recursive: true, force: true });
+    fs.rmSync(externalDir, { recursive: true, force: true });
+  }
+});
+
+test('system corrupt-state recovery commands refuse to replace readable authority', () => {
+  const rootDir = fixture();
+  try {
+    const backupsDir = path.join(rootDir, '.ultra', 'backups');
+    fs.mkdirSync(backupsDir, { recursive: true });
+    const backup = path.join(backupsDir, 'healthy.db');
+    fs.copyFileSync(path.join(rootDir, '.ultra', 'state.db'), backup);
+
+    const restore = invoke(rootDir, [
+      'restore', '--backup', backup,
+      '--confirm', 'REPLACE_CORRUPT_ULTRA_STATE',
+    ]);
+    assert.equal(restore.status, 2);
+    assert.equal(JSON.parse(restore.stdout.trim()).error.code, 'STATE_DB_NOT_CORRUPT');
+
+    const rebaseline = invoke(rootDir, [
+      'rebaseline', '--project-name', 'fixture',
+      '--confirm', 'REBASELINE_CORRUPT_ULTRA_STATE',
+    ]);
+    assert.equal(rebaseline.status, 2);
+    assert.equal(JSON.parse(rebaseline.stdout.trim()).error.code, 'STATE_DB_NOT_CORRUPT');
+
+    const db = require('better-sqlite3')(path.join(rootDir, '.ultra', 'state.db'), { readonly: true });
+    try {
+      assert.equal(db.prepare('SELECT COUNT(*) AS count FROM baselines').get().count, 1);
+    } finally { db.close(); }
+  } finally {
+    fs.rmSync(rootDir, { recursive: true, force: true });
+  }
+});

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/orchestrator/planner/expand-prompt.cjs

@@ -1,62 +0,0 @@
-'use strict';
-
-// Phase 8A.3 — Prompt templates for task → subtasks expansion.
-//
-// Parent context (title, type, priority, complexity, files_modified) is
-// serialized into the user prompt so the LLM can produce children aligned
-// with the parent's shape. sub_count defaults to 3 when omitted.
-
-const DEFAULT_SUB_COUNT = 3;
-
-function buildExpandSystemPrompt({ sub_count = DEFAULT_SUB_COUNT } = {}) {
-  return `You are an engineering task decomposer. Break a single complex task into ${sub_count} smaller subtasks that together deliver the parent's scope.
-
-Output STRICT JSON matching this shape — nothing else, no markdown fences, no prose:
-
-{
-  "children": [
-    {
-      "id": "child-1",
-      "title": "Imperative short title (3-80 chars)",
-      "type": "architecture | feature | bugfix",
-      "priority": "P0 | P1 | P2 | P3",
-      "complexity": 1-10,
-      "deps": ["child-2"],
-      "files_modified": ["src/path/to/file.ts"]
-    }
-  ]
-}
-
-Rules:
-- Exactly ${sub_count} children.
-- Each id matches /^[a-zA-Z0-9_\\-]+$/ and is unique in the list.
-- "deps" references siblings in the same list; omit or use [] when none.
-- "files_modified" overlaps with the parent's files_modified where possible.
-- Each child's complexity is < parent's complexity; sum should approximate the parent.
-- Return JSON only.`;
-}
-
-function buildExpandUserPrompt(parent) {
-  const files = Array.isArray(parent.files_modified) ? parent.files_modified : [];
-  const deps = Array.isArray(parent.deps) ? parent.deps : [];
-  return [
-    'Parent task to decompose:',
-    '',
-    `- id: ${parent.id}`,
-    `- title: ${parent.title}`,
-    `- type: ${parent.type}`,
-    `- priority: ${parent.priority}`,
-    parent.complexity != null ? `- complexity: ${parent.complexity}` : null,
-    files.length ? `- files_modified: ${JSON.stringify(files)}` : null,
-    deps.length ? `- existing deps: ${JSON.stringify(deps)}` : null,
-    parent.trace_to ? `- trace_to: ${parent.trace_to}` : null,
-    '',
-    'Return the children list as JSON following the system schema.',
-  ].filter((l) => l !== null).join('\n');
-}
-
-module.exports = {
-  buildExpandSystemPrompt,
-  buildExpandUserPrompt,
-  DEFAULT_SUB_COUNT,
-};

package/orchestrator/planner/expand-prompt.test.cjs

@@ -1,52 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-
-const {
-  buildExpandSystemPrompt,
-  buildExpandUserPrompt,
-  DEFAULT_SUB_COUNT,
-} = require('./expand-prompt.cjs');
-
-test('buildExpandSystemPrompt: mentions sub_count explicitly', () => {
-  const s = buildExpandSystemPrompt({ sub_count: 4 });
-  assert.match(s, /Exactly 4 children/);
-  assert.match(s, /STRICT JSON/);
-});
-
-test('buildExpandSystemPrompt: falls back to DEFAULT_SUB_COUNT when omitted', () => {
-  const s = buildExpandSystemPrompt({});
-  assert.match(s, new RegExp(`Exactly ${DEFAULT_SUB_COUNT} children`));
-});
-
-test('buildExpandUserPrompt: serializes parent fields into prompt body', () => {
-  const parent = {
-    id: 'parent-1',
-    title: 'Build search feature',
-    type: 'feature',
-    priority: 'P1',
-    complexity: 8,
-    files_modified: ['src/search/index.ts', 'src/search/query.ts'],
-    deps: ['infra-1'],
-    trace_to: 'spec §3.2',
-  };
-  const body = buildExpandUserPrompt(parent);
-  assert.match(body, /parent-1/);
-  assert.match(body, /Build search feature/);
-  assert.match(body, /complexity: 8/);
-  assert.match(body, /src\/search\/index\.ts/);
-  assert.match(body, /infra-1/);
-  assert.match(body, /spec §3\.2/);
-});
-
-test('buildExpandUserPrompt: omits empty optional fields', () => {
-  const parent = {
-    id: 'p', title: 'Tiny task', type: 'feature', priority: 'P3',
-    complexity: null, files_modified: [], deps: [],
-  };
-  const body = buildExpandUserPrompt(parent);
-  assert.doesNotMatch(body, /files_modified/);
-  assert.doesNotMatch(body, /existing deps/);
-  assert.doesNotMatch(body, /complexity:/);
-});