@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-release-check/release-check-runtime-sdd-suite.mjs

@@ -0,0 +1,535 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  assertJsonMarkers,
+  digestObject,
+  parseJsonOutput,
+  repoRoot,
+  run,
+} from './release-check-runtime.mjs';
+
+export function runRuntimeSddPlanPreflightSmoke(options) {
+  const base = '.tmp/vibe-runtime-sdd-preflight';
+  const absoluteBase = path.join(repoRoot, base);
+  fs.rmSync(absoluteBase, { recursive: true, force: true });
+  try {
+    fs.mkdirSync(absoluteBase, { recursive: true });
+    const clean = preparePlanPreflightCase(base, 'clean', ['# SDD preflight clean', '', '- Update `src/a.ts` with tests and acceptance checks inside confirm boundary', '- Update `src/b.ts` after task-01 with review gate evidence', '']);
+    const preview = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--plan', '--from-plan', 'plan.md', '--profile', 'superpowers-parity', '--json', '--root', clean.root], {}, options), 'sdd --plan preflight clean');
+    assertJsonMarkers([
+      ['command', preview.command, 'sdd'],
+      ['mode', preview.mode, 'superpowers-parity-sdd-loop-plan'],
+      ['ok', preview.ok, true],
+      ['sdd_plan.preflight_clean', preview.sdd_plan?.preflight_clean, true],
+      ['sdd_plan.preflight_scan.blocker_count', preview.sdd_plan?.preflight_scan?.blocker_count, 0],
+      ['sdd_plan.preflight_scan.scan_kind', preview.sdd_plan?.preflight_scan?.scan_kind, 'superpowers-parity-sdd-plan-preflight'],
+      ['safety.source_write', preview.safety?.source_write, false],
+      ['safety.subagent', preview.safety?.subagent, false],
+    ], 'sdd --plan preflight clean');
+    if (fs.existsSync(path.join(clean.absoluteRoot, '.vibecoding-state'))) throw new Error('sdd plan preflight preview created unexpected state directory');
+    const cleanRun = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--run-loop', '--from-plan', 'plan.md', '--profile', 'superpowers-parity', '--confirm', '--json', '--root', clean.root], {}, options), 'sdd --run-loop preflight clean');
+    assertJsonMarkers([
+      ['sdd_run_loop.preflight_scan.blocker_count', cleanRun.sdd_run_loop?.preflight_scan?.blocker_count, 0],
+      ['sdd_run_loop.selected_task.task_id', cleanRun.sdd_run_loop?.selected_task?.task_id, 'task-01'],
+    ], 'sdd --run-loop preflight clean');
+
+    const conflict = preparePlanPreflightCase(base, 'conflict', ['# SDD preflight conflict', '', '- Update `src/shared.ts` with tests and acceptance checks', '- Update `src/shared.ts` without review', '']);
+    const conflictPreview = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--plan', '--from-plan', 'plan.md', '--profile', 'superpowers-parity', '--json', '--root', conflict.root], {}, options), 'sdd --plan preflight conflict');
+    assertJsonMarkers([
+      ['ok', conflictPreview.ok, false],
+      ['sdd_plan.preflight_clean', conflictPreview.sdd_plan?.preflight_clean, false],
+      ['sdd_plan.preflight_scan.blocker_count', conflictPreview.sdd_plan?.preflight_scan?.blocker_count, 2],
+      ['sdd_plan.preflight_scan.blockers.0.category', conflictPreview.sdd_plan?.preflight_scan?.blockers?.[0]?.category, 'task-file-overlap'],
+    ], 'sdd --plan preflight conflict');
+    if (fs.existsSync(path.join(conflict.absoluteRoot, '.vibecoding-state'))) throw new Error('sdd conflict preflight preview created unexpected state directory');
+    run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--run-loop', '--from-plan', 'plan.md', '--profile', 'superpowers-parity', '--confirm', '--root', conflict.root], { allowFailure: true, expectOutput: ['sdd preflight blockers must be resolved before run-loop'] }, options);
+    if (fs.existsSync(path.join(conflict.absoluteRoot, '.vibecoding-state'))) throw new Error('sdd conflict run-loop wrote state before preflight stop');
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteBase, { recursive: true, force: true });
+  }
+}
+
+export function runRuntimeSddTaskBriefSmoke(options) {
+  const base = '.tmp/vibe-runtime-sdd-task-brief';
+  const absoluteBase = path.join(repoRoot, base);
+  fs.rmSync(absoluteBase, { recursive: true, force: true });
+  try {
+    fs.mkdirSync(absoluteBase, { recursive: true });
+    const clean = prepareTaskBriefCase(base, 'clean');
+    const preview = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--task-brief', '--from-plan', 'plan.md', '--task', 'task-01', '--profile', 'superpowers-parity', '--json', '--root', clean.root], {}, options), 'sdd --task-brief preview');
+    assertJsonMarkers([
+      ['command', preview.command, 'sdd'],
+      ['mode', preview.mode, 'superpowers-parity-sdd-task-brief'],
+      ['ok', preview.ok, true],
+      ['sdd_task_brief.stage', preview.sdd_task_brief?.stage, 'Stage 149'],
+      ['sdd_task_brief.task_id', preview.sdd_task_brief?.task_id, 'task-01'],
+      ['sdd_task_brief.writes', preview.sdd_task_brief?.writes, false],
+      ['sdd_task_brief.implementer_source_of_truth', preview.sdd_task_brief?.implementer_source_of_truth, true],
+      ['safety.sdd_task_brief_artifact', preview.safety?.sdd_task_brief_artifact, false],
+      ['safety.platform_api', preview.safety?.platform_api, false],
+      ['safety.model_invocation', preview.safety?.model_invocation, false],
+      ['safety.subagent', preview.safety?.subagent, false],
+      ['safety.git_write', preview.safety?.git_write, false],
+    ], 'sdd --task-brief preview');
+    if (fs.existsSync(path.join(clean.absoluteRoot, '.vibecoding-state'))) throw new Error('sdd task-brief preview created unexpected state directory');
+
+    const confirmed = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--task-brief', '--from-plan', 'plan.md', '--task', 'task-01', '--profile', 'superpowers-parity', '--confirm', '--json', '--root', clean.root], {}, options), 'sdd --task-brief confirm');
+    assertJsonMarkers([
+      ['sdd_task_brief.writes', confirmed.sdd_task_brief?.writes, true],
+      ['sdd_task_brief.boundary_assertions.state_directory_created', confirmed.sdd_task_brief?.boundary_assertions?.state_directory_created, true],
+      ['safety.sdd_task_brief_artifact', confirmed.safety?.sdd_task_brief_artifact, true],
+    ], 'sdd --task-brief confirm');
+    if (!fs.existsSync(path.join(clean.absoluteRoot, '.vibecoding-state', confirmed.files.task_brief))) throw new Error('sdd task-brief did not write markdown sidecar');
+    if (!fs.existsSync(path.join(clean.absoluteRoot, '.vibecoding-state', confirmed.files.task_brief_artifact))) throw new Error('sdd task-brief did not write JSON sidecar');
+
+    const runLoop = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--run-loop', '--from-plan', 'plan.md', '--profile', 'superpowers-parity', '--confirm', '--json', '--root', clean.root], {}, options), 'sdd --run-loop with task brief');
+    assertJsonMarkers([
+      ['sdd_run_loop.task_brief.brief_file', runLoop.sdd_run_loop?.task_brief?.brief_file, confirmed.sdd_task_brief?.brief_file],
+      ['sdd_run_loop.task_brief.brief_digest', runLoop.sdd_run_loop?.task_brief?.brief_digest, confirmed.sdd_task_brief?.brief_digest],
+      ['sdd_run_loop.dispatch_artifacts.0.brief_digest', runLoop.sdd_run_loop?.dispatch_artifacts?.[0]?.brief_digest, confirmed.sdd_task_brief?.brief_digest],
+      ['files.task_brief_artifact', runLoop.files?.task_brief_artifact, confirmed.files.task_brief_artifact],
+    ], 'sdd --run-loop with task brief');
+    const dispatchPath = path.join(clean.absoluteRoot, '.vibecoding-state', 'subagent-adapter-dispatches', runLoop.files.dispatch_artifacts[0]);
+    const dispatch = JSON.parse(fs.readFileSync(dispatchPath, 'utf8'));
+    if (dispatch.brief_digest !== confirmed.sdd_task_brief.brief_digest) throw new Error('sdd dispatch did not bind task brief digest');
+
+    const missing = prepareTaskBriefCase(base, 'missing-task');
+    run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--task-brief', '--from-plan', 'plan.md', '--task', 'task-99', '--profile', 'superpowers-parity', '--root', missing.root], { allowFailure: true, expectOutput: ['sdd task not found: task-99'] }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--task-brief', '--from-plan', 'plan.md', '--task', '../task-01', '--profile', 'superpowers-parity', '--root', missing.root], { allowFailure: true, expectOutput: ['Invalid task id: ../task-01'] }, options);
+
+    const drift = prepareTaskBriefCase(base, 'plan-drift');
+    run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--task-brief', '--from-plan', 'plan.md', '--task', 'task-01', '--profile', 'superpowers-parity', '--confirm', '--root', drift.root], {}, options);
+    fs.writeFileSync(path.join(drift.absoluteRoot, 'plan.md'), ['# SDD task brief fixture', '', '- Changed first task', '- Second task', ''].join('\n'), 'utf8');
+    run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--run-loop', '--from-plan', 'plan.md', '--profile', 'superpowers-parity', '--confirm', '--root', drift.root], { allowFailure: true, expectOutput: ['sdd task brief plan digest drift'] }, options);
+
+    const digestDrift = prepareTaskBriefCase(base, 'brief-digest-drift');
+    const digestEnvelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--task-brief', '--from-plan', 'plan.md', '--task', 'task-01', '--profile', 'superpowers-parity', '--confirm', '--json', '--root', digestDrift.root], {}, options), 'sdd --task-brief digest fixture');
+    fs.appendFileSync(path.join(digestDrift.absoluteRoot, '.vibecoding-state', digestEnvelope.files.task_brief), '\nmanual drift\n', 'utf8');
+    run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--run-loop', '--from-plan', 'plan.md', '--profile', 'superpowers-parity', '--confirm', '--root', digestDrift.root], { allowFailure: true, expectOutput: ['sdd task brief digest mismatch'] }, options);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteBase, { recursive: true, force: true });
+  }
+}
+
+export function runRuntimeSddReviewPackageSmoke(options) {
+  const base = '.tmp/vibe-runtime-sdd-review-package';
+  const absoluteBase = path.join(repoRoot, base);
+  fs.rmSync(absoluteBase, { recursive: true, force: true });
+  try {
+    fs.mkdirSync(absoluteBase, { recursive: true });
+    const clean = prepareReviewPackageCase(base, 'clean', options);
+    const preview = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--review-package', '--from-plan', 'plan.md', '--task', 'task-01', '--base', clean.baseSha, '--head', clean.headSha, '--profile', 'superpowers-parity', '--json', '--root', clean.root], {}, options), 'sdd --review-package preview');
+    assertJsonMarkers([
+      ['command', preview.command, 'sdd'],
+      ['mode', preview.mode, 'superpowers-parity-sdd-review-package'],
+      ['ok', preview.ok, true],
+      ['sdd_review_package.stage', preview.sdd_review_package?.stage, 'Stage 149'],
+      ['sdd_review_package.task_id', preview.sdd_review_package?.task_id, 'task-01'],
+      ['sdd_review_package.commit_count', preview.sdd_review_package?.commit_count, 2],
+      ['sdd_review_package.writes', preview.sdd_review_package?.writes, false],
+      ['sdd_review_package.boundary_assertions.git_read', preview.sdd_review_package?.boundary_assertions?.git_read, true],
+      ['sdd_review_package.boundary_assertions.git_write', preview.sdd_review_package?.boundary_assertions?.git_write, false],
+      ['sdd_review_package.boundary_assertions.sdd_review_package_artifact', preview.sdd_review_package?.boundary_assertions?.sdd_review_package_artifact, false],
+      ['safety.platform_api', preview.safety?.platform_api, false],
+      ['safety.model_invocation', preview.safety?.model_invocation, false],
+      ['safety.subagent', preview.safety?.subagent, false],
+    ], 'sdd --review-package preview');
+    if (fs.existsSync(path.join(clean.absoluteRoot, '.vibecoding-state', 'sdd', 'review-packages'))) throw new Error('sdd review-package preview wrote review package state');
+
+    const confirmed = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--review-package', '--from-plan', 'plan.md', '--task', 'task-01', '--base', clean.baseSha, '--head', clean.headSha, '--profile', 'superpowers-parity', '--confirm', '--json', '--root', clean.root], {}, options), 'sdd --review-package confirm');
+    assertJsonMarkers([
+      ['sdd_review_package.writes', confirmed.sdd_review_package?.writes, true],
+      ['sdd_review_package.boundary_assertions.sdd_review_package_artifact', confirmed.sdd_review_package?.boundary_assertions?.sdd_review_package_artifact, true],
+      ['sdd_review_package.net_diff_line_count', confirmed.sdd_review_package?.net_diff_line_count > 0, true],
+      ['safety.git_write', confirmed.safety?.git_write, false],
+    ], 'sdd --review-package confirm');
+    if (!fs.existsSync(path.join(clean.absoluteRoot, '.vibecoding-state', confirmed.files.review_package))) throw new Error('sdd review-package did not write diff markdown sidecar');
+    if (!fs.existsSync(path.join(clean.absoluteRoot, '.vibecoding-state', confirmed.files.review_package_artifact))) throw new Error('sdd review-package did not write JSON sidecar');
+    const packageText = fs.readFileSync(path.join(clean.absoluteRoot, '.vibecoding-state', confirmed.files.review_package), 'utf8');
+    if (!packageText.includes('second-task-commit') || !packageText.includes('first-task-commit')) throw new Error('sdd review-package did not include full base..head commit list');
+    if (!packageText.includes('diff --git')) throw new Error('sdd review-package did not include net diff');
+
+    const invalidBase = prepareReviewPackageCase(base, 'invalid-base', options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--review-package', '--from-plan', 'plan.md', '--task', 'task-01', '--base', '1234567', '--head', invalidBase.headSha, '--profile', 'superpowers-parity', '--root', invalidBase.root], { allowFailure: true, expectOutput: ['sdd review package git read failed for base commit'] }, options);
+
+    const wrongTask = prepareReviewPackageCase(base, 'wrong-task', options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--review-package', '--from-plan', 'plan.md', '--task', 'task-02', '--base', wrongTask.baseSha, '--head', wrongTask.headSha, '--profile', 'superpowers-parity', '--root', wrongTask.root], { allowFailure: true, expectOutput: ['sdd review package task is not active: task-02'] }, options);
+
+    const briefDrift = prepareReviewPackageCase(base, 'brief-drift', options);
+    mutateProgressRecord(briefDrift, (record) => { record.task_brief_digest = 'sha256:drift'; });
+    run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--review-package', '--from-plan', 'plan.md', '--task', 'task-01', '--base', briefDrift.baseSha, '--head', briefDrift.headSha, '--profile', 'superpowers-parity', '--root', briefDrift.root], { allowFailure: true, expectOutput: ['sdd review package task brief digest mismatch'] }, options);
+
+    const reportDrift = prepareReviewPackageCase(base, 'report-drift', options);
+    fs.appendFileSync(path.join(reportDrift.absoluteRoot, '.vibecoding-state', reportDrift.reportFile), '\nmanual drift\n', 'utf8');
+    run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--review-package', '--from-plan', 'plan.md', '--task', 'task-01', '--base', reportDrift.baseSha, '--head', reportDrift.headSha, '--profile', 'superpowers-parity', '--root', reportDrift.root], { allowFailure: true, expectOutput: ['sdd review package report digest mismatch'] }, options);
+
+    const headShortcut = prepareReviewPackageCase(base, 'head-shortcut', options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--review-package', '--from-plan', 'plan.md', '--task', 'task-01', '--base', 'HEAD~1', '--head', headShortcut.headSha, '--profile', 'superpowers-parity', '--root', headShortcut.root], { allowFailure: true, expectOutput: ['sdd --review-package requires base sha; HEAD shortcuts are not accepted'] }, options);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteBase, { recursive: true, force: true });
+  }
+}
+
+export function runRuntimeSddConsumptionSmoke(options) {
+  const base = '.tmp/vibe-runtime-sdd-consumption';
+  const absoluteBase = path.join(repoRoot, base);
+  fs.rmSync(absoluteBase, { recursive: true, force: true });
+  try {
+    fs.mkdirSync(absoluteBase, { recursive: true });
+    const clean = prepareCase(base, 'clean', options);
+    const cleanInput = adapterResultFixture(clean);
+    fs.writeFileSync(path.join(clean.absoluteRoot, 'adapter-result.json'), `${JSON.stringify(cleanInput, null, 2)}\n`, 'utf8');
+    const envelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--consume-adapter-result', '--from-plan', 'plan.md', '--from-file', 'adapter-result.json', '--profile', 'superpowers-parity', '--confirm', '--json', '--root', clean.root], {}, options), 'sdd --consume-adapter-result --json');
+    assertJsonMarkers([
+      ['command', envelope.command, 'sdd'],
+      ['mode', envelope.mode, 'superpowers-parity-sdd-adapter-consumption'],
+      ['ok', envelope.ok, true],
+      ['sdd_adapter_consumption.stage', envelope.sdd_adapter_consumption?.stage, 'P12'],
+      ['sdd_adapter_consumption.task_id', envelope.sdd_adapter_consumption?.task_id, 'task-01'],
+      ['sdd_adapter_consumption.review_status', envelope.sdd_adapter_consumption?.review_status, 'clean'],
+      ['sdd_adapter_consumption.next_task_allowed', envelope.sdd_adapter_consumption?.next_task_allowed, true],
+      ['sdd_adapter_consumption.boundary_assertions.platform_api', envelope.sdd_adapter_consumption?.boundary_assertions?.platform_api, false],
+      ['sdd_adapter_consumption.boundary_assertions.model_invocation', envelope.sdd_adapter_consumption?.boundary_assertions?.model_invocation, false],
+      ['sdd_adapter_consumption.boundary_assertions.subagent', envelope.sdd_adapter_consumption?.boundary_assertions?.subagent, false],
+      ['safety.stage', envelope.safety?.stage, 'P12'],
+      ['safety.git_write', envelope.safety?.git_write, false],
+    ], 'sdd --consume-adapter-result --json');
+    if (!fs.existsSync(path.join(clean.absoluteRoot, '.vibecoding-state', envelope.files.adapter_consumption))) throw new Error('sdd adapter consumption did not write consumption sidecar');
+    const nextRun = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--run-loop', '--from-plan', 'plan.md', '--profile', 'superpowers-parity', '--confirm', '--json', '--root', clean.root], {}, options), 'sdd --run-loop after clean adapter consumption');
+    assertJsonMarkers([
+      ['sdd_run_loop.selected_task.task_id', nextRun.sdd_run_loop?.selected_task?.task_id, 'task-02'],
+    ], 'sdd --run-loop after clean adapter consumption');
+
+    const mismatch = prepareCase(base, 'task-mismatch', options);
+    const mismatchInput = adapterResultFixture(mismatch, { resultTaskId: 'task-99' });
+    fs.writeFileSync(path.join(mismatch.absoluteRoot, 'adapter-result.json'), `${JSON.stringify(mismatchInput, null, 2)}\n`, 'utf8');
+    run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--consume-adapter-result', '--from-plan', 'plan.md', '--from-file', 'adapter-result.json', '--profile', 'superpowers-parity', '--confirm', '--root', mismatch.root], { allowFailure: true, expectOutput: ['sdd adapter result result_artifact task id mismatch'] }, options);
+
+    const drift = prepareCase(base, 'digest-drift', options);
+    const driftInput = adapterResultFixture(drift, { dispatchDigest: 'sha256:drift' });
+    fs.writeFileSync(path.join(drift.absoluteRoot, 'adapter-result.json'), `${JSON.stringify(driftInput, null, 2)}\n`, 'utf8');
+    run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--consume-adapter-result', '--from-plan', 'plan.md', '--from-file', 'adapter-result.json', '--profile', 'superpowers-parity', '--confirm', '--root', drift.root], { allowFailure: true, expectOutput: ['sdd adapter result dispatch digest drift'] }, options);
+
+    const missingVerdict = prepareCase(base, 'missing-verdict', options);
+    const missingVerdictInput = adapterResultFixture(missingVerdict, { verdict: '' });
+    delete missingVerdictInput.review_artifact.verdict;
+    fs.writeFileSync(path.join(missingVerdict.absoluteRoot, 'adapter-result.json'), `${JSON.stringify(missingVerdictInput, null, 2)}\n`, 'utf8');
+    run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--consume-adapter-result', '--from-plan', 'plan.md', '--from-file', 'adapter-result.json', '--profile', 'superpowers-parity', '--confirm', '--root', missingVerdict.root], { allowFailure: true, expectOutput: ['sdd adapter result requires review_artifact.verdict'] }, options);
+
+    const blocked = prepareCase(base, 'blocked-review', options);
+    const blockedInput = adapterResultFixture(blocked, { verdict: 'blocked', findings: [{ severity: 'Critical', status: 'open', title: 'unsafe source change' }] });
+    fs.writeFileSync(path.join(blocked.absoluteRoot, 'adapter-result.json'), `${JSON.stringify(blockedInput, null, 2)}\n`, 'utf8');
+    const blockedEnvelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--consume-adapter-result', '--from-plan', 'plan.md', '--from-file', 'adapter-result.json', '--profile', 'superpowers-parity', '--confirm', '--json', '--root', blocked.root], {}, options), 'sdd --consume-adapter-result blocked review');
+    assertJsonMarkers([
+      ['ok', blockedEnvelope.ok, false],
+      ['sdd_adapter_consumption.review_status', blockedEnvelope.sdd_adapter_consumption?.review_status, 'blocked'],
+      ['sdd_adapter_consumption.next_task_allowed', blockedEnvelope.sdd_adapter_consumption?.next_task_allowed, false],
+      ['progress_ledger.active_task_id', blockedEnvelope.progress_ledger?.active_task_id, 'task-01'],
+    ], 'sdd --consume-adapter-result blocked review');
+    run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--run-loop', '--from-plan', 'plan.md', '--profile', 'superpowers-parity', '--confirm', '--root', blocked.root], { allowFailure: true, expectOutput: ['sdd review gate is still open for task-01'] }, options);
+
+    const missingReport = prepareCase(base, 'missing-report', options);
+    const missingReportInput = adapterResultFixture(missingReport);
+    delete missingReportInput.report_artifact;
+    fs.writeFileSync(path.join(missingReport.absoluteRoot, 'adapter-result.json'), `${JSON.stringify(missingReportInput, null, 2)}\n`, 'utf8');
+    run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--consume-adapter-result', '--from-plan', 'plan.md', '--from-file', 'adapter-result.json', '--profile', 'superpowers-parity', '--confirm', '--root', missingReport.root], { allowFailure: true, expectOutput: ['sdd adapter result requires implementer report artifact path and digest'] }, options);
+
+    const reportDigestDrift = prepareCase(base, 'report-digest-drift', options);
+    const reportDigestDriftInput = adapterResultFixture(reportDigestDrift, { reportDigest: 'sha256:drift' });
+    fs.writeFileSync(path.join(reportDigestDrift.absoluteRoot, 'adapter-result.json'), `${JSON.stringify(reportDigestDriftInput, null, 2)}\n`, 'utf8');
+    run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--consume-adapter-result', '--from-plan', 'plan.md', '--from-file', 'adapter-result.json', '--profile', 'superpowers-parity', '--confirm', '--root', reportDigestDrift.root], { allowFailure: true, expectOutput: ['sdd adapter result implementer report digest drift'] }, options);
+
+    const reportTaskMismatch = prepareCase(base, 'report-task-mismatch', options);
+    mutateReportFile(reportTaskMismatch, (report) => { report.task_id = 'task-99'; });
+    const reportTaskMismatchInput = adapterResultFixture(reportTaskMismatch);
+    fs.writeFileSync(path.join(reportTaskMismatch.absoluteRoot, 'adapter-result.json'), `${JSON.stringify(reportTaskMismatchInput, null, 2)}\n`, 'utf8');
+    run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--consume-adapter-result', '--from-plan', 'plan.md', '--from-file', 'adapter-result.json', '--profile', 'superpowers-parity', '--confirm', '--root', reportTaskMismatch.root], { allowFailure: true, expectOutput: ['sdd implementer report task id mismatch'] }, options);
+
+    const missingTestSummary = prepareCase(base, 'missing-test-summary', options);
+    mutateReportFile(missingTestSummary, (report) => { delete report.tests.summary; });
+    const missingTestInput = adapterResultFixture(missingTestSummary);
+    fs.writeFileSync(path.join(missingTestSummary.absoluteRoot, 'adapter-result.json'), `${JSON.stringify(missingTestInput, null, 2)}\n`, 'utf8');
+    const missingTestEnvelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--consume-adapter-result', '--from-plan', 'plan.md', '--from-file', 'adapter-result.json', '--profile', 'superpowers-parity', '--confirm', '--json', '--root', missingTestSummary.root], {}, options), 'sdd --consume-adapter-result missing test summary');
+    assertJsonMarkers([
+      ['ok', missingTestEnvelope.ok, false],
+      ['sdd_adapter_consumption.report_status', missingTestEnvelope.sdd_adapter_consumption?.report_status, 'DONE'],
+      ['sdd_adapter_consumption.next_task_allowed', missingTestEnvelope.sdd_adapter_consumption?.next_task_allowed, false],
+      ['progress_ledger.active_task_id', missingTestEnvelope.progress_ledger?.active_task_id, 'task-01'],
+    ], 'sdd --consume-adapter-result missing test summary');
+
+    const missingSelfReview = prepareCase(base, 'missing-self-review', options);
+    mutateReportFile(missingSelfReview, (report) => { delete report.self_review.summary; });
+    const missingSelfInput = adapterResultFixture(missingSelfReview);
+    fs.writeFileSync(path.join(missingSelfReview.absoluteRoot, 'adapter-result.json'), `${JSON.stringify(missingSelfInput, null, 2)}\n`, 'utf8');
+    const missingSelfEnvelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--consume-adapter-result', '--from-plan', 'plan.md', '--from-file', 'adapter-result.json', '--profile', 'superpowers-parity', '--confirm', '--json', '--root', missingSelfReview.root], {}, options), 'sdd --consume-adapter-result missing self review');
+    assertJsonMarkers([
+      ['ok', missingSelfEnvelope.ok, false],
+      ['sdd_adapter_consumption.report_status', missingSelfEnvelope.sdd_adapter_consumption?.report_status, 'DONE'],
+      ['sdd_adapter_consumption.next_task_allowed', missingSelfEnvelope.sdd_adapter_consumption?.next_task_allowed, false],
+      ['progress_ledger.active_task_id', missingSelfEnvelope.progress_ledger?.active_task_id, 'task-01'],
+    ], 'sdd --consume-adapter-result missing self review');
+
+    const questions = prepareCase(base, 'questions-report', options);
+    mutateReportFile(questions, (report) => { report.status = 'QUESTIONS'; report.questions = ['Need product answer']; });
+    const questionsInput = adapterResultFixture(questions, { reportStatus: 'QUESTIONS' });
+    fs.writeFileSync(path.join(questions.absoluteRoot, 'adapter-result.json'), `${JSON.stringify(questionsInput, null, 2)}\n`, 'utf8');
+    const questionsEnvelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--consume-adapter-result', '--from-plan', 'plan.md', '--from-file', 'adapter-result.json', '--profile', 'superpowers-parity', '--confirm', '--json', '--root', questions.root], {}, options), 'sdd --consume-adapter-result questions report');
+    assertJsonMarkers([
+      ['ok', questionsEnvelope.ok, false],
+      ['sdd_adapter_consumption.report_status', questionsEnvelope.sdd_adapter_consumption?.report_status, 'QUESTIONS'],
+      ['sdd_adapter_consumption.ledger_patch.status', questionsEnvelope.sdd_adapter_consumption?.ledger_patch?.status, 'questions-open'],
+      ['progress_ledger.active_task_id', questionsEnvelope.progress_ledger?.active_task_id, 'task-01'],
+    ], 'sdd --consume-adapter-result questions report');
+
+    const reportBlocked = prepareCase(base, 'blocked-report-status', options);
+    mutateReportFile(reportBlocked, (report) => { report.status = 'BLOCKED'; report.concerns = ['Implementation blocked']; });
+    const reportBlockedInput = adapterResultFixture(reportBlocked, { reportStatus: 'BLOCKED' });
+    fs.writeFileSync(path.join(reportBlocked.absoluteRoot, 'adapter-result.json'), `${JSON.stringify(reportBlockedInput, null, 2)}\n`, 'utf8');
+    const reportBlockedEnvelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--consume-adapter-result', '--from-plan', 'plan.md', '--from-file', 'adapter-result.json', '--profile', 'superpowers-parity', '--confirm', '--json', '--root', reportBlocked.root], {}, options), 'sdd --consume-adapter-result blocked report status');
+    assertJsonMarkers([
+      ['ok', reportBlockedEnvelope.ok, false],
+      ['sdd_adapter_consumption.report_status', reportBlockedEnvelope.sdd_adapter_consumption?.report_status, 'BLOCKED'],
+      ['sdd_adapter_consumption.ledger_patch.status', reportBlockedEnvelope.sdd_adapter_consumption?.ledger_patch?.status, 'blocked-report'],
+      ['progress_ledger.active_task_id', reportBlockedEnvelope.progress_ledger?.active_task_id, 'task-01'],
+    ], 'sdd --consume-adapter-result blocked report status');
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteBase, { recursive: true, force: true });
+  }
+}
+
+export function runRuntimeCloseoutSmoke(options) {
+  const base = '.tmp/vibe-runtime-closeout';
+  const absoluteBase = path.join(repoRoot, base);
+  fs.rmSync(absoluteBase, { recursive: true, force: true });
+  try {
+    fs.mkdirSync(absoluteBase, { recursive: true });
+    const clean = prepareCloseoutCase(base, 'clean');
+    writeCloseoutFixtures(clean);
+    const envelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'release', '--closeout-readiness', '--from-file', `${clean.root}/ledger.json`, '--from-evidence', `${clean.root}/tests.json`, '--from-diff-coverage', `${clean.root}/diff.json`, '--from-readiness', `${clean.root}/readiness.json`, '--profile', 'superpowers-parity', '--json', '--root', clean.root], {}, options), 'release --closeout-readiness clean');
+    assertJsonMarkers([
+      ['command', envelope.command, 'release'],
+      ['mode', envelope.mode, 'superpowers-parity-closeout-readiness'],
+      ['ok', envelope.ok, true],
+      ['state_present', envelope.state_present, false],
+      ['closeout_readiness.stage', envelope.closeout_readiness?.stage, 'P13'],
+      ['closeout_readiness.closeout_ready', envelope.closeout_readiness?.closeout_ready, true],
+      ['closeout_readiness.manual_next_action', envelope.closeout_readiness?.manual_next_action, 'commit'],
+      ['closeout_readiness.policy.runtime_git_execution_authorized', envelope.closeout_readiness?.policy?.runtime_git_execution_authorized, false],
+      ['closeout_readiness.boundary_assertions.git_write', envelope.closeout_readiness?.boundary_assertions?.git_write, false],
+      ['closeout_readiness.boundary_assertions.pr', envelope.closeout_readiness?.boundary_assertions?.pr, false],
+      ['closeout_readiness.boundary_assertions.subagent', envelope.closeout_readiness?.boundary_assertions?.subagent, false],
+      ['safety.stage', envelope.safety?.stage, 'P13'],
+      ['safety.git', envelope.safety?.git, false],
+      ['safety.platform_api', envelope.safety?.platform_api, false],
+    ], 'release --closeout-readiness clean');
+    assertCloseoutStateAbsent(clean, 'release --closeout-readiness clean');
+
+    const missingReview = prepareCloseoutCase(base, 'missing-review');
+    writeCloseoutFixtures(missingReview, { ledger: { completed_task_ids: ['task-01'], active_task_id: null, task_records: [] } });
+    const missingReviewEnvelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'release', '--closeout-readiness', '--from-file', `${missingReview.root}/ledger.json`, '--from-evidence', `${missingReview.root}/tests.json`, '--from-diff-coverage', `${missingReview.root}/diff.json`, '--from-readiness', `${missingReview.root}/readiness.json`, '--profile', 'superpowers-parity', '--json', '--root', missingReview.root], {}, options), 'release --closeout-readiness missing review');
+    assertJsonMarkers([
+      ['ok', missingReviewEnvelope.ok, false],
+      ['closeout_readiness.gates.1.status', missingReviewEnvelope.closeout_readiness?.gates?.[1]?.status, 'blocked'],
+      ['closeout_readiness.manual_next_action', missingReviewEnvelope.closeout_readiness?.manual_next_action, 'stop'],
+    ], 'release --closeout-readiness missing review');
+    assertCloseoutStateAbsent(missingReview, 'release --closeout-readiness missing review');
+
+    const blockedReview = prepareCloseoutCase(base, 'blocked-review');
+    writeCloseoutFixtures(blockedReview, { ledger: { completed_task_ids: ['task-01'], active_task_id: 'task-01', task_records: [{ task_id: 'task-01', review_status: 'blocked', blocker_count: 1 }] } });
+    const blockedReviewEnvelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'release', '--closeout-readiness', '--from-file', `${blockedReview.root}/ledger.json`, '--from-evidence', `${blockedReview.root}/tests.json`, '--from-diff-coverage', `${blockedReview.root}/diff.json`, '--from-readiness', `${blockedReview.root}/readiness.json`, '--profile', 'superpowers-parity', '--json', '--root', blockedReview.root], {}, options), 'release --closeout-readiness blocked review');
+    assertJsonMarkers([
+      ['ok', blockedReviewEnvelope.ok, false],
+      ['closeout_readiness.gates.0.status', blockedReviewEnvelope.closeout_readiness?.gates?.[0]?.status, 'blocked'],
+      ['closeout_readiness.gates.1.status', blockedReviewEnvelope.closeout_readiness?.gates?.[1]?.status, 'blocked'],
+    ], 'release --closeout-readiness blocked review');
+    assertCloseoutStateAbsent(blockedReview, 'release --closeout-readiness blocked review');
+
+    const missingEvidence = prepareCloseoutCase(base, 'missing-evidence');
+    writeCloseoutFixtures(missingEvidence, { tests: { status: 'failed' }, diff: { changed_file_count: 0, blocked_reasons: ['missing diff evidence'] } });
+    const missingEvidenceEnvelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'release', '--closeout-readiness', '--from-file', `${missingEvidence.root}/ledger.json`, '--from-evidence', `${missingEvidence.root}/tests.json`, '--from-diff-coverage', `${missingEvidence.root}/diff.json`, '--from-readiness', `${missingEvidence.root}/readiness.json`, '--profile', 'superpowers-parity', '--json', '--root', missingEvidence.root], {}, options), 'release --closeout-readiness missing evidence');
+    assertJsonMarkers([
+      ['ok', missingEvidenceEnvelope.ok, false],
+      ['closeout_readiness.gates.2.status', missingEvidenceEnvelope.closeout_readiness?.gates?.[2]?.status, 'blocked'],
+      ['closeout_readiness.gates.3.status', missingEvidenceEnvelope.closeout_readiness?.gates?.[3]?.status, 'blocked'],
+    ], 'release --closeout-readiness missing evidence');
+    assertCloseoutStateAbsent(missingEvidence, 'release --closeout-readiness missing evidence');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'release', '--diff-read', '--from-plan', `${clean.root}/ledger.json`, '--from-diff-coverage', `${clean.root}/diff.json`, '--root', clean.root], { allowFailure: true, expectOutput: ['--from-diff-coverage is only supported by release --closeout-readiness'] }, options);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteBase, { recursive: true, force: true });
+  }
+}
+
+function preparePlanPreflightCase(base, name, lines) {
+  const root = `${base}/${name}`;
+  const absoluteRoot = path.join(repoRoot, root);
+  fs.rmSync(absoluteRoot, { recursive: true, force: true });
+  fs.mkdirSync(absoluteRoot, { recursive: true });
+  fs.writeFileSync(path.join(absoluteRoot, 'plan.md'), lines.join('\n'), 'utf8');
+  return { root, absoluteRoot };
+}
+
+function prepareTaskBriefCase(base, name) {
+  const root = `${base}/${name}`;
+  const absoluteRoot = path.join(repoRoot, root);
+  fs.rmSync(absoluteRoot, { recursive: true, force: true });
+  fs.mkdirSync(absoluteRoot, { recursive: true });
+  fs.writeFileSync(path.join(absoluteRoot, 'plan.md'), ['# SDD task brief fixture', '', '- First task', '- Second task', ''].join('\n'), 'utf8');
+  return { root, absoluteRoot };
+}
+
+function prepareReviewPackageCase(base, name, options) {
+  const context = prepareTaskBriefCase(base, name);
+  initReviewPackageGitFixture(context, options);
+  const baseSha = gitText(['-C', context.absoluteRoot, 'rev-parse', 'HEAD'], options).trim();
+  fs.writeFileSync(path.join(context.absoluteRoot, 'feature-a.txt'), 'first task change\n', 'utf8');
+  gitText(['-C', context.absoluteRoot, 'add', 'feature-a.txt'], options);
+  gitText(['-C', context.absoluteRoot, '-c', 'user.name=VibeRuntime', '-c', 'user.email=vibe@example.invalid', 'commit', '-m', 'first-task-commit'], options);
+  fs.writeFileSync(path.join(context.absoluteRoot, 'feature-b.txt'), 'second task change\n', 'utf8');
+  gitText(['-C', context.absoluteRoot, 'add', 'feature-b.txt'], options);
+  gitText(['-C', context.absoluteRoot, '-c', 'user.name=VibeRuntime', '-c', 'user.email=vibe@example.invalid', 'commit', '-m', 'second-task-commit'], options);
+  const headSha = gitText(['-C', context.absoluteRoot, 'rev-parse', 'HEAD'], options).trim();
+  run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--run-loop', '--from-plan', 'plan.md', '--profile', 'superpowers-parity', '--confirm', '--json', '--root', context.root], {}, options);
+  const reportFile = bindReviewPackageReport(context);
+  return { ...context, baseSha, headSha, reportFile };
+}
+
+function initReviewPackageGitFixture(context, options) {
+  gitText(['-C', context.absoluteRoot, 'init'], options);
+  fs.writeFileSync(path.join(context.absoluteRoot, 'README.md'), 'review package fixture\n', 'utf8');
+  gitText(['-C', context.absoluteRoot, 'add', 'README.md', 'plan.md'], options);
+  gitText(['-C', context.absoluteRoot, '-c', 'user.name=VibeRuntime', '-c', 'user.email=vibe@example.invalid', 'commit', '-m', 'initial-fixture'], options);
+}
+
+function bindReviewPackageReport(context) {
+  const progressPath = path.join(context.absoluteRoot, '.vibecoding-state', 'sdd', 'progress.json');
+  const progress = JSON.parse(fs.readFileSync(progressPath, 'utf8'));
+  const record = progress.task_records.find((item) => item.task_id === 'task-01');
+  const reportFile = 'sdd/reports/task-01.implementer-report.json';
+  const report = {
+    artifact_kind: 'sdd-implementer-report',
+    task_id: 'task-01',
+    status: 'DONE',
+    commits: [],
+    source_plan_digest: progress.source_plan_digest,
+    brief_digest: record.task_brief_digest,
+    tests: { status: 'passed', summary: 'fixture checks passed' },
+    self_review: { status: 'clean', summary: 'fixture self review passed' },
+    concerns: [],
+    questions: [],
+  };
+  const reportText = `${JSON.stringify(report, null, 2)}\n`;
+  fs.mkdirSync(path.join(context.absoluteRoot, '.vibecoding-state', 'sdd', 'reports'), { recursive: true });
+  fs.writeFileSync(path.join(context.absoluteRoot, '.vibecoding-state', reportFile), reportText, 'utf8');
+  record.report_artifact = reportFile;
+  record.report_digest = digestText(reportText);
+  progress.progress_digest = digestObject(withoutKey(progress, 'progress_digest'));
+  fs.writeFileSync(progressPath, `${JSON.stringify(progress, null, 2)}\n`, 'utf8');
+  return reportFile;
+}
+
+function mutateProgressRecord(context, update) {
+  const progressPath = path.join(context.absoluteRoot, '.vibecoding-state', 'sdd', 'progress.json');
+  const progress = JSON.parse(fs.readFileSync(progressPath, 'utf8'));
+  const record = progress.task_records.find((item) => item.task_id === 'task-01');
+  update(record, progress);
+  progress.progress_digest = digestObject(withoutKey(progress, 'progress_digest'));
+  fs.writeFileSync(progressPath, `${JSON.stringify(progress, null, 2)}\n`, 'utf8');
+}
+
+function gitText(args, options) {
+  return run('git', args, {}, options).stdout || '';
+}
+
+function digestText(text) {
+  return crypto.createHash('sha256').update(String(text || '')).digest('hex');
+}
+
+function prepareCloseoutCase(base, name) {
+  const root = `${base}/${name}`;
+  const absoluteRoot = path.join(repoRoot, root);
+  fs.rmSync(absoluteRoot, { recursive: true, force: true });
+  fs.mkdirSync(absoluteRoot, { recursive: true });
+  return { root, absoluteRoot };
+}
+
+function writeCloseoutFixtures(context, overrides = {}) {
+  const fixtures = closeoutFixtures(overrides);
+  for (const [file, data] of Object.entries(fixtures)) {
+    fs.writeFileSync(path.join(context.absoluteRoot, file), `${JSON.stringify(data, null, 2)}\n`, 'utf8');
+  }
+}
+
+function closeoutFixtures(overrides = {}) {
+  return {
+    'ledger.json': overrides.ledger || { completed_task_ids: ['task-01'], active_task_id: null, task_records: [{ task_id: 'task-01', review_status: 'clean', blocker_count: 0 }] },
+    'tests.json': overrides.tests || { ok: true, status: 'passed' },
+    'diff.json': overrides.diff || { diff_coverage: { coverage_complete: true, changed_file_count: 2 }, blocked_reasons: [] },
+    'readiness.json': overrides.readiness || { task_commit_readiness: { gate_pass: true, gates: [{ id: 'task-commit-readiness-pass', status: 'ready' }], commit_policy: { runtime_git_execution_authorized: false } } },
+  };
+}
+
+function assertCloseoutStateAbsent(context, label) {
+  if (fs.existsSync(path.join(context.absoluteRoot, '.vibecoding-state'))) throw new Error(`${label} created unexpected state directory`);
+}
+
+function prepareCase(base, name, options) {
+  const root = `${base}/${name}`;
+  const absoluteRoot = path.join(repoRoot, root);
+  fs.rmSync(absoluteRoot, { recursive: true, force: true });
+  fs.mkdirSync(absoluteRoot, { recursive: true });
+  fs.writeFileSync(path.join(absoluteRoot, 'plan.md'), ['# SDD consumption fixture', '', '- First task', '- Second task', ''].join('\n'), 'utf8');
+  const runLoop = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'sdd', '--run-loop', '--from-plan', 'plan.md', '--profile', 'superpowers-parity', '--confirm', '--json', '--root', root], {}, options), `sdd --run-loop ${name}`);
+  const dispatchFile = runLoop.files.dispatch_artifacts.find((file) => file.includes('.task-01.reviewer.')) || runLoop.files.dispatch_artifacts[0];
+  const dispatchPath = path.join(absoluteRoot, '.vibecoding-state', 'subagent-adapter-dispatches', dispatchFile);
+  const dispatch = JSON.parse(fs.readFileSync(dispatchPath, 'utf8'));
+  const reportFile = bindReviewPackageReport({ root, absoluteRoot });
+  const reportText = fs.readFileSync(path.join(absoluteRoot, '.vibecoding-state', reportFile), 'utf8');
+  return { root, absoluteRoot, dispatchFile, dispatch, dispatchDigest: digestObject(withoutKey(dispatch, 'dispatch_digest')), reportFile, reportDigest: digestText(reportText) };
+}
+
+function mutateReportFile(context, update) {
+  const reportPath = path.join(context.absoluteRoot, '.vibecoding-state', context.reportFile);
+  const report = JSON.parse(fs.readFileSync(reportPath, 'utf8'));
+  update(report);
+  const reportText = `${JSON.stringify(report, null, 2)}\n`;
+  fs.writeFileSync(reportPath, reportText, 'utf8');
+  context.reportDigest = digestText(reportText);
+  mutateProgressRecord(context, (record) => { record.report_digest = context.reportDigest; });
+}
+
+function adapterResultFixture(context, overrides = {}) {
+  const taskId = overrides.taskId || 'task-01';
+  const resultTaskId = overrides.resultTaskId || taskId;
+  const reviewTaskId = overrides.reviewTaskId || taskId;
+  return {
+    schema_version: 1,
+    artifact_kind: 'sdd-adapter-result-envelope',
+    dispatch_artifact: {
+      file: context.dispatchFile,
+      task_id: taskId,
+      role: context.dispatch.role,
+      source_plan_digest: context.dispatch.source_plan_digest,
+      dispatch_digest: overrides.dispatchDigest || context.dispatchDigest,
+    },
+    result_artifact: { artifact_kind: 'sdd-adapter-result', task_id: resultTaskId, status: 'completed', digest: 'fixture-result-digest' },
+    report_artifact: { artifact_kind: 'sdd-implementer-report', file: context.reportFile, task_id: taskId, status: overrides.reportStatus || 'DONE', digest: overrides.reportDigest || context.reportDigest },
+    review_artifact: { artifact_kind: 'sdd-adapter-review', task_id: reviewTaskId, status: 'completed', verdict: overrides.verdict || 'clean', findings: overrides.findings || [], digest: 'fixture-review-digest' },
+    fix_artifact: overrides.fixArtifact || null,
+    boundary_assertions: {
+      runtime_subagent: false,
+      runtime_platform_api: false,
+      runtime_model_invocation: false,
+      runtime_source_write: false,
+      runtime_git_write: false,
+      runtime_worktree_write: false,
+    },
+  };
+}
+
+function withoutKey(object, key) {
+  const copy = { ...object };
+  delete copy[key];
+  return copy;
+}