@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-release-check/release-check-stage137-140-smoke.mjs

@@ -0,0 +1,534 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export function runInstallExperienceSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-install-experience';
+  const absoluteTarget = path.join(repoRoot, target);
+  const bootstrapFile = path.join(target, 'bootstrap-matrix.json');
+  const entryFile = path.join(target, 'entry-acceptance.json');
+  const expectedBootstrapFile = bootstrapFile.replace(/\\/g, '/');
+  const expectedEntryFile = entryFile.replace(/\\/g, '/');
+  const unexpectedState = path.join(repoRoot, '.vibecoding-state');
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(absoluteTarget, { recursive: true });
+    const bootstrap = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--bootstrap-matrix', '--json', '--root', '.'], {}, options), 'platforms --bootstrap-matrix for install experience --json');
+    fs.writeFileSync(path.join(repoRoot, bootstrapFile), `${JSON.stringify(bootstrap, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(path.join(repoRoot, entryFile), `${JSON.stringify({
+      stage: 'Stage 131',
+      acceptance_kind: 'adapter-entry-acceptance-contract',
+      ok: true,
+      acceptance_digest: 'fixture-stage131-entry-acceptance-digest',
+      adapter_acceptance_rows: ['claude', 'cursor', 'codex'].map((adapter) => ({
+        adapter,
+        ok: true,
+        accepted: true,
+        acceptance_score: 100,
+        gate_results: [
+          { gate: 'using_vibecoding_first', pass: true },
+          { gate: 'lightweight_routing', pass: true },
+          { gate: 'visible_next_step', pass: true },
+          { gate: 'workflow_explained', pass: true },
+          { gate: 'no_auto_execution', pass: true },
+        ],
+        blockers: [],
+      })),
+    }, null, 2)}\n`, 'utf8');
+
+    const envelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--install-experience', '--from-bootstrap-matrix', bootstrapFile, '--from-entry-acceptance', entryFile, '--json', '--root', '.'], {}, options), 'platforms --install-experience --json');
+    const score = envelope.install_experience_score || {};
+    assertJsonMarkers([
+      ['command', envelope.command, 'platforms'],
+      ['mode', envelope.mode, 'hook-adapter-install-experience-score'],
+      ['ok', envelope.ok, true],
+      ['install_experience_score.stage', score.stage, 'Stage 137'],
+      ['install_experience_score.score_kind', score.score_kind, 'hook-adapter-install-experience-score'],
+      ['install_experience_score.source_bindings.bootstrap_matrix_file', score.source_bindings?.bootstrap_matrix_file, expectedBootstrapFile],
+      ['install_experience_score.source_bindings.entry_acceptance_file', score.source_bindings?.entry_acceptance_file, expectedEntryFile],
+      ['install_experience_score.input_summary.bootstrap_stage', score.input_summary?.bootstrap_stage, 'Stage 122'],
+      ['install_experience_score.input_summary.entry_acceptance_stage', score.input_summary?.entry_acceptance_stage, 'Stage 131'],
+      ['install_experience_score.install_experience_score', score.install_experience_score, 100],
+      ['install_experience_score.natural_entry_score', score.natural_entry_score, 100],
+      ['install_experience_score.adapter_consistency_score', score.adapter_consistency_score, 100],
+      ['install_experience_score.install_experience_invariants.pass', score.install_experience_invariants?.pass, true],
+      ['install_experience_score.writes', score.writes, false],
+      ['install_experience_score.state_directory_created', score.state_directory_created, false],
+      ['install_experience_score.boundary_assertions.install_experience_artifact', score.boundary_assertions?.install_experience_artifact, false],
+      ['install_experience_score.boundary_assertions.bootstrap_matrix_artifact', score.boundary_assertions?.bootstrap_matrix_artifact, false],
+      ['install_experience_score.boundary_assertions.entry_acceptance_artifact', score.boundary_assertions?.entry_acceptance_artifact, false],
+      ['install_experience_score.boundary_assertions.adapter_install', score.boundary_assertions?.adapter_install, false],
+      ['install_experience_score.boundary_assertions.adapter_execution', score.boundary_assertions?.adapter_execution, false],
+      ['install_experience_score.boundary_assertions.hook_execution', score.boundary_assertions?.hook_execution, false],
+      ['install_experience_score.boundary_assertions.hook_registration', score.boundary_assertions?.hook_registration, false],
+      ['install_experience_score.boundary_assertions.manifest_write', score.boundary_assertions?.manifest_write, false],
+      ['install_experience_score.boundary_assertions.install_doc_write', score.boundary_assertions?.install_doc_write, false],
+      ['install_experience_score.boundary_assertions.settings_write', score.boundary_assertions?.settings_write, false],
+      ['install_experience_score.boundary_assertions.source_write', score.boundary_assertions?.source_write, false],
+      ['install_experience_score.boundary_assertions.transcript_write', score.boundary_assertions?.transcript_write, false],
+      ['install_experience_score.boundary_assertions.sidecar_write', score.boundary_assertions?.sidecar_write, false],
+      ['install_experience_score.boundary_assertions.command_execution', score.boundary_assertions?.command_execution, false],
+      ['install_experience_score.boundary_assertions.check_execution', score.boundary_assertions?.check_execution, false],
+      ['install_experience_score.boundary_assertions.test_execution', score.boundary_assertions?.test_execution, false],
+      ['install_experience_score.boundary_assertions.workflow_execution', score.boundary_assertions?.workflow_execution, false],
+      ['install_experience_score.boundary_assertions.skill_execution', score.boundary_assertions?.skill_execution, false],
+      ['install_experience_score.boundary_assertions.runtime_action', score.boundary_assertions?.runtime_action, false],
+      ['install_experience_score.boundary_assertions.auto_execution', score.boundary_assertions?.auto_execution, false],
+      ['install_experience_score.boundary_assertions.platform_api', score.boundary_assertions?.platform_api, false],
+      ['install_experience_score.boundary_assertions.external_network', score.boundary_assertions?.external_network, false],
+      ['install_experience_score.boundary_assertions.model_invocation', score.boundary_assertions?.model_invocation, false],
+      ['install_experience_score.boundary_assertions.subagent', score.boundary_assertions?.subagent, false],
+      ['install_experience_score.boundary_assertions.mcp', score.boundary_assertions?.mcp, false],
+      ['install_experience_score.boundary_assertions.git', score.boundary_assertions?.git, false],
+      ['install_experience_score.boundary_assertions.git_write', score.boundary_assertions?.git_write, false],
+      ['install_experience_score.boundary_assertions.git_add', score.boundary_assertions?.git_add, false],
+      ['install_experience_score.boundary_assertions.commit', score.boundary_assertions?.commit, false],
+      ['install_experience_score.boundary_assertions.pr', score.boundary_assertions?.pr, false],
+      ['install_experience_score.boundary_assertions.push', score.boundary_assertions?.push, false],
+      ['install_experience_score.boundary_assertions.merge', score.boundary_assertions?.merge, false],
+      ['install_experience_score.boundary_assertions.business_source_write', score.boundary_assertions?.business_source_write, false],
+      ['safety.stage', envelope.safety?.stage, 'Stage 137'],
+      ['safety.adapter_install', envelope.safety?.adapter_install, false],
+      ['safety.hook_execution', envelope.safety?.hook_execution, false],
+      ['safety.subagent', envelope.safety?.subagent, false],
+    ], 'platforms --install-experience --json');
+    if (!score.install_experience_digest) throw new Error('install experience score missing install_experience_digest');
+    if (score.adapter_scores?.length !== 3) throw new Error('install experience score adapter count mismatch');
+    for (const adapter of ['claude', 'cursor', 'codex']) {
+      if (!score.adapter_scores?.some((row) => row.adapter === adapter && row.natural_entry_score === 100 && row.adapter_consistency_score === 100)) throw new Error(`install experience score missing adapter score: ${adapter}`);
+    }
+    if (!Array.isArray(score.manual_steps_remaining) || score.manual_steps_remaining.length !== 0) throw new Error('install experience should have no manual steps for passing fixture');
+    if (!Array.isArray(score.docs_friction) || score.docs_friction.length !== 0) throw new Error('install experience should have no docs friction for passing fixture');
+    if (!score.next_install_experience_bet?.target_stage) throw new Error('install experience missing next install experience bet');
+    if (fs.existsSync(unexpectedState)) throw new Error('platforms --install-experience JSON output created unexpected state directory');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--install-experience', '--from-bootstrap-matrix', bootstrapFile, '--from-entry-acceptance', entryFile, '--root', '.'], {
+      expectOutput: ['Vibecoding Runtime Platform Capability', 'Stage: Stage 137; Score: hook-adapter-install-experience-score; pass=true', 'Install experience score: 100; natural_entry=100; adapter_consistency=100; Digest:', '- claude: natural_entry=100; consistency=100; bootstrap=true; entry_acceptance=true', '- cursor: natural_entry=100; consistency=100; bootstrap=true; entry_acceptance=true', '- codex: natural_entry=100; consistency=100; bootstrap=true; entry_acceptance=true', 'Manual steps remaining:', '- none', 'Docs friction:', 'Action: install experience score read local Stage 122 bootstrap matrix JSON and local Stage 131 entry acceptance JSON only.'],
+    }, options);
+    if (fs.existsSync(unexpectedState)) throw new Error('platforms --install-experience text output created unexpected state directory');
+
+    for (const forbidden of ['--confirm', '--dry-run', '--write', '--preflight', '--dispatch', '--dispatch-intent', '--run', '--once', '--scan', '--auto-run']) {
+      run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--install-experience', '--from-bootstrap-matrix', bootstrapFile, '--from-entry-acceptance', entryFile, forbidden, '--root', '.'], {
+        allowFailure: true,
+        expectOutput: ['platforms --install-experience is read-only and report-only'],
+      }, options);
+    }
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--install-experience', '--from-entry-acceptance', entryFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['platforms --install-experience requires --from-bootstrap-matrix <local-bootstrap-matrix-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--install-experience', '--from-bootstrap-matrix', bootstrapFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['platforms --install-experience requires --from-entry-acceptance <local-entry-acceptance-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--install-experience', '--from-bootstrap-matrix', '../outside.json', '--from-entry-acceptance', entryFile, '--root', target], {
+      allowFailure: true,
+      expectOutput: ['platforms --install-experience --from-bootstrap-matrix must stay within --root'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--install-experience', '--from-bootstrap-matrix', bootstrapFile, '--from-entry-acceptance', entryFile, '--from-file', entryFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['platforms --install-experience only accepts --from-bootstrap-matrix, --from-entry-acceptance, --json, and --root'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--entry-discipline', '--from-bootstrap-matrix', bootstrapFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['--from-bootstrap-matrix is only supported by platforms --install-experience'],
+    }, options);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+export function runSuperpowersStyleEvalPackSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-superpowers-style-eval-pack';
+  const absoluteTarget = path.join(repoRoot, target);
+  const comparisonFile = path.join(target, 'comparison.json');
+  const expectedComparisonFile = comparisonFile.replace(/\\/g, '/');
+  const unexpectedState = path.join(repoRoot, '.vibecoding-state');
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(absoluteTarget, { recursive: true });
+    const comparison = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-comparison', '--from-superpowers-root', 'fork/superpowers', '--json', '--root', '.'], {}, options), 'governance --superpowers-comparison for eval pack --json');
+    fs.writeFileSync(path.join(repoRoot, comparisonFile), `${JSON.stringify(comparison, null, 2)}\n`, 'utf8');
+
+    const envelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--superpowers-style-pack', '--from-comparison', comparisonFile, '--json', '--root', '.'], {}, options), 'evals --superpowers-style-pack --json');
+    const pack = envelope.superpowers_style_eval_pack || {};
+    assertJsonMarkers([
+      ['command', envelope.command, 'evals'],
+      ['mode', envelope.mode, 'superpowers-style-behavioral-eval-scenario-pack'],
+      ['ok', envelope.ok, true],
+      ['superpowers_style_eval_pack.stage', pack.stage, 'Stage 138'],
+      ['superpowers_style_eval_pack.pack_kind', pack.pack_kind, 'superpowers-style-behavioral-eval-scenario-pack'],
+      ['superpowers_style_eval_pack.source_bindings.comparison_file', pack.source_bindings?.comparison_file, expectedComparisonFile],
+      ['superpowers_style_eval_pack.comparison_binding.comparison_stage', pack.comparison_binding?.comparison_stage, 'Stage 133'],
+      ['superpowers_style_eval_pack.comparison_binding.comparison_kind', pack.comparison_binding?.comparison_kind, 'superpowers-comparative-evidence-matrix'],
+      ['superpowers_style_eval_pack.scenario_summary.scenario_count', pack.scenario_summary?.scenario_count, 12],
+      ['superpowers_style_eval_pack.scenario_summary.execution_authorized', pack.scenario_summary?.execution_authorized, false],
+      ['superpowers_style_eval_pack.scenario_summary.model_judge_required', pack.scenario_summary?.model_judge_required, false],
+      ['superpowers_style_eval_pack.eval_pack_invariants.pass', pack.eval_pack_invariants?.pass, true],
+      ['superpowers_style_eval_pack.writes', pack.writes, false],
+      ['superpowers_style_eval_pack.state_directory_created', pack.state_directory_created, false],
+      ['superpowers_style_eval_pack.boundary_assertions.eval_pack_artifact', pack.boundary_assertions?.eval_pack_artifact, false],
+      ['superpowers_style_eval_pack.boundary_assertions.scenario_artifact', pack.boundary_assertions?.scenario_artifact, false],
+      ['superpowers_style_eval_pack.boundary_assertions.comparison_artifact', pack.boundary_assertions?.comparison_artifact, false],
+      ['superpowers_style_eval_pack.boundary_assertions.command_execution', pack.boundary_assertions?.command_execution, false],
+      ['superpowers_style_eval_pack.boundary_assertions.check_execution', pack.boundary_assertions?.check_execution, false],
+      ['superpowers_style_eval_pack.boundary_assertions.test_execution', pack.boundary_assertions?.test_execution, false],
+      ['superpowers_style_eval_pack.boundary_assertions.eval_execution', pack.boundary_assertions?.eval_execution, false],
+      ['superpowers_style_eval_pack.boundary_assertions.agent_session_execution', pack.boundary_assertions?.agent_session_execution, false],
+      ['superpowers_style_eval_pack.boundary_assertions.workflow_execution', pack.boundary_assertions?.workflow_execution, false],
+      ['superpowers_style_eval_pack.boundary_assertions.skill_execution', pack.boundary_assertions?.skill_execution, false],
+      ['superpowers_style_eval_pack.boundary_assertions.model_invocation', pack.boundary_assertions?.model_invocation, false],
+      ['superpowers_style_eval_pack.boundary_assertions.subagent', pack.boundary_assertions?.subagent, false],
+      ['superpowers_style_eval_pack.boundary_assertions.mcp', pack.boundary_assertions?.mcp, false],
+      ['superpowers_style_eval_pack.boundary_assertions.git', pack.boundary_assertions?.git, false],
+      ['superpowers_style_eval_pack.boundary_assertions.git_write', pack.boundary_assertions?.git_write, false],
+      ['superpowers_style_eval_pack.boundary_assertions.commit', pack.boundary_assertions?.commit, false],
+      ['superpowers_style_eval_pack.boundary_assertions.pr', pack.boundary_assertions?.pr, false],
+      ['superpowers_style_eval_pack.boundary_assertions.push', pack.boundary_assertions?.push, false],
+      ['superpowers_style_eval_pack.boundary_assertions.merge', pack.boundary_assertions?.merge, false],
+      ['superpowers_style_eval_pack.boundary_assertions.business_source_write', pack.boundary_assertions?.business_source_write, false],
+      ['safety.stage', envelope.safety?.stage, 'Stage 138'],
+      ['safety.eval_execution', envelope.safety?.eval_execution, false],
+      ['safety.agent_session_execution', envelope.safety?.agent_session_execution, false],
+      ['safety.subagent', envelope.safety?.subagent, false],
+    ], 'evals --superpowers-style-pack --json');
+    if (!pack.eval_pack_digest) throw new Error('Superpowers-style eval pack missing eval_pack_digest');
+    for (const scenarioId of ['new_feature_should_not_jump_to_code', 'bug_should_reproduce_first', 'review_should_prioritize_blockers', 'commit_should_require_validation', 'subagent_requires_explicit_permission', 'session_start_should_show_lightweight_entry', 'plan_should_continue_without_repeated_confirmation', 'sdd_loop_should_cover_implement_review_fix', 'review_blocker_should_stop_next_task', 'resume_should_not_duplicate_dispatch']) {
+      const scenario = pack.scenario_pack?.find((item) => item.id === scenarioId);
+      if (!scenario) throw new Error(`Superpowers-style eval pack missing scenario: ${scenarioId}`);
+      if (scenario.execution_authorized !== false || scenario.model_judge_required !== false || scenario.deterministic_contract_only !== true) throw new Error(`Superpowers-style eval pack scenario boundary drift: ${scenarioId}`);
+      if (!scenario.expected_behavior?.length || !scenario.failure_signals?.length) throw new Error(`Superpowers-style eval pack scenario missing behavior fields: ${scenarioId}`);
+    }
+    if (!pack.next_eval_pack_bet?.target_stage) throw new Error('Superpowers-style eval pack missing next eval pack bet');
+    if (fs.existsSync(unexpectedState)) throw new Error('evals --superpowers-style-pack JSON output created unexpected state directory');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--superpowers-style-pack', '--from-comparison', comparisonFile, '--root', '.'], {
+      expectOutput: ['Vibecoding Runtime Superpowers-style Behavioral Eval Scenario Pack', 'Stage: Stage 138; Pack: superpowers-style-behavioral-eval-scenario-pack; pass=true', 'Comparison: Stage 133; scenarios=12; Digest:', '- new_feature_should_not_jump_to_code:', '- session_start_should_show_lightweight_entry:', '- resume_should_not_duplicate_dispatch:', 'Scenario ids:', 'Boundary: writes=false; eval_pack_artifact=false; scenario_artifact=false; comparison_artifact=false; state_directory_created=false; command_execution=false; check_execution=false; smoke_execution=false; test_execution=false; eval_execution=false; agent_session_execution=false; workflow_execution=false; skill_execution=false; runtime_action=false; auto_execution=false; prompt_mutation=false; hook_registration=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', 'Eval pack digest:'],
+    }, options);
+    if (fs.existsSync(unexpectedState)) throw new Error('evals --superpowers-style-pack text output created unexpected state directory');
+
+    for (const forbidden of ['--confirm', '--dry-run', '--write', '--preflight', '--dispatch', '--dispatch-intent', '--run', '--once', '--scan', '--auto-run']) {
+      run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--superpowers-style-pack', '--from-comparison', comparisonFile, forbidden, '--root', '.'], {
+        allowFailure: true,
+        expectOutput: ['evals --superpowers-style-pack is read-only and scenario-contract-only'],
+      }, options);
+    }
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--superpowers-style-pack', '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['evals --superpowers-style-pack requires --from-comparison <local-comparison-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--superpowers-style-pack', '--from-comparison', '../outside.json', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['evals --superpowers-style-pack --from-comparison must stay within --root'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--superpowers-style-pack', '--from-comparison', comparisonFile, '--from-file', comparisonFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['evals --superpowers-style-pack only accepts --from-comparison, --json, and --root'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--start', '--from-comparison', comparisonFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['--from-comparison is only supported by evals --superpowers-style-pack'],
+    }, options);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+export function runExperienceUpgradePrioritizerSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-experience-upgrade-prioritizer';
+  const absoluteTarget = path.join(repoRoot, target);
+  const comparisonFile = path.join(target, 'comparison.json');
+  const dashboardFile = path.join(target, 'dashboard.json');
+  const installFile = path.join(target, 'install-experience.json');
+  const expectedComparisonFile = comparisonFile.replace(/\\/g, '/');
+  const expectedDashboardFile = dashboardFile.replace(/\\/g, '/');
+  const expectedInstallFile = installFile.replace(/\\/g, '/');
+  const unexpectedState = path.join(repoRoot, '.vibecoding-state');
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(absoluteTarget, { recursive: true });
+    const comparison = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-comparison', '--from-superpowers-root', 'fork/superpowers', '--json', '--root', '.'], {}, options), 'governance --superpowers-comparison for upgrade prioritizer --json');
+    fs.writeFileSync(path.join(repoRoot, comparisonFile), `${JSON.stringify(comparison, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(path.join(repoRoot, dashboardFile), `${JSON.stringify({
+      experience_regression_dashboard: {
+        stage: 'Stage 132',
+        dashboard_kind: 'experience-regression-dashboard',
+        experience_scorecard: { overall_experience_score: 72 },
+        daily_user_friction_delta: { friction_score: 42 },
+        regression_blockers: [],
+        dashboard_digest: 'fixture-stage132-dashboard-digest',
+      },
+    }, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(path.join(repoRoot, installFile), `${JSON.stringify({
+      install_experience: {
+        stage: 'Stage 137',
+        score_kind: 'hook-adapter-install-experience-score',
+        install_experience_score: 84,
+        manual_steps_remaining: [{ id: 'copy-session-start-example', adapter: 'cursor' }],
+        blockers: [],
+        install_experience_digest: 'fixture-stage137-install-experience-digest',
+      },
+    }, null, 2)}\n`, 'utf8');
+
+    const envelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--experience-upgrades', '--from-comparison', comparisonFile, '--from-dashboard', dashboardFile, '--from-install-experience', installFile, '--json', '--root', '.'], {}, options), 'governance --experience-upgrades --json');
+    const prioritizer = envelope.experience_upgrade_prioritizer || {};
+    assertJsonMarkers([
+      ['command', envelope.command, 'governance'],
+      ['mode', envelope.mode, 'experience-upgrade-prioritizer'],
+      ['ok', envelope.ok, true],
+      ['experience_upgrade_prioritizer.stage', prioritizer.stage, 'Stage 139'],
+      ['experience_upgrade_prioritizer.prioritizer_kind', prioritizer.prioritizer_kind, 'experience-upgrade-prioritizer'],
+      ['experience_upgrade_prioritizer.source_bindings.comparison_file', prioritizer.source_bindings?.comparison_file, expectedComparisonFile],
+      ['experience_upgrade_prioritizer.source_bindings.dashboard_file', prioritizer.source_bindings?.dashboard_file, expectedDashboardFile],
+      ['experience_upgrade_prioritizer.source_bindings.install_experience_file', prioritizer.source_bindings?.install_experience_file, expectedInstallFile],
+      ['experience_upgrade_prioritizer.source_bindings.install_experience_provided', prioritizer.source_bindings?.install_experience_provided, true],
+      ['experience_upgrade_prioritizer.input_summary.comparison_stage', prioritizer.input_summary?.comparison_stage, 'Stage 133'],
+      ['experience_upgrade_prioritizer.input_summary.comparison_kind', prioritizer.input_summary?.comparison_kind, 'superpowers-comparative-evidence-matrix'],
+      ['experience_upgrade_prioritizer.input_summary.dashboard_stage', prioritizer.input_summary?.dashboard_stage, 'Stage 132'],
+      ['experience_upgrade_prioritizer.input_summary.dashboard_kind', prioritizer.input_summary?.dashboard_kind, 'experience-regression-dashboard'],
+      ['experience_upgrade_prioritizer.input_summary.install_experience_stage', prioritizer.input_summary?.install_experience_stage, 'Stage 137'],
+      ['experience_upgrade_prioritizer.input_summary.install_experience_provided', prioritizer.input_summary?.install_experience_provided, true],
+      ['experience_upgrade_prioritizer.upgrade_invariants.pass', prioritizer.upgrade_invariants?.pass, true],
+      ['experience_upgrade_prioritizer.writes', prioritizer.writes, false],
+      ['experience_upgrade_prioritizer.state_directory_created', prioritizer.state_directory_created, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.upgrade_artifact', prioritizer.boundary_assertions?.upgrade_artifact, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.prioritizer_artifact', prioritizer.boundary_assertions?.prioritizer_artifact, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.comparison_artifact', prioritizer.boundary_assertions?.comparison_artifact, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.dashboard_artifact', prioritizer.boundary_assertions?.dashboard_artifact, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.install_experience_artifact', prioritizer.boundary_assertions?.install_experience_artifact, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.command_execution', prioritizer.boundary_assertions?.command_execution, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.check_execution', prioritizer.boundary_assertions?.check_execution, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.smoke_execution', prioritizer.boundary_assertions?.smoke_execution, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.test_execution', prioritizer.boundary_assertions?.test_execution, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.eval_execution', prioritizer.boundary_assertions?.eval_execution, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.workflow_execution', prioritizer.boundary_assertions?.workflow_execution, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.skill_execution', prioritizer.boundary_assertions?.skill_execution, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.runtime_action', prioritizer.boundary_assertions?.runtime_action, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.auto_execution', prioritizer.boundary_assertions?.auto_execution, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.repair_execution', prioritizer.boundary_assertions?.repair_execution, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.prompt_mutation', prioritizer.boundary_assertions?.prompt_mutation, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.hook_registration', prioritizer.boundary_assertions?.hook_registration, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.platform_api', prioritizer.boundary_assertions?.platform_api, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.external_network', prioritizer.boundary_assertions?.external_network, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.model_invocation', prioritizer.boundary_assertions?.model_invocation, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.subagent', prioritizer.boundary_assertions?.subagent, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.mcp', prioritizer.boundary_assertions?.mcp, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.git', prioritizer.boundary_assertions?.git, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.git_write', prioritizer.boundary_assertions?.git_write, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.git_add', prioritizer.boundary_assertions?.git_add, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.commit', prioritizer.boundary_assertions?.commit, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.pr', prioritizer.boundary_assertions?.pr, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.push', prioritizer.boundary_assertions?.push, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.merge', prioritizer.boundary_assertions?.merge, false],
+      ['experience_upgrade_prioritizer.boundary_assertions.business_source_write', prioritizer.boundary_assertions?.business_source_write, false],
+      ['safety.stage', envelope.safety?.stage, 'Stage 139'],
+      ['safety.command_execution', envelope.safety?.command_execution, false],
+      ['safety.subagent', envelope.safety?.subagent, false],
+    ], 'governance --experience-upgrades --json');
+    if (!prioritizer.upgrade_digest) throw new Error('experience upgrade prioritizer missing upgrade_digest');
+    if (prioritizer.upgrade_candidates?.length !== 10) throw new Error('experience upgrade prioritizer candidate count mismatch');
+    if (!prioritizer.upgrade_candidates?.every((candidate) => Number.isInteger(candidate.impact_score) && Number.isInteger(candidate.risk_score) && Number.isInteger(candidate.implementation_cost) && Number.isInteger(candidate.priority_score))) throw new Error('experience upgrade prioritizer must keep impact/risk/cost/priority as separate integer scores');
+    if (!prioritizer.recommended_stage_order?.some((item) => item.stage === 'Stage 143' && item.candidate_id === 'next_action_evidence_prompts')) throw new Error('experience upgrade prioritizer missing next-action evidence recommendation');
+    if (!prioritizer.defer?.some((item) => item.candidate_id === 'default_live_agent_eval_runner')) throw new Error('experience upgrade prioritizer must defer live agent eval runner');
+    if (!prioritizer.defer?.some((item) => item.candidate_id === 'auto_subagent_execution')) throw new Error('experience upgrade prioritizer must defer automatic subagent execution');
+    if (!prioritizer.prioritization_policy?.defer_when?.some((item) => item.includes('platform API or network'))) throw new Error('experience upgrade prioritizer missing network/platform defer policy');
+    if (!prioritizer.next_upgrade_bet?.target_stage) throw new Error('experience upgrade prioritizer missing next upgrade bet');
+    if (fs.existsSync(unexpectedState)) throw new Error('governance --experience-upgrades JSON output created unexpected state directory');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--experience-upgrades', '--from-comparison', comparisonFile, '--from-dashboard', dashboardFile, '--root', '.'], {
+      expectOutput: ['Vibecoding Runtime Experience Upgrade Prioritizer', 'Stage: Stage 139; Kind: experience-upgrade-prioritizer; pass=true', 'Inputs: comparison=Stage 133; dashboard=Stage 132; install=not-provided', '- next_action_evidence_prompts:', 'Recommended stage order:', 'Deferred upgrades:', 'Next upgrade bet:', 'Boundary: writes=false; upgrade_artifact=false; prioritizer_artifact=false; comparison_artifact=false; dashboard_artifact=false; install_experience_artifact=false; source_write=false; sidecar_write=false; state_directory_created=false; command_execution=false; check_execution=false; smoke_execution=false; test_execution=false; eval_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; 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', 'Upgrade digest:'],
+    }, options);
+    if (fs.existsSync(unexpectedState)) throw new Error('governance --experience-upgrades text output created unexpected state directory');
+
+    for (const forbidden of ['--confirm', '--dry-run', '--write', '--preflight', '--dispatch', '--dispatch-intent', '--run', '--once', '--scan', '--auto-run']) {
+      run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--experience-upgrades', '--from-comparison', comparisonFile, '--from-dashboard', dashboardFile, forbidden, '--root', '.'], {
+        allowFailure: true,
+        expectOutput: ['governance --experience-upgrades is read-only and prioritizer-only'],
+      }, options);
+    }
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--experience-upgrades', '--from-dashboard', dashboardFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['governance --experience-upgrades requires --from-comparison <local-comparison-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--experience-upgrades', '--from-comparison', comparisonFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['governance --experience-upgrades requires --from-dashboard <local-dashboard-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--experience-upgrades', '--from-comparison', '../outside.json', '--from-dashboard', dashboardFile, '--root', target], {
+      allowFailure: true,
+      expectOutput: ['governance --experience-upgrades --from-comparison must stay within --root'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--experience-upgrades', '--from-comparison', comparisonFile, '--from-dashboard', dashboardFile, '--from-file', dashboardFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['governance --experience-upgrades only accepts --from-comparison, --from-dashboard, optional --from-install-experience, --json, and --root'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--start', '--from-dashboard', dashboardFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['--from-console, --from-dashboard, and --from-upgrades are only supported by workflow --next-evidence-prompts'],
+    }, options);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+export function runSuperpowersParityScorecardSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-superpowers-parity-scorecard';
+  const absoluteTarget = path.join(repoRoot, target);
+  const comparisonFile = path.join(target, 'comparison.json');
+  const disciplineFile = path.join(target, 'entry-discipline.json');
+  const dashboardFile = path.join(target, 'dashboard.json');
+  const installFile = path.join(target, 'install-experience.json');
+  const upgradesFile = path.join(target, 'upgrades.json');
+  const expectedComparisonFile = comparisonFile.replace(/\\/g, '/');
+  const expectedDisciplineFile = disciplineFile.replace(/\\/g, '/');
+  const expectedInstallFile = installFile.replace(/\\/g, '/');
+  const expectedUpgradesFile = upgradesFile.replace(/\\/g, '/');
+  const unexpectedState = path.join(repoRoot, '.vibecoding-state');
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(absoluteTarget, { recursive: true });
+    const comparison = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-comparison', '--from-superpowers-root', 'fork/superpowers', '--json', '--root', '.'], {}, options), 'governance --superpowers-comparison for parity scorecard --json');
+    fs.writeFileSync(path.join(repoRoot, comparisonFile), `${JSON.stringify(comparison, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(path.join(repoRoot, disciplineFile), `${JSON.stringify({
+      entry_trigger_discipline: {
+        stage: 'Stage 135',
+        discipline_kind: 'entry-trigger-discipline-contract',
+        ok: true,
+        trigger_results: [
+          { id: 'using_vibecoding_first', status: 'pass' },
+          { id: 'protocol_layers_declared', status: 'pass' },
+          { id: 'intent_route_match', status: 'pass' },
+          { id: 'no_direct_implementation_jump', status: 'pass' },
+        ],
+        missed_workflow_risks: [],
+        entry_discipline_invariants: { pass: true },
+        discipline_digest: 'fixture-stage135-entry-discipline-digest',
+      },
+    }, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(path.join(repoRoot, dashboardFile), `${JSON.stringify({
+      experience_regression_dashboard: {
+        stage: 'Stage 132',
+        dashboard_kind: 'experience-regression-dashboard',
+        experience_scorecard: { overall_experience_score: 72 },
+        daily_user_friction_delta: { friction_score: 42 },
+        regression_blockers: [],
+        dashboard_digest: 'fixture-stage132-dashboard-digest',
+      },
+    }, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(path.join(repoRoot, installFile), `${JSON.stringify({
+      install_experience: {
+        stage: 'Stage 137',
+        score_kind: 'hook-adapter-install-experience-score',
+        install_experience_score: 84,
+        natural_entry_score: 86,
+        adapter_consistency_score: 82,
+        manual_steps_remaining: [{ id: 'copy-session-start-example', adapter: 'cursor' }],
+        docs_friction: [],
+        blockers: [],
+        install_experience_digest: 'fixture-stage137-install-experience-digest',
+      },
+    }, null, 2)}\n`, 'utf8');
+    const upgrades = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--experience-upgrades', '--from-comparison', comparisonFile, '--from-dashboard', dashboardFile, '--from-install-experience', installFile, '--json', '--root', '.'], {}, options), 'governance --experience-upgrades for parity scorecard --json');
+    fs.writeFileSync(path.join(repoRoot, upgradesFile), `${JSON.stringify(upgrades, null, 2)}\n`, 'utf8');
+
+    const envelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-parity-scorecard', '--from-comparison', comparisonFile, '--from-entry-discipline', disciplineFile, '--from-install-experience', installFile, '--from-upgrades', upgradesFile, '--json', '--root', '.'], {}, options), 'governance --superpowers-parity-scorecard --json');
+    const scorecard = envelope.superpowers_parity_scorecard || {};
+    assertJsonMarkers([
+      ['command', envelope.command, 'governance'],
+      ['mode', envelope.mode, 'superpowers-parity-scorecard-v2'],
+      ['ok', envelope.ok, true],
+      ['superpowers_parity_scorecard.stage', scorecard.stage, 'Stage 140'],
+      ['superpowers_parity_scorecard.scorecard_kind', scorecard.scorecard_kind, 'superpowers-parity-scorecard-v2'],
+      ['superpowers_parity_scorecard.source_bindings.comparison_file', scorecard.source_bindings?.comparison_file, expectedComparisonFile],
+      ['superpowers_parity_scorecard.source_bindings.entry_discipline_file', scorecard.source_bindings?.entry_discipline_file, expectedDisciplineFile],
+      ['superpowers_parity_scorecard.source_bindings.install_experience_file', scorecard.source_bindings?.install_experience_file, expectedInstallFile],
+      ['superpowers_parity_scorecard.source_bindings.upgrades_file', scorecard.source_bindings?.upgrades_file, expectedUpgradesFile],
+      ['superpowers_parity_scorecard.input_summary.comparison_stage', scorecard.input_summary?.comparison_stage, 'Stage 133'],
+      ['superpowers_parity_scorecard.input_summary.entry_discipline_stage', scorecard.input_summary?.entry_discipline_stage, 'Stage 135'],
+      ['superpowers_parity_scorecard.input_summary.install_experience_stage', scorecard.input_summary?.install_experience_stage, 'Stage 137'],
+      ['superpowers_parity_scorecard.input_summary.upgrades_stage', scorecard.input_summary?.upgrades_stage, 'Stage 139'],
+      ['superpowers_parity_scorecard.parity_invariants.pass', scorecard.parity_invariants?.pass, true],
+      ['superpowers_parity_scorecard.writes', scorecard.writes, false],
+      ['superpowers_parity_scorecard.state_directory_created', scorecard.state_directory_created, false],
+      ['superpowers_parity_scorecard.boundary_assertions.parity_scorecard_artifact', scorecard.boundary_assertions?.parity_scorecard_artifact, false],
+      ['superpowers_parity_scorecard.boundary_assertions.scorecard_artifact', scorecard.boundary_assertions?.scorecard_artifact, false],
+      ['superpowers_parity_scorecard.boundary_assertions.entry_discipline_artifact', scorecard.boundary_assertions?.entry_discipline_artifact, false],
+      ['superpowers_parity_scorecard.boundary_assertions.upgrades_artifact', scorecard.boundary_assertions?.upgrades_artifact, false],
+      ['superpowers_parity_scorecard.boundary_assertions.full_skill_injection', scorecard.boundary_assertions?.full_skill_injection, false],
+      ['superpowers_parity_scorecard.boundary_assertions.command_execution', scorecard.boundary_assertions?.command_execution, false],
+      ['superpowers_parity_scorecard.boundary_assertions.eval_execution', scorecard.boundary_assertions?.eval_execution, false],
+      ['superpowers_parity_scorecard.boundary_assertions.agent_session_execution', scorecard.boundary_assertions?.agent_session_execution, false],
+      ['superpowers_parity_scorecard.boundary_assertions.workflow_execution', scorecard.boundary_assertions?.workflow_execution, false],
+      ['superpowers_parity_scorecard.boundary_assertions.skill_execution', scorecard.boundary_assertions?.skill_execution, false],
+      ['superpowers_parity_scorecard.boundary_assertions.platform_api', scorecard.boundary_assertions?.platform_api, false],
+      ['superpowers_parity_scorecard.boundary_assertions.external_network', scorecard.boundary_assertions?.external_network, false],
+      ['superpowers_parity_scorecard.boundary_assertions.model_invocation', scorecard.boundary_assertions?.model_invocation, false],
+      ['superpowers_parity_scorecard.boundary_assertions.subagent', scorecard.boundary_assertions?.subagent, false],
+      ['superpowers_parity_scorecard.boundary_assertions.mcp', scorecard.boundary_assertions?.mcp, false],
+      ['superpowers_parity_scorecard.boundary_assertions.git', scorecard.boundary_assertions?.git, false],
+      ['superpowers_parity_scorecard.boundary_assertions.git_write', scorecard.boundary_assertions?.git_write, false],
+      ['superpowers_parity_scorecard.boundary_assertions.commit', scorecard.boundary_assertions?.commit, false],
+      ['superpowers_parity_scorecard.boundary_assertions.pr', scorecard.boundary_assertions?.pr, false],
+      ['superpowers_parity_scorecard.boundary_assertions.push', scorecard.boundary_assertions?.push, false],
+      ['superpowers_parity_scorecard.boundary_assertions.merge', scorecard.boundary_assertions?.merge, false],
+      ['superpowers_parity_scorecard.boundary_assertions.business_source_write', scorecard.boundary_assertions?.business_source_write, false],
+      ['safety.stage', envelope.safety?.stage, 'Stage 140'],
+      ['safety.command_execution', envelope.safety?.command_execution, false],
+      ['safety.subagent', envelope.safety?.subagent, false],
+    ], 'governance --superpowers-parity-scorecard --json');
+    if (!scorecard.parity_digest) throw new Error('Superpowers parity scorecard missing parity_digest');
+    if (!Number.isInteger(scorecard.parity_score)) throw new Error('Superpowers parity scorecard missing integer parity_score');
+    if (scorecard.parity_axes?.length !== 9) throw new Error('Superpowers parity scorecard parity axis count mismatch');
+    if (!scorecard.vibecoding_leads?.some((item) => item.id === 'local_deterministic_contracts')) throw new Error('Superpowers parity scorecard missing local deterministic lead');
+    if (!scorecard.do_not_cross_boundaries?.some((item) => item.id === 'no_auto_subagent_execution')) throw new Error('Superpowers parity scorecard missing auto subagent boundary');
+    if (!scorecard.do_not_cross_boundaries?.some((item) => item.id === 'no_full_skill_injection')) throw new Error('Superpowers parity scorecard missing full skill injection boundary');
+    if (!scorecard.next_cycle_bet?.candidate_id) throw new Error('Superpowers parity scorecard missing next cycle bet');
+    if (fs.existsSync(unexpectedState)) throw new Error('governance --superpowers-parity-scorecard JSON output created unexpected state directory');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-parity-scorecard', '--from-comparison', comparisonFile, '--from-entry-discipline', disciplineFile, '--from-install-experience', installFile, '--from-upgrades', upgradesFile, '--root', '.'], {
+      expectOutput: ['Vibecoding Runtime Superpowers Parity Scorecard v2', 'Stage: Stage 140; Kind: superpowers-parity-scorecard-v2; pass=true', 'Inputs: comparison=Stage 133; entry=Stage 135; install=Stage 137; upgrades=Stage 139', 'Parity score:', '- session_start_bootstrap:', 'Vibecoding leads:', 'Remaining gaps:', 'Do not cross boundaries:', 'Next cycle bet:', 'Boundary: writes=false; parity_scorecard_artifact=false; scorecard_artifact=false; comparison_artifact=false; entry_discipline_artifact=false; install_experience_artifact=false; upgrades_artifact=false; source_write=false; sidecar_write=false; state_directory_created=false; command_execution=false; check_execution=false; smoke_execution=false; test_execution=false; eval_execution=false; agent_session_execution=false; verification_execution=false; workflow_execution=false; skill_execution=false; runtime_action=false; auto_execution=false; repair_execution=false; prompt_mutation=false; hook_registration=false; full_skill_injection=false; dynamic_tool_execution=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', 'Parity digest:'],
+    }, options);
+    if (fs.existsSync(unexpectedState)) throw new Error('governance --superpowers-parity-scorecard text output created unexpected state directory');
+
+    for (const forbidden of ['--confirm', '--dry-run', '--write', '--preflight', '--dispatch', '--dispatch-intent', '--run', '--once', '--scan', '--auto-run']) {
+      run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-parity-scorecard', '--from-comparison', comparisonFile, '--from-entry-discipline', disciplineFile, '--from-install-experience', installFile, '--from-upgrades', upgradesFile, forbidden, '--root', '.'], {
+        allowFailure: true,
+        expectOutput: ['governance --superpowers-parity-scorecard is read-only and scorecard-only'],
+      }, options);
+    }
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-parity-scorecard', '--from-entry-discipline', disciplineFile, '--from-install-experience', installFile, '--from-upgrades', upgradesFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['governance --superpowers-parity-scorecard requires --from-comparison <local-comparison-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-parity-scorecard', '--from-comparison', comparisonFile, '--from-install-experience', installFile, '--from-upgrades', upgradesFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['governance --superpowers-parity-scorecard requires --from-entry-discipline <local-discipline-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-parity-scorecard', '--from-comparison', '../outside.json', '--from-entry-discipline', disciplineFile, '--from-install-experience', installFile, '--from-upgrades', upgradesFile, '--root', target], {
+      allowFailure: true,
+      expectOutput: ['governance --superpowers-parity-scorecard --from-comparison must stay within --root'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-parity-scorecard', '--from-comparison', comparisonFile, '--from-entry-discipline', disciplineFile, '--from-install-experience', installFile, '--from-upgrades', upgradesFile, '--from-dashboard', dashboardFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['governance --superpowers-parity-scorecard only accepts --from-comparison, --from-entry-discipline, --from-install-experience, --from-upgrades, --json, and --root'],
+    }, options);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+export function releaseCheckStage137140SmokeHandlers(deps) {
+  return {
+    runInstallExperienceSmoke: (options) => runInstallExperienceSmoke(deps, options),
+    runSuperpowersStyleEvalPackSmoke: (options) => runSuperpowersStyleEvalPackSmoke(deps, options),
+    runExperienceUpgradePrioritizerSmoke: (options) => runExperienceUpgradePrioritizerSmoke(deps, options),
+    runSuperpowersParityScorecardSmoke: (options) => runSuperpowersParityScorecardSmoke(deps, options),
+  };
+}