@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-release-check/release-check-stage121-136-smoke.mjs

@@ -0,0 +1,917 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import {
+  READ_ONLY_RUNTIME_CONTROL_FLAGS_WITH_PREVIEW,
+  assertNoSmokeState,
+  cleanupSmokeTmpRoot,
+  prepareSmokeTmpRoot,
+  readonlySmokeMarkers,
+  runForbiddenFlagChecks,
+  writeSmokeJsonFixture,
+} from './release-check-json-assertion-helpers.mjs';
+import {
+  PLATFORM_ENTRY_ACCEPTANCE_FORBIDDEN_FLAGS,
+  RUNTIME_READ_ONLY_FORBIDDEN_FLAGS,
+  stage119BlockedEvidenceFixture,
+  stage126SessionEvidenceFixture,
+  stage127ConsoleFrictionFixture,
+  stage127RunbookFixture,
+  stage128TokenFrictionFixture,
+  stage129FrictionFixture,
+  stage129LearningEvidenceFixture,
+  stage131TranscriptFixture,
+  stage27InstalledMultiroundUxTranscriptFixture,
+  stage132ConsoleFixture,
+  stage132FrictionFixture,
+  stage132LearningPatternFixture,
+  stage132TokenBudgetFixture,
+  stage134BadSessionStartFixture,
+  stage134ClaudeSessionStartFixture,
+  stage134CodexSessionStartFixture,
+  stage134CursorSdkSessionStartFixture,
+  stage134CursorSessionStartFixture,
+  stage134FullSkillInjectionSessionStartFixture,
+  stage134HiddenExecutionSessionStartFixture,
+  stage134MissingSemanticFieldsSessionStartFixture,
+  stage135BadTranscriptFixture,
+  stage135GoodTranscriptFixture,
+  stringifySmokeFixture,
+} from './release-check-stage121-136-fixtures.mjs';
+
+import { runBehavioralEvaluationContractSmoke } from './release-check-behavior-smoke.mjs';
+
+export { runBehavioralEvaluationContractSmoke };
+
+export function runSuperpowersRegressionGuardSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const unexpectedState = path.join(repoRoot, '.vibecoding-state');
+
+  const guardEnvelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-regression-guard', '--from-superpowers', 'fork/superpowers', '--json', '--root', '.'], {}, options), 'governance --superpowers-regression-guard --json');
+  const guard = guardEnvelope.superpowers_regression_guard || {};
+  assertJsonMarkers(readonlySmokeMarkers(guardEnvelope, 'superpowersRegressionGuard'), 'governance --superpowers-regression-guard --json');
+  if (!guard.regression_guard_digest) throw new Error('Superpowers regression guard missing regression_guard_digest');
+  if (!guard.source_bindings?.gap_matrix_digest || !guard.source_bindings?.registry_digest || !guard.source_bindings?.automation_readiness_digest || !guard.source_bindings?.traceability_digest) throw new Error('Superpowers regression guard missing source binding digest');
+  if (guard.protected_stage_sequence?.length !== 10) throw new Error('Superpowers regression guard protected stage sequence count mismatch');
+  for (const stage of ['Stage 115', 'Stage 116', 'Stage 117', 'Stage 118', 'Stage 119', 'Stage 120', 'Stage 121', 'Stage 122', 'Stage 123', 'Stage 124']) {
+    if (!guard.protected_stage_sequence?.includes(stage)) throw new Error(`Superpowers regression guard missing protected stage: ${stage}`);
+  }
+  for (const command of ['governance --superpowers-gap', 'workflow --entry-ux', 'planner --executable-plan', 'automation --stage-runbook', 'verification --execution-evidence', 'release --staged-commit-readiness', 'evals --behavior-contract', 'platforms --bootstrap-matrix', 'governance --traceability-map', 'completion --evidence-bundle']) {
+    const row = guard.protected_capabilities?.find((item) => item.command === command);
+    if (!row || row.pass !== true) throw new Error(`Superpowers regression guard protected capability failed: ${command}`);
+  }
+  if (guard.dimension_scorecard?.length !== 10) throw new Error('Superpowers regression guard dimension scorecard count mismatch');
+  if (!guard.dimension_scorecard?.every((row) => row.status === 'guarded')) throw new Error('Superpowers regression guard dimension scorecard must be guarded');
+  if (!guard.regression_gates?.every((gate) => gate.pass === true)) throw new Error('Superpowers regression guard gates must pass');
+  if (guard.blockers?.length !== 0) throw new Error('Superpowers regression guard should not have blockers');
+  if (fs.existsSync(unexpectedState)) throw new Error('governance --superpowers-regression-guard JSON output created unexpected state directory');
+
+  run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-regression-guard', '--from-superpowers', 'fork/superpowers', '--root', '.'], {
+    expectOutput: ['Vibecoding Runtime Superpowers Regression Guard', 'Stage: Stage 125; Guard: superpowers-regression-guard; pass=true', 'Claim: guarded-superiority; Target: fork/superpowers', 'Registry: Stage 101; version=47', '- stage_115_gap_baseline_gate: pass=true', '- registry_inventory_regression_gate: pass=true', '- automation_readiness_regression_gate: pass=true', '- skill_runtime_traceability_regression_gate: pass=true', '- superiority_dimension_scorecard_gate: pass=true', 'Protected capabilities:', 'Dimension scorecard:', 'Boundary: writes=false; superpowers_regression_guard_artifact=false; superpowers_gap_artifact=false; traceability_map_artifact=false; automation_readiness_artifact=false; command_execution=false; check_execution=false; test_execution=false; git=false; git_write=false; pr=false; push=false; merge=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; business_source_write=false', 'Regression guard digest:', 'Manual next action:'],
+  }, options);
+  if (fs.existsSync(unexpectedState)) throw new Error('governance --superpowers-regression-guard text output created unexpected state directory');
+
+  runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-regression-guard', '--from-superpowers', 'fork/superpowers'], ['--root', '.'], RUNTIME_READ_ONLY_FORBIDDEN_FLAGS, 'governance --superpowers-regression-guard is read-only', options);
+
+  run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-regression-guard', '--root', '.'], {
+    allowFailure: true,
+    expectOutput: ['governance --superpowers-regression-guard requires --from-superpowers'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-regression-guard', '--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-regression-guard', '--from-superpowers', 'missing-superpowers', '--root', '.'], {
+    allowFailure: true,
+    expectOutput: ['governance --superpowers-gap --from-superpowers directory not found'],
+  }, options);
+}
+
+function experienceFrictionUnsupportedCases({ target, evidenceFile }) {
+  return [
+    {
+      args: ['tools/vibe-runtime/index.mjs', 'governance', '--experience-friction', '--root', target],
+      expected: 'governance --experience-friction requires --from-file',
+    },
+    {
+      args: ['tools/vibe-runtime/index.mjs', 'governance', '--experience-friction', '--from-file', '../outside.json', '--root', target],
+      expected: 'governance --experience-friction --from-file must stay within --root',
+    },
+    {
+      args: ['tools/vibe-runtime/index.mjs', 'governance', '--experience-friction', '--from-file', evidenceFile, '--from-superpowers', 'fork/superpowers', '--root', target],
+      expected: '--from-superpowers is only supported by governance --superpowers-gap, governance --superpowers-comparison, or governance --superpowers-regression-guard',
+    },
+  ];
+}
+
+function runExperienceFrictionUnsupportedCases(run, context, options) {
+  for (const { args, expected } of experienceFrictionUnsupportedCases(context)) {
+    run('node', args, {
+      allowFailure: true,
+      expectOutput: [expected],
+    }, options);
+  }
+}
+
+export function runExperienceFrictionSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-experience-friction';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+  const evidenceFile = path.join(target, 'stage126-session-evidence.json');
+
+  try {
+    writeSmokeJsonFixture(repoRoot, evidenceFile, stage126SessionEvidenceFixture());
+
+    const friction = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--experience-friction', '--from-file', evidenceFile, '--json', '--root', target], {}, options), 'governance --experience-friction --json');
+    assertJsonMarkers(readonlySmokeMarkers(friction, 'experienceFriction'), 'governance --experience-friction --json');
+    if (!friction.experience_friction_matrix?.friction_digest) throw new Error('experience friction matrix missing friction_digest');
+    if (friction.experience_friction_matrix?.dimensions?.length !== 8) throw new Error('experience friction dimension count mismatch');
+    if (!friction.experience_friction_matrix?.priority_fixes?.some((fix) => fix.recommended_stage === 'Stage 127')) throw new Error('experience friction missing Stage 127 priority fix');
+    if (!friction.experience_friction_matrix?.priority_fixes?.some((fix) => fix.recommended_stage === 'Stage 128')) throw new Error('experience friction missing Stage 128 token priority fix');
+    if (!friction.experience_friction_matrix?.recommended_stage_sequence?.includes('Stage 130')) throw new Error('experience friction missing Stage 130 stage sequence');
+    if (friction.experience_friction_matrix?.friction_score <= 0) throw new Error('experience friction score should be positive');
+    assertNoSmokeState(repoRoot, target, 'governance --experience-friction JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--experience-friction', '--from-file', evidenceFile, '--root', target], {
+      expectOutput: ['Vibecoding Runtime Experience Friction Matrix', 'Stage: Stage 126; Kind: experience-friction-matrix; pass=true', 'Friction score:', '- entry_confusion:', '- next_action_unclear:', 'Priority fixes:', 'Recommended stage sequence:', 'Boundary: writes=false; experience_friction_artifact=false; command_execution=false; check_execution=false; test_execution=false; workflow_execution=false; skill_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', 'Experience friction digest:', 'Manual next action:'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'governance --experience-friction text output');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'governance', '--experience-friction', '--from-file', evidenceFile], ['--root', target], RUNTIME_READ_ONLY_FORBIDDEN_FLAGS, 'governance --experience-friction is read-only', options);
+
+    runExperienceFrictionUnsupportedCases(run, { target, evidenceFile }, options);
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}
+
+function nextActionConsoleFixtures({ frictionFile, runbookFile, evidenceFile }) {
+  return [
+    [frictionFile, stage127ConsoleFrictionFixture()],
+    [runbookFile, stage127RunbookFixture()],
+    [evidenceFile, stage119BlockedEvidenceFixture()],
+  ];
+}
+
+function nextActionConsoleUnsupportedCases({ target, frictionFile }) {
+  return [
+    {
+      args: ['tools/vibe-runtime/index.mjs', 'workflow', '--next-action-console', '--root', target],
+      expected: 'workflow --next-action-console requires --from-friction',
+    },
+    {
+      args: ['tools/vibe-runtime/index.mjs', 'workflow', '--next-action-console', '--from-friction', '../outside.json', '--root', target],
+      expected: 'workflow --next-action-console --from-friction must stay within --root',
+    },
+    {
+      args: ['tools/vibe-runtime/index.mjs', 'workflow', '--next-action-console', '--from-friction', frictionFile, '--from-file', frictionFile, '--root', target],
+      expected: 'workflow --next-action-console only accepts --from-friction',
+    },
+  ];
+}
+
+function runNextActionConsoleUnsupportedCases(run, context, options) {
+  for (const { args, expected } of nextActionConsoleUnsupportedCases(context)) {
+    run('node', args, {
+      allowFailure: true,
+      expectOutput: [expected],
+    }, options);
+  }
+}
+
+export function runNextActionConsoleSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-next-action-console';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+  const frictionFile = path.join(target, 'stage126-friction.json');
+  const runbookFile = path.join(target, 'stage118-runbook.json');
+  const evidenceFile = path.join(target, 'stage119-evidence.json');
+
+  try {
+    for (const [file, fixture] of nextActionConsoleFixtures({ frictionFile, runbookFile, evidenceFile })) {
+      writeSmokeJsonFixture(repoRoot, file, fixture);
+    }
+
+    const consoleEnvelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--next-action-console', '--from-friction', frictionFile, '--from-runbook', runbookFile, '--from-evidence', evidenceFile, '--json', '--root', target], {}, options), 'workflow --next-action-console --json');
+    assertJsonMarkers(readonlySmokeMarkers(consoleEnvelope, 'nextActionConsole'), 'workflow --next-action-console --json');
+    if (!consoleEnvelope.next_action_console?.console_digest) throw new Error('next action console missing console_digest');
+    if (!consoleEnvelope.next_action_console?.copy_ready_command_preview?.some((item) => item.id === 'refresh-console' && item.preview_only === true)) throw new Error('next action console missing refresh-console preview');
+    if (!consoleEnvelope.next_action_console?.evidence_needed_next?.some((item) => item.id === 'local-validation-evidence')) throw new Error('next action console missing local validation evidence need');
+    if (!consoleEnvelope.next_action_console?.do_not_do_yet?.some((item) => item.includes('git add'))) throw new Error('next action console missing git non-action boundary');
+    assertNoSmokeState(repoRoot, target, 'workflow --next-action-console JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--next-action-console', '--from-friction', frictionFile, '--root', target], {
+      expectOutput: ['Vibecoding Runtime One-screen Next Action Console', 'Stage: Stage 127; Kind: one-screen-next-action-console; pass=true', 'Current position:', 'Recommended next action:', 'Copy-ready command preview:', 'Evidence needed next:', 'Do not do yet:', 'Boundary: writes=false; next_action_console_artifact=false; command_execution=false; check_execution=false; test_execution=false; workflow_execution=false; skill_execution=false; runtime_action=false; evidence_write=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', 'Next action console digest:'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'workflow --next-action-console text output');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'workflow', '--next-action-console', '--from-friction', frictionFile], ['--root', target], RUNTIME_READ_ONLY_FORBIDDEN_FLAGS, 'workflow read-only modes do not accept execution', options);
+
+    runNextActionConsoleUnsupportedCases(run, { target, frictionFile }, options);
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}
+
+export function runTokenSaviorBudgetSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-token-savior-budget';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+  const frictionFile = path.join(target, 'stage126-friction.json');
+
+  try {
+    writeSmokeJsonFixture(repoRoot, frictionFile, stage128TokenFrictionFixture());
+
+    const budget = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--savior-budget', '--prompt', 'next-entry-with-token-pain', '--from-friction', frictionFile, '--json', '--root', target], {}, options), 'tokens --savior-budget --json');
+    assertJsonMarkers(readonlySmokeMarkers(budget, 'tokenSaviorBudget'), 'tokens --savior-budget --json');
+    if (!budget.token_savior_budget?.budget_digest) throw new Error('token savior budget missing budget_digest');
+    if (!budget.token_savior_budget?.skills_to_surface?.some((item) => item.skill === 'using-vibecoding')) throw new Error('token savior budget missing using-vibecoding surface skill');
+    if (!budget.token_savior_budget?.skills_to_defer?.some((item) => item.skill === 'vibe-writing-skills')) throw new Error('token savior budget missing deferred skill list');
+    if (!budget.token_savior_budget?.commands_to_surface?.every((item) => item.preview_only === true && item.execute === false)) throw new Error('token savior budget commands must be preview-only');
+    assertNoSmokeState(repoRoot, target, 'tokens --savior-budget JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--savior-budget', '--prompt', 'release-review-needs-broader-context', '--root', target], {
+      expectOutput: ['Vibecoding Runtime Token Savior Entry Budget', 'Stage: Stage 128; Kind: token-savior-entry-budget-contract; pass=true', 'Recommended profile:', 'Skills to surface:', 'Skills to defer:', 'Commands to surface:', 'Token saving reasoning:', 'Boundary: writes=false; token_savior_budget_artifact=false; command_execution=false; workflow_execution=false; skill_execution=false; runtime_action=false; dynamic_tool_execution=false; embeddings=false; remote_config=false; shell_interception=false; command_mutation=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', 'Token savior budget digest:'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'tokens --savior-budget text output');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'tokens', '--savior-budget', '--prompt', 'next-entry'], ['--root', target], RUNTIME_READ_ONLY_FORBIDDEN_FLAGS, 'tokens --savior-budget is read-only', options);
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--savior-budget', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['tokens --savior-budget requires --prompt <text>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--savior-budget', '--prompt', 'next-entry', '--from-friction', '../outside.json', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['tokens --savior-budget --from-friction must stay within --root'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--advice', '--prompt', 'next-entry', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['--prompt is only supported by tokens --savior-budget'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--experience-friction', '--from-friction', frictionFile, '--root', target], {
+      allowFailure: true,
+      expectOutput: ['--from-friction, --from-console, --from-token-budget, and --from-learning-pattern are only supported by governance --experience-dashboard'],
+    }, options);
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}
+
+export function runAdapterEntryAcceptanceSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-adapter-entry-acceptance';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+  const transcriptFile = path.join(target, 'stage131-transcript.json');
+
+  try {
+    writeSmokeJsonFixture(repoRoot, transcriptFile, stage131TranscriptFixture());
+
+    const acceptance = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--entry-acceptance', '--from-file', transcriptFile, '--adapter', 'cursor', '--json', '--root', target], {}, options), 'platforms --entry-acceptance --json');
+    assertJsonMarkers(readonlySmokeMarkers(acceptance, 'adapterEntryAcceptance'), 'platforms --entry-acceptance --json');
+    if (!acceptance.adapter_entry_acceptance?.acceptance_digest) throw new Error('adapter entry acceptance missing acceptance_digest');
+    for (const gateName of ['using_vibecoding_first', 'lightweight_routing', 'visible_next_step', 'no_auto_execution', 'workflow_explained']) {
+      const gate = acceptance.adapter_entry_acceptance?.gate_results?.find((item) => item.gate === gateName);
+      if (!gate?.pass) throw new Error(`adapter entry acceptance gate did not pass: ${gateName}`);
+    }
+    assertNoSmokeState(repoRoot, target, 'platforms --entry-acceptance JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--entry-acceptance', '--from-file', transcriptFile, '--adapter', 'cursor', '--root', target], {
+      expectOutput: ['Vibecoding Runtime Platform Capability', 'Mode: adapter-entry-acceptance-contract', 'Stage: Stage 131; Acceptance: adapter-entry-acceptance-contract; accepted=true', 'Adapter: cursor; Score: 100; Digest:', 'using_vibecoding_first: pass=true', 'lightweight_routing: pass=true', 'visible_next_step: pass=true', 'no_auto_execution: pass=true', 'workflow_explained: pass=true'],
+    }, options);
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'platforms', '--entry-acceptance', '--from-file', transcriptFile], ['--root', target], PLATFORM_ENTRY_ACCEPTANCE_FORBIDDEN_FLAGS, 'platforms --entry-acceptance is read-only', options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--entry-acceptance', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['platforms --entry-acceptance requires --from-file <local-adapter-transcript-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--entry-acceptance', '--from-file', transcriptFile, '--adapter', 'unknown', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['--adapter must be claude, cursor, or codex'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--entry-acceptance', '--from-file', '../outside.json', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['adapter entry transcript must be inside root'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--savior-budget', '--prompt', 'entry check', '--from-file', transcriptFile, '--root', target], {
+      allowFailure: true,
+      expectOutput: ['Unknown argument'],
+    }, options);
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}
+
+export function runInstalledMultiroundUxSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-installed-multiround-ux';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+  const transcriptFile = path.join(target, 'stage27-installed-multiround.json');
+  const hiddenExecutionFile = path.join(target, 'stage27-hidden-execution.json');
+  const missingCloseoutFile = path.join(target, 'stage27-missing-closeout.json');
+  const ignoredReviewBlockerFile = path.join(target, 'stage27-ignored-review-blocker.json');
+
+  try {
+    writeSmokeJsonFixture(repoRoot, transcriptFile, stage27InstalledMultiroundUxTranscriptFixture());
+    writeSmokeJsonFixture(repoRoot, hiddenExecutionFile, stage27InstalledMultiroundUxTranscriptFixture({ unsafe: 'hidden-execution' }));
+    writeSmokeJsonFixture(repoRoot, missingCloseoutFile, stage27InstalledMultiroundUxTranscriptFixture({ unsafe: 'missing-closeout-evidence' }));
+    writeSmokeJsonFixture(repoRoot, ignoredReviewBlockerFile, stage27InstalledMultiroundUxTranscriptFixture({ unsafe: 'ignored-review-blocker' }));
+
+    const acceptance = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--entry-acceptance', '--from-file', transcriptFile, '--adapter', 'cursor', '--json', '--root', target], {}, options), 'platforms --entry-acceptance installed multiround --json');
+    if (acceptance.mode !== 'adapter-entry-acceptance-contract') throw new Error('installed multi-round UX acceptance used the wrong envelope mode');
+    if (acceptance.safety?.adapter_execution !== false || acceptance.safety?.subagent !== false || acceptance.safety?.git_write !== false) throw new Error('installed multi-round UX acceptance boundary must stay read-only');
+    const installed = acceptance.adapter_entry_acceptance?.installed_multiround_ux_acceptance || {};
+    if (installed.stage !== 'Stage 27') throw new Error('installed multi-round UX acceptance missing Stage 27 marker');
+    if (installed.acceptance_kind !== 'installed-multiround-ux-close-loop-acceptance') throw new Error('installed multi-round UX acceptance kind mismatch');
+    if (installed.accepted !== true || acceptance.ok !== true) throw new Error('installed multi-round UX acceptance should pass');
+    for (const turn of ['first_turn', 'continue_task', 'bug_debug', 'completion_closeout', 'review_feedback']) {
+      if (installed.prompt_turn_coverage?.[turn] !== true) throw new Error(`installed multi-round UX missing prompt turn ${turn}`);
+    }
+    for (const gateName of ['installed_multiround_prompt_coverage', 'visible_route_each_round', 'continue_task_plan_trace', 'bug_debug_reproduction_gate', 'completion_closeout_evidence_gate', 'review_feedback_gate_loop', 'session_continuity_close_loop', 'no_multiround_execution_claims']) {
+      const gate = installed.gate_results?.find((item) => item.gate === gateName);
+      if (!gate?.pass) throw new Error(`installed multi-round UX gate did not pass: ${gateName}`);
+    }
+    assertNoSmokeState(repoRoot, target, 'platforms --entry-acceptance installed multiround JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--entry-acceptance', '--from-file', transcriptFile, '--adapter', 'cursor', '--root', target], {
+      expectOutput: ['Stage: Stage 131; Acceptance: adapter-entry-acceptance-contract; accepted=true', 'Installed multi-round: stage=Stage 27; kind=installed-multiround-ux-close-loop-acceptance; accepted=true', 'installed_multiround_prompt_coverage: pass=true', 'completion_closeout_evidence_gate: pass=true', 'review_feedback_gate_loop: pass=true', 'session_continuity_close_loop: pass=true'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'platforms --entry-acceptance installed multiround text output');
+
+    const hiddenExecution = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--entry-acceptance', '--from-file', hiddenExecutionFile, '--adapter', 'cursor', '--json', '--root', target], {}, options), 'platforms --entry-acceptance installed multiround hidden execution --json');
+    if (hiddenExecution.ok !== false || !hiddenExecution.adapter_entry_acceptance?.blockers?.some((blocker) => blocker.includes('no_multiround_execution_claims'))) throw new Error('installed multi-round UX should reject hidden execution claims');
+    const missingCloseout = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--entry-acceptance', '--from-file', missingCloseoutFile, '--adapter', 'cursor', '--json', '--root', target], {}, options), 'platforms --entry-acceptance installed multiround missing closeout --json');
+    if (missingCloseout.ok !== false || !missingCloseout.adapter_entry_acceptance?.blockers?.some((blocker) => blocker.includes('completion_closeout_evidence_gate'))) throw new Error('installed multi-round UX should reject missing closeout evidence');
+    const ignoredReviewBlocker = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--entry-acceptance', '--from-file', ignoredReviewBlockerFile, '--adapter', 'cursor', '--json', '--root', target], {}, options), 'platforms --entry-acceptance installed multiround ignored review blocker --json');
+    if (ignoredReviewBlocker.ok !== false || !ignoredReviewBlocker.adapter_entry_acceptance?.blockers?.some((blocker) => blocker.includes('review_feedback_gate_loop'))) throw new Error('installed multi-round UX should reject ignored review blocker');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'platforms', '--entry-acceptance', '--from-file', transcriptFile], ['--root', target], PLATFORM_ENTRY_ACCEPTANCE_FORBIDDEN_FLAGS, 'platforms --entry-acceptance is read-only', options);
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}
+
+function experienceRegressionDashboardFixtures({ frictionFile, consoleFile, tokenBudgetFile, learningPatternFile }) {
+  return [
+    [frictionFile, stage132FrictionFixture()],
+    [consoleFile, stage132ConsoleFixture()],
+    [tokenBudgetFile, stage132TokenBudgetFixture()],
+    [learningPatternFile, stage132LearningPatternFixture()],
+  ];
+}
+
+function experienceRegressionDashboardUnsupportedCases({ target, frictionFile, tokenBudgetFile }) {
+  return [
+    {
+      args: ['tools/vibe-runtime/index.mjs', 'governance', '--experience-dashboard', '--root', target],
+      expected: 'governance --experience-dashboard requires --from-friction <local-friction-json>',
+    },
+    {
+      args: ['tools/vibe-runtime/index.mjs', 'governance', '--experience-dashboard', '--from-friction', '../outside.json', '--root', target],
+      expected: 'governance --experience-dashboard --from-friction must stay within --root',
+    },
+    {
+      args: ['tools/vibe-runtime/index.mjs', 'governance', '--experience-dashboard', '--from-friction', frictionFile, '--from-file', frictionFile, '--root', target],
+      expected: 'governance --experience-dashboard only accepts --from-friction, optional --from-console, optional --from-token-budget, optional --from-learning-pattern, optional --intent, --json, and --root',
+    },
+    {
+      args: ['tools/vibe-runtime/index.mjs', 'tokens', '--savior-budget', '--prompt', 'entry-check', '--from-token-budget', tokenBudgetFile, '--root', target],
+      expected: '--from-token-budget is only supported by governance --experience-dashboard',
+    },
+  ];
+}
+
+function runExperienceRegressionDashboardUnsupportedCases(run, context, options) {
+  for (const { args, expected } of experienceRegressionDashboardUnsupportedCases(context)) {
+    run('node', args, {
+      allowFailure: true,
+      expectOutput: [expected],
+    }, options);
+  }
+}
+
+export function runExperienceRegressionDashboardSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-experience-regression-dashboard';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+  const frictionFile = path.join(target, 'stage126-friction.json');
+  const consoleFile = path.join(target, 'stage127-console.json');
+  const tokenBudgetFile = path.join(target, 'stage128-token-budget.json');
+  const learningPatternFile = path.join(target, 'stage129-learning-pattern.json');
+
+  try {
+    for (const [file, fixture] of experienceRegressionDashboardFixtures({ frictionFile, consoleFile, tokenBudgetFile, learningPatternFile })) {
+      writeSmokeJsonFixture(repoRoot, file, fixture);
+    }
+
+    const dashboard = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--experience-dashboard', '--from-friction', frictionFile, '--from-console', consoleFile, '--from-token-budget', tokenBudgetFile, '--from-learning-pattern', learningPatternFile, '--intent', 'implementation', '--json', '--root', target], {}, options), 'governance --experience-dashboard --json');
+    assertJsonMarkers(readonlySmokeMarkers(dashboard, 'experienceDashboard'), 'governance --experience-dashboard --json');
+    if (!dashboard.experience_regression_dashboard?.dashboard_digest) throw new Error('experience regression dashboard missing dashboard_digest');
+    if (!Array.isArray(dashboard.experience_regression_dashboard?.regression_blockers) || dashboard.experience_regression_dashboard.regression_blockers.length !== 0) throw new Error('experience regression dashboard expected no regression blockers in baseline fixture');
+    for (const section of ['experience_scorecard', 'superpowers_comparison_delta', 'token_savior_delta', 'learning_loop_delta', 'daily_user_friction_delta']) {
+      if (!dashboard.experience_regression_dashboard?.dashboard_sections?.includes(section)) throw new Error(`experience regression dashboard missing section ${section}`);
+    }
+    assertNoSmokeState(repoRoot, target, 'governance --experience-dashboard JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--experience-dashboard', '--from-friction', frictionFile, '--from-console', consoleFile, '--from-token-budget', tokenBudgetFile, '--from-learning-pattern', learningPatternFile, '--root', target], {
+      expectOutput: ['Vibecoding Runtime Experience Regression Dashboard', 'Stage: Stage 132; Kind: experience-regression-dashboard; pass=true', 'Score: 90; rating=strong', 'Superpowers delta: status=parity-protected', 'Token Savior delta: status=budget-bound; profile=tiny_entry', 'Learning loop delta: status=candidate-only; candidates=1; promotion_required=true', 'Daily friction delta: status=reduced', 'Next bet: experience-loop-ready', 'Boundary: writes=false; experience_dashboard_artifact=false; regression_dashboard_artifact=false; sidecar_write=false; state_directory_created=false; source_write=false; command_execution=false; check_execution=false; smoke_execution=false; test_execution=false; verification_execution=false; workflow_execution=false; skill_execution=false; runtime_action=false; auto_execution=false; evidence_write=false; dashboard_write=false; dynamic_tool_execution=false; embeddings=false; remote_config=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; git=false; git_write=false; git_add=false; commit=false; pr=false; push=false; merge=false; business_source_write=false', 'Dashboard digest:'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'governance --experience-dashboard text output');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'governance', '--experience-dashboard', '--from-friction', frictionFile], ['--root', target], RUNTIME_READ_ONLY_FORBIDDEN_FLAGS, 'governance --experience-dashboard is read-only and report-only', options);
+    runExperienceRegressionDashboardUnsupportedCases(run, { target, frictionFile, tokenBudgetFile }, options);
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}
+
+export function runSuperpowersComparisonSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const unexpectedState = path.join(repoRoot, '.vibecoding-state');
+
+  const comparisonEnvelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-comparison', '--from-superpowers-root', 'fork/superpowers', '--json', '--root', '.'], {}, options), 'governance --superpowers-comparison --json');
+  const matrix = comparisonEnvelope.superpowers_comparison_matrix || {};
+  assertJsonMarkers(readonlySmokeMarkers(comparisonEnvelope, 'superpowersComparison'), 'governance --superpowers-comparison --json');
+  if (!matrix.comparison_digest) throw new Error('Superpowers comparison matrix missing comparison_digest');
+  if (!matrix.source_bindings?.source_digest || !matrix.source_bindings?.superpowers_root_digest) throw new Error('Superpowers comparison matrix missing source binding digest');
+  if (matrix.dimensions?.length !== 10) throw new Error('Superpowers comparison matrix dimension count mismatch');
+  for (const dimensionId of ['session_start_bootstrap', 'skill_trigger_discipline', 'methodology_coverage', 'hook_shape_coverage', 'adapter_packaging', 'eval_and_test_harness', 'subagent_boundary', 'contributor_guardrails', 'token_and_context_economy', 'daily_user_friction']) {
+    if (!matrix.dimensions?.some((dimension) => dimension.id === dimensionId)) throw new Error(`Superpowers comparison matrix missing dimension: ${dimensionId}`);
+  }
+  if (!Array.isArray(matrix.parity_gaps)) throw new Error('Superpowers comparison matrix parity_gaps must be a list');
+  if (!matrix.vibecoding_advantages?.some((item) => item.includes('local deterministic runtime contracts'))) throw new Error('Superpowers comparison matrix missing Vibecoding deterministic advantage');
+  if (!matrix.borrowable_patterns?.some((item) => item.target_stage === 'Stage 134')) throw new Error('Superpowers comparison matrix missing Stage 134 borrowable pattern');
+  if (!matrix.do_not_copy?.some((item) => item.includes('Do not inject the full using-vibecoding skill'))) throw new Error('Superpowers comparison matrix missing full-skill do-not-copy boundary');
+  if (!matrix.recommended_stage_sequence?.includes('Stage 140')) throw new Error('Superpowers comparison matrix missing Stage 140 recommendation');
+  if (!matrix.next_comparison_bet?.target_stage) throw new Error('Superpowers comparison matrix missing next comparison bet');
+  if (fs.existsSync(unexpectedState)) throw new Error('governance --superpowers-comparison JSON output created unexpected state directory');
+
+  run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-comparison', '--from-superpowers-root', 'fork/superpowers', '--root', '.'], {
+    expectOutput: ['Vibecoding Runtime Superpowers Comparative Evidence Matrix', 'Stage: Stage 133; Kind: superpowers-comparative-evidence-matrix; pass=true', 'Target: fork/superpowers; root=fork/superpowers', '- session_start_bootstrap:', '- skill_trigger_discipline:', '- daily_user_friction:', 'Parity gaps:', 'Vibecoding advantages:', 'Borrowable patterns:', 'Do not copy:', 'Recommended stage sequence:', 'Next comparison bet:', 'Boundary: writes=false; superpowers_comparison_artifact=false; comparison_matrix_artifact=false; source_write=false; sidecar_write=false; state_directory_created=false; command_execution=false; check_execution=false; smoke_execution=false; test_execution=false; verification_execution=false; hook_execution=false; workflow_execution=false; skill_execution=false; runtime_action=false; auto_execution=false; repair_execution=false; prompt_mutation=false; hook_registration=false; dynamic_tool_execution=false; embeddings=false; remote_config=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; git=false; git_write=false; git_add=false; commit=false; pr=false; push=false; merge=false; business_source_write=false', 'Superpowers comparison digest:'],
+  }, options);
+  if (fs.existsSync(unexpectedState)) throw new Error('governance --superpowers-comparison text output created unexpected state directory');
+
+  const compatibilityEnvelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-comparison', '--from-superpowers', 'fork/superpowers', '--json', '--root', '.'], {}, options), 'governance --superpowers-comparison --from-superpowers --json');
+  if (compatibilityEnvelope.superpowers_comparison_matrix?.stage !== 'Stage 133') throw new Error('governance --superpowers-comparison should accept --from-superpowers compatibility input');
+
+  runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-comparison', '--from-superpowers-root', 'fork/superpowers'], ['--root', '.'], RUNTIME_READ_ONLY_FORBIDDEN_FLAGS, 'governance --superpowers-comparison is read-only and report-only', options);
+
+  run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-comparison', '--root', '.'], {
+    allowFailure: true,
+    expectOutput: ['governance --superpowers-comparison requires --from-superpowers-root <local-superpowers-root>'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-comparison', '--from-superpowers-root', '../superpowers', '--root', '.'], {
+    allowFailure: true,
+    expectOutput: ['governance --superpowers-comparison --from-superpowers-root must stay within --root'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-comparison', '--from-superpowers-root', 'missing-superpowers', '--root', '.'], {
+    allowFailure: true,
+    expectOutput: ['governance --superpowers-comparison --from-superpowers-root directory not found'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-comparison', '--from-superpowers-root', 'fork/superpowers', '--from-file', 'README.md', '--root', '.'], {
+    allowFailure: true,
+    expectOutput: ['governance --superpowers-comparison only accepts --from-superpowers-root, --json, and --root'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-gap', '--from-superpowers-root', 'fork/superpowers', '--root', '.'], {
+    allowFailure: true,
+    expectOutput: ['governance --superpowers-gap requires --from-superpowers, not --from-superpowers-root'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-regression-guard', '--from-superpowers-root', 'fork/superpowers', '--root', '.'], {
+    allowFailure: true,
+    expectOutput: ['governance --superpowers-regression-guard requires --from-superpowers, not --from-superpowers-root'],
+  }, options);
+}
+
+export function runMethodologyCoverageMapSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const unexpectedState = path.join(repoRoot, '.vibecoding-state');
+
+  const coverageEnvelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'methodology', '--coverage-map', '--from-superpowers-root', 'fork/superpowers', '--json', '--root', '.'], {}, options), 'methodology --coverage-map --json');
+  const coverage = coverageEnvelope.methodology_coverage_map || {};
+  assertJsonMarkers(readonlySmokeMarkers(coverageEnvelope, 'methodologyCoverage'), 'methodology --coverage-map --json');
+  if (!coverage.coverage_digest) throw new Error('methodology coverage map missing coverage_digest');
+  if (!coverage.source_bindings?.source_digest || !coverage.source_bindings?.superpowers_root_digest) throw new Error('methodology coverage map missing source binding digest');
+  if (coverage.methodology_coverage_map?.length !== 11) throw new Error('methodology coverage map pattern count mismatch');
+  for (const patternId of ['brainstorming', 'planning', 'writing_plans', 'tdd', 'debugging', 'review', 'completion', 'worktree_isolation', 'subagent_driven_development', 'writing_skills', 'contributor_pr_guardrails']) {
+    if (!coverage.methodology_coverage_map?.some((pattern) => pattern.id === patternId)) throw new Error(`methodology coverage map missing pattern: ${patternId}`);
+  }
+  if (!Array.isArray(coverage.covered_patterns)) throw new Error('methodology coverage covered_patterns must be a list');
+  if (!Array.isArray(coverage.partial_patterns)) throw new Error('methodology coverage partial_patterns must be a list');
+  if (!Array.isArray(coverage.missing_patterns)) throw new Error('methodology coverage missing_patterns must be a list');
+  if (!coverage.vibecoding_specific_patterns?.some((item) => item.id === 'local_runtime_contracts')) throw new Error('methodology coverage missing local runtime contract pattern');
+  if (!coverage.vibecoding_specific_patterns?.some((item) => item.id === 'token_savior_budget')) throw new Error('methodology coverage missing Token Savior pattern');
+  if (!coverage.vibecoding_specific_patterns?.some((item) => item.id === 'experience_dashboard')) throw new Error('methodology coverage missing experience dashboard pattern');
+  if (!coverage.coverage_summary || coverage.coverage_summary.total_patterns !== 11) throw new Error('methodology coverage summary mismatch');
+  if (!coverage.next_coverage_bet?.target_stage) throw new Error('methodology coverage missing next coverage bet');
+  if (fs.existsSync(unexpectedState)) throw new Error('methodology --coverage-map JSON output created unexpected state directory');
+
+  run('node', ['tools/vibe-runtime/index.mjs', 'methodology', '--coverage-map', '--from-superpowers-root', 'fork/superpowers', '--root', '.'], {
+    expectOutput: ['Vibecoding Runtime Methodology Coverage Map', 'Stage: Stage 136; Kind: methodology-coverage-map; pass=true', 'Target: fork/superpowers; root=fork/superpowers', 'Coverage summary:', '- brainstorming:', '- writing_plans:', '- contributor_pr_guardrails:', 'Covered patterns:', 'Partial patterns:', 'Missing patterns:', 'Vibecoding-specific patterns:', 'Next coverage bet:', 'Boundary: writes=false; methodology_coverage_artifact=false; coverage_map_artifact=false; source_write=false; sidecar_write=false; state_directory_created=false; command_execution=false; check_execution=false; smoke_execution=false; test_execution=false; verification_execution=false; hook_execution=false; adapter_execution=false; workflow_execution=false; skill_execution=false; runtime_action=false; auto_execution=false; repair_execution=false; prompt_mutation=false; skill_mutation=false; hook_registration=false; dynamic_tool_execution=false; embeddings=false; remote_config=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; git=false; git_write=false; git_add=false; commit=false; pr=false; push=false; merge=false; business_source_write=false', 'Coverage digest:'],
+  }, options);
+  if (fs.existsSync(unexpectedState)) throw new Error('methodology --coverage-map text output created unexpected state directory');
+
+  runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'methodology', '--coverage-map', '--from-superpowers-root', 'fork/superpowers'], ['--root', '.'], RUNTIME_READ_ONLY_FORBIDDEN_FLAGS, 'methodology --coverage-map is read-only and report-only', options);
+
+  run('node', ['tools/vibe-runtime/index.mjs', 'methodology', '--coverage-map', '--root', '.'], {
+    allowFailure: true,
+    expectOutput: ['methodology --coverage-map requires --from-superpowers-root <local-superpowers-root>'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'methodology', '--coverage-map', '--from-superpowers-root', '../superpowers', '--root', '.'], {
+    allowFailure: true,
+    expectOutput: ['methodology --coverage-map --from-superpowers-root must stay within --root'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'methodology', '--coverage-map', '--from-superpowers-root', 'missing-superpowers', '--root', '.'], {
+    allowFailure: true,
+    expectOutput: ['methodology --coverage-map --from-superpowers-root directory not found'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'methodology', '--coverage-map', '--from-superpowers-root', 'fork/superpowers', '--from-file', 'README.md', '--root', '.'], {
+    allowFailure: true,
+    expectOutput: ['methodology --coverage-map only accepts --from-superpowers-root, --json, and --root'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'methodology', '--coverage-map', '--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);
+}
+
+export function runEntryTriggerDisciplineSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-entry-trigger-discipline';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+  const goodFile = path.join(target, 'good-transcript.json');
+  const badFile = path.join(target, 'bad-transcript.json');
+
+  try {
+    writeSmokeJsonFixture(repoRoot, goodFile, stage135GoodTranscriptFixture());
+    writeSmokeJsonFixture(repoRoot, badFile, stage135BadTranscriptFixture());
+
+    const discipline = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--entry-discipline', '--from-transcript', goodFile, '--intent', 'feature', '--json', '--root', target], {}, options), 'workflow --entry-discipline --json');
+    const entry = discipline.entry_trigger_discipline || {};
+    assertJsonMarkers(readonlySmokeMarkers(discipline, 'entryTriggerDiscipline'), 'workflow --entry-discipline --json');
+    if (!entry.discipline_digest) throw new Error('entry trigger discipline missing discipline_digest');
+    for (const gate of ['using_vibecoding_first', 'protocol_layers_declared', 'intent_route_match', 'no_direct_implementation_jump', 'no_blind_bug_fix', 'no_false_skill_claim', 'no_forbidden_trigger']) {
+      if (!entry.trigger_results?.some((result) => result.gate === gate && result.pass === true)) throw new Error(`entry trigger discipline missing passing gate ${gate}`);
+    }
+    assertNoSmokeState(repoRoot, target, 'workflow --entry-discipline JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--entry-discipline', '--from-transcript', goodFile, '--intent', 'feature', '--root', target], {
+      expectOutput: ['Vibecoding Runtime Entry Trigger Discipline Contract', 'Stage: Stage 135; Kind: entry-trigger-discipline-contract; pass=true', 'Intent: feature; Transcript: good-transcript.json', 'Expected route:', '- using_vibecoding_first: pass=true', '- protocol_layers_declared: pass=true', '- intent_route_match: pass=true', 'Boundary: writes=false; entry_discipline_artifact=false; transcript_write=false; source_write=false; sidecar_write=false; state_directory_created=false; command_execution=false; check_execution=false; test_execution=false; workflow_execution=false; skill_execution=false; runtime_action=false; auto_execution=false; git=false; git_write=false; git_add=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 discipline digest:'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'workflow --entry-discipline text output');
+
+    const rejected = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--entry-discipline', '--from-transcript', badFile, '--intent', 'debug', '--json', '--root', target], {}, options), 'workflow --entry-discipline rejected --json');
+    if (rejected.ok !== false) throw new Error('entry trigger discipline should reject blind bug fix transcript');
+    if (!rejected.entry_trigger_discipline?.missed_workflow_risks?.some((risk) => risk.includes('using_vibecoding_first') || risk.includes('no_blind_bug_fix'))) throw new Error('entry trigger discipline rejected transcript missing workflow risk');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'workflow', '--entry-discipline', '--from-transcript', goodFile, '--intent', 'feature'], ['--root', target], RUNTIME_READ_ONLY_FORBIDDEN_FLAGS, 'workflow read-only modes do not accept execution', options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--entry-discipline', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['workflow --entry-discipline requires --from-transcript'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--entry-discipline', '--from-transcript', 'package.json', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['workflow --entry-discipline transcript must be inside root'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--entry-discipline', '--from-transcript', goodFile, '--from-file', goodFile, '--root', target], {
+      allowFailure: true,
+      expectOutput: ['workflow --entry-discipline only accepts --from-transcript'],
+    }, options);
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}
+
+export function runSessionStartShapeSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-session-start-shape';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+  const claudeFile = path.join(target, 'claude-session-start.json');
+  const cursorFile = path.join(target, 'cursor-session-start.json');
+  const codexFile = path.join(target, 'codex-session-start.json');
+  const cursorSdkFile = path.join(target, 'cursor-sdk-session-start.json');
+  const badFile = path.join(target, 'bad-session-start.json');
+  const missingSemanticFile = path.join(target, 'missing-semantic-session-start.json');
+  const fullSkillFile = path.join(target, 'full-skill-session-start.json');
+  const hiddenExecutionFile = path.join(target, 'hidden-execution-session-start.json');
+
+  try {
+    writeSmokeJsonFixture(repoRoot, claudeFile, stage134ClaudeSessionStartFixture());
+    writeSmokeJsonFixture(repoRoot, cursorFile, stage134CursorSessionStartFixture());
+    writeSmokeJsonFixture(repoRoot, codexFile, stage134CodexSessionStartFixture());
+    writeSmokeJsonFixture(repoRoot, cursorSdkFile, stage134CursorSdkSessionStartFixture());
+    writeSmokeJsonFixture(repoRoot, badFile, stage134BadSessionStartFixture());
+    writeSmokeJsonFixture(repoRoot, missingSemanticFile, stage134MissingSemanticFieldsSessionStartFixture());
+    writeSmokeJsonFixture(repoRoot, fullSkillFile, stage134FullSkillInjectionSessionStartFixture());
+    writeSmokeJsonFixture(repoRoot, hiddenExecutionFile, stage134HiddenExecutionSessionStartFixture());
+
+    const shape = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--session-start-shape', '--from-file', claudeFile, '--adapter', 'claude', '--json', '--root', target], {}, options), 'platforms --session-start-shape --json');
+    const acceptance = shape.session_start_shape_acceptance || {};
+    assertJsonMarkers(readonlySmokeMarkers(shape, 'sessionStartShape'), 'platforms --session-start-shape --json');
+    if (!acceptance.shape_digest) throw new Error('session-start shape acceptance missing shape_digest');
+    for (const gate of ['adapter_output_shape', 'context_present', 'using_vibecoding_marker', 'lightweight_routing_marker', 'semantic_field_markers', 'context_policy_marker', 'boundary_declaration_marker', 'no_full_skill_injection', 'no_execution_claims', 'no_forbidden_trigger']) {
+      if (!acceptance.shape_results?.some((result) => result.gate === gate && result.pass === true)) throw new Error(`session-start shape acceptance missing passing gate ${gate}`);
+    }
+    assertNoSmokeState(repoRoot, target, 'platforms --session-start-shape JSON output');
+
+    const cursorShape = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--session-start-shape', '--from-file', cursorFile, '--adapter', 'cursor', '--json', '--root', target], {}, options), 'platforms --session-start-shape cursor --json');
+    if (cursorShape.session_start_shape_acceptance?.output_summary?.context_path !== 'additional_context') throw new Error('cursor session-start shape should use additional_context');
+    const codexShape = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--session-start-shape', '--from-file', codexFile, '--adapter', 'codex', '--json', '--root', target], {}, options), 'platforms --session-start-shape codex --json');
+    if (codexShape.session_start_shape_acceptance?.output_summary?.context_path !== 'additionalContext') throw new Error('codex session-start shape should use additionalContext');
+    const cursorSdkShape = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--session-start-shape', '--from-file', cursorSdkFile, '--adapter', 'cursor-sdk', '--json', '--root', target], {}, options), 'platforms --session-start-shape cursor-sdk --json');
+    if (cursorSdkShape.session_start_shape_acceptance?.output_summary?.context_path !== 'additionalContext') throw new Error('cursor-sdk session-start shape should use additionalContext');
+    for (const [label, acceptedShape] of [['cursor', cursorShape], ['codex', codexShape], ['cursor-sdk', cursorSdkShape]]) {
+      const accepted = acceptedShape.session_start_shape_acceptance || {};
+      if (accepted.accepted !== true || accepted.ok !== true) throw new Error(`${label} session-start shape should be accepted`);
+      for (const marker of ['selected_skill', 'visible_route', 'next_manual_action', 'context_policy', 'no_execution_claims']) {
+        if (accepted.context_markers?.[marker] !== true) throw new Error(`${label} session-start shape missing ${marker}`);
+      }
+    }
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--session-start-shape', '--from-file', cursorFile, '--adapter', 'cursor', '--root', target], {
+      expectOutput: ['Stage: Stage 134; Acceptance: session-start-shape-acceptance; accepted=true', 'Adapter: cursor; Context path: additional_context', '- adapter_output_shape: pass=true', '- using_vibecoding_marker: pass=true', '- no_forbidden_trigger: pass=true'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'platforms --session-start-shape text output');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'platforms', '--session-start-shape', '--from-file', claudeFile, '--adapter', 'claude'], ['--root', target], RUNTIME_READ_ONLY_FORBIDDEN_FLAGS, 'platforms --session-start-shape is read-only', options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--session-start-shape', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['platforms --session-start-shape requires --from-file'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--session-start-shape', '--from-file', claudeFile, '--root', target], {
+      allowFailure: true,
+      expectOutput: ['platforms --session-start-shape requires --adapter'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--session-start-shape', '--from-file', '../outside.json', '--adapter', 'claude', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['session-start captured output must be inside root'],
+    }, options);
+    const rejected = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--session-start-shape', '--from-file', badFile, '--adapter', 'cursor', '--json', '--root', target], {}, options), 'platforms --session-start-shape rejected markers --json');
+    if (rejected.ok !== false || !rejected.session_start_shape_acceptance?.blockers?.some((blocker) => blocker.includes('using_vibecoding_marker'))) throw new Error('session-start shape should reject missing using-vibecoding marker');
+    const missingSemantic = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--session-start-shape', '--from-file', missingSemanticFile, '--adapter', 'codex', '--json', '--root', target], {}, options), 'platforms --session-start-shape missing semantic fields --json');
+    if (missingSemantic.ok !== false || !missingSemantic.session_start_shape_acceptance?.blockers?.some((blocker) => blocker.includes('semantic_field_markers'))) throw new Error('session-start shape should reject missing selected skill, visible route, or next manual action');
+    const fullSkill = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--session-start-shape', '--from-file', fullSkillFile, '--adapter', 'cursor-sdk', '--json', '--root', target], {}, options), 'platforms --session-start-shape full skill injection --json');
+    if (fullSkill.ok !== false || !fullSkill.session_start_shape_acceptance?.blockers?.some((blocker) => blocker.includes('no_full_skill_injection'))) throw new Error('session-start shape should reject full skill injection');
+    const hiddenExecution = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--session-start-shape', '--from-file', hiddenExecutionFile, '--adapter', 'codex', '--json', '--root', target], {}, options), 'platforms --session-start-shape hidden execution --json');
+    if (hiddenExecution.ok !== false || !hiddenExecution.session_start_shape_acceptance?.blockers?.some((blocker) => blocker.includes('no_execution_claims') || blocker.includes('no_forbidden_trigger'))) throw new Error('session-start shape should reject hidden execution or command execution claims');
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}
+
+export function runStageScriptletSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-stage-scriptlet';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+  const runbookFile = path.join(target, 'stage118-runbook.json');
+  const consoleFile = path.join(target, 'stage127-console.json');
+
+  try {
+    fs.writeFileSync(path.join(repoRoot, runbookFile), `${JSON.stringify({
+      sequential_stage_runbook: {
+        stage: 'Stage 118',
+        runbook_kind: 'sequential-stage-runbook',
+        ready_for_evidence_binding: true,
+        blocked_reasons: [],
+        evidence_required: ['syntax check output', 'runtime-check Result: passed', '.vibecoding-state absent'],
+        stage_runbook_digest: 'fixture-stage118-runbook-digest',
+        stage_sequence: [
+          {
+            stage_id: 'stage130-fixture-01',
+            title: 'Stage 130 fixture implementation',
+            sequence_index: 1,
+            files_to_change: ['tools/vibe-runtime/runtime-stage-scriptlet.mjs', 'tools/vibe-runtime/index.mjs'],
+            validation_commands: [
+              'node --check tools/vibe-runtime/runtime-stage-scriptlet.mjs',
+              'node tools/vibe-runtime-check/index.mjs --root D:/workspace_mine/vibe-coading',
+              'powershell -NoProfile -Command "Test-Path .vibecoding-state"',
+            ],
+            evidence_required: ['exit_code=0 for syntax check', 'Result: passed', 'False'],
+            stop_if: ['runtime-check fails', 'state directory appears'],
+            commit_subject: 'stage 130: add copy-ready stage scriptlet',
+            execution_authorized: false,
+            actions_executed: false,
+            command_execution_authorized: false,
+            git_write_authorized: false,
+          },
+          {
+            stage_id: 'stage130-fixture-02',
+            title: 'Stage 130 follow-up docs',
+            sequence_index: 2,
+            files_to_change: ['tools/vibe-runtime/README.md'],
+            validation_commands: ['git diff --check'],
+            evidence_required: ['exit_code=0'],
+            stop_if: ['whitespace check fails'],
+            commit_subject: 'stage 130 docs follow-up',
+            execution_authorized: false,
+            actions_executed: false,
+            command_execution_authorized: false,
+            git_write_authorized: false,
+          },
+        ],
+      },
+    }, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(path.join(repoRoot, consoleFile), `${JSON.stringify({
+      next_action_console: {
+        stage: 'Stage 127',
+        console_kind: 'one-screen-next-action-console',
+        console_digest: 'fixture-stage127-console-digest',
+        recommended_next_action: { id: 'prepare-copy-ready-scriptlet', action: 'Generate a copy-ready scriptlet preview.' },
+        copy_ready_command_preview: [
+          { id: 'runtime-check-preview', command: 'node tools/vibe-runtime-check/index.mjs --root D:/workspace_mine/vibe-coading', preview_only: true },
+        ],
+        evidence_needed_next: [{ id: 'runtime-check', reason: 'Result: passed marker required' }],
+        do_not_do_yet: ['do not git commit before Stage 119/120 evidence binding'],
+      },
+    }, null, 2)}\n`, 'utf8');
+
+    const scriptlet = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'automation', '--stage-scriptlet', '--from-runbook', runbookFile, '--from-console', consoleFile, '--stage', 'stage130-fixture-01', '--json', '--root', target], {}, options), 'automation --stage-scriptlet --json');
+    assertJsonMarkers(readonlySmokeMarkers(scriptlet, 'stageScriptlet'), 'automation --stage-scriptlet --json');
+    if (!scriptlet.stage_scriptlet?.scriptlet_digest) throw new Error('stage scriptlet missing scriptlet_digest');
+    if (!scriptlet.stage_scriptlet?.powershell_commands?.some((command) => command.includes('node --check tools/vibe-runtime/runtime-stage-scriptlet.mjs'))) throw new Error('stage scriptlet missing syntax check PowerShell command');
+    if (!scriptlet.stage_scriptlet?.expected_markers?.includes('Result: passed')) throw new Error('stage scriptlet missing runtime-check expected marker');
+    if (!scriptlet.stage_scriptlet?.evidence_capture_template?.evidence_items?.length) throw new Error('stage scriptlet missing evidence capture items');
+    if (scriptlet.stage_scriptlet?.scriptlet_steps?.some((step) => step.preview_only !== true || step.execution_authorized !== false || step.actions_executed !== false || step.evidence_written !== false)) throw new Error('stage scriptlet produced executable step');
+    assertNoSmokeState(repoRoot, target, 'automation --stage-scriptlet JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'automation', '--stage-scriptlet', '--from-runbook', runbookFile, '--root', target], {
+      expectOutput: ['Vibecoding Runtime Copy-ready Stage Execution Scriptlet', 'Stage: Stage 130; Kind: copy-ready-stage-execution-scriptlet; pass=true', 'PowerShell commands', 'Expected markers', 'Stop if', 'Evidence template:', 'Boundary: writes=false; stage_scriptlet_artifact=false; scriptlet_artifact=false; evidence_write=false; sidecar_write=false; state_directory_created=false; command_execution=false; check_execution=false; smoke_execution=false; test_execution=false; validation_execution=false; workflow_execution=false; skill_execution=false; runtime_action=false; git=false; git_write=false; git_add=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 scriptlet digest:'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'automation --stage-scriptlet text output');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'automation', '--stage-scriptlet', '--from-runbook', runbookFile], ['--root', target], READ_ONLY_RUNTIME_CONTROL_FLAGS_WITH_PREVIEW, 'automation --stage-scriptlet is read-only', options);
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'automation', '--stage-scriptlet', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['automation --stage-scriptlet requires --from-runbook <local-runbook-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'automation', '--stage-scriptlet', '--from-runbook', '../outside.json', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['automation --stage-scriptlet --from-runbook must stay within --root'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'automation', '--stage-scriptlet', '--from-runbook', runbookFile, '--from-console', '../outside.json', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['automation --stage-scriptlet --from-console must stay within --root'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'automation', '--stage-scriptlet', '--from-runbook', runbookFile, '--from-plan', runbookFile, '--root', target], {
+      allowFailure: true,
+      expectOutput: ['automation --stage-scriptlet only accepts one local runbook file'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'automation', '--stage-runbook', '--from-plan', runbookFile, '--from-console', consoleFile, '--root', target], {
+      allowFailure: true,
+      expectOutput: ['automation --stage-runbook only accepts one local plan file'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--next-action-console', '--from-runbook', runbookFile, '--root', target], {
+      allowFailure: true,
+      expectOutput: ['workflow --next-action-console requires --from-friction <local-friction-json>'],
+    }, options);
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}
+
+function experienceLearningPatternUnsupportedCases({ target, frictionFile, observationFile }) {
+  return [
+    {
+      args: ['tools/vibe-runtime/index.mjs', 'learning', '--experience-pattern', '--root', target],
+      expected: 'learning --experience-pattern requires --from-friction <local-friction-json>',
+    },
+    {
+      args: ['tools/vibe-runtime/index.mjs', 'learning', '--experience-pattern', '--from-friction', '../outside.json', '--root', target],
+      expected: 'learning --experience-pattern --from-friction must stay within --root',
+    },
+    {
+      args: ['tools/vibe-runtime/index.mjs', 'learning', '--experience-pattern', '--from-friction', frictionFile, '--from-file', frictionFile, '--root', target],
+      expected: 'learning --experience-pattern only accepts --from-friction and optional --from-observations',
+    },
+    {
+      args: ['tools/vibe-runtime/index.mjs', 'learning', '--advice', '--from-friction', frictionFile, '--root', target],
+      expected: '--from-friction is only supported by learning --experience-pattern',
+    },
+    {
+      args: ['tools/vibe-runtime/index.mjs', 'governance', '--experience-friction', '--from-observations', observationFile, '--root', target],
+      expected: '--from-observations is only supported by learning --instincts, learning --advice, or learning --experience-pattern',
+    },
+  ];
+}
+
+function runExperienceLearningPatternUnsupportedCases(run, context, options) {
+  for (const { args, expected } of experienceLearningPatternUnsupportedCases(context)) {
+    run('node', args, {
+      allowFailure: true,
+      expectOutput: [expected],
+    }, options);
+  }
+}
+
+export function runExperienceLearningPatternSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-experience-learning-pattern';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+  const frictionFile = path.join(target, 'stage126-friction.json');
+  const evidenceFile = path.join(target, 'stage61-session-evidence.json');
+
+  try {
+    writeSmokeJsonFixture(repoRoot, frictionFile, stage129FrictionFixture());
+
+    const pattern = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'learning', '--experience-pattern', '--from-friction', frictionFile, '--intent', 'workflow', '--json', '--root', target], {}, options), 'learning --experience-pattern --json');
+    assertJsonMarkers(readonlySmokeMarkers(pattern, 'experienceLearningPattern'), 'learning --experience-pattern --json');
+    if (!pattern.experience_learning_pattern?.experience_pattern_digest) throw new Error('experience learning pattern missing experience_pattern_digest');
+    if (!pattern.experience_learning_pattern?.candidate_experience_patterns?.some((item) => item.id === 'visible-next-action-instinct' && item.preview_only === true && item.auto_apply === false)) throw new Error('experience learning pattern missing visible next-action candidate');
+    for (const skill of ['vibe-writing-skills', 'vibe-writing-plans', 'vibe-test-driven-development']) {
+      if (!pattern.experience_learning_pattern?.required_workflow?.includes(skill)) throw new Error(`experience learning pattern missing required workflow ${skill}`);
+    }
+    assertNoSmokeState(repoRoot, target, 'learning --experience-pattern JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'learning', '--experience-pattern', '--from-friction', frictionFile, '--root', target], {
+      expectOutput: ['Vibecoding Runtime Experience Learning Pattern Gate', 'Stage: Stage 129; Kind: ecc-learning-experience-pattern-gate; pass=true', 'Repeat signal:', 'Suggested trigger:', 'Suggested action:', 'Candidate experience patterns', 'Promotion required: true; workflow=vibe-writing-skills -> vibe-writing-plans -> vibe-test-driven-development', 'Boundary: writes=false; experience_pattern_artifact=false; learning_observation_write=false; candidate_instinct_write=false; learning_promotion_write=false; skill_write=false; writes_formal_skills=false; writes_agents_md=false; writes_claude_md=false; prompt_mutation=false; hook_registration=false; command_execution=false; workflow_execution=false; skill_execution=false; runtime_action=false; automatic_promotion=false; agent_first_delegation=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', 'Experience pattern digest:'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'learning --experience-pattern text output');
+
+    writeSmokeJsonFixture(repoRoot, evidenceFile, stage129LearningEvidenceFixture());
+    const observation = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'learning', '--observe', '--from-file', evidenceFile, '--confirm', '--json', '--root', target], {}, options), 'learning --observe --confirm --json');
+    const observationFile = observation.learning_file;
+    if (!observationFile || !observationFile.endsWith('.learning-observation.json')) throw new Error('learning observation setup did not return learning_file');
+    const withObservation = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'learning', '--experience-pattern', '--from-friction', frictionFile, '--from-observations', observationFile, '--json', '--root', target], {}, options), 'learning --experience-pattern --from-observations --json');
+    assertJsonMarkers([
+      ['experience_learning_pattern.observation_summary.provided', withObservation.experience_learning_pattern?.observation_summary?.provided, true],
+      ['experience_learning_pattern.observation_summary.observation_count', withObservation.experience_learning_pattern?.observation_summary?.observation_count, 1],
+      ['experience_learning_pattern.repeat_signal.repeated_workflow_count', withObservation.experience_learning_pattern?.repeat_signal?.repeated_workflow_count, 3],
+      ['experience_learning_pattern.repeat_signal.correction_count', withObservation.experience_learning_pattern?.repeat_signal?.correction_count, 1],
+    ], 'learning --experience-pattern --from-observations --json');
+    if (!withObservation.experience_learning_pattern?.candidate_experience_patterns?.some((item) => item.id === 'repeat-signal-learning-gate')) throw new Error('experience learning pattern missing repeat-signal candidate with observation input');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'learning', '--experience-pattern', '--from-friction', frictionFile], ['--root', target], READ_ONLY_RUNTIME_CONTROL_FLAGS_WITH_PREVIEW, 'learning --experience-pattern is read-only', options);
+    runExperienceLearningPatternUnsupportedCases(run, { target, frictionFile, observationFile }, options);
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}
+
+export function runAdapterBootstrapMatrixSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-adapter-bootstrap-matrix';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+
+  try {
+    const matrix = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--bootstrap-matrix', '--json', '--root', repoRoot], {}, options), 'platforms --bootstrap-matrix --json');
+    assertJsonMarkers(readonlySmokeMarkers(matrix, 'adapterBootstrapMatrix'), 'platforms --bootstrap-matrix --json');
+    if (!matrix.adapter_bootstrap_matrix?.matrix_digest) throw new Error('adapter bootstrap matrix missing matrix_digest');
+    for (const adapter of ['claude', 'cursor', 'codex']) {
+      const row = matrix.adapter_bootstrap_matrix?.adapter_rows?.find((item) => item.adapter === adapter);
+      if (!row) throw new Error(`adapter bootstrap matrix missing ${adapter} row`);
+      if (row.pass !== true) throw new Error(`adapter bootstrap matrix ${adapter} row did not pass`);
+      if (row.bootstrap_policy?.injectsFullSkill !== false) throw new Error(`${adapter} row missing injectsFullSkill=false`);
+      if (row.bootstrap_policy?.writesRuntimeState !== false) throw new Error(`${adapter} row missing writesRuntimeState=false`);
+      if (row.bootstrap_policy?.autoRunsNextSkill !== false) throw new Error(`${adapter} row missing autoRunsNextSkill=false`);
+      if (row.runtime_bridge?.canAutoExecuteSkill !== false) throw new Error(`${adapter} row missing canAutoExecuteSkill=false`);
+      if (row.runtime_bridge?.canCallSubagent !== false) throw new Error(`${adapter} row missing canCallSubagent=false`);
+      if (row.runtime_bridge?.canTouchGit !== false) throw new Error(`${adapter} row missing canTouchGit=false`);
+    }
+    assertNoSmokeState(repoRoot, target, 'platforms --bootstrap-matrix JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--bootstrap-matrix', '--root', repoRoot], {
+      expectOutput: ['Vibecoding Runtime Platform Capability', 'Mode: adapter-bootstrap-conformance-matrix', 'Stage: Stage 122; Matrix: adapter-bootstrap-conformance-matrix; pass=true', 'injectsFullSkill=false', 'writesRuntimeState=false'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'platforms --bootstrap-matrix text output');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'platforms', '--bootstrap-matrix'], ['--root', repoRoot], ['--confirm', '--write', '--dry-run'], 'platforms --bootstrap-matrix is read-only', options);
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}
+
+export function runSkillRuntimeTraceabilitySmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-skill-runtime-traceability';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+
+  try {
+    const traceability = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--traceability-map', '--json', '--root', repoRoot], {}, options), 'governance --traceability-map --json');
+    assertJsonMarkers(readonlySmokeMarkers(traceability, 'skillRuntimeTraceability'), 'governance --traceability-map --json');
+    if (!traceability.skill_runtime_traceability_map?.traceability_digest) throw new Error('skill runtime traceability map missing traceability_digest');
+    if (traceability.skill_runtime_traceability_map?.skill_rows?.length !== 24) throw new Error('skill runtime traceability map expected 24 skill rows');
+    if (traceability.skill_runtime_traceability_map?.traceability_rows?.length !== 24) throw new Error('skill runtime traceability map expected 24 traceability rows');
+    for (const skill of ['using-vibecoding', 'vibe-product-discovery', 'vibe-product-spec', 'vibe-ui-design', 'vibe-product-acceptance', 'vibe-writing-plans', 'vibe-finishing-a-development-branch', 'vibe-writing-skills']) {
+      const row = traceability.skill_runtime_traceability_map?.traceability_rows?.find((item) => item.skill === skill);
+      if (!row) throw new Error(`skill runtime traceability map missing ${skill} row`);
+      if (row.pass !== true) throw new Error(`skill runtime traceability ${skill} row did not pass`);
+      if (!row.runtime_commands?.length) throw new Error(`skill runtime traceability ${skill} row missing runtime commands`);
+    }
+    assertNoSmokeState(repoRoot, target, 'governance --traceability-map JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--traceability-map', '--root', repoRoot], {
+      expectOutput: ['Vibecoding Runtime Governance', 'Mode: skill-to-runtime-traceability-map', 'Stage: Stage 123; Map: skill-to-runtime-traceability-map; pass=true', 'Skills: 24; Links: 24', 'governance --traceability-map'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'governance --traceability-map text output');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'governance', '--traceability-map'], ['--root', repoRoot], ['--confirm', '--write', '--dry-run', '--run', '--once', '--scan'], 'governance --traceability-map is read-only', options);
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}
+
+export function releaseCheckStage121136SmokeHandlers(deps) {
+  return {
+    runSuperpowersRegressionGuardSmoke: (options) => runSuperpowersRegressionGuardSmoke(deps, options),
+    runExperienceFrictionSmoke: (options) => runExperienceFrictionSmoke(deps, options),
+    runNextActionConsoleSmoke: (options) => runNextActionConsoleSmoke(deps, options),
+    runTokenSaviorBudgetSmoke: (options) => runTokenSaviorBudgetSmoke(deps, options),
+    runAdapterEntryAcceptanceSmoke: (options) => runAdapterEntryAcceptanceSmoke(deps, options),
+    runInstalledMultiroundUxSmoke: (options) => runInstalledMultiroundUxSmoke(deps, options),
+    runExperienceRegressionDashboardSmoke: (options) => runExperienceRegressionDashboardSmoke(deps, options),
+    runSuperpowersComparisonSmoke: (options) => runSuperpowersComparisonSmoke(deps, options),
+    runMethodologyCoverageMapSmoke: (options) => runMethodologyCoverageMapSmoke(deps, options),
+    runEntryTriggerDisciplineSmoke: (options) => runEntryTriggerDisciplineSmoke(deps, options),
+    runSessionStartShapeSmoke: (options) => runSessionStartShapeSmoke(deps, options),
+    runStageScriptletSmoke: (options) => runStageScriptletSmoke(deps, options),
+    runExperienceLearningPatternSmoke: (options) => runExperienceLearningPatternSmoke(deps, options),
+    runBehavioralEvaluationContractSmoke: (options) => runBehavioralEvaluationContractSmoke(deps, options),
+    runAdapterBootstrapMatrixSmoke: (options) => runAdapterBootstrapMatrixSmoke(deps, options),
+    runSkillRuntimeTraceabilitySmoke: (options) => runSkillRuntimeTraceabilitySmoke(deps, options),
+  };
+}