ultra-builder-pro-cli 0.11.0 → 0.12.1

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

@@ -0,0 +1,225 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+const { initStateDb, closeStateDb } = require('./state-db.cjs');
+const baselines = require('./baseline-workflow.cjs');
+
+function fixture() {
+  const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-baseline-'));
+  execFileSync('git', ['init', '-q'], { cwd: rootDir });
+  execFileSync('git', ['config', 'user.email', 'test@ubp.dev'], { cwd: rootDir });
+  execFileSync('git', ['config', 'user.name', 'ubp-test'], { cwd: rootDir });
+  fs.mkdirSync(path.join(rootDir, '.ultra', 'specs'), { recursive: true });
+  fs.mkdirSync(path.join(rootDir, 'src'), { recursive: true });
+  fs.writeFileSync(path.join(rootDir, '.ultra', 'specs', 'product.md'), '# Product\n\nObserved behavior.\n');
+  fs.writeFileSync(path.join(rootDir, '.ultra', 'specs', 'architecture.md'), '# Architecture\n\nCurrent boundary.\n');
+  fs.writeFileSync(path.join(rootDir, 'src', 'index.js'), 'module.exports = true;\n');
+  execFileSync('git', ['add', '.'], { cwd: rootDir });
+  execFileSync('git', ['commit', '-q', '-m', 'seed'], { cwd: rootDir });
+  const revision = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: rootDir, encoding: 'utf8' }).trim();
+  const { db } = initStateDb(path.join(rootDir, '.ultra', 'state.db'));
+  return { rootDir, db, revision };
+}
+
+function cleanup(fx) {
+  closeStateDb(fx.db);
+  fs.rmSync(fx.rootDir, { recursive: true, force: true });
+}
+
+function adoptionEvidence() {
+  return {
+    spec_refs: [
+      { kind: 'product', path: '.ultra/specs/product.md' },
+      { kind: 'architecture', path: '.ultra/specs/architecture.md' },
+    ],
+    evidence: [
+      { kind: 'source', ref: 'src/index.js', summary: 'Current public module entry point.' },
+      { kind: 'docs', ref: '.ultra/specs/product.md', summary: 'Observed behavior baseline.' },
+    ],
+    verification: [
+      { name: 'module smoke', command: 'node -e "require(\'./src\')"', status: 'pass', evidence: 'exit 0' },
+    ],
+    unknowns: [],
+  };
+}
+
+test('brownfield baseline converges only after current specs, source evidence, verification, and approval', () => {
+  const fx = fixture();
+  try {
+    const started = baselines.startBaseline(fx.db, {
+      id: 'project-baseline', project_name: 'fixture', project_type: 'cli', stack: 'node',
+      mode: 'brownfield', repository_revision: fx.revision, scope: ['.'],
+    }, { rootDir: fx.rootDir });
+    assert.equal(started.status, 'adopting');
+
+    const recorded = baselines.recordBaseline(fx.db, {
+      id: started.id, repository_revision: fx.revision, ...adoptionEvidence(),
+    }, { rootDir: fx.rootDir });
+    assert.match(recorded.spec_refs[0].digest, /^[0-9a-f]{64}$/);
+    assert.equal(recorded.evidence[0].summary, 'Current public module entry point.');
+
+    const converged = baselines.convergeBaseline(fx.db, {
+      id: started.id,
+      expected_revision: fx.revision,
+      approved_by: 'project-owner',
+      approval_note: 'The captured baseline matches the current checkout.',
+      accept_known_red: false,
+    }, { rootDir: fx.rootDir });
+    assert.deepEqual(converged.blockers, []);
+    assert.equal(converged.ready, true);
+    assert.equal(converged.baseline.status, 'ready');
+    assert.equal(converged.baseline.approved_by, 'project-owner');
+  } finally {
+    cleanup(fx);
+  }
+});
+
+test('baseline convergence records deterministic blockers for missing evidence and unaccepted known-red verification', () => {
+  const fx = fixture();
+  try {
+    baselines.startBaseline(fx.db, {
+      id: 'blocked-baseline', project_name: 'fixture', mode: 'brownfield',
+      repository_revision: fx.revision,
+    }, { rootDir: fx.rootDir });
+    baselines.recordBaseline(fx.db, {
+      id: 'blocked-baseline',
+      repository_revision: fx.revision,
+      spec_refs: [{ kind: 'product', path: '.ultra/specs/product.md' }],
+      evidence: [],
+      verification: [{
+        name: 'legacy suite', command: 'npm test', status: 'known_red',
+        evidence: 'Two failures predate adoption.', rationale: 'Tracked as existing debt.',
+      }],
+      unknowns: [{ summary: 'Production authorization behavior is not verified.', blocking: true }],
+    }, { rootDir: fx.rootDir });
+
+    const result = baselines.convergeBaseline(fx.db, {
+      id: 'blocked-baseline', expected_revision: fx.revision,
+      approved_by: 'project-owner', approval_note: 'Review attempted.', accept_known_red: false,
+    }, { rootDir: fx.rootDir });
+    assert.equal(result.ready, false);
+    assert.equal(result.status, 'blocked');
+    assert.ok(result.blockers.includes('BASELINE_SPEC_MISSING:architecture'));
+    assert.ok(result.blockers.includes('BASELINE_SOURCE_EVIDENCE_MISSING'));
+    assert.ok(result.blockers.includes('BASELINE_KNOWN_RED_NOT_ACCEPTED:legacy suite'));
+    assert.ok(result.blockers.includes('BASELINE_UNKNOWN_BLOCKING:Production authorization behavior is not verified.'));
+  } finally {
+    cleanup(fx);
+  }
+});
+
+test('baseline stores provider metadata only and detects specification drift after convergence', () => {
+  const fx = fixture();
+  try {
+    baselines.startBaseline(fx.db, {
+      id: 'provider-baseline', project_name: 'fixture', mode: 'brownfield',
+      repository_revision: fx.revision,
+    }, { rootDir: fx.rootDir });
+    assert.throws(
+      () => baselines.recordBaseline(fx.db, {
+        id: 'provider-baseline',
+        provider_refs: { memory: { provider: 'cloud-mem', content: 'captured prompt' } },
+      }, { rootDir: fx.rootDir }),
+      (error) => error.code === 'PROVIDER_CONTENT_FORBIDDEN',
+    );
+    baselines.recordBaseline(fx.db, {
+      id: 'provider-baseline', repository_revision: fx.revision,
+      provider_refs: { memory: { provider: 'cloud-mem', reference: 'cmem://fixture', status: 'fresh' } },
+      ...adoptionEvidence(),
+    }, { rootDir: fx.rootDir });
+    baselines.convergeBaseline(fx.db, {
+      id: 'provider-baseline', expected_revision: fx.revision,
+      approved_by: 'project-owner', approval_note: 'Approved current behavior.',
+    }, { rootDir: fx.rootDir });
+
+    fs.appendFileSync(path.join(fx.rootDir, '.ultra', 'specs', 'product.md'), '\nChanged outside convergence.\n');
+    const health = baselines.inspectBaseline(fx.db, { rootDir: fx.rootDir });
+    assert.equal(health.status, 'fail');
+    assert.ok(health.blockers.includes('BASELINE_SPEC_STALE:.ultra/specs/product.md'));
+  } finally {
+    cleanup(fx);
+  }
+});
+
+test('re-adoption requires explicit replacement and supersedes the prior ready baseline', () => {
+  const fx = fixture();
+  try {
+    const digest = (file) => crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+    fx.db.prepare(
+      `INSERT INTO baselines
+       (id, project_name, mode, status, repository_revision, spec_refs_json, evidence_json, verification_json,
+        approved_by, approval_note, converged_at)
+       VALUES (?, ?, 'brownfield', 'ready', ?, ?, ?, ?, ?, ?, ?)`,
+    ).run(
+      'ready-baseline', 'fixture', fx.revision,
+      JSON.stringify([
+        { kind: 'product', path: '.ultra/specs/product.md', digest: digest(path.join(fx.rootDir, '.ultra/specs/product.md')) },
+        { kind: 'architecture', path: '.ultra/specs/architecture.md', digest: digest(path.join(fx.rootDir, '.ultra/specs/architecture.md')) },
+      ]),
+      JSON.stringify([{ kind: 'source', ref: 'src/index.js', summary: 'Current entry point.' }]),
+      JSON.stringify([{ name: 'smoke', command: 'node -e "require(\'./src\')"', status: 'pass', evidence: 'exit 0' }]),
+      'owner', 'approved', new Date().toISOString(),
+    );
+
+    assert.throws(
+      () => baselines.startBaseline(fx.db, {
+        id: 'replacement', project_name: 'fixture', mode: 'brownfield', repository_revision: fx.revision,
+      }, { rootDir: fx.rootDir }),
+      (error) => error.code === 'BASELINE_EXISTS',
+    );
+    const replacement = baselines.startBaseline(fx.db, {
+      id: 'replacement', project_name: 'fixture', mode: 'brownfield',
+      repository_revision: fx.revision, replace_ready: true,
+    }, { rootDir: fx.rootDir });
+    assert.equal(replacement.status, 'adopting');
+    assert.equal(baselines.readBaseline(fx.db, 'ready-baseline').status, 'superseded');
+    const supersededHealth = baselines.inspectBaseline(fx.db, {
+      rootDir: fx.rootDir, id: 'ready-baseline',
+    });
+    assert.ok(supersededHealth.blockers.includes('BASELINE_NOT_READY:superseded'));
+  } finally {
+    cleanup(fx);
+  }
+});
+
+test('greenfield baseline derives a stable workspace revision when Git is not initialized', () => {
+  const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-greenfield-baseline-'));
+  fs.mkdirSync(path.join(rootDir, '.ultra', 'specs'), { recursive: true });
+  fs.writeFileSync(path.join(rootDir, '.ultra', 'specs', 'product.md'), '# Product\n\nAccepted intent.\n');
+  fs.writeFileSync(path.join(rootDir, '.ultra', 'specs', 'architecture.md'), '# Architecture\n\nAccepted constraints.\n');
+  const { db } = initStateDb(path.join(rootDir, '.ultra', 'state.db'));
+  try {
+    baselines.startBaseline(db, {
+      id: 'greenfield', project_name: 'new-project', mode: 'greenfield', scope: ['.'],
+    }, { rootDir });
+    const recorded = baselines.recordBaseline(db, {
+      id: 'greenfield',
+      spec_refs: [
+        { kind: 'product', path: '.ultra/specs/product.md' },
+        { kind: 'architecture', path: '.ultra/specs/architecture.md' },
+      ],
+      evidence: [{ kind: 'docs', ref: '.ultra/specs/product.md', summary: 'Owner-approved product intent.' }],
+      verification: [{
+        name: 'spec review', command: 'review baseline specifications', status: 'pass',
+        evidence: 'Product and architecture contracts agree.',
+      }],
+      unknowns: [],
+    }, { rootDir });
+    assert.match(recorded.repository_revision, /^workspace:[0-9a-f]{64}$/);
+    const result = baselines.convergeBaseline(db, {
+      id: 'greenfield', expected_revision: recorded.repository_revision,
+      approved_by: 'owner', approval_note: 'Approved before planning.',
+    }, { rootDir });
+    assert.equal(result.ready, true);
+  } finally {
+    closeStateDb(db);
+    fs.rmSync(rootDir, { recursive: true, force: true });
+  }
+});

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

@@ -8,12 +8,10 @@ const { spawnSync } = require('node:child_process');
 const ops = require('./state-ops.cjs');
 const contextSpine = require('./context-spine.cjs');
 const specLearning = require('./spec-learning.cjs');
+const providerRefs = require('./provider-refs.cjs');
+const baselines = require('./baseline-workflow.cjs');
 
 const CHANGE_ID = /^[a-zA-Z0-9_-]+$/;
-const PROVIDER_KINDS = new Set(['memory', 'code_graph']);
-const PROVIDER_FIELDS = new Set([
-  'provider', 'project', 'reference', 'revision', 'indexed_head', 'status',
-]);
 const CHANGE_PATCH_FIELDS = new Set(['title', 'intent', 'status', 'docs_impact', 'provider_refs']);
 const CHANGE_TRANSITIONS = Object.freeze({
   active: new Set(['active', 'blocked', 'cancelled']),
@@ -83,29 +81,7 @@ function normalizeDocsImpact(value) {
 }
 
 function normalizeProviderRefs(value) {
-  if (value == null) return {};
-  if (typeof value !== 'object' || Array.isArray(value)) {
-    throw new ChangeWorkflowError('VALIDATION_ERROR', 'provider_refs must be an object');
-  }
-  const out = {};
-  for (const [kind, ref] of Object.entries(value)) {
-    if (!PROVIDER_KINDS.has(kind) || !ref || typeof ref !== 'object' || Array.isArray(ref)) {
-      throw new ChangeWorkflowError('VALIDATION_ERROR', `invalid external provider reference: ${kind}`);
-    }
-    for (const key of Object.keys(ref)) {
-      if (!PROVIDER_FIELDS.has(key)) {
-        throw new ChangeWorkflowError(
-          'PROVIDER_CONTENT_FORBIDDEN',
-          `provider_refs.${kind}.${key} is not metadata; provider content remains external`,
-        );
-      }
-    }
-    if (typeof ref.provider !== 'string' || !ref.provider.trim()) {
-      throw new ChangeWorkflowError('VALIDATION_ERROR', `provider_refs.${kind}.provider required`);
-    }
-    out[kind] = { ...ref };
-  }
-  return out;
+  return providerRefs.normalizeProviderRefs(value, ChangeWorkflowError);
 }
 
 function gitHead(rootDir) {
@@ -254,6 +230,7 @@ function compileContext(db, input, { rootDir = process.cwd() } = {}) {
     readiness: spine.readiness,
     context: spine.context,
     execution_contract: spine.execution_contract,
+    baseline: spine.baseline,
     resume: spine.resume,
     providers,
     provider_boundary: 'metadata references only; memory and code graph content remain external',
@@ -504,6 +481,13 @@ function evidenceBlockers(change, evidence, tasks) {
   return blockers;
 }
 
+function baselineConvergenceBlockers(db) {
+  const baseline = baselines.readBaseline(db);
+  if (!baseline) return ['BASELINE_MISSING'];
+  if (baseline.status !== 'ready') return [`BASELINE_NOT_READY:${baseline.status}`];
+  return [];
+}
+
 function convergeChange(db, input, { rootDir = process.cwd() } = {}) {
   const change = readChange(db, input.id);
   if (!change) throw new ChangeWorkflowError('CHANGE_NOT_FOUND', `change ${input.id} not found`);
@@ -512,6 +496,7 @@ function convergeChange(db, input, { rootDir = process.cwd() } = {}) {
   }
   const tasks = db.prepare('SELECT id, type, status, stale FROM tasks WHERE change_id = ? ORDER BY id').all(change.id);
   const blockers = new Set(evidenceBlockers(change, input.evidence, tasks));
+  for (const blocker of baselineConvergenceBlockers(db)) blockers.add(blocker);
   if (tasks.length === 0) blockers.add('NO_TASKS');
   if (tasks.some((task) => !['completed', 'expanded'].includes(task.status))) blockers.add('TASKS_INCOMPLETE');
   if (tasks.some((task) => Boolean(task.stale))) blockers.add('TASK_CONTEXT_STALE');
@@ -671,6 +656,18 @@ function archiveChange(db, input, { rootDir = process.cwd() } = {}) {
       });
       db.prepare("UPDATE artifacts SET status = 'archived', updated_at = ? WHERE change_id = ?")
         .run(nowIso(), change.id);
+      baselines.reconcileBaseline(db, {
+        baseline_updates: updates,
+        change_id: change.id,
+      }, { rootDir });
+      const baselineHealth = baselines.inspectBaseline(db, { rootDir });
+      if (baselineHealth.blockers.length > 0) {
+        throw new ChangeWorkflowError(
+          'BASELINE_RECONCILIATION_INCOMPLETE',
+          `baseline reconciliation remains incomplete: ${baselineHealth.blockers.join(', ')}`,
+          { blockers: baselineHealth.blockers },
+        );
+      }
       ops.appendEventInTx(db, {
         type: 'change_archived', change_id: change.id,
         payload: { archive_path: relative, baseline_updates: updates, no_baseline_change_reason: noChangeReason || null },

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

@@ -10,6 +10,7 @@ const { execFileSync } = require('node:child_process');
 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');
 
 function fixture() {
   const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-change-'));
@@ -20,6 +21,11 @@ function fixture() {
   execFileSync('git', ['add', 'README.md'], { cwd: rootDir });
   execFileSync('git', ['commit', '-q', '-m', 'seed'], { cwd: rootDir });
   const { db } = initStateDb(path.join(rootDir, '.ultra', 'state.db'));
+  db.prepare(
+    `INSERT INTO baselines
+     (id, project_name, mode, status, approved_by, approval_note, converged_at)
+     VALUES ('test-baseline', 'fixture', 'migrated', 'ready', 'test', 'legacy fixture', ?)`,
+  ).run(new Date().toISOString());
   return { rootDir, db };
 }
 
@@ -179,14 +185,82 @@ test('convergeChange blocks incomplete work and marks a fully evidenced standard
   }
 });
 
+test('convergeChange requires an approved baseline after active work has remained executable', () => {
+  const fx = fixture();
+  try {
+    changes.createChange(fx.db, {
+      id: 'chg-baseline-gate', title: 'Keep runtime work moving', kind: 'quick',
+      intent: 'Defer baseline closure to convergence without losing implementation progress.',
+      docs_impact: { status: 'none', files: [], rationale: 'Internal workflow behavior only.' },
+    }, { rootDir: fx.rootDir });
+    ops.createTask(fx.db, {
+      id: 'baseline-gate-task', title: 'Exercise convergence boundary', type: 'feature', priority: 'P0',
+      change_id: 'chg-baseline-gate',
+    });
+    ops.updateTaskStatus(fx.db, 'baseline-gate-task', 'in_progress');
+    ops.updateTaskStatus(fx.db, 'baseline-gate-task', 'completed');
+    changes.compileContext(fx.db, {
+      id: 'chg-baseline-gate', ...executionContext('baseline-gate-task'),
+    }, { rootDir: fx.rootDir });
+    fx.db.prepare('DELETE FROM baselines').run();
+
+    const result = changes.convergeChange(fx.db, {
+      id: 'chg-baseline-gate',
+      evidence: [
+        { category: 'diff', status: 'pass', evidence: 'diff reviewed' },
+        { category: 'tests', status: 'pass', evidence: 'workflow regression passed', seam: 'convergence gate' },
+        { category: 'spec', status: 'pass', evidence: 'change remains aligned' },
+      ],
+    }, { rootDir: fx.rootDir });
+
+    assert.equal(result.ready, false);
+    assert.ok(result.blockers.includes('BASELINE_MISSING'));
+  } finally {
+    cleanup(fx);
+  }
+});
+
 test('archiveChange moves a ready change into immutable history and records baseline reconciliation', () => {
   const fx = fixture();
   try {
+    fs.mkdirSync(path.join(fx.rootDir, '.ultra', 'specs'), { recursive: true });
+    fs.writeFileSync(path.join(fx.rootDir, '.ultra', 'specs', 'product.md'), '# Product\n\nCurrent behavior.\n');
+    fs.writeFileSync(path.join(fx.rootDir, '.ultra', 'specs', 'architecture.md'), '# Architecture\n\nCurrent boundary.\n');
+    const fileDigest = (file) => require('node:crypto').createHash('sha256')
+      .update(fs.readFileSync(file)).digest('hex');
+    fx.db.prepare(
+      `UPDATE baselines SET mode = 'brownfield', repository_revision = ?, spec_refs_json = ?
+       WHERE id = 'test-baseline'`,
+    ).run(
+      execFileSync('git', ['rev-parse', 'HEAD'], { cwd: fx.rootDir, encoding: 'utf8' }).trim(),
+      JSON.stringify([
+        {
+          kind: 'product', path: '.ultra/specs/product.md',
+          digest: fileDigest(path.join(fx.rootDir, '.ultra', 'specs', 'product.md')),
+        },
+        {
+          kind: 'architecture', path: '.ultra/specs/architecture.md',
+          digest: fileDigest(path.join(fx.rootDir, '.ultra', 'specs', 'architecture.md')),
+        },
+      ]),
+    );
     changes.createChange(fx.db, {
       id: 'chg-archive', title: 'Archive verified change', kind: 'quick',
       intent: 'Preserve the completed change as project history.',
       docs_impact: { status: 'none', files: [], rationale: 'Internal test-only behavior.' },
     }, { rootDir: fx.rootDir });
+    fs.appendFileSync(
+      path.join(fx.rootDir, '.ultra', 'specs', 'product.md'),
+      '\nBehavior learned and approved by this change.\n',
+    );
+    execFileSync('git', ['add', '.ultra/specs/product.md'], { cwd: fx.rootDir });
+    execFileSync('git', ['commit', '-q', '-m', 'update baseline behavior'], { cwd: fx.rootDir });
+    const changedHead = execFileSync(
+      'git', ['rev-parse', 'HEAD'], { cwd: fx.rootDir, encoding: 'utf8' },
+    ).trim();
+    const drift = baselines.inspectBaseline(fx.db, { rootDir: fx.rootDir });
+    assert.ok(drift.blockers.includes('BASELINE_HEAD_STALE'));
+    assert.ok(drift.blockers.includes('BASELINE_SPEC_STALE:.ultra/specs/product.md'));
     ops.createTask(fx.db, {
       id: 'archive-task', title: 'Complete archive path', type: 'bugfix', priority: 'P1',
       change_id: 'chg-archive',
@@ -214,7 +288,7 @@ test('archiveChange moves a ready change into immutable history and records base
 
     const archived = changes.archiveChange(fx.db, {
       id: 'chg-archive', summary: 'Verified quick fix archived.',
-      no_baseline_change_reason: 'No canonical spec changed.',
+      baseline_updates: ['.ultra/specs/product.md'],
     }, { rootDir: fx.rootDir });
     assert.equal(archived.change.status, 'archived');
     assert.ok(fs.existsSync(archived.archive_path));
@@ -228,6 +302,84 @@ test('archiveChange moves a ready change into immutable history and records base
       assert.doesNotMatch(artifact.path, /changes\/active/);
       assert.ok(fs.existsSync(path.join(fx.rootDir, artifact.path)), artifact.path);
     }
+    const reconciliation = fx.db.prepare(
+      "SELECT type, payload_json FROM events WHERE type = 'baseline_reconciled' ORDER BY id DESC LIMIT 1",
+    ).get();
+    assert.equal(reconciliation.type, 'baseline_reconciled');
+    assert.deepEqual(JSON.parse(reconciliation.payload_json).baseline_updates, ['.ultra/specs/product.md']);
+    const reconciled = baselines.inspectBaseline(fx.db, { rootDir: fx.rootDir });
+    assert.equal(reconciled.status, 'pass');
+    assert.equal(reconciled.baseline.repository_revision, changedHead);
+  } finally {
+    cleanup(fx);
+  }
+});
+
+test('archiveChange rolls back when declared reconciliation leaves a tracked specification stale', () => {
+  const fx = fixture();
+  try {
+    const specPath = path.join(fx.rootDir, '.ultra', 'specs', 'product.md');
+    fs.mkdirSync(path.dirname(specPath), { recursive: true });
+    fs.writeFileSync(specPath, '# Product\n\nOriginal behavior.\n');
+    const originalHead = execFileSync(
+      'git', ['rev-parse', 'HEAD'], { cwd: fx.rootDir, encoding: 'utf8' },
+    ).trim();
+    const originalDigest = require('node:crypto').createHash('sha256')
+      .update(fs.readFileSync(specPath)).digest('hex');
+    fx.db.prepare(
+      `UPDATE baselines SET mode = 'brownfield', repository_revision = ?, spec_refs_json = ?
+       WHERE id = 'test-baseline'`,
+    ).run(originalHead, JSON.stringify([
+      { kind: 'product', path: '.ultra/specs/product.md', digest: originalDigest },
+    ]));
+    changes.createChange(fx.db, {
+      id: 'chg-reconcile-rollback', title: 'Reject incomplete reconciliation', kind: 'quick',
+      intent: 'Keep the active change recoverable until every tracked specification is reconciled.',
+      docs_impact: { status: 'none', files: [], rationale: 'Workflow integrity only.' },
+    }, { rootDir: fx.rootDir });
+    fs.appendFileSync(specPath, '\nChanged behavior that must be declared.\n');
+    execFileSync('git', ['add', '.ultra/specs/product.md'], { cwd: fx.rootDir });
+    execFileSync('git', ['commit', '-q', '-m', 'change tracked product spec'], { cwd: fx.rootDir });
+    ops.createTask(fx.db, {
+      id: 'reconcile-rollback-task', title: 'Exercise archive rollback', type: 'feature', priority: 'P0',
+      change_id: 'chg-reconcile-rollback',
+    });
+    ops.updateTaskStatus(fx.db, 'reconcile-rollback-task', 'in_progress');
+    ops.updateTaskStatus(fx.db, 'reconcile-rollback-task', 'completed');
+    changes.compileContext(fx.db, {
+      id: 'chg-reconcile-rollback', ...executionContext('reconcile-rollback-task'),
+    }, { rootDir: fx.rootDir });
+    const converged = changes.convergeChange(fx.db, {
+      id: 'chg-reconcile-rollback',
+      evidence: [
+        { category: 'diff', status: 'pass', evidence: 'archive diff reviewed' },
+        {
+          category: 'tests', status: 'pass', evidence: 'archive rollback regression passed',
+          seam: 'archive reconciliation boundary',
+        },
+        { category: 'spec', status: 'pass', evidence: 'tracked specification change identified' },
+      ],
+    }, { rootDir: fx.rootDir });
+    assert.equal(converged.ready, true);
+
+    assert.throws(
+      () => changes.archiveChange(fx.db, {
+        id: 'chg-reconcile-rollback', summary: 'Attempt an incomplete archive.',
+        no_baseline_change_reason: 'No baseline update declared.',
+      }, { rootDir: fx.rootDir }),
+      (error) => error.code === 'BASELINE_RECONCILIATION_INCOMPLETE'
+        && error.details.blockers.includes('BASELINE_SPEC_STALE:.ultra/specs/product.md'),
+    );
+
+    const active = changes.readChange(fx.db, 'chg-reconcile-rollback');
+    assert.equal(active.status, 'ready');
+    assert.ok(fs.existsSync(path.join(fx.rootDir, active.artifact_root)));
+    assert.equal(fs.existsSync(path.join(fx.rootDir, active.artifact_root, 'archive-summary.md')), false);
+    assert.equal(baselines.readBaseline(fx.db).repository_revision, originalHead);
+    const reconciliationEvents = fx.db.prepare(
+      "SELECT COUNT(*) AS count FROM events WHERE type = 'baseline_reconciled' AND change_id = ?",
+    ).get('chg-reconcile-rollback');
+    assert.equal(reconciliationEvents.count, 0);
   } finally {
     cleanup(fx);
   }
@@ -447,12 +599,12 @@ test('compileContext v2 persists role-scoped context, budget, execution contract
   }
 });
 
-test('compileContext blocks a required missing ref or an over-budget role packet', () => {
+test('compileContext blocks a required missing ref', () => {
   const fx = fixture();
   try {
     changes.createChange(fx.db, {
       id: 'chg-context-budget', title: 'Bound context packet', kind: 'quick',
-      intent: 'Fail closed when required context is missing or too large.',
+      intent: 'Fail closed when required context is missing while reporting size pressure.',
     }, { rootDir: fx.rootDir });
     ops.createTask(fx.db, {
       id: 'budget-task', title: 'Compile bounded packet', type: 'bugfix', priority: 'P0',
@@ -466,14 +618,58 @@ test('compileContext blocks a required missing ref or an over-budget role packet
           { ref: 'missing-contract.md', kind: 'spec', reason: 'Required contract', required: true },
           { ref: 'README.md', kind: 'source', reason: 'Current implementation', required: true },
         ],
-        budget: { max_tokens: 1, max_files: 1 },
+        budget: { max_tokens: 2_000, max_files: 4 },
       }),
     }, { rootDir: fx.rootDir });
 
     assert.equal(compiled.manifest.readiness.status, 'blocked');
     assert.ok(compiled.manifest.readiness.blockers.includes('CONTEXT_REQUIRED_REF_MISSING:missing-contract.md'));
-    assert.ok(compiled.manifest.readiness.blockers.includes('CONTEXT_FILE_BUDGET_EXCEEDED'));
-    assert.ok(compiled.manifest.readiness.blockers.includes('CONTEXT_TOKEN_BUDGET_EXCEEDED'));
+  } finally {
+    cleanup(fx);
+  }
+});
+
+test('an incident can proceed with four necessary large files while context budgets remain advisory', () => {
+  const fx = fixture();
+  try {
+    const refs = [];
+    for (let index = 1; index <= 4; index += 1) {
+      const ref = `incident-runtime-${index}.cjs`;
+      fs.writeFileSync(path.join(fx.rootDir, ref), 'x'.repeat(8_000));
+      refs.push({
+        ref, kind: 'source', reason: `Required incident runtime boundary ${index}`, required: true,
+      });
+    }
+    changes.createChange(fx.db, {
+      id: 'chg-incident-context', title: 'Recover IM runtime', kind: 'incident',
+      intent: 'Keep an urgent root-cause fix executable when its required files exceed guidance.',
+    }, { rootDir: fx.rootDir });
+    ops.createTask(fx.db, {
+      id: 'incident-context-task', title: 'Repair IM terminal transition', type: 'bugfix', priority: 'P0',
+      change_id: 'chg-incident-context',
+    });
+
+    const compiled = changes.compileContext(fx.db, {
+      id: 'chg-incident-context',
+      ...executionContext('incident-context-task', {
+        context_refs: refs,
+        budget: { max_tokens: 100, max_files: 2 },
+        execution_contract: {
+          slice_kind: 'tracer_bullet',
+          public_seam: 'IM terminal transition',
+          verification_command: 'node --test im-terminal.test.cjs',
+          context_budget_percent: 80,
+        },
+      }),
+    }, { rootDir: fx.rootDir });
+
+    assert.equal(compiled.manifest.readiness.status, 'ready');
+    assert.deepEqual(compiled.manifest.readiness.blockers, []);
+    assert.ok(compiled.manifest.readiness.warnings.includes('CONTEXT_FILE_BUDGET_EXCEEDED'));
+    assert.ok(compiled.manifest.readiness.warnings.includes('CONTEXT_TOKEN_BUDGET_EXCEEDED'));
+    assert.ok(compiled.manifest.readiness.warnings.includes('EXECUTION_CONTEXT_BUDGET_ADVISORY'));
+    assert.equal(compiled.manifest.context.file_count, 4);
+    assert.ok(compiled.manifest.context.token_estimate > 100);
   } finally {
     cleanup(fx);
   }