@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-release-check/release-check-stage103-118-smoke.mjs

@@ -0,0 +1,861 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import {
+  READ_ONLY_RUNTIME_CONTROL_FLAGS,
+  READ_ONLY_RUNTIME_CONTROL_FLAGS_WITH_DRY_RUN,
+  READ_ONLY_RUNTIME_CONTROL_FLAGS_WITH_DRY_RUN_SECOND,
+  READ_ONLY_RUNTIME_CONTROL_FLAGS_WITH_PREVIEW,
+  assertNoSmokeState,
+  cleanupSmokeTmpRoot,
+  prepareSmokeTmpRoot,
+  readonlySmokeMarkers,
+  runForbiddenFlagChecks,
+  writeSmokeJsonFixture,
+} from './release-check-json-assertion-helpers.mjs';
+import {
+  assertAutomationReadinessCatalog,
+  stage105PlanFixtureText,
+  stage106PlanFixtureText,
+  stage107PlanFixtureText,
+  stage108PlanFixtureText,
+  stage109CloseLoopDashboardPlanFixtureText,
+  stage110EvidenceIntakeFixture,
+  stage110EvidenceIntakePlanFixtureText,
+  stage111DiffCoverageExpectedFiles,
+  stage112ResolutionEvidenceFixture,
+  stage112ReviewFixture,
+  stage112ReviewPlanFixtureText,
+  stage113TddTraceFixture,
+  stage113TddTracePlanFixtureText,
+  stage114HumanFriendlyAliasPlanFixtureText,
+  stage115ProgressiveEntryUxGapFixture,
+} from './release-check-stage103-118-fixtures.mjs';
+import {
+  stage112ReviewIntakeJsonMarkers,
+  stage112ReviewIntakeTextExpectations,
+  stage112ReviewResolutionJsonMarkers,
+  stage112ReviewResolutionTextExpectations,
+} from './release-check-stage103-118-smoke-specs.mjs';
+
+export function runAutomationReadinessSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-automation-readiness';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+
+  try {
+    const readiness = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'automation', '--readiness', '--json', '--root', target], {}, options), 'automation --readiness --json');
+    assertJsonMarkers(readonlySmokeMarkers(readiness, 'automationReadiness'), 'automation --readiness --json');
+    if (!readiness.runtime_automation_readiness?.registry_digest) throw new Error('automation readiness missing registry_digest');
+    if (!readiness.runtime_automation_readiness?.readiness_digest) throw new Error('automation readiness missing readiness_digest');
+    assertAutomationReadinessCatalog(readiness.runtime_automation_readiness);
+    assertNoSmokeState(repoRoot, target, 'automation --readiness JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'automation', '--readiness', '--root', target], {
+      expectOutput: ['Vibecoding Runtime Automation Readiness Matrix', 'Stage: Stage 103; Kind: runtime-automation-readiness-matrix; pass=true', 'auto_safe:', 'confirm_required:', 'advice_only:', 'forbidden:', 'Transition: automation_readiness_only=true; automation_plan_created=false; one_shot_execution_created=false', 'Boundary: writes=false; automation_readiness_artifact=false; automation_plan_artifact=false; one_shot_execution_artifact=false', 'Readiness digest:'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'automation --readiness text output');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'automation', '--readiness'], ['--root', target], READ_ONLY_RUNTIME_CONTROL_FLAGS_WITH_PREVIEW, 'automation --readiness is read-only', options);
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}
+
+export function runWorkflowLoopContractSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-workflow-loop-contract';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+
+  try {
+    const contract = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--loop-contract', '--intent', 'implementation', '--json', '--root', target], {}, options), 'workflow --loop-contract --intent implementation --json');
+    assertJsonMarkers(readonlySmokeMarkers(contract, 'workflowLoopContract'), 'workflow --loop-contract --intent implementation --json');
+    if (!contract.workflow_loop_contract?.loop_contract_digest) throw new Error('workflow loop contract missing loop_contract_digest');
+    if (!contract.workflow_loop_contract?.source_bindings?.workflow_start_digest) throw new Error('workflow loop contract missing workflow_start_digest');
+    if (!contract.workflow_loop_contract?.source_bindings?.workflow_sequence_digest) throw new Error('workflow loop contract missing workflow_sequence_digest');
+    if (!contract.workflow_loop_contract?.source_bindings?.automation_readiness_digest) throw new Error('workflow loop contract missing automation_readiness_digest');
+    if (!contract.workflow_loop_contract?.source_bindings?.registry_digest) throw new Error('workflow loop contract missing registry_digest');
+    assertNoSmokeState(repoRoot, target, 'workflow --loop-contract JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--loop-contract', '--intent', 'implementation', '--root', target], {
+      expectOutput: ['Vibecoding Runtime Workflow Loop Contract', 'Stage: Stage 104; Kind: workflow-loop-contract; pass=true', 'Loop phases', 'plan', 'docs', 'code', 'self_test', 'commit_readiness', 'Boundary: writes=false; workflow_loop_contract_artifact=false; automation_plan_artifact=false', 'Loop contract digest:'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'workflow --loop-contract text output');
+
+    const promptContract = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--loop-contract', '--prompt', '实现一个运行时闭环合同', '--json', '--root', target], {}, options), 'workflow --loop-contract --prompt --json');
+    assertJsonMarkers([
+      ['mode', promptContract.mode, 'workflow-loop-contract'],
+      ['workflow_loop_contract.stage', promptContract.workflow_loop_contract?.stage, 'Stage 104'],
+      ['workflow_loop_contract.contract_kind', promptContract.workflow_loop_contract?.contract_kind, 'workflow-loop-contract'],
+    ], 'workflow --loop-contract --prompt --json');
+    if (!promptContract.workflow_loop_contract?.loop_contract_digest) throw new Error('workflow loop contract prompt output missing digest');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'workflow', '--loop-contract', '--intent', 'implementation'], ['--root', target], READ_ONLY_RUNTIME_CONTROL_FLAGS, 'workflow read-only modes do not accept execution', options);
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}
+
+export function runPlanActionManifestSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-plan-action-manifest';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+  const planFile = path.join(target, 'stage105-plan.md');
+  const absolutePlanFile = path.join(repoRoot, planFile);
+
+  try {
+    fs.writeFileSync(absolutePlanFile, stage105PlanFixtureText());
+
+    const manifest = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'planner', '--action-manifest', '--from-file', planFile, '--intent', 'implementation', '--json', '--root', target], {}, options), 'planner --action-manifest --json');
+    assertJsonMarkers(readonlySmokeMarkers(manifest, 'planActionManifest'), 'planner --action-manifest --json');
+    if (!manifest.plan_action_manifest?.plan_action_manifest_digest) throw new Error('plan action manifest missing plan_action_manifest_digest');
+    if (!manifest.plan_action_manifest?.source_bindings?.plan_lint_digest) throw new Error('plan action manifest missing plan_lint_digest');
+    if (!manifest.plan_action_manifest?.source_bindings?.workflow_loop_contract_digest) throw new Error('plan action manifest missing workflow_loop_contract_digest');
+    if (!manifest.plan_action_manifest?.source_bindings?.automation_readiness_digest) throw new Error('plan action manifest missing automation_readiness_digest');
+    if (!manifest.plan_action_manifest?.source_bindings?.registry_digest) throw new Error('plan action manifest missing registry_digest');
+    assertNoSmokeState(repoRoot, target, 'planner --action-manifest JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'planner', '--action-manifest', '--from-file', planFile, '--root', target], {
+      expectOutput: ['Vibecoding Runtime Plan-to-Action Manifest', 'Stage: Stage 105; Kind: plan-to-action-manifest; pass=true', 'Action items:', 'execution_authorized=false', 'Boundary: writes=false; plan_action_manifest_artifact=false; automation_plan_artifact=false', 'Plan action manifest digest:'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'planner --action-manifest text output');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'planner', '--action-manifest', '--from-file', planFile], ['--root', target], READ_ONLY_RUNTIME_CONTROL_FLAGS, 'planner --action-manifest is read-only', options);
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}
+
+export function runSelfTestProfileSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-self-test-profile';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+  const planFile = path.join(target, 'stage106-plan.md');
+  const absolutePlanFile = path.join(repoRoot, planFile);
+
+  try {
+    fs.writeFileSync(absolutePlanFile, stage106PlanFixtureText());
+
+    const profile = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'verification', '--self-test-profile', '--from-file', planFile, '--intent', 'implementation', '--json', '--root', target], {}, options), 'verification --self-test-profile --json');
+    assertJsonMarkers(readonlySmokeMarkers(profile, 'selfTestProfile'), 'verification --self-test-profile --json');
+    if (!profile.self_test_gate_profile?.self_test_gate_profile_digest) throw new Error('self-test gate profile missing self_test_gate_profile_digest');
+    if (!profile.self_test_gate_profile?.source_bindings?.plan_action_manifest_digest) throw new Error('self-test gate profile missing plan_action_manifest_digest binding');
+    if (!profile.self_test_gate_profile?.source_bindings?.registry_digest) throw new Error('self-test gate profile missing registry_digest binding');
+    if (!profile.self_test_gate_profile?.recommended_order?.length) throw new Error('self-test gate profile missing recommended_order');
+    assertNoSmokeState(repoRoot, target, 'verification --self-test-profile JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'verification', '--self-test-profile', '--from-file', planFile, '--root', target], {
+      expectOutput: ['Vibecoding Runtime Self-test Gate Profile', 'Stage: Stage 106; Kind: self-test-gate-profile; pass=true', 'Gate items:', 'status=planned_not_run', 'execution_authorized=false', 'Boundary: writes=false; self_test_gate_profile_artifact=false', 'Self-test gate profile digest:'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'verification --self-test-profile text output');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'verification', '--self-test-profile', '--from-file', planFile], ['--root', '.'], READ_ONLY_RUNTIME_CONTROL_FLAGS, 'verification --self-test-profile is read-only', options);
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}
+
+export function runCommitReadinessSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-commit-readiness';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+  const planFile = path.join(target, 'stage107-plan.md');
+  const absolutePlanFile = path.join(repoRoot, planFile);
+
+  try {
+    fs.writeFileSync(absolutePlanFile, stage107PlanFixtureText(), 'utf8');
+
+    const readiness = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'release', '--commit-readiness', '--from-file', planFile, '--subject', 'feat(runtime): add Stage 107 commit readiness envelope', '--intent', 'implementation', '--json', '--root', target], {}, options), 'release --commit-readiness --json');
+    assertJsonMarkers(readonlySmokeMarkers(readiness, 'commitReadiness'), 'release --commit-readiness --json');
+    if (!readiness.commit_readiness?.commit_readiness_digest) throw new Error('commit readiness missing commit_readiness_digest');
+    if (!readiness.commit_readiness?.source_bindings?.plan_action_manifest_digest) throw new Error('commit readiness missing plan_action_manifest_digest binding');
+    if (!readiness.commit_readiness?.source_bindings?.self_test_gate_profile_digest) throw new Error('commit readiness missing self_test_gate_profile_digest binding');
+    if (!readiness.commit_readiness?.source_bindings?.commit_guard_digest) throw new Error('commit readiness missing commit_guard_digest binding');
+    if (!readiness.commit_readiness?.source_bindings?.registry_digest) throw new Error('commit readiness missing registry_digest binding');
+    if (!readiness.commit_readiness?.readiness_order?.length) throw new Error('commit readiness missing readiness_order');
+    assertNoSmokeState(repoRoot, target, 'release --commit-readiness JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'release', '--commit-readiness', '--from-file', planFile, '--subject', 'feat(runtime): add Stage 107 commit readiness envelope', '--root', target], {
+      expectOutput: ['Vibecoding Runtime Commit Readiness Envelope', 'Stage: Stage 107; Kind: commit-readiness-envelope; pass=true', 'Readiness: envelope_valid=true; commit_ready=false; manual_evidence_required=true; commit_execution_authorized=false', 'execution_authorized=false; commit_execution_authorized=false', 'Boundary: writes=false; commit_readiness_artifact=false; commit_artifact=false; command_execution=false; test_execution=false; git=false; git_write=false; commit=false', 'Commit readiness digest:'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'release --commit-readiness text output');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'release', '--commit-readiness', '--from-file', planFile, '--subject', 'feat(runtime): add Stage 107 commit readiness envelope'], ['--root', target], READ_ONLY_RUNTIME_CONTROL_FLAGS_WITH_PREVIEW, 'release --commit-readiness is read-only', options);
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'release', '--commit-readiness', '--from-file', planFile, '--root', target], {
+      allowFailure: true,
+      expectOutput: ['release --commit-readiness requires --subject'],
+    }, options);
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}
+
+export function runConfirmedOneShotPlanSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-confirmed-one-shot-plan';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+  const planFile = path.join(target, 'stage108-plan.md');
+  const absolutePlanFile = path.join(repoRoot, planFile);
+
+  try {
+    fs.writeFileSync(absolutePlanFile, stage108PlanFixtureText(), 'utf8');
+
+    const plan = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'automation', '--one-shot-plan', '--from-file', planFile, '--subject', 'feat(runtime): add Stage 108 confirmed one-shot plan', '--confirm-plan', 'confirm-stage-108-plan-only', '--intent', 'implementation', '--json', '--root', target], {}, options), 'automation --one-shot-plan --json');
+    assertJsonMarkers(readonlySmokeMarkers(plan, 'confirmedOneShotPlan'), 'automation --one-shot-plan --json');
+    if (!plan.confirmed_one_shot_plan?.confirmed_one_shot_plan_digest) throw new Error('confirmed one-shot plan missing confirmed_one_shot_plan_digest');
+    if (!plan.confirmed_one_shot_plan?.source_bindings?.commit_readiness_digest) throw new Error('confirmed one-shot plan missing commit_readiness_digest binding');
+    if (!plan.confirmed_one_shot_plan?.source_bindings?.automation_readiness_digest) throw new Error('confirmed one-shot plan missing automation_readiness_digest binding');
+    if (!plan.confirmed_one_shot_plan?.source_bindings?.registry_digest) throw new Error('confirmed one-shot plan missing registry_digest binding');
+    if (!plan.confirmed_one_shot_plan?.execution_order?.length) throw new Error('confirmed one-shot plan missing execution_order');
+    if (!plan.confirmed_one_shot_plan?.recovery_notes?.length) throw new Error('confirmed one-shot plan missing recovery_notes');
+    assertNoSmokeState(repoRoot, target, 'automation --one-shot-plan JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'automation', '--one-shot-plan', '--from-file', planFile, '--subject', 'feat(runtime): add Stage 108 confirmed one-shot plan', '--confirm-plan', 'confirm-stage-108-plan-only', '--root', target], {
+      expectOutput: ['Vibecoding Runtime Confirmed One-shot Execution Plan', 'Stage: Stage 108; Kind: confirmed-one-shot-execution-plan; pass=true', 'Confirmation: plan_confirmed=true; actions_executed=false; execution_authorized=false', 'ready_for_runtime_execution=false', 'status=planned_not_executed; actions_executed=false; execution_authorized=false', 'Boundary: writes=false; confirmed_one_shot_plan_artifact=false; one_shot_execution_plan_artifact=false; one_shot_execution_artifact=false; command_execution=false; test_execution=false; git=false; git_write=false; commit=false', 'Confirmed one-shot plan digest:'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'automation --one-shot-plan text output');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'automation', '--one-shot-plan', '--from-file', planFile, '--subject', 'feat(runtime): add Stage 108 confirmed one-shot plan', '--confirm-plan', 'confirm-stage-108-plan-only'], ['--root', target], READ_ONLY_RUNTIME_CONTROL_FLAGS_WITH_PREVIEW, 'automation --one-shot-plan is read-only', options);
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'automation', '--one-shot-plan', '--from-file', planFile, '--subject', 'feat(runtime): add Stage 108 confirmed one-shot plan', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['automation --one-shot-plan requires --confirm-plan'],
+    }, options);
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'automation', '--one-shot-plan', '--from-file', planFile, '--confirm-plan', 'confirm-stage-108-plan-only', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['automation --one-shot-plan requires --subject'],
+    }, options);
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}
+
+export function runCloseLoopDashboardSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-close-loop-dashboard';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+  const planFile = path.join(target, 'stage109-plan.md');
+  const absolutePlanFile = path.join(repoRoot, planFile);
+
+  try {
+    fs.writeFileSync(absolutePlanFile, stage109CloseLoopDashboardPlanFixtureText(), 'utf8');
+
+    const dashboard = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--close-loop-dashboard', '--from-file', planFile, '--subject', 'feat(runtime): add Stage 109 close-loop dashboard', '--confirm-plan', 'confirm-stage-109-dashboard-only', '--intent', 'implementation', '--json', '--root', target], {}, options), 'workflow --close-loop-dashboard --json');
+    assertJsonMarkers(readonlySmokeMarkers(dashboard, 'closeLoopDashboard'), 'workflow --close-loop-dashboard --json');
+    if (!dashboard.close_loop_dashboard?.close_loop_dashboard_digest) throw new Error('close-loop dashboard missing close_loop_dashboard_digest');
+    if (!dashboard.close_loop_dashboard?.source_bindings?.plan_action_manifest_digest) throw new Error('close-loop dashboard missing plan_action_manifest_digest binding');
+    if (!dashboard.close_loop_dashboard?.source_bindings?.self_test_gate_profile_digest) throw new Error('close-loop dashboard missing self_test_gate_profile_digest binding');
+    if (!dashboard.close_loop_dashboard?.source_bindings?.commit_readiness_digest) throw new Error('close-loop dashboard missing commit_readiness_digest binding');
+    if (!dashboard.close_loop_dashboard?.source_bindings?.confirmed_one_shot_plan_digest) throw new Error('close-loop dashboard missing confirmed_one_shot_plan_digest binding');
+    if (!dashboard.close_loop_dashboard?.source_bindings?.automation_readiness_digest) throw new Error('close-loop dashboard missing automation_readiness_digest binding');
+    if (!dashboard.close_loop_dashboard?.source_bindings?.registry_digest) throw new Error('close-loop dashboard missing registry_digest binding');
+    assertNoSmokeState(repoRoot, target, 'workflow --close-loop-dashboard JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--close-loop-dashboard', '--from-file', planFile, '--subject', 'feat(runtime): add Stage 109 close-loop dashboard', '--root', target], {
+      expectOutput: ['Vibecoding Runtime Close-loop Dashboard', 'Stage: Stage 109; Kind: close-loop-dashboard; pass=true', 'Plan: pass=true', 'Self-test: gates=', 'Commit: gates=', 'One-shot: confirmation_provided=false', 'ready_for_runtime_execution=false; actions_executed=false; execution_authorized=false', 'Boundary: writes=false; close_loop_dashboard_artifact=false; command_execution=false; test_execution=false; check_execution=false; git=false; git_write=false; commit=false', 'Close-loop dashboard digest:'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'workflow --close-loop-dashboard text output');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'workflow', '--close-loop-dashboard', '--from-file', planFile, '--subject', 'feat(runtime): add Stage 109 close-loop dashboard'], ['--root', target], READ_ONLY_RUNTIME_CONTROL_FLAGS_WITH_PREVIEW, 'workflow read-only modes do not accept execution', options);
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--close-loop-dashboard', '--from-file', planFile, '--root', target], {
+      allowFailure: true,
+      expectOutput: ['workflow --close-loop-dashboard requires --subject'],
+    }, options);
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}
+
+export function runEvidenceIntakeSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-evidence-intake';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+  const planFile = path.join(target, 'stage110-plan.md');
+  const evidenceFile = path.join(target, 'stage110-evidence.json');
+  const absolutePlanFile = path.join(repoRoot, planFile);
+
+  try {
+    fs.writeFileSync(absolutePlanFile, stage110EvidenceIntakePlanFixtureText(), 'utf8');
+    writeSmokeJsonFixture(repoRoot, evidenceFile, stage110EvidenceIntakeFixture());
+
+    const intake = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'verification', '--evidence-intake', '--from-file', evidenceFile, '--from-plan', planFile, '--json', '--root', target], {}, options), 'verification --evidence-intake --json');
+    assertJsonMarkers(readonlySmokeMarkers(intake, 'evidenceIntake'), 'verification --evidence-intake --json');
+    if (!intake.evidence_intake?.evidence_intake_digest) throw new Error('evidence intake missing evidence_intake_digest');
+    if (!intake.evidence_intake?.source_bindings?.plan_action_manifest_digest) throw new Error('evidence intake missing plan_action_manifest_digest binding');
+    if (!intake.evidence_intake?.source_bindings?.self_test_gate_profile_digest) throw new Error('evidence intake missing self_test_gate_profile_digest binding');
+    if (!intake.evidence_intake?.source_bindings?.registry_digest) throw new Error('evidence intake missing registry_digest binding');
+    assertNoSmokeState(repoRoot, target, 'verification --evidence-intake JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'verification', '--evidence-intake', '--from-file', evidenceFile, '--from-plan', planFile, '--root', target], {
+      expectOutput: ['Vibecoding Runtime Evidence Intake Envelope', 'Stage: Stage 110; Kind: evidence-intake-envelope; pass=true', 'Evidence: checks=4; structure_valid=true; freshness_valid=true; gate_coverage_complete=true', 'command_executed_by_stage_110=false; execution_authorized=false', 'Boundary: writes=false; evidence_intake_artifact=false; evidence_artifact_write=false; command_execution=false; check_execution=false; test_execution=false; git=false; git_write=false; commit=false', 'Evidence intake digest:'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'verification --evidence-intake text output');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'verification', '--evidence-intake', '--from-file', evidenceFile], ['--root', target], READ_ONLY_RUNTIME_CONTROL_FLAGS_WITH_DRY_RUN, 'verification read-only modes do not accept execution', options);
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'verification', '--evidence-intake', '--from-plan', planFile, '--root', target], {
+      allowFailure: true,
+      expectOutput: ['verification --evidence-intake requires --from-file'],
+    }, options);
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}
+
+function assertGitDiffReadSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, { target, planFile, diffFile }, options) {
+  const diffRead = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'release', '--diff-read', '--from-plan', planFile, '--json', '--root', target], {}, options), 'release --diff-read --json');
+  assertJsonMarkers([
+    ['command', diffRead.command, 'release'],
+    ['mode', diffRead.mode, 'git-diff-read-evidence'],
+    ['artifact_kind', diffRead.artifact_kind, 'diff-coverage-evidence'],
+    ['runtime_read_git_diff', diffRead.runtime_read_git_diff, true],
+    ['git_read', diffRead.git_read, true],
+    ['git_write', diffRead.git_write, false],
+    ['worktree_write', diffRead.worktree_write, false],
+    ['git_diff_read.stage', diffRead.git_diff_read?.stage, 'P3'],
+    ['git_diff_read.read_kind', diffRead.git_diff_read?.read_kind, 'git-diff-read-evidence'],
+    ['git_diff_read.git_diff_read.command_count', diffRead.git_diff_read?.git_diff_read?.command_count, 6],
+    ['git_diff_read.git_diff_read.allowed_command_count', diffRead.git_diff_read?.git_diff_read?.allowed_command_count, 6],
+    ['git_diff_read.git_diff_read.git_write', diffRead.git_diff_read?.git_diff_read?.git_write, false],
+    ['git_diff_read.git_diff_read.worktree_write', diffRead.git_diff_read?.git_diff_read?.worktree_write, false],
+    ['git_diff_read.diff_coverage_evidence.artifact_kind', diffRead.git_diff_read?.diff_coverage_evidence?.artifact_kind, 'diff-coverage-evidence'],
+    ['git_diff_read.diff_coverage_evidence.runtime_read_git_diff', diffRead.git_diff_read?.diff_coverage_evidence?.runtime_read_git_diff, true],
+    ['git_diff_read.boundary_assertions.git_read', diffRead.git_diff_read?.boundary_assertions?.git_read, true],
+    ['git_diff_read.boundary_assertions.git_write', diffRead.git_diff_read?.boundary_assertions?.git_write, false],
+    ['git_diff_read.boundary_assertions.worktree_write', diffRead.git_diff_read?.boundary_assertions?.worktree_write, false],
+    ['safety.stage', diffRead.safety?.stage, 'P3'],
+    ['safety.git_write', diffRead.safety?.git_write, false],
+    ['safety.worktree_write', diffRead.safety?.worktree_write, false],
+  ], 'release --diff-read --json');
+  if (!diffRead.git_diff_read?.diff_read_digest) throw new Error('git diff read missing diff_read_digest');
+  if (!diffRead.git_diff_read?.source_bindings?.plan_action_manifest_digest) throw new Error('git diff read missing plan_action_manifest_digest binding');
+  if (!diffRead.git_diff_read?.source_bindings?.registry_digest) throw new Error('git diff read missing registry_digest binding');
+  assertNoSmokeState(repoRoot, target, 'release --diff-read JSON output');
+
+  run('node', ['tools/vibe-runtime/index.mjs', 'release', '--diff-read', '--from-plan', planFile, '--root', target], {
+    expectOutput: ['Vibecoding Runtime Git Diff Read Evidence', 'Kind: git-diff-read-evidence', 'Commands: total=6; allowed=6', 'git_read=true; git_write=false; worktree_write=false', 'Boundary: writes=false; diff_coverage_artifact=false; sidecar_write=false; runtime_read_git_diff=true; git_read=true; git_write=false; worktree_write=false', 'Git diff read digest:'],
+  }, options);
+  assertNoSmokeState(repoRoot, target, 'release --diff-read text output');
+
+  runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'release', '--diff-read', '--from-plan', planFile], ['--root', target], READ_ONLY_RUNTIME_CONTROL_FLAGS_WITH_DRY_RUN, 'release --diff-read is read-only', options);
+
+  run('node', ['tools/vibe-runtime/index.mjs', 'release', '--diff-read', '--root', target], {
+    allowFailure: true,
+    expectOutput: ['release --diff-read requires --from-plan'],
+  }, options);
+
+  run('node', ['tools/vibe-runtime/index.mjs', 'release', '--diff-read', '--from-plan', planFile, '--from-file', diffFile, '--root', target], {
+    allowFailure: true,
+    expectOutput: ['release --diff-read only accepts one local plan file'],
+  }, options);
+}
+
+export function runDiffCoverageSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-diff-coverage';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+  const planFile = path.join(target, 'stage111-plan.md');
+  const diffFile = path.join(target, 'stage111-diff.txt');
+  const absolutePlanFile = path.join(repoRoot, planFile);
+  const absoluteDiffFile = path.join(repoRoot, diffFile);
+  const expectedFiles = stage111DiffCoverageExpectedFiles();
+
+  try {
+    fs.writeFileSync(absolutePlanFile, [
+      '# Stage 111 fixture plan',
+      '',
+      '## Task 1',
+      '- [ ] Add `tools/vibe-runtime/runtime-diff-coverage-envelope.mjs` pure diff coverage envelope fields.',
+      '- [ ] Update `tools/vibe-runtime/index.mjs` CLI release --diff-coverage dispatch.',
+      '- [ ] Sync `tools/vibe-runtime/runtime-capability-registry.mjs` and `tools/vibe-runtime/runtime-automation-readiness.mjs`.',
+      '- [ ] Sync `tools/vibe-runtime-check/index.mjs` and `tools/vibe-release-check/index.mjs` validation markers.',
+      '- [ ] Document `tools/vibe-runtime/README.md` and `docs/runtime-roadmap.md`.',
+      '',
+      'Interfaces: diff_coverage, changed_files, expected_files, covered_expected_files, missing_expected_files, unexpected_files, docs_coverage, code_coverage, diff_coverage_invariants, diff_coverage_digest.',
+      'Verification: node --check changed runtime files, runtime-check, release-check, and git diff --check evidence captured manually outside Stage 111.',
+      'Acceptance: all expected files are covered, unexpected_files is empty, git_executed_by_stage_111=false, execution_authorized=false, and diff_coverage_digest is present.',
+      'Review: local boundary review confirms no git, no command execution, no state write, no network, no model, no MCP, no subagent.',
+      'Completion boundary: Stage 111 only reads a local diff file and a local plan file.',
+    ].join('\n'), 'utf8');
+    fs.writeFileSync(absoluteDiffFile, expectedFiles.join('\n'), 'utf8');
+
+    const coverage = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'release', '--diff-coverage', '--from-file', diffFile, '--from-plan', planFile, '--json', '--root', target], {}, options), 'release --diff-coverage --json');
+    assertJsonMarkers([
+      ...readonlySmokeMarkers(coverage, 'diffCoverage'),
+      ['diff_coverage.diff_coverage.changed_file_count', coverage.diff_coverage?.diff_coverage?.changed_file_count, expectedFiles.length],
+    ], 'release --diff-coverage --json');
+    if (!coverage.diff_coverage?.diff_coverage_digest) throw new Error('diff coverage missing diff_coverage_digest');
+    if (!coverage.diff_coverage?.source_bindings?.plan_action_manifest_digest) throw new Error('diff coverage missing plan_action_manifest_digest binding');
+    if (!coverage.diff_coverage?.source_bindings?.registry_digest) throw new Error('diff coverage missing registry_digest binding');
+    assertNoSmokeState(repoRoot, target, 'release --diff-coverage JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'release', '--diff-coverage', '--from-file', diffFile, '--from-plan', planFile, '--root', target], {
+      expectOutput: ['Vibecoding Runtime Diff Coverage Envelope', 'Stage: Stage 111; Kind: diff-coverage-envelope; pass=true', 'Diff: changed=8; expected=8; covered=8; missing=0; unexpected=0; git_executed_by_stage_111=false; diff_generated_by_stage_111=false', 'Boundary: writes=false; diff_coverage_artifact=false; diff_artifact_write=false; command_execution=false; git=false; git_write=false; commit=false', 'Diff coverage digest:'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'release --diff-coverage text output');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'release', '--diff-coverage', '--from-file', diffFile, '--from-plan', planFile], ['--root', target], READ_ONLY_RUNTIME_CONTROL_FLAGS_WITH_DRY_RUN, 'release --diff-coverage is read-only', options);
+
+    assertGitDiffReadSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, { target, planFile, diffFile }, options);
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'release', '--diff-coverage', '--from-file', diffFile, '--root', target], {
+      allowFailure: true,
+      expectOutput: ['release --diff-coverage requires --from-plan'],
+    }, options);
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}
+
+export function runReviewEnvelopeSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-review-envelope';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+  const planFile = path.join(target, 'stage112-plan.md');
+  const reviewFile = path.join(target, 'review.json');
+  const resolutionEvidenceFile = path.join(target, 'resolution-evidence.json');
+  const blindRepairFile = path.join(target, 'blind-repair-review.json');
+  const intakeFile = path.join(target, 'review-intake-output.json');
+  const absolutePlanFile = path.join(repoRoot, planFile);
+  const absoluteIntakeFile = path.join(repoRoot, intakeFile);
+
+  try {
+    fs.writeFileSync(absolutePlanFile, stage112ReviewPlanFixtureText(), 'utf8');
+    writeSmokeJsonFixture(repoRoot, reviewFile, stage112ReviewFixture());
+    writeSmokeJsonFixture(repoRoot, resolutionEvidenceFile, stage112ResolutionEvidenceFixture());
+    writeSmokeJsonFixture(repoRoot, blindRepairFile, {
+      created_at: '2026-07-18T00:05:00.000Z',
+      claim: 'Automatically repaired review feedback and ran tests without binding source evidence.',
+      review_items: [{
+        id: 'review-blind-repair',
+        severity: 'important',
+        category: 'test_gap',
+        comment: 'Add explicit verification for the review feedback gate before continuing.',
+        impacted_files: ['tools/vibe-runtime/runtime-review-envelope.mjs'],
+        required_change: 'Bind review feedback to a verification plan before any repair claim.',
+        required_evidence: ['review feedback gate reports no blind repair claim'],
+      }],
+    });
+
+    const intake = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'review', '--intake', '--from-file', reviewFile, '--from-plan', planFile, '--json', '--root', target], {}, options), 'review --intake --json');
+    assertJsonMarkers(stage112ReviewIntakeJsonMarkers(intake), 'review --intake --json');
+    if (!intake.review_intake?.review_intake_digest) throw new Error('review intake missing review_intake_digest');
+    if (!intake.review_intake?.source_bindings?.registry_digest) throw new Error('review intake missing registry_digest binding');
+    assertNoSmokeState(repoRoot, target, 'review --intake JSON output');
+
+    fs.writeFileSync(absoluteIntakeFile, JSON.stringify(intake, null, 2), 'utf8');
+    const resolution = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'review', '--resolution', '--from-file', intakeFile, '--from-evidence', resolutionEvidenceFile, '--json', '--root', target], {}, options), 'review --resolution --json');
+    assertJsonMarkers(stage112ReviewResolutionJsonMarkers(resolution), 'review --resolution --json');
+    if (!resolution.review_resolution?.review_resolution_digest) throw new Error('review resolution missing review_resolution_digest');
+    if (!resolution.review_resolution?.source_bindings?.registry_digest) throw new Error('review resolution missing registry_digest binding');
+    assertNoSmokeState(repoRoot, target, 'review --resolution JSON output');
+
+    const blindRepair = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'review', '--intake', '--from-file', blindRepairFile, '--json', '--root', target], {}, options), 'review --intake blind repair --json');
+    if (blindRepair.review_intake?.review_feedback_gate?.gate_kind !== 'skill-driven-review-feedback-gate') throw new Error('review feedback gate missing for blind repair fixture');
+    if (blindRepair.review_intake?.next_task_gate?.blocked !== true) throw new Error('blind repair review feedback must block next task');
+    if (!blindRepair.review_intake?.review_feedback_gate?.forbidden_claim_scan?.includes('blind or automatic repair claim')) throw new Error('review feedback gate must flag automatic repair claim');
+    if (!blindRepair.review_intake?.review_feedback_gate?.forbidden_claim_scan?.includes('verification execution claim')) throw new Error('review feedback gate must flag unverified verification claim');
+    assertNoSmokeState(repoRoot, target, 'review --intake blind repair JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'review', '--intake', '--from-file', reviewFile, '--from-plan', planFile, '--root', target], {
+      expectOutput: stage112ReviewIntakeTextExpectations(),
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'review', '--resolution', '--from-file', intakeFile, '--from-evidence', resolutionEvidenceFile, '--root', target], {
+      expectOutput: stage112ReviewResolutionTextExpectations(),
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'review text output');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'review', '--intake', '--from-file', reviewFile], ['--root', target], READ_ONLY_RUNTIME_CONTROL_FLAGS_WITH_DRY_RUN, 'review read-only modes do not accept execution', options);
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'review', '--resolution', '--from-file', intakeFile, '--root', target], {
+      allowFailure: true,
+      expectOutput: ['review --resolution requires --from-evidence'],
+    }, options);
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}
+
+export function runTddTraceSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-tdd-trace';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+  const planFile = path.join(target, 'stage113-plan.md');
+  const traceFile = path.join(target, 'tdd-trace.json');
+  const absolutePlanFile = path.join(repoRoot, planFile);
+
+  try {
+    fs.writeFileSync(absolutePlanFile, stage113TddTracePlanFixtureText(), 'utf8');
+    writeSmokeJsonFixture(repoRoot, traceFile, stage113TddTraceFixture());
+
+    const trace = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'verification', '--tdd-trace', '--from-file', traceFile, '--from-plan', planFile, '--json', '--root', target], {}, options), 'verification --tdd-trace --json');
+    assertJsonMarkers(readonlySmokeMarkers(trace, 'tddTrace'), 'verification --tdd-trace --json');
+    if (!trace.tdd_trace_contract?.tdd_trace_digest) throw new Error('TDD trace contract missing tdd_trace_digest');
+    if (!trace.tdd_trace_contract?.source_bindings?.registry_digest) throw new Error('TDD trace contract missing registry_digest binding');
+    assertNoSmokeState(repoRoot, target, 'verification --tdd-trace JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'verification', '--tdd-trace', '--from-file', traceFile, '--from-plan', planFile, '--root', target], {
+      expectOutput: ['Vibecoding Runtime TDD Trace Contract', 'Stage: Stage 113; Kind: tdd-trace-contract; pass=true', 'Cycle: RED -> GREEN -> REFACTOR; valid=true; test_execution_by_stage_113=false; command_execution_by_stage_113=false', 'RED: verified=true; exit_status=1; expected_failure=true; execution_authorized=false', 'GREEN: verified=true; exit_status=0; execution_authorized=false', 'REFACTOR: verified=true; exit_status=0; skipped=false; execution_authorized=false', 'Boundary: writes=false; tdd_trace_artifact=false; test_result_artifact=false; command_execution=false; check_execution=false; test_execution=false; repair_execution=false; git=false; git_write=false; commit=false', 'TDD trace digest:'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'verification --tdd-trace text output');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'verification', '--tdd-trace', '--from-file', traceFile], ['--root', target], READ_ONLY_RUNTIME_CONTROL_FLAGS_WITH_DRY_RUN, 'verification --tdd-trace is read-only', options);
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'verification', '--tdd-trace', '--from-file', traceFile, '--intent', 'implementation', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['--intent is only supported by verification --self-test-profile'],
+    }, options);
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}
+
+export function runHumanFriendlyAliasSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-human-friendly-alias';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+  const planFile = `${target}/plan.md`;
+  const absolutePlanFile = path.join(repoRoot, planFile);
+
+  try {
+    fs.writeFileSync(absolutePlanFile, stage114HumanFriendlyAliasPlanFixtureText(), 'utf8');
+
+    const closeLoop = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--close-loop', '--from-file', planFile, '--subject', 'feat(runtime): add aliases', '--json', '--root', target], {}, options), 'workflow --close-loop --json');
+    assertJsonMarkers([
+      ['command', closeLoop.command, 'workflow'],
+      ['mode', closeLoop.mode, 'human-friendly-close-loop-alias'],
+      ['ok', closeLoop.ok, true],
+      ['human_friendly_alias.stage', closeLoop.human_friendly_alias?.stage, 'Stage 114'],
+      ['human_friendly_alias.alias_kind', closeLoop.human_friendly_alias?.alias_kind, 'human-friendly-close-loop-alias'],
+      ['human_friendly_alias.source_bindings.close_loop_dashboard_stage', closeLoop.human_friendly_alias?.source_bindings?.close_loop_dashboard_stage, 'Stage 109'],
+      ['human_friendly_alias.source_bindings.registry_version', closeLoop.human_friendly_alias?.source_bindings?.registry_version, 47],
+      ['human_friendly_alias.sections.Plan.execution_authorized', closeLoop.human_friendly_alias?.sections?.Plan?.execution_authorized, false],
+      ['human_friendly_alias.sections.Next evidence.execution_authorized', closeLoop.human_friendly_alias?.sections?.['Next evidence']?.execution_authorized, false],
+      ['human_friendly_alias.boundary_assertions.human_friendly_alias_artifact', closeLoop.human_friendly_alias?.boundary_assertions?.human_friendly_alias_artifact, false],
+      ['human_friendly_alias.boundary_assertions.command_execution', closeLoop.human_friendly_alias?.boundary_assertions?.command_execution, false],
+      ['human_friendly_alias.boundary_assertions.git_write', closeLoop.human_friendly_alias?.boundary_assertions?.git_write, false],
+      ['human_friendly_alias.boundary_assertions.commit', closeLoop.human_friendly_alias?.boundary_assertions?.commit, false],
+      ['safety.stage', closeLoop.safety?.stage, 'Stage 114'],
+    ], 'workflow --close-loop --json');
+    if (!closeLoop.human_friendly_alias?.human_friendly_alias_digest) throw new Error('close-loop alias missing human_friendly_alias_digest');
+    if (!closeLoop.human_friendly_alias?.labels?.includes('Next evidence')) throw new Error('close-loop alias missing Next evidence label');
+    assertNoSmokeState(repoRoot, target, 'workflow --close-loop JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--close-loop', '--from-file', planFile, '--subject', 'feat(runtime): add aliases', '--root', target], {
+      expectOutput: ['Vibecoding Runtime Human-friendly Alias', 'Kind: human-friendly-close-loop-alias; pass=true', 'Plan:', 'Docs:', 'Code:', 'Self-test:', 'Diff:', 'Review:', 'TDD:', 'Commit:', 'Next evidence:', 'Boundary: writes=false; human_friendly_alias_artifact=false; command_execution=false; check_execution=false; test_execution=false; repair_execution=false; git=false; git_write=false; commit=false', 'Human-friendly alias digest:'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'workflow --close-loop text output');
+
+    const nextEvidence = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--next-evidence', '--from-file', planFile, '--json', '--root', target], {}, options), 'workflow --next-evidence --json');
+    assertJsonMarkers([
+      ['command', nextEvidence.command, 'workflow'],
+      ['mode', nextEvidence.mode, 'human-friendly-next-evidence-alias'],
+      ['ok', nextEvidence.ok, true],
+      ['human_friendly_alias.stage', nextEvidence.human_friendly_alias?.stage, 'Stage 114'],
+      ['human_friendly_alias.alias_kind', nextEvidence.human_friendly_alias?.alias_kind, 'human-friendly-next-evidence-alias'],
+      ['human_friendly_alias.source_bindings.plan_action_manifest_stage', nextEvidence.human_friendly_alias?.source_bindings?.plan_action_manifest_stage, 'Stage 105'],
+      ['human_friendly_alias.source_bindings.registry_version', nextEvidence.human_friendly_alias?.source_bindings?.registry_version, 47],
+      ['human_friendly_alias.evidence_inputs.evidence.status', nextEvidence.human_friendly_alias?.evidence_inputs?.evidence?.status, 'missing'],
+      ['human_friendly_alias.next_evidence.kind', nextEvidence.human_friendly_alias?.next_evidence?.kind, 'Self-test evidence'],
+      ['human_friendly_alias.sections.Commit.execution_authorized', nextEvidence.human_friendly_alias?.sections?.Commit?.execution_authorized, false],
+      ['human_friendly_alias.boundary_assertions.next_evidence_alias_artifact', nextEvidence.human_friendly_alias?.boundary_assertions?.next_evidence_alias_artifact, false],
+      ['human_friendly_alias.boundary_assertions.check_execution', nextEvidence.human_friendly_alias?.boundary_assertions?.check_execution, false],
+      ['human_friendly_alias.boundary_assertions.test_execution', nextEvidence.human_friendly_alias?.boundary_assertions?.test_execution, false],
+      ['human_friendly_alias.boundary_assertions.git_write', nextEvidence.human_friendly_alias?.boundary_assertions?.git_write, false],
+      ['safety.stage', nextEvidence.safety?.stage, 'Stage 114'],
+    ], 'workflow --next-evidence --json');
+    if (!nextEvidence.human_friendly_alias?.human_friendly_alias_digest) throw new Error('next-evidence alias missing human_friendly_alias_digest');
+    if (!nextEvidence.human_friendly_alias?.evidence_gaps?.some((gap) => gap.kind === 'Self-test evidence')) throw new Error('next-evidence alias missing self-test evidence gap');
+    assertNoSmokeState(repoRoot, target, 'workflow --next-evidence JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--next-evidence', '--from-file', planFile, '--root', target], {
+      expectOutput: ['Vibecoding Runtime Human-friendly Alias', 'Kind: human-friendly-next-evidence-alias; pass=true', 'Plan:', 'Self-test:', 'Diff:', 'Review:', 'TDD:', 'Commit:', 'Next evidence: Self-test evidence; Provide --evidence-file with local check output JSON.', 'Evidence gaps:', 'Boundary: writes=false; human_friendly_alias_artifact=false; command_execution=false; check_execution=false; test_execution=false; repair_execution=false; git=false; git_write=false; commit=false', 'Human-friendly alias digest:'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'workflow --next-evidence text output');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'workflow', '--next-evidence', '--from-file', planFile], ['--root', target], READ_ONLY_RUNTIME_CONTROL_FLAGS_WITH_DRY_RUN, 'workflow read-only modes do not accept execution', options);
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--next-evidence', '--from-file', planFile, '--subject', 'feat(runtime): add aliases', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['workflow --next-evidence only accepts one local plan file'],
+    }, options);
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}
+
+export function runSuperpowersGapSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const unexpectedState = path.join(repoRoot, '.vibecoding-state');
+
+  const gap = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-gap', '--from-superpowers', 'fork/superpowers', '--json', '--root', '.'], {}, options), 'governance --superpowers-gap --json');
+  assertJsonMarkers(readonlySmokeMarkers(gap, 'superpowersGap'), 'governance --superpowers-gap --json');
+  if (!gap.superpowers_gap_matrix?.gap_matrix_digest) throw new Error('Superpowers gap matrix missing gap_matrix_digest');
+  if (gap.superpowers_gap_matrix?.dimensions?.length !== 10) throw new Error('Superpowers gap matrix dimension count mismatch');
+  if (!gap.superpowers_gap_matrix?.dimensions?.some((dimension) => dimension.id === 'execution_loop' && dimension.recommended_stage === 'Stage 118')) throw new Error('Superpowers gap matrix missing execution_loop Stage 118 recommendation');
+  if (!gap.superpowers_gap_matrix?.recommended_stage_sequence?.includes('Stage 120')) throw new Error('Superpowers gap matrix missing Stage 120 recommendation');
+  if (!gap.superpowers_gap_matrix?.dimensions?.some((dimension) => dimension.id === 'entry_ux' && dimension.recommended_stage === 'Stage 116')) throw new Error('Superpowers gap matrix missing entry UX Stage 116 dimension');
+  if (fs.existsSync(unexpectedState)) throw new Error('governance --superpowers-gap JSON output created unexpected state directory');
+
+  run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-gap', '--from-superpowers', 'fork/superpowers', '--root', '.'], {
+    expectOutput: ['Vibecoding Runtime Superpowers Gap Matrix', 'Stage: Stage 115; Kind: superpowers-gap-matrix; pass=true', 'Sources: superpowers=', '- entry_ux: priority=low; superpowers=100; vibecoding=100; stage=Stage 116', '- planning_quality: priority=low; superpowers=100; vibecoding=100; stage=Stage 117', '- commit_closeout: priority=low; superpowers=100; vibecoding=100; stage=Stage 120', 'Recommended stage sequence:', 'Boundary: writes=false; superpowers_gap_artifact=false; command_execution=false; skill_execution=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', 'Superpowers gap digest:'],
+  }, options);
+  if (fs.existsSync(unexpectedState)) throw new Error('governance --superpowers-gap text output created unexpected state directory');
+
+  runForbiddenFlagChecks(
+    run,
+    ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-gap', '--from-superpowers', 'fork/superpowers'],
+    ['--root', '.'],
+    ['--confirm', '--dry-run', '--preflight', '--dispatch', '--dispatch-intent'],
+    'governance --superpowers-gap is read-only',
+    options,
+  );
+  runForbiddenFlagChecks(
+    run,
+    ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-gap', '--from-superpowers', 'fork/superpowers'],
+    ['--root', '.'],
+    ['--write', '--run', '--once', '--scan', '--auto-run'],
+    'governance supports local attest, PR readiness, compatibility report, convergence report, and read-only audit only',
+    options,
+  );
+
+  run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-gap', '--root', '.'], {
+    allowFailure: true,
+    expectOutput: ['governance --superpowers-gap requires --from-superpowers'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-gap', '--from-superpowers', '../superpowers', '--root', '.'], {
+    allowFailure: true,
+    expectOutput: ['governance --superpowers-gap --from-superpowers must stay within --root'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-gap', '--from-superpowers', 'missing-superpowers', '--root', '.'], {
+    allowFailure: true,
+    expectOutput: ['governance --superpowers-gap --from-superpowers directory not found'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--advice', '--from-superpowers', 'fork/superpowers', '--root', '.'], {
+    allowFailure: true,
+    expectOutput: ['--from-superpowers is only supported by governance --superpowers-gap, governance --superpowers-comparison, or governance --superpowers-regression-guard'],
+  }, options);
+}
+
+function progressiveEntryUxUnsupportedCases({ target, gapFile }) {
+  return [
+    {
+      args: ['tools/vibe-runtime/index.mjs', 'workflow', '--entry-ux', '--root', target],
+      expected: 'workflow --entry-ux requires --prompt <text>',
+    },
+    {
+      args: ['tools/vibe-runtime/index.mjs', 'workflow', '--start', '--prompt', 'start-here', '--from-gap', gapFile, '--root', target],
+      expected: '--from-gap is only supported by workflow --entry-ux',
+    },
+    {
+      args: ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-gap', '--from-gap', gapFile, '--root', target],
+      expected: '--from-gap is only supported by workflow --entry-ux',
+    },
+  ];
+}
+
+function runProgressiveEntryUxUnsupportedCases(run, context, options) {
+  for (const { args, expected } of progressiveEntryUxUnsupportedCases(context)) {
+    run('node', args, {
+      allowFailure: true,
+      expectOutput: [expected],
+    }, options);
+  }
+}
+
+export function runProgressiveEntryUxSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-progressive-entry-ux';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+  const gapFile = path.join(target, 'stage115-gap.json');
+
+  try {
+    writeSmokeJsonFixture(repoRoot, gapFile, stage115ProgressiveEntryUxGapFixture());
+
+    const entryUx = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--entry-ux', '--prompt', 'implement-next-stage', '--json', '--root', target], {}, options), 'workflow --entry-ux --json');
+    assertJsonMarkers(readonlySmokeMarkers(entryUx, 'progressiveEntryUx'), 'workflow --entry-ux --json');
+    if (!entryUx.progressive_entry_ux?.contract_digest) throw new Error('progressive entry UX missing contract_digest');
+    if (!entryUx.progressive_entry_ux?.visible_sentence) throw new Error('progressive entry UX missing visible_sentence');
+    if (!entryUx.progressive_entry_ux?.do_not_do_yet?.some((item) => item.includes('不要运行命令'))) throw new Error('progressive entry UX missing command prohibition guidance');
+    assertNoSmokeState(repoRoot, target, 'workflow --entry-ux JSON output');
+
+    const withGap = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--entry-ux', '--prompt', 'review-branch', '--from-gap', gapFile, '--json', '--root', target], {}, options), 'workflow --entry-ux --from-gap --json');
+    assertJsonMarkers([
+      ['progressive_entry_ux.normalized_intent', withGap.progressive_entry_ux?.normalized_intent, 'review'],
+      ['progressive_entry_ux.source_bindings.gap_matrix_provided', withGap.progressive_entry_ux?.source_bindings?.gap_matrix_provided, true],
+      ['progressive_entry_ux.source_bindings.stage116_gap_found', withGap.progressive_entry_ux?.source_bindings?.stage116_gap_found, true],
+      ['progressive_entry_ux.source_bindings.gap_file_status', withGap.progressive_entry_ux?.source_bindings?.gap_file_status, 'provided'],
+      ['progressive_entry_ux.source_bindings.gap_matrix_digest', withGap.progressive_entry_ux?.source_bindings?.gap_matrix_digest, 'fixture-stage115-gap-digest'],
+    ], 'workflow --entry-ux --from-gap --json');
+    if (!withGap.progressive_entry_ux?.source_bindings?.gap_file_digest) throw new Error('progressive entry UX missing local gap file digest');
+    assertNoSmokeState(repoRoot, target, 'workflow --entry-ux --from-gap JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--entry-ux', '--prompt', 'finish-and-commit-safely', '--from-gap', gapFile, '--root', target], {
+      expectOutput: ['Vibecoding Runtime Progressive Entry UX', 'Stage: Stage 116; Kind: progressive-entry-ux-contract; pass=true', 'Recommended workflow:', 'Minimum next action:', 'Visible sentence:', 'Bootstrap policy: injectsFullSkill=false; session_create=false; skill_execution_claimed=false', 'Gap binding: provided=true', 'Boundary: writes=false; progressive_entry_ux_artifact=false; command_execution=false; skill_execution=false; workflow_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', 'Entry UX digest:'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'workflow --entry-ux text output');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'workflow', '--entry-ux', '--prompt', 'implement-next-stage'], ['--root', target], READ_ONLY_RUNTIME_CONTROL_FLAGS_WITH_DRY_RUN_SECOND, 'workflow read-only modes do not accept execution', options);
+    runProgressiveEntryUxUnsupportedCases(run, { target, gapFile }, options);
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}
+
+export function runExecutablePlanSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-executable-plan-contract';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+  const planFile = path.join(target, 'stage117-plan.md');
+  const weakPlanFile = path.join(target, 'weak-plan.md');
+  const absolutePlanFile = path.join(repoRoot, planFile);
+  const absoluteWeakPlanFile = path.join(repoRoot, weakPlanFile);
+
+  try {
+    fs.writeFileSync(absolutePlanFile, `# Stage 117 executable plan fixture
+
+## Stage 117 boundary
+
+- Stage 117: Implement executable plan contract in tools/vibe-runtime/runtime-executable-plan-contract.mjs and tools/vibe-runtime/index.mjs.
+- Update docs/runtime-roadmap.md and tools/vibe-runtime/README.md with Stage 117 docs expectations.
+- Validate tools/vibe-runtime-check/index.mjs and tools/vibe-release-check/index.mjs marker expectations.
+- Stop if runtime-check fails or plan_quality_score is below threshold.
+- Rollback / stop conditions: stop if command would write outside .tmp or if any git push/PR/merge is required.
+
+Expected output marker: Result: PASS
+Expected output marker: executable_plan_contract
+
+Verification commands:
+- node --check tools/vibe-runtime/runtime-executable-plan-contract.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 117 可执行计划质量合同
+`, 'utf8');
+    fs.writeFileSync(absoluteWeakPlanFile, `# weak plan\n\n- TODO later\n`, 'utf8');
+
+    const executable = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'planner', '--executable-plan', '--from-file', planFile, '--json', '--root', repoRoot], {}, options), 'planner --executable-plan --json');
+    assertJsonMarkers(readonlySmokeMarkers(executable, 'executablePlan'), 'planner --executable-plan --json');
+    if (!executable.executable_plan_contract?.executable_plan_digest) throw new Error('executable plan missing executable_plan_digest');
+    if (!executable.executable_plan_contract?.task_readiness?.some((item) => item.readiness_status === 'ready_for_runbook')) throw new Error('executable plan missing ready_for_runbook task readiness');
+    if (!executable.executable_plan_contract?.task_quality_contract?.per_task_gates?.every((item) => item.pass === true && item.execution_authorized === false && item.auto_repair === false)) throw new Error('executable plan task quality gates must pass without execution or auto repair');
+    if (!executable.executable_plan_contract?.task_readiness?.every((item) => item.files_to_change?.length > 0 && item.verification_commands?.length > 0 && item.expected_output_markers?.length > 0 && item.stop_conditions?.length > 0)) throw new Error('executable plan task readiness must bind files, verification, output markers, and stop conditions per task');
+    if (!executable.executable_plan_contract?.requirement_checks?.every((item) => item.execution_authorized === false)) throw new Error('executable plan requirement checks must keep execution_authorized=false');
+    assertNoSmokeState(repoRoot, target, 'planner --executable-plan JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'planner', '--executable-plan', '--from-file', planFile, '--root', repoRoot], {
+      expectOutput: ['Vibecoding Runtime Executable Plan Quality Contract', 'Stage: Stage 117; Kind: executable-plan-quality-contract; pass=true', 'Plan quality score: 100/80; pass=true', 'Task quality: pass=true; per_task_gates=', 'Failure mode: blocking_gaps_only=true; auto_repair=false; plan_mutation=false', 'Tasks:', 'Boundary: writes=false; executable_plan_artifact=false; plan_repair_artifact=false; source_write=false; sidecar_write=false; state_directory_created=false; command_execution=false; check_execution=false; test_execution=false; repair_execution=false; action_item_execution=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', 'Executable plan digest:'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'planner --executable-plan text output');
+
+    const weak = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'planner', '--executable-plan', '--from-file', weakPlanFile, '--json', '--root', repoRoot], {}, options), 'planner --executable-plan weak --json');
+    if (weak.executable_plan_contract?.plan_quality_pass !== false) throw new Error('weak executable plan should not pass quality gate');
+    if (weak.executable_plan_contract?.task_quality_contract?.pass !== false) throw new Error('weak executable plan should fail task quality contract');
+    if (weak.executable_plan_contract?.task_quality_contract?.blocking_gaps_only !== true) throw new Error('weak executable plan should only expose blocking gaps');
+    if (weak.executable_plan_contract?.task_quality_contract?.auto_repair !== false) throw new Error('weak executable plan must not auto repair');
+    if (weak.executable_plan_contract?.failure_mode?.plan_mutation !== false) throw new Error('weak executable plan failure mode must not mutate plan');
+    if (!weak.executable_plan_contract?.missing_requirements?.includes('exact_file_paths')) throw new Error('weak executable plan should report exact_file_paths gap');
+    if (!weak.executable_plan_contract?.blocked_reasons?.some((item) => item.includes('missing exact file paths'))) throw new Error('weak executable plan should report blocked reason');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'planner', '--executable-plan', '--from-file', planFile], ['--root', repoRoot], READ_ONLY_RUNTIME_CONTROL_FLAGS_WITH_DRY_RUN_SECOND, 'planner --executable-plan is read-only', options);
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'planner', '--executable-plan', '--root', repoRoot], {
+      allowFailure: true,
+      expectOutput: ['planner --executable-plan requires --from-file <local-plan-file>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'planner', '--executable-plan', '--from-file', planFile, '--intent', 'implementation', '--root', repoRoot], {
+      allowFailure: true,
+      expectOutput: ['--intent is only supported by planner --action-manifest'],
+    }, options);
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}
+
+export function runStageRunbookSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-stage-runbook';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+  const planFile = path.join(target, 'stage118-plan.md');
+  const weakPlanFile = path.join(target, 'weak-runbook-plan.md');
+  const executablePlanFile = path.join(target, 'stage117-executable-plan.json');
+  const absolutePlanFile = path.join(repoRoot, planFile);
+  const absoluteWeakPlanFile = path.join(repoRoot, weakPlanFile);
+  const absoluteExecutablePlanFile = path.join(repoRoot, executablePlanFile);
+
+  try {
+    fs.writeFileSync(absolutePlanFile, `# Stage 118 sequential stage runbook fixture
+
+## Stage 118 boundary
+
+- Stage 118: Implement sequential stage runbook in tools/vibe-runtime/runtime-sequential-stage-runbook.mjs and tools/vibe-runtime/index.mjs.
+- Update docs/runtime-roadmap.md and tools/vibe-runtime/README.md with Stage 118 docs expectations.
+- Validate tools/vibe-runtime-check/index.mjs and tools/vibe-release-check/index.mjs marker expectations.
+- Stop if runtime-check fails or if the runbook would execute commands automatically.
+- Rollback / stop conditions: stop if command would write outside .tmp or if any git push/PR/merge is required.
+
+Expected output marker: Result: PASS
+Expected output marker: sequential_stage_runbook
+
+Verification commands:
+- node --check tools/vibe-runtime/runtime-sequential-stage-runbook.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 118 顺序阶段运行手册合同
+`, 'utf8');
+    fs.writeFileSync(absoluteWeakPlanFile, `# weak runbook plan\n\n- TODO later\n`, 'utf8');
+
+    const executable = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'planner', '--executable-plan', '--from-file', planFile, '--json', '--root', repoRoot], {}, options), 'planner --executable-plan fixture --json');
+    fs.writeFileSync(absoluteExecutablePlanFile, `${JSON.stringify(executable, null, 2)}\n`, 'utf8');
+
+    const runbook = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'automation', '--stage-runbook', '--from-plan', planFile, '--from-executable-plan', executablePlanFile, '--json', '--root', repoRoot], {}, options), 'automation --stage-runbook --json');
+    assertJsonMarkers(readonlySmokeMarkers(runbook, 'stageRunbook'), 'automation --stage-runbook --json');
+    if (!runbook.sequential_stage_runbook?.stage_runbook_digest) throw new Error('stage runbook missing stage_runbook_digest');
+    if (!runbook.sequential_stage_runbook?.source_bindings?.executable_plan_digest) throw new Error('stage runbook missing executable plan digest binding');
+    if (!runbook.sequential_stage_runbook?.source_bindings?.registry_digest) throw new Error('stage runbook missing registry digest binding');
+    if (!runbook.sequential_stage_runbook?.stage_sequence?.some((item) => item.execution_authorized === false && item.actions_executed === false && item.command_execution_authorized === false && item.git_write_authorized === false)) throw new Error('stage runbook stage items must keep execution_authorized/actions_executed=false');
+    if (!runbook.sequential_stage_runbook?.stage_order_gate?.per_stage_gates?.every((item) => item.input_required?.length > 0 && item.commit_condition?.commit_execution_authorized === false && item.execution_authorized === false && item.command_execution_authorized === false && item.git_write_authorized === false && Array.isArray(item.mutex_conflicts))) throw new Error('stage runbook order gates must bind inputs, commit conditions, mutex conflicts, and no execution authorization');
+    if (!runbook.sequential_stage_runbook?.stage_order_gate?.per_stage_gates?.some((item) => item.dependency_gate === 'previous_stage_must_pass_evidence_and_commit_readiness')) throw new Error('stage runbook order gate missing previous-stage dependency gate');
+    assertNoSmokeState(repoRoot, target, 'automation --stage-runbook JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'automation', '--stage-runbook', '--from-plan', planFile, '--from-executable-plan', executablePlanFile, '--root', repoRoot], {
+      expectOutput: ['Vibecoding Runtime Sequential Stage Runbook', 'Stage: Stage 118; Kind: sequential-stage-runbook; pass=true', 'Stages:', 'ready_for_evidence_binding=true', 'Stage order gate: pass=true; per_stage_gates=', 'auto_execution=false; command_execution=false; git_write=false', 'Execution order:', 'Evidence required:', 'Boundary: writes=false; stage_runbook_artifact=false; runbook_artifact=false; source_write=false; plan_mutation=false; sidecar_write=false; state_directory_created=false; command_execution=false; check_execution=false; test_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', 'Stage runbook digest:'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'automation --stage-runbook text output');
+
+    const weak = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'automation', '--stage-runbook', '--from-plan', weakPlanFile, '--json', '--root', repoRoot], {}, options), 'automation --stage-runbook weak --json');
+    if (weak.sequential_stage_runbook?.ready_for_evidence_binding !== false) throw new Error('weak stage runbook should not be ready for evidence binding');
+    if (weak.sequential_stage_runbook?.stage_order_gate?.pass !== false) throw new Error('weak stage runbook should fail stage_order_gate');
+    if (weak.sequential_stage_runbook?.stage_order_gate?.auto_execution !== false) throw new Error('weak stage runbook must not authorize auto execution');
+    if (!weak.sequential_stage_runbook?.blocked_reasons?.includes('missing stage_sequence')) throw new Error('weak stage runbook should report missing stage_sequence');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'automation', '--stage-runbook', '--from-plan', planFile], ['--root', repoRoot], READ_ONLY_RUNTIME_CONTROL_FLAGS_WITH_DRY_RUN_SECOND, 'automation --stage-runbook is read-only', options);
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'automation', '--stage-runbook', '--root', repoRoot], {
+      allowFailure: true,
+      expectOutput: ['automation --stage-runbook requires --from-plan <local-plan-file>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'automation', '--readiness', '--from-executable-plan', executablePlanFile, '--root', repoRoot], {
+      allowFailure: true,
+      expectOutput: ['automation --readiness does not accept workflow'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'automation', '--one-shot-plan', '--from-file', planFile, '--subject', 'feat(runtime): stage 118 fixture', '--confirm-plan', 'CONFIRM_PLAN_ONLY', '--from-executable-plan', executablePlanFile, '--root', repoRoot], {
+      allowFailure: true,
+      expectOutput: ['automation --one-shot-plan only accepts one local plan file'],
+    }, options);
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}
+
+export function releaseCheckStage103118SmokeHandlers(deps) {
+  return {
+    runAutomationReadinessSmoke: (options) => runAutomationReadinessSmoke(deps, options),
+    runWorkflowLoopContractSmoke: (options) => runWorkflowLoopContractSmoke(deps, options),
+    runPlanActionManifestSmoke: (options) => runPlanActionManifestSmoke(deps, options),
+    runSelfTestProfileSmoke: (options) => runSelfTestProfileSmoke(deps, options),
+    runCommitReadinessSmoke: (options) => runCommitReadinessSmoke(deps, options),
+    runConfirmedOneShotPlanSmoke: (options) => runConfirmedOneShotPlanSmoke(deps, options),
+    runCloseLoopDashboardSmoke: (options) => runCloseLoopDashboardSmoke(deps, options),
+    runEvidenceIntakeSmoke: (options) => runEvidenceIntakeSmoke(deps, options),
+    runDiffCoverageSmoke: (options) => runDiffCoverageSmoke(deps, options),
+    runReviewEnvelopeSmoke: (options) => runReviewEnvelopeSmoke(deps, options),
+    runTddTraceSmoke: (options) => runTddTraceSmoke(deps, options),
+    runHumanFriendlyAliasSmoke: (options) => runHumanFriendlyAliasSmoke(deps, options),
+    runSuperpowersGapSmoke: (options) => runSuperpowersGapSmoke(deps, options),
+    runProgressiveEntryUxSmoke: (options) => runProgressiveEntryUxSmoke(deps, options),
+    runExecutablePlanSmoke: (options) => runExecutablePlanSmoke(deps, options),
+    runStageRunbookSmoke: (options) => runStageRunbookSmoke(deps, options),
+  };
+}