ultra-builder-pro-cli 0.11.0 → 0.13.0

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

@@ -10,6 +10,8 @@ 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');
+const archiveJournal = require('./archive-journal.cjs');
 
 function fixture() {
   const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-change-'));
@@ -20,6 +22,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', 'greenfield', 'ready', 'test', 'accepted fixture', ?)`,
+  ).run(new Date().toISOString());
   return { rootDir, db };
 }
 
@@ -124,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 {
@@ -179,14 +343,103 @@ 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('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 {
+    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 +467,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 +481,139 @@ 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);
+  }
+});
+
+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);
   }
@@ -447,12 +833,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 +852,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);
   }