ultra-builder-pro-cli 0.12.1 → 0.14.0

package/mcp-server/lib/change-workflow.test.cjs

@@ -11,6 +11,7 @@ const { initStateDb, closeStateDb } = require('./state-db.cjs');
 const ops = require('./state-ops.cjs');
 const changes = require('./change-workflow.cjs');
 const baselines = require('./baseline-workflow.cjs');
+const archiveJournal = require('./archive-journal.cjs');
 
 function fixture() {
   const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-change-'));
@@ -24,7 +25,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());
   return { rootDir, db };
 }
@@ -130,6 +131,163 @@ test('createChange persists a change and an inspectable external-provider contex
   }
 });
 
+test('new ordinary changes require a ready baseline while incidents require an explicit break-glass record', () => {
+  const fx = fixture();
+  try {
+    assert.throws(
+      () => changes.createChange(fx.db, {
+        id: 'chg-invalid-bypass', title: 'Ordinary work', kind: 'quick',
+        intent: 'Do not attach break-glass approval to ordinary work.',
+        baseline_bypass: { reason: 'Not applicable.', approved_by: 'owner' },
+      }, { rootDir: fx.rootDir }),
+      (error) => error.code === 'VALIDATION_ERROR',
+    );
+    fx.db.prepare('DELETE FROM baselines').run();
+    assert.throws(
+      () => changes.createChange(fx.db, {
+        id: 'chg-normal-without-baseline', title: 'Do ordinary work', kind: 'quick',
+        intent: 'Do not start ordinary work before adoption.',
+      }, { rootDir: fx.rootDir }),
+      (error) => error.code === 'BASELINE_NOT_READY',
+    );
+    assert.throws(
+      () => changes.createChange(fx.db, {
+        id: 'chg-incident-without-approval', title: 'Recover production', kind: 'incident',
+        intent: 'Restore the public runtime without waiting for adoption.',
+      }, { rootDir: fx.rootDir }),
+      (error) => error.code === 'BASELINE_BYPASS_REQUIRED',
+    );
+
+    const created = changes.createChange(fx.db, {
+      id: 'chg-incident-break-glass', title: 'Recover production', kind: 'incident',
+      intent: 'Restore the public runtime without waiting for adoption.',
+      baseline_bypass: {
+        reason: 'Production is unavailable and baseline adoption cannot precede recovery.',
+        approved_by: 'incident-commander',
+      },
+    }, { rootDir: fx.rootDir });
+    assert.equal(created.change.baseline_bypass.approved_by, 'incident-commander');
+    assert.equal(created.change.baseline_bypass.mode, 'incident_break_glass');
+    assert.match(created.change.baseline_bypass.recorded_at, /^\d{4}-\d{2}-\d{2}T/);
+  } finally { cleanup(fx); }
+});
+
+test('task creation authority rejects missing and terminal change ownership even with a healthy baseline', () => {
+  const fx = fixture();
+  try {
+    assert.throws(
+      () => changes.assertTaskCreationAllowed(fx.db, { change_id: 'missing-change' }, { rootDir: fx.rootDir }),
+      (error) => error.code === 'CHANGE_NOT_FOUND',
+    );
+    for (const status of ['ready', 'archived', 'cancelled']) {
+      const id = `terminal-${status}`;
+      changes.createChange(fx.db, {
+        id, title: `Terminal ${status}`, kind: 'quick',
+        intent: 'Verify terminal changes cannot receive new tasks.',
+      }, { rootDir: fx.rootDir });
+      fx.db.prepare('UPDATE changes SET status = ? WHERE id = ?').run(status, id);
+      assert.throws(
+        () => changes.assertTaskCreationAllowed(fx.db, { change_id: id }, { rootDir: fx.rootDir }),
+        (error) => error.code === 'CHANGE_NOT_MUTABLE',
+      );
+    }
+  } finally { cleanup(fx); }
+});
+
+test('incident break-glass remains executable and archives with a mandatory baseline reconciliation gap', () => {
+  const fx = fixture();
+  try {
+    fx.db.prepare(
+      "UPDATE baselines SET mode = 'brownfield', status = 'adopting' WHERE id = 'test-baseline'",
+    ).run();
+    const created = changes.createChange(fx.db, {
+      id: 'chg-break-glass-closure', title: 'Restore the production path', kind: 'incident',
+      intent: 'Repair the urgent runtime failure before baseline adoption can finish.',
+      docs_impact: { status: 'none', files: [], rationale: 'Internal runtime recovery.' },
+      baseline_bypass: {
+        reason: 'Production recovery cannot wait for the incomplete brownfield baseline.',
+        approved_by: 'incident-commander',
+      },
+    }, { rootDir: fx.rootDir });
+    ops.createTask(fx.db, {
+      id: 'break-glass-task', title: 'Repair urgent runtime failure', type: 'bugfix', priority: 'P0',
+      change_id: 'chg-break-glass-closure',
+    });
+    ops.updateTaskStatus(fx.db, 'break-glass-task', 'in_progress');
+    ops.updateTaskStatus(fx.db, 'break-glass-task', 'completed');
+    const compiled = changes.compileContext(fx.db, {
+      id: 'chg-break-glass-closure', ...executionContext('break-glass-task'),
+    }, { rootDir: fx.rootDir });
+    assert.equal(compiled.manifest.readiness.status, 'ready');
+    assert.ok(compiled.manifest.readiness.warnings.includes('BASELINE_NOT_READY:adopting'));
+
+    const diagnosisPath = path.join(path.dirname(created.intent_path), 'diagnosis.md');
+    fs.writeFileSync(diagnosisPath, [
+      '# Incident diagnosis: Restore the production path', '',
+      '## Reproduction', '', 'The public runtime fails on the terminal transition.', '',
+      '## Hypotheses', '', 'The transition loses its durable terminal write.', '',
+      '## Root cause', '', 'The terminal path returns before the durable write completes.', '',
+      '## Regression test', '', 'The regression test reproduces the lost write and then passes.', '',
+      '## Recovery', '', 'Replay the terminal write and verify the public runtime.', '',
+    ].join('\n'));
+
+    const converged = changes.convergeChange(fx.db, {
+      id: 'chg-break-glass-closure', evidence: incidentEvidence(),
+    }, { rootDir: fx.rootDir });
+    assert.equal(converged.ready, true);
+
+    const archived = changes.archiveChange(fx.db, {
+      id: 'chg-break-glass-closure', summary: 'Production restored with regression evidence.',
+      no_baseline_change_reason: 'Baseline adoption is tracked by the reconciliation gap.',
+    }, { rootDir: fx.rootDir });
+    assert.equal(archived.change.status, 'archived');
+    assert.equal(archived.baseline_bypass, true);
+    const baseline = baselines.readBaseline(fx.db, 'test-baseline');
+    assert.equal(baseline.status, 'adopting');
+    assert.deepEqual(
+      baseline.gaps.map((gap) => ({ id: gap.id, category: gap.category, status: gap.status, blocking: gap.blocking })),
+      [{
+        id: 'incident-chg-break-glass-closure-reconciliation',
+        category: 'baseline_blocker', status: 'open', blocking: true,
+      }],
+    );
+    assert.equal(baseline.gaps[0].owner, 'incident-commander');
+    assert.ok(baseline.gaps[0].evidence_refs.some((ref) => ref.includes('changes/archive/')));
+  } finally { cleanup(fx); }
+});
+
+test('an already-active ordinary change remains executable when baseline adoption later becomes incomplete', () => {
+  const fx = fixture();
+  try {
+    changes.createChange(fx.db, {
+      id: 'chg-grandfathered-context', title: 'Finish active work', kind: 'quick',
+      intent: 'Preserve an already-active bounded change while baseline recovery runs.',
+    }, { rootDir: fx.rootDir });
+    ops.createTask(fx.db, {
+      id: 'grandfathered-task', title: 'Finish active work', type: 'bugfix', priority: 'P0',
+      change_id: 'chg-grandfathered-context',
+    });
+    fx.db.prepare(
+      "UPDATE baselines SET status = 'adopting', mode = 'brownfield' WHERE id = 'test-baseline'",
+    ).run();
+
+    assert.doesNotThrow(() => changes.assertTaskCreationAllowed(fx.db, {
+      change_id: 'chg-grandfathered-context',
+    }, { rootDir: fx.rootDir }));
+    assert.throws(
+      () => changes.assertTaskCreationAllowed(fx.db, {}, { rootDir: fx.rootDir }),
+      (error) => error.code === 'BASELINE_NOT_READY',
+    );
+
+    const compiled = changes.compileContext(fx.db, {
+      id: 'chg-grandfathered-context', ...executionContext('grandfathered-task'),
+    }, { rootDir: fx.rootDir });
+    assert.equal(compiled.manifest.readiness.status, 'ready');
+    assert.ok(compiled.manifest.readiness.warnings.includes('BASELINE_NOT_READY:adopting'));
+    assert.deepEqual(compiled.manifest.readiness.blockers, []);
+  } finally { cleanup(fx); }
+});
+
 test('convergeChange blocks incomplete work and marks a fully evidenced standard change ready', () => {
   const fx = fixture();
   try {
@@ -220,6 +378,27 @@ test('convergeChange requires an approved baseline after active work has remaine
   }
 });
 
+test('change creation rejects a schema-migration compatibility baseline until re-adoption', () => {
+  const fx = fixture();
+  try {
+    fx.db.prepare(
+      `UPDATE baselines SET mode = 'migrated', approved_by = 'schema-migration',
+       approval_note = 'compatibility only' WHERE id = 'test-baseline'`,
+    ).run();
+    assert.throws(
+      () => changes.createChange(fx.db, {
+        id: 'chg-migrated-gate', title: 'Require owner adoption', kind: 'quick',
+        intent: 'Do not let schema migration impersonate project-owner approval.',
+        docs_impact: { status: 'none', files: [], rationale: 'Gate behavior only.' },
+      }, { rootDir: fx.rootDir }),
+      (error) => error.code === 'BASELINE_NOT_READY'
+        && error.details.blockers.includes('BASELINE_MIGRATION_REVIEW_REQUIRED'),
+    );
+  } finally {
+    cleanup(fx);
+  }
+});
+
 test('archiveChange moves a ready change into immutable history and records baseline reconciliation', () => {
   const fx = fixture();
   try {
@@ -385,6 +564,61 @@ test('archiveChange rolls back when declared reconciliation leaves a tracked spe
   }
 });
 
+test('archiveChange resumes a durable journal after the filesystem move outlives the process', () => {
+  const fx = fixture();
+  try {
+    changes.createChange(fx.db, {
+      id: 'chg-crash-resume', title: 'Resume interrupted archive', kind: 'quick',
+      intent: 'Finish an authorized archive after a process crash.',
+      docs_impact: { status: 'none', files: [], rationale: 'Recovery-only behavior.' },
+    }, { rootDir: fx.rootDir });
+    ops.createTask(fx.db, {
+      id: 'crash-resume-task', title: 'Verify archive recovery', type: 'bugfix', priority: 'P0',
+      change_id: 'chg-crash-resume',
+    });
+    ops.updateTaskStatus(fx.db, 'crash-resume-task', 'in_progress');
+    ops.updateTaskStatus(fx.db, 'crash-resume-task', 'completed');
+    changes.compileContext(fx.db, {
+      id: 'chg-crash-resume', ...executionContext('crash-resume-task'),
+    }, { rootDir: fx.rootDir });
+    const converged = changes.convergeChange(fx.db, {
+      id: 'chg-crash-resume',
+      evidence: [
+        { category: 'diff', status: 'pass', evidence: 'recovery diff reviewed' },
+        {
+          category: 'tests', status: 'pass', evidence: 'crash recovery passed', seam: 'archive retry',
+          signal: {
+            command: 'node --test archive-journal.test.cjs',
+            expected_red: 'archive retry fails after the filesystem move',
+            observed_red: true, observed_green: true, deterministic: true, duration_ms: 10,
+          },
+        },
+        { category: 'spec', status: 'not_applicable', evidence: 'No contract change.' },
+      ],
+    }, { rootDir: fx.rootDir });
+    assert.equal(converged.ready, true);
+    const input = {
+      id: 'chg-crash-resume', summary: 'Resume the interrupted archive safely.',
+      no_baseline_change_reason: 'No baseline content changed.',
+    };
+    const change = changes.readChange(fx.db, input.id);
+    const interrupted = archiveJournal.prepareArchiveMove({
+      rootDir: fx.rootDir, change, summary: input.summary, baselineUpdates: [],
+      noBaselineChangeReason: input.no_baseline_change_reason,
+    });
+    assert.equal(changes.readChange(fx.db, input.id).status, 'ready');
+    assert.equal(fs.existsSync(interrupted.source), false);
+    assert.equal(fs.existsSync(interrupted.destination), true);
+
+    const resumed = changes.archiveChange(fx.db, input, { rootDir: fx.rootDir });
+    assert.equal(resumed.change.status, 'archived');
+    assert.equal(resumed.archive_path, interrupted.destination);
+    assert.equal(archiveJournal.listArchiveIntents(fx.rootDir).length, 0);
+  } finally {
+    cleanup(fx);
+  }
+});
+
 test('provider references reject embedded memory or graph payloads', () => {
   const fx = fixture();
   try {

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

@@ -52,6 +52,11 @@ 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.',

package/mcp-server/lib/doctor.cjs

@@ -9,6 +9,8 @@ const runtime = require('./runtime-state.cjs');
 const projector = require('./projector.cjs');
 const recovery = require('../../orchestrator/recovery.cjs');
 const baselines = require('./baseline-workflow.cjs');
+const changes = require('./change-workflow.cjs');
+const archiveJournal = require('./archive-journal.cjs');
 
 const SPEC_CONSUMER = 'spec-staleness';
 
@@ -49,11 +51,14 @@ function inspectSystem(db, { rootDir = process.cwd() } = {}) {
          WHERE status IN ('active', 'blocked', 'ready') AND artifact_root IS NOT NULL`,
       ).all().filter((row) => row.artifact_root && !fs.existsSync(path.resolve(rootDir, row.artifact_root))).length
     : 0;
+  const archiveIntents = missing.length === 0 ? archiveJournal.listArchiveIntents(rootDir) : [];
+  const corruptArchiveIntents = archiveIntents.filter((item) => item.error).length;
   const baseline = missing.length === 0
     ? baselines.inspectBaseline(db, { rootDir })
     : { status: 'fail', blockers: ['BASELINE_STATE_UNAVAILABLE'], warnings: [], baseline: null };
   const degraded = integrity !== 'ok' || missing.length > 0 || incidents.length > 0
     || pending.length > 0 || running.length > 0 || failed.length > 0 || orphanSessions > 0 || activeMissing > 0
+    || archiveIntents.length > 0
     || eventCursor > projectedCursor;
   return {
     status: degraded ? 'degraded' : 'healthy',
@@ -67,6 +72,10 @@ function inspectSystem(db, { rootDir = process.cwd() } = {}) {
       },
       sessions: { status: orphanSessions === 0 ? 'pass' : 'fail', orphan: orphanSessions },
       change_artifacts: { status: activeMissing === 0 ? 'pass' : 'fail', missing: activeMissing },
+      archive_recovery: {
+        status: archiveIntents.length === 0 ? 'pass' : 'fail',
+        pending: archiveIntents.length, corrupt: corruptArchiveIntents,
+      },
       baseline: {
         status: baseline.status === 'pass' ? 'pass' : 'warning',
         readiness: baseline.status,
@@ -74,6 +83,9 @@ function inspectSystem(db, { rootDir = process.cwd() } = {}) {
         baseline_status: baseline.baseline?.status || null,
         id: baseline.baseline?.id || null,
         repository_revision: baseline.baseline?.repository_revision || null,
+        repository_branch: baseline.baseline?.repository_branch || null,
+        worktree_state: baseline.baseline?.worktree_state || 'unavailable',
+        gaps: baseline.baseline ? baselines.summarizeGaps(baseline.baseline.gaps) : null,
         blockers: baseline.blockers,
         warnings: baseline.warnings,
       },
@@ -100,6 +112,7 @@ async function runDoctor(db, {
 } = {}) {
   if (!repair) return { ...inspectSystem(db, { rootDir }), repair_performed: false };
   const backupPath = await backupDatabase(db, rootDir);
+  const archives = changes.recoverInterruptedArchives(db, { rootDir });
   const recovered = recovery.recoverOnBoot(db);
   const cursor = runtime.readConsumerCursor(db, SPEC_CONSUMER);
   const consumed = ops.consumeSpecChangedEvents(db, { since_id: cursor, limit: 500 });
@@ -114,7 +127,7 @@ async function runDoctor(db, {
     ...inspectSystem(db, { rootDir }),
     repair_performed: true,
     backup_path: backupPath,
-    repair: { recovered, consumed, interrupted, requeued, ensured, projections },
+    repair: { archives, recovered, consumed, interrupted, requeued, ensured, projections },
   };
 }
 

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

@@ -11,15 +11,17 @@ 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({ migratedBaseline = true } = {}) {
+function fixture({ baseline = true } = {}) {
   const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-doctor-'));
   const { db } = initStateDb(path.join(rootDir, '.ultra', 'state.db'));
-  if (migratedBaseline) {
+  if (baseline) {
     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());
   }
   return { rootDir, db };
@@ -44,7 +46,7 @@ test('doctor reports structured health for an initialized Ultra project', async
 });
 
 test('doctor reports incomplete brownfield adoption as advisory rather than authority failure', async () => {
-  const fx = fixture({ migratedBaseline: false });
+  const fx = fixture({ baseline: false });
   try {
     baselines.startBaseline(fx.db, {
       id: 'adoption', project_name: 'legacy', mode: 'brownfield', scope: ['.'],
@@ -53,6 +55,9 @@ test('doctor reports incomplete brownfield adoption as advisory rather than auth
     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);
@@ -108,3 +113,36 @@ test('doctor reports running projection work and repairs only stale interrupted
     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);
+  }
+});