@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-release-check/release-check-stage11-smoke.mjs

@@ -0,0 +1,66 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+function writeJson(file, payload) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+}
+
+function taskFile(root, name) {
+  return path.join(root, `${name}.task.json`);
+}
+
+function assertBlocked(json, expectedMarker, label) {
+  const reasons = json.patch_queue_preview?.items?.[0]?.blocked_reasons || [];
+  if (!reasons.some((reason) => reason.includes(expectedMarker))) {
+    throw new Error(`${label} did not block with ${expectedMarker}; got ${reasons.join('; ')}`);
+  }
+}
+
+export function runPatchQueueSourceApplyGateSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const root = path.join(repoRoot, '.tmp', 'vibe-stage11-patch-queue');
+  fs.rmSync(root, { recursive: true, force: true });
+  fs.mkdirSync(root, { recursive: true });
+  try {
+    const validTask = {
+      id: 'stage11-valid',
+      allowed_paths: ['tools/vibe-runtime/runtime-source-patch-plan-model.mjs'],
+      estimated_changed_files: ['tools/vibe-runtime/runtime-source-patch-plan-model.mjs'],
+      diff_digest: 'valid-diff-digest',
+      risk_classification: 'standard',
+      rollback_patch: 'diff --git a/tools/vibe-runtime/runtime-source-patch-plan-model.mjs b/tools/vibe-runtime/runtime-source-patch-plan-model.mjs\n',
+      verification_commands: ['node --check tools/vibe-runtime/runtime-source-patch-plan-model.mjs'],
+      budget: { max_files: 1, max_patch_bytes: 1000 },
+      patch_bytes: 80,
+    };
+    writeJson(taskFile(root, 'valid'), validTask);
+    const validJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'source', '--patch-plan', '--from-task', '.tmp/vibe-stage11-patch-queue/valid.task.json', '--json'], {}, options), 'source --patch-plan valid');
+    assertJsonMarkers([
+      ['stage11.command', validJson.command, 'source'],
+      ['stage11.mode', validJson.mode, 'source-patch-plan'],
+      ['stage11.queue.preview_only', validJson.patch_queue_preview?.preview_only, true],
+      ['stage11.queue.item.status', validJson.patch_queue_preview?.items?.[0]?.status, 'ready-for-approval'],
+      ['stage11.applyGate.approval_required', validJson.source_apply_gate?.approval_required, true],
+      ['stage11.safety.source_apply', validJson.safety?.source_apply, false],
+    ], 'source --patch-plan valid');
+
+    const fixtures = [
+      ['out-of-scope', { ...validTask, id: 'out-of-scope', estimated_changed_files: ['templates/AGENTS.md'] }, 'outside allowlist'],
+      ['over-budget', { ...validTask, id: 'over-budget', estimated_changed_files: ['a.mjs', 'b.mjs'], allowed_paths: ['a.mjs', 'b.mjs'], budget: { max_files: 1, max_patch_bytes: 1000 } }, 'budget exceeded'],
+      ['no-rollback', { ...validTask, id: 'no-rollback', rollback_patch: '' }, 'rollback patch is required'],
+      ['high-risk', { ...validTask, id: 'high-risk', estimated_changed_files: ['tools/vibe-runtime/index.mjs'], allowed_paths: ['tools/vibe-runtime/index.mjs'] }, 'high-risk runtime path'],
+    ];
+    for (const [name, payload, marker] of fixtures) {
+      writeJson(taskFile(root, name), payload);
+      const json = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'source', '--patch-plan', '--from-task', `.tmp/vibe-stage11-patch-queue/${name}.task.json`, '--json'], {}, options), `source --patch-plan ${name}`);
+      assertJsonMarkers([
+        [`stage11.${name}.status`, json.patch_queue_preview?.items?.[0]?.status, 'blocked'],
+        [`stage11.${name}.real_apply_allowed`, json.patch_queue_preview?.real_apply_allowed, false],
+        [`stage11.${name}.gate.status`, json.source_apply_gate?.status, 'blocked'],
+      ], `source --patch-plan ${name}`);
+      assertBlocked(json, marker, `source --patch-plan ${name}`);
+    }
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}

package/tools/vibe-release-check/release-check-stage119-120-fixture-specs.mjs

@@ -0,0 +1,119 @@
+export const executionEvidenceForbiddenFlags = Object.freeze(['--confirm', '--dry-run', '--write', '--preflight', '--dispatch', '--dispatch-intent', '--run', '--once', '--scan', '--auto-run']);
+export const stagedCommitReadinessForbiddenFlags = Object.freeze(['--confirm', '--preview', '--dry-run', '--write', '--preflight', '--dispatch', '--dispatch-intent', '--run', '--once', '--scan', '--auto-run']);
+
+export function stage119EvidenceFixture(stage) {
+  return {
+    created_at: '2026-03-14T00:00:00.000Z',
+    stage_evidence: [
+      {
+        id: 'stage119-valid-static-check-01',
+        stage_id: stage.stage_id,
+        category: 'static_check',
+        command: stage.validation_commands[0],
+        exit_status: 0,
+        key_output: 'execution_evidence_binding ready_for_next_stage Result: PASS',
+        artifact: '.tmp/vibe-execution-evidence/stage119-static-check.log',
+        source_digest: 'fixture-stage119-static-check-digest',
+        freshness: 'fresh',
+        covers: stage.evidence_required,
+      },
+      {
+        id: 'stage119-valid-test-01',
+        stage_id: stage.stage_id,
+        category: 'test',
+        command: 'npm test -- --runInBand',
+        exit_status: 0,
+        key_output: 'test evidence Result: PASS',
+        artifact: '.tmp/vibe-execution-evidence/stage119-test.log',
+        source_digest: 'fixture-stage119-test-digest',
+        freshness: 'fresh',
+        covers: ['test evidence'],
+      },
+      {
+        id: 'stage119-valid-manual-01',
+        stage_id: stage.stage_id,
+        category: 'manual_verification',
+        command: 'manual verification record',
+        exit_status: 'manual',
+        key_output: 'manual verification confirms Stage 119 evidence binder category gate output',
+        artifact: '.tmp/vibe-execution-evidence/stage119-manual.md',
+        source_digest: 'fixture-stage119-manual-digest',
+        freshness: 'fresh',
+        covers: ['manual verification evidence'],
+      },
+    ],
+  };
+}
+
+export function weakStageEvidenceFixture(stage, id) {
+  return {
+    created_at: '2026-03-14T00:00:00.000Z',
+    stage_evidence: [
+      {
+        id,
+        stage_id: stage.stage_id,
+        command: stage.validation_commands[0],
+        exit_status: 1,
+        key_output: 'failure marker',
+        freshness: 'stale',
+        covers: [],
+      },
+    ],
+  };
+}
+
+export function stage120EvidenceFixture(stage) {
+  return {
+    created_at: '2026-03-14T00:00:00.000Z',
+    stage_evidence: [
+      {
+        id: 'stage120-valid-static-check-01',
+        stage_id: stage.stage_id,
+        category: 'static_check',
+        command: stage.validation_commands[0],
+        exit_status: 0,
+        key_output: 'staged_commit_readiness commit_allowed_by_contract=false contract_ready=true Result: PASS',
+        artifact: '.tmp/vibe-staged-commit-readiness/stage120-static-check.log',
+        source_digest: 'fixture-stage120-static-check-digest',
+        freshness: 'fresh',
+        covers: stage.evidence_required,
+      },
+      {
+        id: 'stage120-valid-test-01',
+        stage_id: stage.stage_id,
+        category: 'test',
+        command: 'npm test -- --runInBand',
+        exit_status: 0,
+        key_output: 'test evidence Result: PASS',
+        artifact: '.tmp/vibe-staged-commit-readiness/stage120-test.log',
+        source_digest: 'fixture-stage120-test-digest',
+        freshness: 'fresh',
+        covers: ['test evidence'],
+      },
+      {
+        id: 'stage120-valid-manual-01',
+        stage_id: stage.stage_id,
+        category: 'manual_verification',
+        command: 'manual verification record',
+        exit_status: 'manual',
+        key_output: 'manual verification confirms Stage 120 staged commit readiness output',
+        artifact: '.tmp/vibe-staged-commit-readiness/stage120-manual.md',
+        source_digest: 'fixture-stage120-manual-digest',
+        freshness: 'fresh',
+        covers: ['manual verification evidence'],
+      },
+      {
+        id: 'stage120-valid-diff-coverage-01',
+        stage_id: stage.stage_id,
+        category: 'diff_coverage',
+        command: 'git diff --check evidence captured outside Stage 120',
+        exit_status: 0,
+        key_output: 'diff coverage evidence binds required Stage 120 files to the staged commit readiness validation',
+        artifact: '.tmp/vibe-staged-commit-readiness/stage120-diff-coverage.json',
+        source_digest: 'fixture-stage120-diff-coverage-digest',
+        freshness: 'fresh',
+        covers: ['diff coverage evidence', ...stage.files_to_change],
+      },
+    ],
+  };
+}

package/tools/vibe-release-check/release-check-stage119-120-smoke.mjs

@@ -0,0 +1,325 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  assertJsonMarkers,
+  digestObject,
+  parseJsonOutput,
+  repoRoot,
+  run,
+  tmpRoot,
+} from './release-check-runtime.mjs';
+import {
+  executionEvidenceForbiddenFlags,
+  stagedCommitReadinessForbiddenFlags,
+  stage119EvidenceFixture,
+  stage120EvidenceFixture,
+  weakStageEvidenceFixture,
+} from './release-check-stage119-120-fixture-specs.mjs';
+
+function writeJsonFixture(absoluteFile, fixture) {
+  fs.writeFileSync(absoluteFile, `${JSON.stringify(fixture, null, 2)}\n`, 'utf8');
+}
+
+function assertExecutionEvidenceBinding(binding, stage) {
+  assertJsonMarkers([
+    ['command', binding.command, 'verification'],
+    ['mode', binding.mode, 'execution-evidence-binding'],
+    ['ok', binding.ok, true],
+    ['execution_evidence_binding.stage', binding.execution_evidence_binding?.stage, 'Stage 119'],
+    ['execution_evidence_binding.binding_kind', binding.execution_evidence_binding?.binding_kind, 'execution-evidence-binding'],
+    ['execution_evidence_binding.source_bindings.runbook_stage', binding.execution_evidence_binding?.source_bindings?.runbook_stage, 'Stage 118'],
+    ['execution_evidence_binding.source_bindings.runbook_kind', binding.execution_evidence_binding?.source_bindings?.runbook_kind, 'sequential-stage-runbook'],
+    ['execution_evidence_binding.source_bindings.registry_version', binding.execution_evidence_binding?.source_bindings?.registry_version, 47],
+    ['execution_evidence_binding.execution_evidence_binding.ready_for_next_stage', binding.execution_evidence_binding?.execution_evidence_binding?.ready_for_next_stage, true],
+    ['execution_evidence_binding.execution_evidence_binding.category_gate_pass', binding.execution_evidence_binding?.execution_evidence_binding?.category_gate_pass, true],
+    ['execution_evidence_binding.execution_evidence_binding.required_evidence_category_count', binding.execution_evidence_binding?.execution_evidence_binding?.required_evidence_category_count, 3],
+    ['execution_evidence_binding.execution_evidence_binding.missing_evidence_category_count', binding.execution_evidence_binding?.execution_evidence_binding?.missing_evidence_category_count, 0],
+    ['execution_evidence_binding.evidence_category_contract.contract_kind', binding.execution_evidence_binding?.evidence_category_contract?.contract_kind, 'stage-required-evidence-categories'],
+    ['execution_evidence_binding.evidence_category_contract.tdd_review_diff_coverage_are_first_class', binding.execution_evidence_binding?.evidence_category_contract?.tdd_review_diff_coverage_are_first_class, true],
+    ['execution_evidence_binding.ready_for_next_stage', binding.execution_evidence_binding?.ready_for_next_stage, true],
+    ['execution_evidence_binding.execution_evidence_invariants.pass', binding.execution_evidence_binding?.execution_evidence_invariants?.pass, true],
+    ['execution_evidence_binding.writes', binding.execution_evidence_binding?.writes, false],
+    ['execution_evidence_binding.state_directory_created', binding.execution_evidence_binding?.state_directory_created, false],
+    ['execution_evidence_binding.boundary_assertions.execution_evidence_artifact', binding.execution_evidence_binding?.boundary_assertions?.execution_evidence_artifact, false],
+    ['execution_evidence_binding.boundary_assertions.evidence_artifact_write', binding.execution_evidence_binding?.boundary_assertions?.evidence_artifact_write, false],
+    ['execution_evidence_binding.boundary_assertions.source_write', binding.execution_evidence_binding?.boundary_assertions?.source_write, false],
+    ['execution_evidence_binding.boundary_assertions.runbook_mutation', binding.execution_evidence_binding?.boundary_assertions?.runbook_mutation, false],
+    ['execution_evidence_binding.boundary_assertions.command_execution', binding.execution_evidence_binding?.boundary_assertions?.command_execution, false],
+    ['execution_evidence_binding.boundary_assertions.check_execution', binding.execution_evidence_binding?.boundary_assertions?.check_execution, false],
+    ['execution_evidence_binding.boundary_assertions.test_execution', binding.execution_evidence_binding?.boundary_assertions?.test_execution, false],
+    ['execution_evidence_binding.boundary_assertions.runtime_action', binding.execution_evidence_binding?.boundary_assertions?.runtime_action, false],
+    ['execution_evidence_binding.boundary_assertions.git_write', binding.execution_evidence_binding?.boundary_assertions?.git_write, false],
+    ['execution_evidence_binding.boundary_assertions.commit', binding.execution_evidence_binding?.boundary_assertions?.commit, false],
+    ['execution_evidence_binding.boundary_assertions.subagent', binding.execution_evidence_binding?.boundary_assertions?.subagent, false],
+    ['execution_evidence_binding.boundary_assertions.mcp', binding.execution_evidence_binding?.boundary_assertions?.mcp, false],
+    ['safety.stage', binding.safety?.stage, 'Stage 119'],
+    ['safety.command_execution', binding.safety?.command_execution, false],
+    ['safety.subagent', binding.safety?.subagent, false],
+  ], 'verification --execution-evidence --json');
+  if (!binding.execution_evidence_binding?.execution_evidence_digest) throw new Error('execution evidence binding missing execution_evidence_digest');
+  if (!binding.execution_evidence_binding?.source_bindings?.stage_runbook_digest) throw new Error('execution evidence binding missing Stage 118 runbook digest binding');
+  if (!binding.execution_evidence_binding?.stage_evidence_category_gate?.some((item) => item.stage_id === stage.stage_id && item.pass === true && item.required_categories?.includes('static_check') && item.required_categories?.includes('test') && item.required_categories?.includes('manual_verification') && item.covered_categories?.includes('static_check') && item.covered_categories?.includes('test') && item.covered_categories?.includes('manual_verification') && item.execution_authorized === false)) throw new Error('execution evidence binding missing stage evidence category gate coverage');
+  if (!binding.execution_evidence_binding?.stage_evidence_status?.some((item) => item.stage_id === stage.stage_id && item.ready_for_next_stage === true && item.execution_authorized === false)) throw new Error('execution evidence binding stage status missing ready false-execution boundary');
+}
+
+export function runExecutionEvidenceSmoke(options) {
+  const target = '.tmp/vibe-execution-evidence';
+  const absoluteTarget = path.join(repoRoot, target);
+  const planFile = path.join(target, 'stage119-plan.md');
+  const runbookFile = path.join(target, 'stage118-runbook.json');
+  const evidenceFile = path.join(target, 'stage119-evidence.json');
+  const weakEvidenceFile = path.join(target, 'stage119-weak-evidence.json');
+  const absolutePlanFile = path.join(repoRoot, planFile);
+  const absoluteRunbookFile = path.join(repoRoot, runbookFile);
+  const absoluteEvidenceFile = path.join(repoRoot, evidenceFile);
+  const absoluteWeakEvidenceFile = path.join(repoRoot, weakEvidenceFile);
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(absoluteTarget, { recursive: true });
+    fs.writeFileSync(absolutePlanFile, `# Stage 119 execution evidence fixture
+
+- Stage 119: Bind local execution evidence in tools/vibe-runtime/runtime-execution-evidence-binder.mjs and tools/vibe-runtime/index.mjs.
+- Update docs/runtime-roadmap.md and tools/vibe-runtime/README.md with Stage 119 docs expectations.
+- Validate tools/vibe-runtime-check/index.mjs and tools/vibe-release-check/index.mjs marker expectations.
+- Stop if verification --execution-evidence would run commands or write evidence.
+
+Expected output marker: execution_evidence_binding
+Expected output marker: ready_for_next_stage
+
+Verification commands:
+- node --check tools/vibe-runtime/runtime-execution-evidence-binder.mjs
+- node --check tools/vibe-runtime/index.mjs
+- node tools/vibe-runtime-check/index.mjs --root D:/workspace_mine/vibe-coading
+
+Commit subject: feat(runtime): 添加 Stage 119 执行证据绑定合同
+`, 'utf8');
+
+    const generatedRunbook = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'automation', '--stage-runbook', '--from-plan', planFile, '--json', '--root', repoRoot], {}, options), 'automation --stage-runbook for execution evidence --json');
+    fs.writeFileSync(absoluteRunbookFile, `${JSON.stringify(generatedRunbook, null, 2)}\n`, 'utf8');
+    const stage = generatedRunbook.sequential_stage_runbook?.stage_sequence?.[0];
+    if (!stage?.stage_id) throw new Error('execution evidence smoke missing generated runbook stage');
+    writeJsonFixture(absoluteEvidenceFile, stage119EvidenceFixture(stage));
+    writeJsonFixture(absoluteWeakEvidenceFile, weakStageEvidenceFixture(stage, 'stage119-weak-evidence-01'));
+
+    const binding = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'verification', '--execution-evidence', '--from-runbook', runbookFile, '--from-file', evidenceFile, '--stage', stage.stage_id, '--json', '--root', repoRoot], {}, options), 'verification --execution-evidence --json');
+    assertExecutionEvidenceBinding(binding, stage);
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('verification --execution-evidence JSON output created unexpected state directory');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'verification', '--execution-evidence', '--from-runbook', runbookFile, '--from-file', evidenceFile, '--stage', stage.stage_id, '--root', repoRoot], {
+      expectOutput: ['Vibecoding Runtime Execution Evidence Binding', 'Stage: Stage 119; Kind: execution-evidence-binding; pass=true', 'Binding: stages=1; evidence=3', 'ready_for_next_stage=true', 'Evidence category gate: pass=true; required_categories=3; missing_categories=0; first_class=tdd_trace,review,diff_coverage', 'Boundary: writes=false; execution_evidence_artifact=false; evidence_artifact_write=false; source_write=false; runbook_mutation=false; sidecar_write=false; state_directory_created=false; command_execution=false; check_execution=false; test_execution=false; repair_execution=false; runtime_action=false; git=false; git_write=false; commit=false; pr=false; push=false; merge=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; business_source_write=false', 'Execution evidence digest:'],
+    }, options);
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('verification --execution-evidence text output created unexpected state directory');
+
+    const weak = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'verification', '--execution-evidence', '--from-runbook', runbookFile, '--from-file', weakEvidenceFile, '--stage', stage.stage_id, '--json', '--root', repoRoot], {}, options), 'verification --execution-evidence weak --json');
+    if (weak.execution_evidence_binding?.ready_for_next_stage !== false) throw new Error('weak execution evidence should not be ready for next stage');
+    if (!weak.execution_evidence_binding?.missing_evidence?.length) throw new Error('weak execution evidence should report missing evidence');
+    if (!weak.execution_evidence_binding?.missing_evidence_categories?.some((item) => item.category === 'test' || item.category === 'manual_verification')) throw new Error('weak execution evidence should report missing required evidence categories');
+    if (weak.execution_evidence_binding?.execution_evidence_binding?.category_gate_pass !== false) throw new Error('weak execution evidence should fail category gate');
+    if (!weak.execution_evidence_binding?.failed_commands?.length) throw new Error('weak execution evidence should report failed command evidence');
+
+    for (const forbidden of executionEvidenceForbiddenFlags) {
+      run('node', ['tools/vibe-runtime/index.mjs', 'verification', '--execution-evidence', '--from-runbook', runbookFile, '--from-file', evidenceFile, forbidden, '--root', repoRoot], {
+        allowFailure: true,
+        expectOutput: ['verification --execution-evidence is read-only'],
+      }, options);
+    }
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'verification', '--execution-evidence', '--from-file', evidenceFile, '--root', repoRoot], {
+      allowFailure: true,
+      expectOutput: ['verification --execution-evidence requires --from-runbook <local-runbook-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'verification', '--evidence-intake', '--from-file', evidenceFile, '--from-runbook', runbookFile, '--root', repoRoot], {
+      allowFailure: true,
+      expectOutput: ['--from-runbook and --stage are only supported by verification --execution-evidence'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'automation', '--stage-runbook', '--from-plan', planFile, '--from-runbook', runbookFile, '--root', repoRoot], {
+      allowFailure: true,
+      expectOutput: ['automation --stage-runbook only accepts one local plan file, optional --from-executable-plan, and read-only output flags'],
+    }, options);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+
+
+export function runStagedCommitReadinessSmoke(options) {
+  const target = '.tmp/vibe-staged-commit-readiness';
+  const absoluteTarget = path.join(repoRoot, target);
+  const planFile = path.join(target, 'stage120-plan.md');
+  const runbookFile = path.join(target, 'stage118-runbook.json');
+  const evidenceFile = path.join(target, 'stage119-evidence.json');
+  const weakEvidenceFile = path.join(target, 'stage119-weak-evidence.json');
+  const bindingFile = path.join(target, 'stage119-binding.json');
+  const weakBindingFile = path.join(target, 'stage119-weak-binding.json');
+  const absolutePlanFile = path.join(repoRoot, planFile);
+  const absoluteRunbookFile = path.join(repoRoot, runbookFile);
+  const absoluteEvidenceFile = path.join(repoRoot, evidenceFile);
+  const absoluteWeakEvidenceFile = path.join(repoRoot, weakEvidenceFile);
+  const absoluteBindingFile = path.join(repoRoot, bindingFile);
+  const absoluteWeakBindingFile = path.join(repoRoot, weakBindingFile);
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(absoluteTarget, { recursive: true });
+    fs.writeFileSync(absolutePlanFile, `# Stage 120 staged commit readiness fixture
+
+- Stage 120: Add staged commit readiness contract in tools/vibe-runtime/runtime-staged-commit-readiness.mjs and tools/vibe-runtime/index.mjs.
+- Update docs/runtime-roadmap.md and tools/vibe-runtime/README.md with Stage 120 docs expectations.
+- Validate tools/vibe-runtime-check/index.mjs and tools/vibe-release-check/index.mjs marker expectations.
+- Stop if release --staged-commit-readiness would call git, stage files, commit, push, PR, merge, run commands, or write state.
+- Rollback / stop conditions: stop if Stage 119 execution evidence is not pass-ready or if the commit subject differs from this runbook.
+
+Expected output marker: staged_commit_readiness
+Expected output marker: commit_allowed_by_contract=false
+Expected output marker: contract_ready=true
+
+Verification commands:
+- node --check tools/vibe-runtime/runtime-staged-commit-readiness.mjs
+- node --check tools/vibe-runtime/index.mjs
+- node tools/vibe-runtime-check/index.mjs --root D:/workspace_mine/vibe-coading
+- node tools/vibe-release-check/index.mjs --quiet
+- git diff --check
+
+Commit subject: feat(runtime): 添加 Stage 120 分阶段提交就绪合同
+`, 'utf8');
+
+    const generatedRunbook = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'automation', '--stage-runbook', '--from-plan', planFile, '--json', '--root', repoRoot], {}, options), 'automation --stage-runbook for staged commit readiness --json');
+    fs.writeFileSync(absoluteRunbookFile, `${JSON.stringify(generatedRunbook, null, 2)}\n`, 'utf8');
+    const stage = generatedRunbook.sequential_stage_runbook?.stage_sequence?.[0];
+    if (!stage?.stage_id) throw new Error('staged commit readiness smoke missing generated runbook stage');
+    if (!stage.commit_subject) throw new Error('staged commit readiness smoke missing generated runbook commit subject');
+
+    writeJsonFixture(absoluteEvidenceFile, stage120EvidenceFixture(stage));
+    writeJsonFixture(absoluteWeakEvidenceFile, weakStageEvidenceFixture(stage, 'stage120-weak-evidence-01'));
+
+    const binding = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'verification', '--execution-evidence', '--from-runbook', runbookFile, '--from-file', evidenceFile, '--stage', stage.stage_id, '--json', '--root', repoRoot], {}, options), 'verification --execution-evidence for staged commit readiness --json');
+    fs.writeFileSync(absoluteBindingFile, `${JSON.stringify(binding, null, 2)}\n`, 'utf8');
+    const weakBinding = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'verification', '--execution-evidence', '--from-runbook', runbookFile, '--from-file', weakEvidenceFile, '--stage', stage.stage_id, '--json', '--root', repoRoot], {}, options), 'verification --execution-evidence weak for staged commit readiness --json');
+    fs.writeFileSync(absoluteWeakBindingFile, `${JSON.stringify(weakBinding, null, 2)}\n`, 'utf8');
+
+    const readiness = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'release', '--staged-commit-readiness', '--from-runbook', runbookFile, '--from-evidence', bindingFile, '--stage', stage.stage_id, '--subject', stage.commit_subject, '--json', '--root', repoRoot], {}, options), 'release --staged-commit-readiness --json');
+    assertJsonMarkers([
+      ['command', readiness.command, 'release'],
+      ['mode', readiness.mode, 'staged-commit-readiness-contract'],
+      ['ok', readiness.ok, true],
+      ['staged_commit_readiness.stage', readiness.staged_commit_readiness?.stage, 'Stage 120'],
+      ['staged_commit_readiness.readiness_kind', readiness.staged_commit_readiness?.readiness_kind, 'staged-commit-readiness-contract'],
+      ['staged_commit_readiness.source_bindings.runbook_stage', readiness.staged_commit_readiness?.source_bindings?.runbook_stage, 'Stage 118'],
+      ['staged_commit_readiness.source_bindings.runbook_kind', readiness.staged_commit_readiness?.source_bindings?.runbook_kind, 'sequential-stage-runbook'],
+      ['staged_commit_readiness.source_bindings.execution_evidence_stage', readiness.staged_commit_readiness?.source_bindings?.execution_evidence_stage, 'Stage 119'],
+      ['staged_commit_readiness.source_bindings.execution_evidence_kind', readiness.staged_commit_readiness?.source_bindings?.execution_evidence_kind, 'execution-evidence-binding'],
+      ['staged_commit_readiness.source_bindings.registry_version', readiness.staged_commit_readiness?.source_bindings?.registry_version, 47],
+      ['staged_commit_readiness.staged_commit_readiness.stage_id', readiness.staged_commit_readiness?.staged_commit_readiness?.stage_id, stage.stage_id],
+      ['staged_commit_readiness.staged_commit_readiness.subject_guard_pass', readiness.staged_commit_readiness?.staged_commit_readiness?.subject_guard_pass, true],
+      ['staged_commit_readiness.staged_commit_readiness.evidence_pass', readiness.staged_commit_readiness?.staged_commit_readiness?.evidence_pass, true],
+      ['staged_commit_readiness.staged_commit_readiness.diff_coverage_required', readiness.staged_commit_readiness?.staged_commit_readiness?.diff_coverage_required, true],
+      ['staged_commit_readiness.staged_commit_readiness.contract_ready', readiness.staged_commit_readiness?.staged_commit_readiness?.contract_ready, true],
+      ['staged_commit_readiness.staged_commit_readiness.commit_allowed_by_contract', readiness.staged_commit_readiness?.staged_commit_readiness?.commit_allowed_by_contract, false],
+      ['staged_commit_readiness.staged_commit_readiness.runtime_git_execution_authorized', readiness.staged_commit_readiness?.staged_commit_readiness?.runtime_git_execution_authorized, false],
+      ['staged_commit_readiness.staged_commit_readiness.agent_commit_next_action_allowed', readiness.staged_commit_readiness?.staged_commit_readiness?.agent_commit_next_action_allowed, true],
+      ['staged_commit_readiness.staged_commit_readiness.suggested_commit_subject', readiness.staged_commit_readiness?.staged_commit_readiness?.suggested_commit_subject, stage.commit_subject],
+      ['staged_commit_readiness.staged_commit_readiness.subject_matches_runbook', readiness.staged_commit_readiness?.staged_commit_readiness?.subject_matches_runbook, true],
+      ['staged_commit_readiness.staged_commit_readiness.stage_119_category_gate_pass', readiness.staged_commit_readiness?.staged_commit_readiness?.stage_119_category_gate_pass, true],
+      ['staged_commit_readiness.staged_commit_readiness.commit_readiness_gate_pass', readiness.staged_commit_readiness?.staged_commit_readiness?.commit_readiness_gate_pass, true],
+      ['staged_commit_readiness.staged_commit_readiness.diff_coverage_evidence_bound', readiness.staged_commit_readiness?.staged_commit_readiness?.diff_coverage_evidence_bound, true],
+      ['staged_commit_readiness.staged_commit_readiness.missing_evidence_category_count', readiness.staged_commit_readiness?.staged_commit_readiness?.missing_evidence_category_count, 0],
+      ['staged_commit_readiness.suggested_commit_subject', readiness.staged_commit_readiness?.suggested_commit_subject, stage.commit_subject],
+      ['staged_commit_readiness.commit_readiness_gate.pass', readiness.staged_commit_readiness?.commit_readiness_gate?.pass, true],
+      ['staged_commit_readiness.commit_readiness_gate.stage_119_category_gate_pass', readiness.staged_commit_readiness?.commit_readiness_gate?.stage_119_category_gate_pass, true],
+      ['staged_commit_readiness.commit_readiness_gate.diff_coverage_required', readiness.staged_commit_readiness?.commit_readiness_gate?.diff_coverage_required, true],
+      ['staged_commit_readiness.commit_readiness_gate.diff_coverage_evidence_bound', readiness.staged_commit_readiness?.commit_readiness_gate?.diff_coverage_evidence_bound, true],
+      ['staged_commit_readiness.commit_readiness_gate.runtime_git_execution_authorized', readiness.staged_commit_readiness?.commit_readiness_gate?.runtime_git_execution_authorized, false],
+      ['staged_commit_readiness.commit_readiness_gate.commit_execution_authorized', readiness.staged_commit_readiness?.commit_readiness_gate?.commit_execution_authorized, false],
+      ['staged_commit_readiness.commit_readiness_gate.command_execution_authorized', readiness.staged_commit_readiness?.commit_readiness_gate?.command_execution_authorized, false],
+      ['staged_commit_readiness.subject_guard.pass', readiness.staged_commit_readiness?.subject_guard?.pass, true],
+      ['staged_commit_readiness.subject_guard.subject_matches_runbook', readiness.staged_commit_readiness?.subject_guard?.subject_matches_runbook, true],
+      ['staged_commit_readiness.evidence_pass', readiness.staged_commit_readiness?.evidence_pass, true],
+      ['staged_commit_readiness.diff_coverage_required', readiness.staged_commit_readiness?.diff_coverage_required, true],
+      ['staged_commit_readiness.commit_allowed_by_contract', readiness.staged_commit_readiness?.commit_allowed_by_contract, false],
+      ['staged_commit_readiness.staged_commit_readiness_invariants.pass', readiness.staged_commit_readiness?.staged_commit_readiness_invariants?.pass, true],
+      ['staged_commit_readiness.writes', readiness.staged_commit_readiness?.writes, false],
+      ['staged_commit_readiness.state_directory_created', readiness.staged_commit_readiness?.state_directory_created, false],
+      ['staged_commit_readiness.boundary_assertions.staged_commit_readiness_artifact', readiness.staged_commit_readiness?.boundary_assertions?.staged_commit_readiness_artifact, false],
+      ['staged_commit_readiness.boundary_assertions.commit_artifact', readiness.staged_commit_readiness?.boundary_assertions?.commit_artifact, false],
+      ['staged_commit_readiness.boundary_assertions.evidence_artifact_write', readiness.staged_commit_readiness?.boundary_assertions?.evidence_artifact_write, false],
+      ['staged_commit_readiness.boundary_assertions.source_write', readiness.staged_commit_readiness?.boundary_assertions?.source_write, false],
+      ['staged_commit_readiness.boundary_assertions.runbook_mutation', readiness.staged_commit_readiness?.boundary_assertions?.runbook_mutation, false],
+      ['staged_commit_readiness.boundary_assertions.evidence_mutation', readiness.staged_commit_readiness?.boundary_assertions?.evidence_mutation, false],
+      ['staged_commit_readiness.boundary_assertions.worktree_mutation', readiness.staged_commit_readiness?.boundary_assertions?.worktree_mutation, false],
+      ['staged_commit_readiness.boundary_assertions.command_execution', readiness.staged_commit_readiness?.boundary_assertions?.command_execution, false],
+      ['staged_commit_readiness.boundary_assertions.check_execution', readiness.staged_commit_readiness?.boundary_assertions?.check_execution, false],
+      ['staged_commit_readiness.boundary_assertions.test_execution', readiness.staged_commit_readiness?.boundary_assertions?.test_execution, false],
+      ['staged_commit_readiness.boundary_assertions.runtime_action', readiness.staged_commit_readiness?.boundary_assertions?.runtime_action, false],
+      ['staged_commit_readiness.boundary_assertions.git', readiness.staged_commit_readiness?.boundary_assertions?.git, false],
+      ['staged_commit_readiness.boundary_assertions.git_write', readiness.staged_commit_readiness?.boundary_assertions?.git_write, false],
+      ['staged_commit_readiness.boundary_assertions.commit', readiness.staged_commit_readiness?.boundary_assertions?.commit, false],
+      ['staged_commit_readiness.boundary_assertions.push', readiness.staged_commit_readiness?.boundary_assertions?.push, false],
+      ['staged_commit_readiness.boundary_assertions.pr', readiness.staged_commit_readiness?.boundary_assertions?.pr, false],
+      ['staged_commit_readiness.boundary_assertions.merge', readiness.staged_commit_readiness?.boundary_assertions?.merge, false],
+      ['staged_commit_readiness.boundary_assertions.subagent', readiness.staged_commit_readiness?.boundary_assertions?.subagent, false],
+      ['staged_commit_readiness.boundary_assertions.mcp', readiness.staged_commit_readiness?.boundary_assertions?.mcp, false],
+      ['safety.stage', readiness.safety?.stage, 'Stage 120'],
+      ['safety.command_execution', readiness.safety?.command_execution, false],
+      ['safety.git', readiness.safety?.git, false],
+      ['safety.commit', readiness.safety?.commit, false],
+      ['safety.subagent', readiness.safety?.subagent, false],
+    ], 'release --staged-commit-readiness --json');
+    if (!readiness.staged_commit_readiness?.staged_commit_readiness_digest) throw new Error('staged commit readiness missing staged_commit_readiness_digest');
+    if (!readiness.staged_commit_readiness?.source_bindings?.stage_runbook_digest) throw new Error('staged commit readiness missing Stage 118 runbook digest binding');
+    if (!readiness.staged_commit_readiness?.source_bindings?.execution_evidence_digest) throw new Error('staged commit readiness missing Stage 119 evidence digest binding');
+    if (!readiness.staged_commit_readiness?.required_files?.length) throw new Error('staged commit readiness missing required files');
+    if (!readiness.staged_commit_readiness?.commit_readiness_gate?.required_evidence_categories?.includes('diff_coverage')) throw new Error('staged commit readiness missing diff_coverage commit gate requirement');
+    if (readiness.staged_commit_readiness?.commit_readiness_gate?.missing_evidence_categories?.length) throw new Error('staged commit readiness should not report missing evidence categories');
+    if (!readiness.staged_commit_readiness?.stage_evidence_category_gate?.some((item) => item.stage_id === stage.stage_id && item.pass === true && item.diff_coverage_evidence_bound === true && item.source_categories?.includes('diff_coverage') && item.execution_authorized === false)) throw new Error('staged commit readiness missing Stage 119 category gate diff coverage binding');
+    if (!readiness.staged_commit_readiness?.stage_evidence_status?.some((item) => item.stage_id === stage.stage_id && item.ready_for_next_stage === true && item.execution_authorized === false)) throw new Error('staged commit readiness missing selected Stage 119 evidence status binding');
+    if (!readiness.staged_commit_readiness?.manual_or_agent_commit_next_action?.includes('human-approved local commit outside Stage 120')) throw new Error('staged commit readiness missing manual commit next action boundary');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('release --staged-commit-readiness JSON output created unexpected state directory');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'release', '--staged-commit-readiness', '--from-runbook', runbookFile, '--from-evidence', bindingFile, '--stage', stage.stage_id, '--subject', stage.commit_subject, '--root', repoRoot], {
+      expectOutput: ['Vibecoding Runtime Staged Commit Readiness Contract', 'Stage: Stage 120; Kind: staged-commit-readiness-contract; pass=true', 'commit_allowed_by_contract=false', 'contract_ready=true', 'diff_coverage_evidence_bound=true', 'Commit readiness gate: pass=true', 'stage_119_category_gate_pass=true', 'Subject: pass=true', 'suggested=', '- evidence category gate:', 'Boundary: writes=false; staged_commit_readiness_artifact=false; commit_artifact=false; evidence_artifact_write=false; source_write=false; runbook_mutation=false; evidence_mutation=false; worktree_mutation=false; sidecar_write=false; state_directory_created=false; command_execution=false; check_execution=false; test_execution=false; repair_execution=false; runtime_action=false; git=false; git_write=false; commit=false; pr=false; push=false; merge=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; business_source_write=false', 'Staged commit readiness digest:'],
+    }, options);
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('release --staged-commit-readiness text output created unexpected state directory');
+
+    const wrongSubject = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'release', '--staged-commit-readiness', '--from-runbook', runbookFile, '--from-evidence', bindingFile, '--stage', stage.stage_id, '--subject', 'feat(runtime): wrong staged commit subject', '--json', '--root', repoRoot], {}, options), 'release --staged-commit-readiness wrong subject --json');
+    if (wrongSubject.staged_commit_readiness?.staged_commit_readiness?.contract_ready !== false) throw new Error('wrong staged commit subject should not be contract ready');
+    if (wrongSubject.staged_commit_readiness?.subject_guard?.pass !== false) throw new Error('wrong staged commit subject should fail subject guard');
+    if (!wrongSubject.staged_commit_readiness?.blocked_reasons?.some((item) => item.includes('subject must match selected Stage 118 runbook commit_subject'))) throw new Error('wrong staged commit subject should report subject blocker');
+
+    const weak = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'release', '--staged-commit-readiness', '--from-runbook', runbookFile, '--from-evidence', weakBindingFile, '--stage', stage.stage_id, '--subject', stage.commit_subject, '--json', '--root', repoRoot], {}, options), 'release --staged-commit-readiness weak evidence --json');
+    if (weak.staged_commit_readiness?.staged_commit_readiness?.contract_ready !== false) throw new Error('weak staged commit evidence should not be contract ready');
+    if (weak.staged_commit_readiness?.evidence_pass !== false) throw new Error('weak staged commit evidence should fail evidence pass');
+    if (weak.staged_commit_readiness?.commit_readiness_gate?.pass !== false) throw new Error('weak staged commit evidence should fail commit readiness gate');
+    if (!weak.staged_commit_readiness?.commit_readiness_gate?.missing_evidence_categories?.includes('diff_coverage')) throw new Error('weak staged commit evidence should report missing diff_coverage category');
+    if (weak.staged_commit_readiness?.commit_readiness_gate?.diff_coverage_evidence_bound !== false) throw new Error('weak staged commit evidence should not bind diff coverage');
+    if (!weak.staged_commit_readiness?.blocked_reasons?.some((item) => item.includes('Stage 119 execution evidence binding is not pass-ready'))) throw new Error('weak staged commit evidence should report evidence blocker');
+    if (!weak.staged_commit_readiness?.blocked_reasons?.some((item) => item.includes('diff_coverage evidence category must be bound before commit readiness'))) throw new Error('weak staged commit evidence should report diff coverage blocker');
+
+    for (const forbidden of stagedCommitReadinessForbiddenFlags) {
+      run('node', ['tools/vibe-runtime/index.mjs', 'release', '--staged-commit-readiness', '--from-runbook', runbookFile, '--from-evidence', bindingFile, '--stage', stage.stage_id, '--subject', stage.commit_subject, forbidden, '--root', repoRoot], {
+        allowFailure: true,
+        expectOutput: ['release --staged-commit-readiness is read-only'],
+      }, options);
+    }
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'release', '--staged-commit-readiness', '--from-evidence', bindingFile, '--stage', stage.stage_id, '--subject', stage.commit_subject, '--root', repoRoot], {
+      allowFailure: true,
+      expectOutput: ['release --staged-commit-readiness requires --from-runbook <local-runbook-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'release', '--staged-commit-readiness', '--from-runbook', runbookFile, '--stage', stage.stage_id, '--subject', stage.commit_subject, '--root', repoRoot], {
+      allowFailure: true,
+      expectOutput: ['release --staged-commit-readiness requires --from-evidence <local-execution-evidence-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'release', '--diff-coverage', '--from-file', evidenceFile, '--from-plan', planFile, '--from-runbook', runbookFile, '--root', repoRoot], {
+      allowFailure: true,
+      expectOutput: ['--from-runbook and --stage are only supported by release --staged-commit-readiness'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'verification', '--execution-evidence', '--from-runbook', runbookFile, '--from-file', evidenceFile, '--from-evidence', bindingFile, '--root', repoRoot], {
+      allowFailure: true,
+      expectOutput: ['--from-evidence is only supported by review --resolution, release --staged-commit-readiness, release --closeout-readiness, workflow --next-action-console, or completion --evidence-bundle'],
+    }, options);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}

package/tools/vibe-release-check/release-check-stage12-smoke.mjs

@@ -0,0 +1,59 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+function writeJson(file, payload) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+}
+
+function assertQualityIncludes(json, marker, label) {
+  const quality = json.quality || [];
+  if (!quality.some((item) => String(item).includes(marker))) {
+    throw new Error(`${label} missing quality marker ${marker}; got ${quality.join('; ')}`);
+  }
+}
+
+export function runVerificationDrivenRepairLoopSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const root = path.join(repoRoot, '.tmp', 'vibe-stage12-repair-loop');
+  fs.rmSync(root, { recursive: true, force: true });
+  fs.mkdirSync(root, { recursive: true });
+  try {
+    const base = {
+      task_id: 'stage12-repair',
+      failure_classifications: ['runtime-check'],
+      repair_budget: { max_attempts: 2, attempts_used: 0, allowed_paths: ['tools/vibe-runtime/runtime-evidence-repair-model.mjs'], allowed_patch_types: ['minimal-contract-patch'], must_reverify: true },
+      estimated_changed_files: ['tools/vibe-runtime/runtime-evidence-repair-model.mjs'],
+      diff_digest: 'stage12-diff',
+      rollback_patch: 'diff --git a/tools/vibe-runtime/runtime-evidence-repair-model.mjs b/tools/vibe-runtime/runtime-evidence-repair-model.mjs\n',
+      verification_commands: ['node tools/vibe-runtime-check/index.mjs --root .'],
+    };
+    const cases = [
+      ['passed', { ...base, failure_classifications: [], checks: [{ id: 'runtime-check', exit_status: 0, status: 'passed', freshness: { status: 'fresh' } }] }, 'manual-evidence-required', null],
+      ['failed', base, 'repair-plan-ready-for-patch-queue', null],
+      ['stale', { ...base, failure_classifications: ['stale'] }, 'repair-plan-ready-for-patch-queue', null],
+      ['missing', { task_id: 'missing', repair_budget: base.repair_budget }, 'manual-evidence-required', null],
+      ['scope-violation', { ...base, failure_classifications: ['scope violation'] }, 'repair-plan-ready-for-patch-queue', 'risk classification high'],
+      ['over-budget', { ...base, repair_budget: { ...base.repair_budget, max_attempts: 1, attempts_used: 1 } }, 'blocked', 'retry budget exhausted'],
+      ['architecture-warning', { ...base, architecture_warning_count: 1 }, 'blocked', 'architecture warning present'],
+      ['baseline-expansion', { ...base, baseline_expansion: true }, 'blocked', 'architecture baseline expansion requested'],
+      ['check-weakening', { ...base, check_weakening: true }, 'blocked', 'check weakening requested'],
+    ];
+    for (const [name, payload, status, marker] of cases) {
+      const file = path.join(root, `${name}.json`);
+      writeJson(file, payload);
+      const json = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'verification', '--repair-plan', '--from-file', `.tmp/vibe-stage12-repair-loop/${name}.json`, '--json'], {}, options), `verification --repair-plan ${name}`);
+      assertJsonMarkers([
+        [`stage12.${name}.command`, json.command, 'verification'],
+        [`stage12.${name}.mode`, json.mode, 'verification-driven-repair-loop-plan'],
+        [`stage12.${name}.status`, json.verification_repair_loop_plan?.status, status],
+        [`stage12.${name}.patch_queue_required`, json.verification_repair_loop_plan?.patch_queue_required, true],
+        [`stage12.${name}.source_apply`, json.safety?.source_apply, false],
+        [`stage12.${name}.baseline_write`, json.safety?.architecture_baseline_write, false],
+        [`stage12.${name}.check_weakening`, json.safety?.check_weakening, false],
+      ], `verification --repair-plan ${name}`);
+      if (marker) assertQualityIncludes(json, marker, `verification --repair-plan ${name}`);
+    }
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}

package/tools/vibe-release-check/release-check-stage121-136-fixture-specs.mjs

@@ -0,0 +1,26 @@
+export const RUNTIME_READ_ONLY_FORBIDDEN_FLAGS = Object.freeze([
+  '--confirm',
+  '--dry-run',
+  '--write',
+  '--preflight',
+  '--dispatch',
+  '--dispatch-intent',
+  '--run',
+  '--once',
+  '--scan',
+  '--auto-run',
+]);
+
+export const PLATFORM_ENTRY_ACCEPTANCE_FORBIDDEN_FLAGS = Object.freeze([
+  '--confirm',
+  '--write',
+  '--dry-run',
+  '--preflight',
+  '--dispatch',
+  '--run',
+  '--auto-run',
+]);
+
+export function stringifySmokeFixture(fixture) {
+  return `${JSON.stringify(fixture, null, 2)}\n`;
+}