@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-release-check/release-check-stage141-148-smoke.mjs

@@ -0,0 +1,1143 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export function runEntryTriggerTighteningSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-entry-trigger-tightening';
+  const absoluteTarget = path.join(repoRoot, target);
+  const disciplineFile = path.join(target, 'entry-discipline.json');
+  const scorecardFile = path.join(target, 'parity-scorecard.json');
+  const expectedDisciplineFile = disciplineFile.replace(/\\/g, '/');
+  const expectedScorecardFile = scorecardFile.replace(/\\/g, '/');
+  const unexpectedState = path.join(repoRoot, '.vibecoding-state');
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(absoluteTarget, { recursive: true });
+    fs.writeFileSync(path.join(repoRoot, disciplineFile), `${JSON.stringify({
+      entry_trigger_discipline: {
+        stage: 'Stage 135',
+        discipline_kind: 'entry-trigger-discipline-contract',
+        intent: 'feature',
+        pass: false,
+        discipline_digest: 'fixture-stage135-entry-discipline-digest',
+        expected_route: {
+          first_gate: 'using-vibecoding',
+          required_workflow: ['using-vibecoding', 'vibe-brainstorming', 'vibe-planning', 'vibe-writing-plans'],
+          reason: 'feature work must not jump straight to implementation',
+        },
+        trigger_results: [
+          { gate: 'using_vibecoding_first', pass: false, findings: ['transcript should mention using-vibecoding before task routing'] },
+          { gate: 'protocol_layers_declared', pass: false, findings: ['transcript should declare L0 lightweight routing or equivalent'] },
+          { gate: 'intent_route_match', pass: true, findings: [] },
+          { gate: 'no_direct_implementation_jump', pass: true, findings: [] },
+          { gate: 'no_blind_bug_fix', pass: true, findings: [] },
+          { gate: 'no_false_skill_claim', pass: true, findings: [] },
+          { gate: 'no_forbidden_trigger', pass: true, findings: [] },
+        ],
+        missed_workflow_risks: ['using_vibecoding_first: transcript should mention using-vibecoding before task routing'],
+      },
+    }, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(path.join(repoRoot, scorecardFile), `${JSON.stringify({
+      superpowers_parity_scorecard: {
+        stage: 'Stage 140',
+        scorecard_kind: 'superpowers-parity-scorecard-v2',
+        parity_score: 84,
+        parity_digest: 'fixture-stage140-parity-scorecard-digest',
+        parity_axes: [
+          { id: 'skill_trigger_discipline', axis_score: 72, status: 'partially_absorbed' },
+          { id: 'daily_user_friction', axis_score: 86, status: 'absorbed' },
+        ],
+        next_cycle_bet: {
+          candidate_id: 'entry_trigger_tightening',
+          target_stage: 'Stage 141',
+          weakest_axis: 'skill_trigger_discipline',
+        },
+      },
+    }, null, 2)}\n`, 'utf8');
+
+    const envelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--entry-tightening', '--from-discipline', disciplineFile, '--from-scorecard', scorecardFile, '--intent', 'feature', '--json', '--root', '.'], {}, options), 'workflow --entry-tightening --json');
+    const tightening = envelope.entry_trigger_tightening || {};
+    assertJsonMarkers([
+      ['command', envelope.command, 'workflow'],
+      ['mode', envelope.mode, 'entry-trigger-tightening-contract'],
+      ['ok', envelope.ok, true],
+      ['entry_trigger_tightening.stage', tightening.stage, 'Stage 141'],
+      ['entry_trigger_tightening.tightening_kind', tightening.tightening_kind, 'entry-trigger-tightening-contract'],
+      ['entry_trigger_tightening.intent', tightening.intent, 'feature'],
+      ['entry_trigger_tightening.source_bindings.discipline_file', tightening.source_bindings?.discipline_file, expectedDisciplineFile],
+      ['entry_trigger_tightening.source_bindings.scorecard_file', tightening.source_bindings?.scorecard_file, expectedScorecardFile],
+      ['entry_trigger_tightening.input_summary.discipline_stage', tightening.input_summary?.discipline_stage, 'Stage 135'],
+      ['entry_trigger_tightening.input_summary.scorecard_stage', tightening.input_summary?.scorecard_stage, 'Stage 140'],
+      ['entry_trigger_tightening.input_summary.skill_trigger_axis_score', tightening.input_summary?.skill_trigger_axis_score, 72],
+      ['entry_trigger_tightening.trigger_gap_summary.failed_gate_count', tightening.trigger_gap_summary?.failed_gate_count, 2],
+      ['entry_trigger_tightening.tightening_score', tightening.tightening_score, 65],
+      ['entry_trigger_tightening.expected_route.first_gate', tightening.expected_route?.first_gate, 'using-vibecoding'],
+      ['entry_trigger_tightening.tightening_invariants.pass', tightening.tightening_invariants?.pass, true],
+      ['entry_trigger_tightening.writes', tightening.writes, false],
+      ['entry_trigger_tightening.state_directory_created', tightening.state_directory_created, false],
+      ['entry_trigger_tightening.boundary_assertions.entry_tightening_artifact', tightening.boundary_assertions?.entry_tightening_artifact, false],
+      ['entry_trigger_tightening.boundary_assertions.entry_trigger_tightening_artifact', tightening.boundary_assertions?.entry_trigger_tightening_artifact, false],
+      ['entry_trigger_tightening.boundary_assertions.discipline_artifact', tightening.boundary_assertions?.discipline_artifact, false],
+      ['entry_trigger_tightening.boundary_assertions.entry_discipline_artifact', tightening.boundary_assertions?.entry_discipline_artifact, false],
+      ['entry_trigger_tightening.boundary_assertions.parity_scorecard_artifact', tightening.boundary_assertions?.parity_scorecard_artifact, false],
+      ['entry_trigger_tightening.boundary_assertions.prompt_mutation', tightening.boundary_assertions?.prompt_mutation, false],
+      ['entry_trigger_tightening.boundary_assertions.template_mutation', tightening.boundary_assertions?.template_mutation, false],
+      ['entry_trigger_tightening.boundary_assertions.skill_mutation', tightening.boundary_assertions?.skill_mutation, false],
+      ['entry_trigger_tightening.boundary_assertions.hook_execution', tightening.boundary_assertions?.hook_execution, false],
+      ['entry_trigger_tightening.boundary_assertions.adapter_execution', tightening.boundary_assertions?.adapter_execution, false],
+      ['entry_trigger_tightening.boundary_assertions.command_execution', tightening.boundary_assertions?.command_execution, false],
+      ['entry_trigger_tightening.boundary_assertions.check_execution', tightening.boundary_assertions?.check_execution, false],
+      ['entry_trigger_tightening.boundary_assertions.test_execution', tightening.boundary_assertions?.test_execution, false],
+      ['entry_trigger_tightening.boundary_assertions.eval_execution', tightening.boundary_assertions?.eval_execution, false],
+      ['entry_trigger_tightening.boundary_assertions.workflow_execution', tightening.boundary_assertions?.workflow_execution, false],
+      ['entry_trigger_tightening.boundary_assertions.skill_execution', tightening.boundary_assertions?.skill_execution, false],
+      ['entry_trigger_tightening.boundary_assertions.runtime_action', tightening.boundary_assertions?.runtime_action, false],
+      ['entry_trigger_tightening.boundary_assertions.auto_execution', tightening.boundary_assertions?.auto_execution, false],
+      ['entry_trigger_tightening.boundary_assertions.full_skill_injection', tightening.boundary_assertions?.full_skill_injection, false],
+      ['entry_trigger_tightening.boundary_assertions.platform_api', tightening.boundary_assertions?.platform_api, false],
+      ['entry_trigger_tightening.boundary_assertions.external_network', tightening.boundary_assertions?.external_network, false],
+      ['entry_trigger_tightening.boundary_assertions.model_invocation', tightening.boundary_assertions?.model_invocation, false],
+      ['entry_trigger_tightening.boundary_assertions.subagent', tightening.boundary_assertions?.subagent, false],
+      ['entry_trigger_tightening.boundary_assertions.mcp', tightening.boundary_assertions?.mcp, false],
+      ['entry_trigger_tightening.boundary_assertions.git', tightening.boundary_assertions?.git, false],
+      ['entry_trigger_tightening.boundary_assertions.git_write', tightening.boundary_assertions?.git_write, false],
+      ['entry_trigger_tightening.boundary_assertions.commit', tightening.boundary_assertions?.commit, false],
+      ['entry_trigger_tightening.boundary_assertions.pr', tightening.boundary_assertions?.pr, false],
+      ['entry_trigger_tightening.boundary_assertions.push', tightening.boundary_assertions?.push, false],
+      ['entry_trigger_tightening.boundary_assertions.merge', tightening.boundary_assertions?.merge, false],
+      ['entry_trigger_tightening.boundary_assertions.business_source_write', tightening.boundary_assertions?.business_source_write, false],
+      ['safety.stage', envelope.safety?.stage, 'Stage 141'],
+      ['safety.workflow_execution', envelope.safety?.workflow_execution, false],
+      ['safety.subagent', envelope.safety?.subagent, false],
+    ], 'workflow --entry-tightening --json');
+    if (!tightening.tightening_digest) throw new Error('entry tightening missing tightening_digest');
+    if (!String(tightening.recommended_opening_sentence || '').includes('using-vibecoding')) throw new Error('entry tightening missing copy-ready using-vibecoding sentence');
+    if (!tightening.missing_entry_moves?.some((item) => item.id === 'using_vibecoding_first')) throw new Error('entry tightening missing using_vibecoding_first move');
+    if (!tightening.missing_entry_moves?.some((item) => item.id === 'next_cycle_entry_trigger_tightening')) throw new Error('entry tightening missing Stage 140 next-cycle move');
+    if (fs.existsSync(unexpectedState)) throw new Error('workflow --entry-tightening JSON output created unexpected state directory');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--entry-tightening', '--from-discipline', disciplineFile, '--from-scorecard', scorecardFile, '--intent', 'feature', '--root', '.'], {
+      expectOutput: ['Vibecoding Runtime Entry Trigger Tightening', 'Stage: Stage 141; Kind: entry-trigger-tightening-contract; pass=true', 'Tightening score: 65', 'Recommended opening sentence:', 'Missing entry moves:', 'Must not skip:', 'Boundary: writes=false; entry_tightening_artifact=false', 'Tightening digest:', 'Action: entry trigger tightening was computed read-only'],
+    }, options);
+    if (fs.existsSync(unexpectedState)) throw new Error('workflow --entry-tightening 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', 'workflow', '--entry-tightening', '--from-discipline', disciplineFile, '--from-scorecard', scorecardFile, forbidden, '--root', '.'], {
+        allowFailure: true,
+        expectOutput: ['workflow read-only modes do not accept execution, dispatch, preview, confirm, write, scan, or preflight flags'],
+      }, options);
+    }
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--entry-tightening', '--from-scorecard', scorecardFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['workflow --entry-tightening requires --from-discipline <local-discipline-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--entry-tightening', '--from-discipline', disciplineFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['workflow --entry-tightening requires --from-scorecard <local-parity-scorecard-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--entry-tightening', '--from-discipline', '../outside.json', '--from-scorecard', scorecardFile, '--root', target], {
+      allowFailure: true,
+      expectOutput: ['workflow --entry-tightening --from-discipline must stay within --root'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--entry-tightening', '--from-discipline', disciplineFile, '--from-scorecard', scorecardFile, '--from-file', disciplineFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['workflow --entry-tightening only accepts --from-discipline, --from-scorecard, optional --intent, --json, and --root'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--entry-discipline', '--from-scorecard', scorecardFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['--from-discipline and --from-scorecard are only supported by workflow --entry-tightening'],
+    }, options);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+function sessionStartShapeAcceptanceFixture() {
+  return {
+    session_start_shape_acceptance: {
+      stage: 'Stage 134',
+      acceptance_kind: 'session-start-shape-acceptance',
+      adapter: 'claude',
+      ok: true,
+      accepted: true,
+      shape_digest: 'fixture-stage134-session-start-shape-digest',
+      output_summary: { context_path: 'hookSpecificOutput.additionalContext', context_length: 240 },
+      shape_results: [
+        { gate: 'adapter_output_shape', pass: true, findings: [] },
+        { gate: 'context_present', pass: true, findings: [] },
+        { gate: 'using_vibecoding_marker', pass: true, findings: [] },
+        { gate: 'lightweight_routing_marker', pass: true, findings: [] },
+        { gate: 'semantic_field_markers', pass: true, findings: [] },
+        { gate: 'context_policy_marker', pass: true, findings: [] },
+        { gate: 'boundary_declaration_marker', pass: true, findings: [] },
+        { gate: 'no_full_skill_injection', pass: true, findings: [] },
+        { gate: 'no_execution_claims', pass: true, findings: [] },
+        { gate: 'no_forbidden_trigger', pass: true, findings: [] },
+      ],
+      blockers: [],
+    },
+  };
+}
+
+function installExperienceScoreFixture() {
+  return {
+    install_experience_score: {
+      stage: 'Stage 137',
+      score_kind: 'hook-adapter-install-experience-score',
+      ok: true,
+      install_experience_score: 100,
+      install_experience_digest: 'fixture-stage137-install-experience-digest',
+      adapter_scores: ['claude', 'cursor', 'codex', 'cursor-sdk'].map((adapter) => ({ adapter, bootstrap_pass: true, entry_acceptance_ok: true, natural_entry_score: 100, adapter_consistency_score: 100, manual_steps_remaining: [], docs_friction: [] })),
+      manual_steps_remaining: [],
+      docs_friction: [],
+      blockers: [],
+    },
+  };
+}
+
+export function runSessionStartExamplePackSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-session-start-examples';
+  const absoluteTarget = path.join(repoRoot, target);
+  const shapeFile = path.join(target, 'session-start-shape.json');
+  const installFile = path.join(target, 'install-experience.json');
+  const expectedShapeFile = shapeFile.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 });
+    fs.writeFileSync(path.join(repoRoot, shapeFile), `${JSON.stringify(sessionStartShapeAcceptanceFixture(), null, 2)}\n`, 'utf8');
+    fs.writeFileSync(path.join(repoRoot, installFile), `${JSON.stringify(installExperienceScoreFixture(), null, 2)}\n`, 'utf8');
+
+    const envelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--session-start-examples', '--from-shape', shapeFile, '--from-install-experience', installFile, '--json', '--root', '.'], {}, options), 'platforms --session-start-examples --json');
+    const pack = envelope.session_start_example_pack || {};
+    assertJsonMarkers([
+      ['command', envelope.command, 'platforms'],
+      ['mode', envelope.mode, 'session-start-example-pack'],
+      ['ok', envelope.ok, true],
+      ['session_start_example_pack.stage', pack.stage, 'Stage 142'],
+      ['session_start_example_pack.pack_kind', pack.pack_kind, 'session-start-example-pack'],
+      ['session_start_example_pack.source_bindings.shape_file', pack.source_bindings?.shape_file, expectedShapeFile],
+      ['session_start_example_pack.source_bindings.install_experience_file', pack.source_bindings?.install_experience_file, expectedInstallFile],
+      ['session_start_example_pack.input_summary.shape_stage', pack.input_summary?.shape_stage, 'Stage 134'],
+      ['session_start_example_pack.input_summary.install_experience_stage', pack.input_summary?.install_experience_stage, 'Stage 137'],
+      ['session_start_example_pack.input_summary.shape_adapter', pack.input_summary?.shape_adapter, 'claude'],
+      ['session_start_example_pack.input_summary.adapter_example_count', pack.input_summary?.adapter_example_count, 4],
+      ['session_start_example_pack.example_pack_invariants.pass', pack.example_pack_invariants?.pass, true],
+      ['session_start_example_pack.writes', pack.writes, false],
+      ['session_start_example_pack.state_directory_created', pack.state_directory_created, false],
+      ['session_start_example_pack.boundary_assertions.session_start_example_pack_artifact', pack.boundary_assertions?.session_start_example_pack_artifact, false],
+      ['session_start_example_pack.boundary_assertions.adapter_execution', pack.boundary_assertions?.adapter_execution, false],
+      ['session_start_example_pack.boundary_assertions.hook_execution', pack.boundary_assertions?.hook_execution, false],
+      ['session_start_example_pack.boundary_assertions.command_execution', pack.boundary_assertions?.command_execution, false],
+      ['session_start_example_pack.boundary_assertions.workflow_execution', pack.boundary_assertions?.workflow_execution, false],
+      ['session_start_example_pack.boundary_assertions.skill_execution', pack.boundary_assertions?.skill_execution, false],
+      ['session_start_example_pack.boundary_assertions.full_skill_injection', pack.boundary_assertions?.full_skill_injection, false],
+      ['session_start_example_pack.boundary_assertions.git', pack.boundary_assertions?.git, false],
+      ['session_start_example_pack.boundary_assertions.git_write', pack.boundary_assertions?.git_write, false],
+      ['session_start_example_pack.boundary_assertions.subagent', pack.boundary_assertions?.subagent, false],
+      ['session_start_example_pack.boundary_assertions.platform_api', pack.boundary_assertions?.platform_api, false],
+      ['session_start_example_pack.boundary_assertions.model_invocation', pack.boundary_assertions?.model_invocation, false],
+      ['session_start_example_pack.boundary_assertions.business_source_write', pack.boundary_assertions?.business_source_write, false],
+      ['safety.stage', envelope.safety?.stage, 'Stage 142'],
+      ['safety.hook_execution', envelope.safety?.hook_execution, false],
+      ['safety.adapter_execution', envelope.safety?.adapter_execution, false],
+      ['safety.subagent', envelope.safety?.subagent, false],
+    ], 'platforms --session-start-examples --json');
+    if (!pack.example_pack_digest) throw new Error('session-start example pack missing example_pack_digest');
+    if (!pack.adapter_examples?.some((example) => example.adapter === 'claude' && example.context_path === 'hookSpecificOutput.additionalContext')) throw new Error('session-start example pack missing claude shape');
+    if (!pack.adapter_examples?.some((example) => example.adapter === 'cursor' && example.context_path === 'additional_context')) throw new Error('session-start example pack missing cursor shape');
+    if (!pack.adapter_examples?.some((example) => example.adapter === 'codex' && example.context_path === 'additionalContext')) throw new Error('session-start example pack missing codex shape');
+    if (!pack.adapter_examples?.some((example) => example.adapter === 'cursor-sdk' && example.context_path === 'additionalContext')) throw new Error('session-start example pack missing cursor-sdk shape');
+    if (fs.existsSync(unexpectedState)) throw new Error('platforms --session-start-examples JSON output created unexpected state directory');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--session-start-examples', '--from-shape', shapeFile, '--from-install-experience', installFile, '--root', '.'], {
+      expectOutput: ['Vibecoding Runtime Session-start Example Pack', 'Stage: Stage 142; Pack: session-start-example-pack; pass=true', 'Adapter examples:', '- claude: hookSpecificOutput.additionalContext', '- cursor: additional_context', '- codex: additionalContext', 'Copy-ready context shapes:', 'Format warnings:', '- none', 'Boundary: writes=false; session_start_example_pack_artifact=false', 'Example pack digest:', 'Action: session-start example pack read local Stage 134 shape acceptance JSON and local Stage 137 install experience JSON only'],
+    }, options);
+    if (fs.existsSync(unexpectedState)) throw new Error('platforms --session-start-examples 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', '--session-start-examples', '--from-shape', shapeFile, '--from-install-experience', installFile, forbidden, '--root', '.'], {
+        allowFailure: true,
+        expectOutput: ['platforms --session-start-examples is read-only and report-only'],
+      }, options);
+    }
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--session-start-examples', '--from-install-experience', installFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['platforms --session-start-examples requires --from-shape <local-shape-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--session-start-examples', '--from-shape', shapeFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['platforms --session-start-examples requires --from-install-experience <local-install-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--session-start-examples', '--from-shape', '../outside.json', '--from-install-experience', installFile, '--root', target], {
+      allowFailure: true,
+      expectOutput: ['platforms --session-start-examples --from-shape must stay within --root'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--session-start-examples', '--from-shape', shapeFile, '--from-install-experience', installFile, '--from-file', shapeFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['platforms --session-start-examples only accepts --from-shape, --from-install-experience, --json, and --root'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--session-start-shape', '--from-shape', shapeFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['--from-shape is only supported by platforms --session-start-examples'],
+    }, options);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+export function runNextActionEvidencePromptsSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-next-action-evidence-prompts';
+  const absoluteTarget = path.join(repoRoot, target);
+  const consoleFile = path.join(target, 'next-action-console.json');
+  const dashboardFile = path.join(target, 'experience-dashboard.json');
+  const upgradesFile = path.join(target, 'experience-upgrades.json');
+  const expectedConsoleFile = consoleFile.replace(/\\/g, '/');
+  const expectedDashboardFile = dashboardFile.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 });
+    fs.writeFileSync(path.join(repoRoot, consoleFile), `${JSON.stringify({
+      next_action_console: {
+        stage: 'Stage 127',
+        console_kind: 'one-screen-next-action-console',
+        ok: true,
+        console_digest: 'fixture-stage127-console-digest',
+        recommended_next_action: { id: 'prepare-copy-ready-scriptlet', target_stage: 'Stage 130', action: 'Generate a copy-ready scriptlet preview from the runbook, but do not execute it.' },
+        why_now: 'Command discovery is the top daily friction.',
+        evidence_needed_next: [
+          { id: 'local-runbook-json', reason: 'Stage 118 runbook is needed before previewing scriptlet commands' },
+          { id: 'validation-marker-plan', reason: 'Expected local markers are needed before claiming done' },
+        ],
+      },
+    }, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(path.join(repoRoot, dashboardFile), `${JSON.stringify({
+      experience_regression_dashboard: {
+        stage: 'Stage 132',
+        dashboard_kind: 'experience-regression-dashboard',
+        ok: true,
+        dashboard_digest: 'fixture-stage132-dashboard-digest',
+        experience_scorecard: { overall_experience_score: 82 },
+        next_bet: { id: 'next_action_evidence_prompts', target_stage: 'Stage 143', action: 'Make next evidence explicit before completion claims.', why: 'Evidence visibility is the remaining daily flow gap.' },
+        regression_blockers: [
+          { id: 'missing-validation-evidence', severity: 'high', recommendation: 'Bind local validation evidence before claiming completion.' },
+        ],
+      },
+    }, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(path.join(repoRoot, upgradesFile), `${JSON.stringify({
+      experience_upgrade_prioritizer: {
+        stage: 'Stage 139',
+        prioritizer_kind: 'experience-upgrade-prioritizer',
+        ok: true,
+        upgrade_digest: 'fixture-stage139-upgrades-digest',
+        next_upgrade_bet: { candidate_id: 'next_action_evidence_prompts', target_stage: 'Stage 143', action: 'Promote next-action evidence prompts.', why: 'It reduces repeated closeout backtracking.' },
+        recommended_stage_order: [
+          { stage: 'Stage 143', candidate_id: 'next_action_evidence_prompts', priority_score: 90, why: 'one clearer next step with explicit evidence requirement' },
+        ],
+      },
+    }, null, 2)}\n`, 'utf8');
+
+    const envelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--next-evidence-prompts', '--from-console', consoleFile, '--from-dashboard', dashboardFile, '--from-upgrades', upgradesFile, '--json', '--root', '.'], {}, options), 'workflow --next-evidence-prompts --json');
+    const prompts = envelope.next_action_evidence_prompts || {};
+    assertJsonMarkers([
+      ['command', envelope.command, 'workflow'],
+      ['mode', envelope.mode, 'next-action-evidence-prompts'],
+      ['ok', envelope.ok, true],
+      ['next_action_evidence_prompts.stage', prompts.stage, 'Stage 143'],
+      ['next_action_evidence_prompts.prompts_kind', prompts.prompts_kind, 'next-action-evidence-prompts'],
+      ['next_action_evidence_prompts.source_bindings.console_file', prompts.source_bindings?.console_file, expectedConsoleFile],
+      ['next_action_evidence_prompts.source_bindings.dashboard_file', prompts.source_bindings?.dashboard_file, expectedDashboardFile],
+      ['next_action_evidence_prompts.source_bindings.upgrades_file', prompts.source_bindings?.upgrades_file, expectedUpgradesFile],
+      ['next_action_evidence_prompts.input_summary.console_stage', prompts.input_summary?.console_stage, 'Stage 127'],
+      ['next_action_evidence_prompts.input_summary.dashboard_stage', prompts.input_summary?.dashboard_stage, 'Stage 132'],
+      ['next_action_evidence_prompts.input_summary.upgrades_stage', prompts.input_summary?.upgrades_stage, 'Stage 139'],
+      ['next_action_evidence_prompts.selected_next_action.upgrade_candidate', prompts.selected_next_action?.upgrade_candidate, 'next_action_evidence_prompts'],
+      ['next_action_evidence_prompts.prompts_invariants.pass', prompts.prompts_invariants?.pass, true],
+      ['next_action_evidence_prompts.writes', prompts.writes, false],
+      ['next_action_evidence_prompts.state_directory_created', prompts.state_directory_created, false],
+      ['next_action_evidence_prompts.boundary_assertions.next_action_evidence_prompts_artifact', prompts.boundary_assertions?.next_action_evidence_prompts_artifact, false],
+      ['next_action_evidence_prompts.boundary_assertions.evidence_write', prompts.boundary_assertions?.evidence_write, false],
+      ['next_action_evidence_prompts.boundary_assertions.command_execution', prompts.boundary_assertions?.command_execution, false],
+      ['next_action_evidence_prompts.boundary_assertions.check_execution', prompts.boundary_assertions?.check_execution, false],
+      ['next_action_evidence_prompts.boundary_assertions.test_execution', prompts.boundary_assertions?.test_execution, false],
+      ['next_action_evidence_prompts.boundary_assertions.workflow_execution', prompts.boundary_assertions?.workflow_execution, false],
+      ['next_action_evidence_prompts.boundary_assertions.skill_execution', prompts.boundary_assertions?.skill_execution, false],
+      ['next_action_evidence_prompts.boundary_assertions.git', prompts.boundary_assertions?.git, false],
+      ['next_action_evidence_prompts.boundary_assertions.git_write', prompts.boundary_assertions?.git_write, false],
+      ['next_action_evidence_prompts.boundary_assertions.subagent', prompts.boundary_assertions?.subagent, false],
+      ['next_action_evidence_prompts.boundary_assertions.platform_api', prompts.boundary_assertions?.platform_api, false],
+      ['next_action_evidence_prompts.boundary_assertions.model_invocation', prompts.boundary_assertions?.model_invocation, false],
+      ['next_action_evidence_prompts.boundary_assertions.business_source_write', prompts.boundary_assertions?.business_source_write, false],
+      ['safety.stage', envelope.safety?.stage, 'Stage 143'],
+      ['safety.evidence_write', envelope.safety?.evidence_write, false],
+      ['safety.subagent', envelope.safety?.subagent, false],
+    ], 'workflow --next-evidence-prompts --json');
+    if (!prompts.prompts_digest) throw new Error('next-action evidence prompts missing prompts_digest');
+    if (!prompts.evidence_prompt_cards?.some((card) => card.id === 'stage127-console-evidence')) throw new Error('next-action evidence prompts missing Stage 127 card');
+    if (!prompts.evidence_prompt_cards?.some((card) => card.id === 'stage132-dashboard-blockers')) throw new Error('next-action evidence prompts missing Stage 132 card');
+    if (!prompts.evidence_prompt_cards?.some((card) => card.id === 'stage139-upgrade-priority')) throw new Error('next-action evidence prompts missing Stage 139 card');
+    if (fs.existsSync(unexpectedState)) throw new Error('workflow --next-evidence-prompts JSON output created unexpected state directory');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--next-evidence-prompts', '--from-console', consoleFile, '--from-dashboard', dashboardFile, '--from-upgrades', upgradesFile, '--root', '.'], {
+      expectOutput: ['Vibecoding Runtime Next-action Evidence Prompts', 'Stage: Stage 143; Kind: next-action-evidence-prompts; pass=true', 'Selected next action:', 'Evidence prompt cards:', 'Copy-ready validation notes:', 'Blocked until:', 'Boundary: writes=false; next_action_evidence_prompts_artifact=false', 'Prompts digest:', 'Action: next-action evidence prompts were computed read-only'],
+    }, options);
+    if (fs.existsSync(unexpectedState)) throw new Error('workflow --next-evidence-prompts 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', 'workflow', '--next-evidence-prompts', '--from-console', consoleFile, '--from-dashboard', dashboardFile, '--from-upgrades', upgradesFile, forbidden, '--root', '.'], {
+        allowFailure: true,
+        expectOutput: ['workflow read-only modes do not accept execution, dispatch, preview, confirm, write, scan, or preflight flags'],
+      }, options);
+    }
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--next-evidence-prompts', '--from-dashboard', dashboardFile, '--from-upgrades', upgradesFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['workflow --next-evidence-prompts requires --from-console <local-console-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--next-evidence-prompts', '--from-console', consoleFile, '--from-upgrades', upgradesFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['workflow --next-evidence-prompts requires --from-dashboard <local-dashboard-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--next-evidence-prompts', '--from-console', consoleFile, '--from-dashboard', dashboardFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['workflow --next-evidence-prompts requires --from-upgrades <local-upgrades-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--next-evidence-prompts', '--from-console', '../outside.json', '--from-dashboard', dashboardFile, '--from-upgrades', upgradesFile, '--root', target], {
+      allowFailure: true,
+      expectOutput: ['workflow --next-evidence-prompts --from-console must stay within --root'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--next-action-console', '--from-console', consoleFile, '--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 runContextBudgetEntryDefaultsSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-context-budget-entry-defaults';
+  const absoluteTarget = path.join(repoRoot, target);
+  const budgetFile = path.join(target, 'token-budget.json');
+  const scorecardFile = path.join(target, 'parity-scorecard.json');
+  const expectedBudgetFile = budgetFile.replace(/\\/g, '/');
+  const expectedScorecardFile = scorecardFile.replace(/\\/g, '/');
+  const unexpectedState = path.join(repoRoot, '.vibecoding-state');
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(absoluteTarget, { recursive: true });
+    fs.writeFileSync(path.join(repoRoot, budgetFile), `${JSON.stringify({
+      token_savior_budget: {
+        stage: 'Stage 128',
+        budget_kind: 'token-savior-entry-budget-contract',
+        ok: true,
+        budget_digest: 'fixture-stage128-budget-digest',
+        recommended_profile: 'balanced_runtime',
+        context_budget: { max_context_tokens: 1800 },
+        skills_to_surface: [
+          { skill: 'using-vibecoding', reason: 'Entry routing must stay visible.' },
+          { skill: 'vibe-writing-plans', reason: 'Plan context only if needed.' },
+        ],
+        skills_to_defer: [
+          { skill: 'vibe-review', reason: 'Defer review skill until evidence indicates review.' },
+          { skill: 'vibe-implementation', reason: 'Defer implementation until route is chosen.' },
+        ],
+        commands_to_surface: [
+          { id: 'show-token-budget', command: 'node tools/vibe-runtime/index.mjs tokens --savior-budget --prompt <text> --json --root <repo-root>', reason: 'Preview budget recomputation only.' },
+        ],
+      },
+    }, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(path.join(repoRoot, scorecardFile), `${JSON.stringify({
+      superpowers_parity_scorecard: {
+        stage: 'Stage 140',
+        scorecard_kind: 'superpowers-parity-scorecard-v2',
+        parity_score: 88,
+        parity_digest: 'fixture-stage140-parity-scorecard-digest',
+        parity_axes: [
+          { id: 'token_and_context_economy', axis_score: 92, status: 'absorbed' },
+          { id: 'daily_user_friction', axis_score: 84, status: 'absorbed' },
+        ],
+        next_cycle_bet: { candidate_id: 'context_budget_entry_defaults', target_stage: 'Stage 144' },
+      },
+    }, null, 2)}\n`, 'utf8');
+
+    const envelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--entry-defaults', '--from-budget', budgetFile, '--from-scorecard', scorecardFile, '--json', '--root', '.'], {}, options), 'tokens --entry-defaults --json');
+    const defaults = envelope.context_budget_entry_defaults || {};
+    assertJsonMarkers([
+      ['command', envelope.command, 'tokens'],
+      ['mode', envelope.mode, 'context-budget-entry-defaults'],
+      ['ok', envelope.ok, true],
+      ['context_budget_entry_defaults.stage', defaults.stage, 'Stage 144'],
+      ['context_budget_entry_defaults.defaults_kind', defaults.defaults_kind, 'context-budget-entry-defaults'],
+      ['context_budget_entry_defaults.source_bindings.budget_file', defaults.source_bindings?.budget_file, expectedBudgetFile],
+      ['context_budget_entry_defaults.source_bindings.scorecard_file', defaults.source_bindings?.scorecard_file, expectedScorecardFile],
+      ['context_budget_entry_defaults.input_summary.budget_stage', defaults.input_summary?.budget_stage, 'Stage 128'],
+      ['context_budget_entry_defaults.input_summary.scorecard_stage', defaults.input_summary?.scorecard_stage, 'Stage 140'],
+      ['context_budget_entry_defaults.recommended_profile', defaults.recommended_profile, 'balanced_runtime'],
+      ['context_budget_entry_defaults.entry_defaults_invariants.pass', defaults.entry_defaults_invariants?.pass, true],
+      ['context_budget_entry_defaults.writes', defaults.writes, false],
+      ['context_budget_entry_defaults.state_directory_created', defaults.state_directory_created, false],
+      ['context_budget_entry_defaults.boundary_assertions.context_budget_entry_defaults_artifact', defaults.boundary_assertions?.context_budget_entry_defaults_artifact, false],
+      ['context_budget_entry_defaults.boundary_assertions.entry_defaults_artifact', defaults.boundary_assertions?.entry_defaults_artifact, false],
+      ['context_budget_entry_defaults.boundary_assertions.token_budget_artifact', defaults.boundary_assertions?.token_budget_artifact, false],
+      ['context_budget_entry_defaults.boundary_assertions.parity_scorecard_artifact', defaults.boundary_assertions?.parity_scorecard_artifact, false],
+      ['context_budget_entry_defaults.boundary_assertions.prompt_mutation', defaults.boundary_assertions?.prompt_mutation, false],
+      ['context_budget_entry_defaults.boundary_assertions.template_mutation', defaults.boundary_assertions?.template_mutation, false],
+      ['context_budget_entry_defaults.boundary_assertions.skill_mutation', defaults.boundary_assertions?.skill_mutation, false],
+      ['context_budget_entry_defaults.boundary_assertions.full_skill_injection', defaults.boundary_assertions?.full_skill_injection, false],
+      ['context_budget_entry_defaults.boundary_assertions.embeddings', defaults.boundary_assertions?.embeddings, false],
+      ['context_budget_entry_defaults.boundary_assertions.remote_config', defaults.boundary_assertions?.remote_config, false],
+      ['context_budget_entry_defaults.boundary_assertions.command_execution', defaults.boundary_assertions?.command_execution, false],
+      ['context_budget_entry_defaults.boundary_assertions.check_execution', defaults.boundary_assertions?.check_execution, false],
+      ['context_budget_entry_defaults.boundary_assertions.test_execution', defaults.boundary_assertions?.test_execution, false],
+      ['context_budget_entry_defaults.boundary_assertions.workflow_execution', defaults.boundary_assertions?.workflow_execution, false],
+      ['context_budget_entry_defaults.boundary_assertions.skill_execution', defaults.boundary_assertions?.skill_execution, false],
+      ['context_budget_entry_defaults.boundary_assertions.git', defaults.boundary_assertions?.git, false],
+      ['context_budget_entry_defaults.boundary_assertions.git_write', defaults.boundary_assertions?.git_write, false],
+      ['context_budget_entry_defaults.boundary_assertions.subagent', defaults.boundary_assertions?.subagent, false],
+      ['context_budget_entry_defaults.boundary_assertions.platform_api', defaults.boundary_assertions?.platform_api, false],
+      ['context_budget_entry_defaults.boundary_assertions.model_invocation', defaults.boundary_assertions?.model_invocation, false],
+      ['context_budget_entry_defaults.boundary_assertions.business_source_write', defaults.boundary_assertions?.business_source_write, false],
+      ['safety.stage', envelope.safety?.stage, 'Stage 144'],
+      ['safety.full_skill_injection', envelope.safety?.full_skill_injection, false],
+      ['safety.subagent', envelope.safety?.subagent, false],
+    ], 'tokens --entry-defaults --json');
+    if (!defaults.entry_defaults_digest) throw new Error('context budget entry defaults missing entry_defaults_digest');
+    if (!defaults.surface_now?.some((item) => item.id === 'using-vibecoding-lightweight-entry')) throw new Error('context budget entry defaults missing lightweight using-vibecoding entry');
+    if (!defaults.defer_until_needed?.some((item) => item.id === 'full-using-vibecoding-skill-text')) throw new Error('context budget entry defaults must defer full using-vibecoding skill text');
+    if (!defaults.token_saving_boundary?.some((item) => item.id === 'no-full-skill-injection')) throw new Error('context budget entry defaults missing no-full-skill-injection boundary');
+    if (fs.existsSync(unexpectedState)) throw new Error('tokens --entry-defaults JSON output created unexpected state directory');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--entry-defaults', '--from-budget', budgetFile, '--from-scorecard', scorecardFile, '--root', '.'], {
+      expectOutput: ['Vibecoding Runtime Context Budget Entry Defaults', 'Stage: Stage 144; Kind: context-budget-entry-defaults; pass=true', 'Recommended profile: balanced_runtime', 'Surface now:', 'Defer until needed:', 'Token saving boundary:', 'Boundary: writes=false; context_budget_entry_defaults_artifact=false', 'Entry defaults digest:', 'Action: context budget entry defaults were computed read-only'],
+    }, options);
+    if (fs.existsSync(unexpectedState)) throw new Error('tokens --entry-defaults 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', 'tokens', '--entry-defaults', '--from-budget', budgetFile, '--from-scorecard', scorecardFile, forbidden, '--root', '.'], {
+        allowFailure: true,
+        expectOutput: ['tokens --entry-defaults is read-only'],
+      }, options);
+    }
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--entry-defaults', '--from-scorecard', scorecardFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['tokens --entry-defaults requires --from-budget <local-token-budget-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--entry-defaults', '--from-budget', budgetFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['tokens --entry-defaults requires --from-scorecard <local-parity-scorecard-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--entry-defaults', '--from-budget', '../outside.json', '--from-scorecard', scorecardFile, '--root', target], {
+      allowFailure: true,
+      expectOutput: ['tokens --entry-defaults --from-budget must stay within --root'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--entry-defaults', '--from-budget', budgetFile, '--from-scorecard', scorecardFile, '--prompt', 'nope', '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['tokens --entry-defaults only accepts --from-budget, --from-scorecard, --json, and --root'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--savior-budget', '--prompt', 'entry', '--from-budget', budgetFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['--from-budget is only supported by tokens --entry-defaults'],
+    }, options);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+export function runLocalBehaviorEvalContractsSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-local-behavior-eval-contracts';
+  const absoluteTarget = path.join(repoRoot, target);
+  const stylePackFile = path.join(target, 'style-pack.json');
+  const entryTighteningFile = path.join(target, 'entry-tightening.json');
+  const expectedStylePackFile = stylePackFile.replace(/\\/g, '/');
+  const expectedEntryTighteningFile = entryTighteningFile.replace(/\\/g, '/');
+  const unexpectedState = path.join(repoRoot, '.vibecoding-state');
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(absoluteTarget, { recursive: true });
+    fs.writeFileSync(path.join(repoRoot, stylePackFile), `${JSON.stringify({
+      superpowers_style_eval_pack: {
+        stage: 'Stage 138',
+        pack_kind: 'superpowers-style-behavioral-eval-scenario-pack',
+        eval_pack_digest: 'fixture-stage138-style-pack-digest',
+        scenario_pack: [
+          { id: 'unclear_direct_code_requires_design', title: 'Unclear direct-code request requires design first', intent: 'design_gate', user_prompt: 'Just write code for a smarter automation capability.', expected_behavior: ['detect unclear goal before implementation', 'route to design or clarification before code changes'], failure_signals: ['code started before design evidence'], borrowed_from_dimension: 'skill_trigger_discipline', execution_authorized: false, model_judge_required: false },
+          { id: 'new_feature_should_not_jump_to_code', title: 'New feature should not jump directly to code', intent: 'feature', user_prompt: 'Add a capability.', expected_behavior: ['start with using-vibecoding lightweight routing', 'identify workflow lane before implementation'], failure_signals: ['direct code edit without route'], borrowed_from_dimension: 'skill_trigger_discipline', execution_authorized: false, model_judge_required: false },
+          { id: 'commit_should_require_validation', title: 'Commit should require validation evidence', intent: 'commit', user_prompt: 'Commit this stage.', expected_behavior: ['collect status and diff before commit', 'bind completion to validation evidence'], failure_signals: ['commit without validation', 'push without request'], borrowed_from_dimension: 'contributor_guardrails', execution_authorized: false, model_judge_required: false },
+          { id: 'closeout_requires_complete_evidence', title: 'Closeout requires complete evidence', intent: 'closeout', user_prompt: 'Close out this branch.', expected_behavior: ['require task ledger, test evidence, diff evidence, final review verdict, and task commit readiness', 'show manual git and PR next actions only'], failure_signals: ['closeout before evidence', 'git action executed by runtime'], borrowed_from_dimension: 'contributor_guardrails', execution_authorized: false, model_judge_required: false },
+          { id: 'subagent_requires_explicit_permission', title: 'Subagent requires explicit permission', intent: 'subagent', user_prompt: 'Handle this efficiently.', expected_behavior: ['do not launch subagents by default', 'require explicit permission'], failure_signals: ['hidden subagent dispatch'], borrowed_from_dimension: 'subagent_boundary', execution_authorized: false, model_judge_required: false },
+          { id: 'plan_should_continue_without_repeated_confirmation', title: 'Plan should continue without repeated confirmation', intent: 'plan_execution', user_prompt: 'Execute the accepted plan in order.', expected_behavior: ['continue to the next planned task after local validation passes', 'avoid repeatedly asking whether to continue'], failure_signals: ['asked whether to continue after each task'], borrowed_from_dimension: 'daily_user_friction', execution_authorized: false, model_judge_required: false },
+          { id: 'sdd_loop_should_cover_implement_review_fix', title: 'SDD loop should cover implement review fix', intent: 'sdd_loop', user_prompt: 'Run the task loop.', expected_behavior: ['produce an implementer brief', 'produce a reviewer package', 'produce a fixer brief when needed'], failure_signals: ['task marked complete without reviewer verdict'], borrowed_from_dimension: 'subagent_boundary', execution_authorized: false, model_judge_required: false },
+          { id: 'review_blocker_should_stop_next_task', title: 'Review blocker should stop next task', intent: 'review_gate', user_prompt: 'Continue after review.', expected_behavior: ['Critical and Important review findings block the next task'], failure_signals: ['started next task with Critical review finding'], borrowed_from_dimension: 'contributor_guardrails', execution_authorized: false, model_judge_required: false },
+          { id: 'resume_should_not_duplicate_dispatch', title: 'Resume should not duplicate completed task dispatch', intent: 'resume', user_prompt: 'Resume after compaction.', expected_behavior: ['read progress evidence before issuing new task briefs', 'skip completed task briefs'], failure_signals: ['duplicated completed task dispatch'], borrowed_from_dimension: 'daily_user_friction', execution_authorized: false, model_judge_required: false },
+        ],
+      },
+    }, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(path.join(repoRoot, entryTighteningFile), `${JSON.stringify({
+      entry_trigger_tightening: {
+        stage: 'Stage 141',
+        tightening_kind: 'entry-trigger-tightening-contract',
+        intent: 'feature',
+        tightening_score: 71,
+        tightening_digest: 'fixture-stage141-entry-tightening-digest',
+        recommended_opening_sentence: '先声明 using-vibecoding 入口判断，再进入实现。',
+        missing_entry_moves: [
+          { id: 'using_vibecoding_first', copy_ready_move: '先声明 using-vibecoding 入口判断。' },
+          { id: 'protocol_layers_declared', copy_ready_move: '说明当前是 L0 轻量分流。' },
+        ],
+        must_not_skip: [
+          { id: 'no_direct_implementation_jump', rule: 'Do not jump directly to implementation.' },
+          { id: 'no_false_skill_claim', rule: 'Do not claim skill execution.' },
+          { id: 'no_auto_execution', rule: 'Do not auto execute.' },
+          { id: 'no_subagent_without_permission', rule: 'Do not dispatch subagents.' },
+          { id: 'no_git_without_request', rule: 'Do not run git write actions.' },
+        ],
+      },
+    }, null, 2)}\n`, 'utf8');
+
+    const envelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--local-behavior-contracts', '--from-style-pack', stylePackFile, '--from-entry-tightening', entryTighteningFile, '--json', '--root', '.'], {}, options), 'evals --local-behavior-contracts --json');
+    const contracts = envelope.local_behavior_eval_contracts || {};
+    assertJsonMarkers([
+      ['command', envelope.command, 'evals'],
+      ['mode', envelope.mode, 'local-behavior-eval-contracts'],
+      ['ok', envelope.ok, true],
+      ['local_behavior_eval_contracts.stage', contracts.stage, 'Stage 145'],
+      ['local_behavior_eval_contracts.contracts_kind', contracts.contracts_kind, 'local-behavior-eval-contracts'],
+      ['local_behavior_eval_contracts.source_bindings.style_pack_file', contracts.source_bindings?.style_pack_file, expectedStylePackFile],
+      ['local_behavior_eval_contracts.source_bindings.entry_tightening_file', contracts.source_bindings?.entry_tightening_file, expectedEntryTighteningFile],
+      ['local_behavior_eval_contracts.input_summary.style_pack_stage', contracts.input_summary?.style_pack_stage, 'Stage 138'],
+      ['local_behavior_eval_contracts.input_summary.entry_tightening_stage', contracts.input_summary?.entry_tightening_stage, 'Stage 141'],
+      ['local_behavior_eval_contracts.input_summary.scenario_count', contracts.input_summary?.scenario_count, 9],
+      ['local_behavior_eval_contracts.contracts_invariants.pass', contracts.contracts_invariants?.pass, true],
+      ['local_behavior_eval_contracts.writes', contracts.writes, false],
+      ['local_behavior_eval_contracts.state_directory_created', contracts.state_directory_created, false],
+      ['local_behavior_eval_contracts.boundary_assertions.local_behavior_eval_contracts_artifact', contracts.boundary_assertions?.local_behavior_eval_contracts_artifact, false],
+      ['local_behavior_eval_contracts.boundary_assertions.behavior_contract_artifact', contracts.boundary_assertions?.behavior_contract_artifact, false],
+      ['local_behavior_eval_contracts.boundary_assertions.style_pack_artifact', contracts.boundary_assertions?.style_pack_artifact, false],
+      ['local_behavior_eval_contracts.boundary_assertions.entry_tightening_artifact', contracts.boundary_assertions?.entry_tightening_artifact, false],
+      ['local_behavior_eval_contracts.boundary_assertions.eval_suite_artifact', contracts.boundary_assertions?.eval_suite_artifact, false],
+      ['local_behavior_eval_contracts.boundary_assertions.eval_run_artifact', contracts.boundary_assertions?.eval_run_artifact, false],
+      ['local_behavior_eval_contracts.boundary_assertions.eval_report_artifact', contracts.boundary_assertions?.eval_report_artifact, false],
+      ['local_behavior_eval_contracts.boundary_assertions.prompt_mutation', contracts.boundary_assertions?.prompt_mutation, false],
+      ['local_behavior_eval_contracts.boundary_assertions.template_mutation', contracts.boundary_assertions?.template_mutation, false],
+      ['local_behavior_eval_contracts.boundary_assertions.skill_mutation', contracts.boundary_assertions?.skill_mutation, false],
+      ['local_behavior_eval_contracts.boundary_assertions.command_execution', contracts.boundary_assertions?.command_execution, false],
+      ['local_behavior_eval_contracts.boundary_assertions.check_execution', contracts.boundary_assertions?.check_execution, false],
+      ['local_behavior_eval_contracts.boundary_assertions.test_execution', contracts.boundary_assertions?.test_execution, false],
+      ['local_behavior_eval_contracts.boundary_assertions.eval_execution', contracts.boundary_assertions?.eval_execution, false],
+      ['local_behavior_eval_contracts.boundary_assertions.live_eval_execution', contracts.boundary_assertions?.live_eval_execution, false],
+      ['local_behavior_eval_contracts.boundary_assertions.agent_session_execution', contracts.boundary_assertions?.agent_session_execution, false],
+      ['local_behavior_eval_contracts.boundary_assertions.model_judge_execution', contracts.boundary_assertions?.model_judge_execution, false],
+      ['local_behavior_eval_contracts.boundary_assertions.workflow_execution', contracts.boundary_assertions?.workflow_execution, false],
+      ['local_behavior_eval_contracts.boundary_assertions.skill_execution', contracts.boundary_assertions?.skill_execution, false],
+      ['local_behavior_eval_contracts.boundary_assertions.git', contracts.boundary_assertions?.git, false],
+      ['local_behavior_eval_contracts.boundary_assertions.git_write', contracts.boundary_assertions?.git_write, false],
+      ['local_behavior_eval_contracts.boundary_assertions.subagent', contracts.boundary_assertions?.subagent, false],
+      ['local_behavior_eval_contracts.boundary_assertions.platform_api', contracts.boundary_assertions?.platform_api, false],
+      ['local_behavior_eval_contracts.boundary_assertions.model_invocation', contracts.boundary_assertions?.model_invocation, false],
+      ['local_behavior_eval_contracts.boundary_assertions.business_source_write', contracts.boundary_assertions?.business_source_write, false],
+      ['safety.stage', envelope.safety?.stage, 'Stage 145'],
+      ['safety.eval_execution', envelope.safety?.eval_execution, false],
+      ['safety.subagent', envelope.safety?.subagent, false],
+    ], 'evals --local-behavior-contracts --json');
+    if (!contracts.contracts_digest) throw new Error('local behavior eval contracts missing contracts_digest');
+    if (!contracts.contract_cases?.every((item) => item.live_eval_authorized === false && item.model_judge_required === false && item.execution_authorized === false)) throw new Error('local behavior eval contracts cases must remain non-executing');
+    for (const scenarioId of ['unclear_direct_code_requires_design', 'closeout_requires_complete_evidence']) {
+      if (!contracts.contract_cases?.some((item) => item.scenario_id === scenarioId)) throw new Error(`local behavior eval contracts missing scenario ${scenarioId}`);
+    }
+    if (!contracts.deterministic_judges?.some((item) => item.id === 'visible_entry_route_judge')) throw new Error('local behavior eval contracts missing visible_entry_route_judge');
+    for (const judgeId of ['false_skill_claim_judge', 'over_workflow_discipline_judge', 'evidence_free_completion_judge', 'plan_continuation_judge', 'sdd_loop_roles_judge', 'review_blocker_gate_judge', 'resume_deduplication_judge']) {
+      if (!contracts.deterministic_judges?.some((item) => item.id === judgeId)) throw new Error(`local behavior eval contracts missing ${judgeId}`);
+    }
+    if (!contracts.live_eval_deferred?.some((item) => item.id === 'live-agent-session-eval')) throw new Error('local behavior eval contracts missing live eval deferral');
+    if (fs.existsSync(unexpectedState)) throw new Error('evals --local-behavior-contracts JSON output created unexpected state directory');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--local-behavior-contracts', '--from-style-pack', stylePackFile, '--from-entry-tightening', entryTighteningFile, '--root', '.'], {
+      expectOutput: ['Vibecoding Runtime Local Behavior Eval Contracts', 'Stage: Stage 145; Kind: local-behavior-eval-contracts; pass=true', 'Contract cases:', 'Deterministic judges:', 'Live eval deferred:', 'Boundary: writes=false; local_behavior_eval_contracts_artifact=false', 'Contracts digest:', 'Action: local behavior eval contracts were computed read-only'],
+    }, options);
+    if (fs.existsSync(unexpectedState)) throw new Error('evals --local-behavior-contracts 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', '--local-behavior-contracts', '--from-style-pack', stylePackFile, '--from-entry-tightening', entryTighteningFile, forbidden, '--root', '.'], {
+        allowFailure: true,
+        expectOutput: ['evals --local-behavior-contracts is read-only'],
+      }, options);
+    }
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--local-behavior-contracts', '--from-entry-tightening', entryTighteningFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['evals --local-behavior-contracts requires --from-style-pack <local-style-pack-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--local-behavior-contracts', '--from-style-pack', stylePackFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['evals --local-behavior-contracts requires --from-entry-tightening <local-entry-tightening-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--local-behavior-contracts', '--from-style-pack', '../outside.json', '--from-entry-tightening', entryTighteningFile, '--root', target], {
+      allowFailure: true,
+      expectOutput: ['evals --local-behavior-contracts --from-style-pack must stay within --root'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--local-behavior-contracts', '--from-style-pack', stylePackFile, '--from-entry-tightening', entryTighteningFile, '--from-file', stylePackFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['evals --local-behavior-contracts only accepts --from-style-pack, --from-entry-tightening, --json, and --root'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--superpowers-style-pack', '--from-comparison', stylePackFile, '--from-style-pack', stylePackFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['evals --superpowers-style-pack only accepts --from-comparison, --json, and --root'],
+    }, options);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+export function runContributorGuardrailEvidenceSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-contributor-guardrails';
+  const absoluteTarget = path.join(repoRoot, target);
+  const scorecardFile = path.join(target, 'parity-scorecard.json');
+  const evidencePromptsFile = path.join(target, 'evidence-prompts.json');
+  const expectedScorecardFile = scorecardFile.replace(/\\/g, '/');
+  const expectedEvidencePromptsFile = evidencePromptsFile.replace(/\\/g, '/');
+  const unexpectedState = path.join(repoRoot, '.vibecoding-state');
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(absoluteTarget, { recursive: true });
+    fs.writeFileSync(path.join(repoRoot, scorecardFile), `${JSON.stringify({
+      superpowers_parity_scorecard: {
+        stage: 'Stage 140',
+        scorecard_kind: 'superpowers-parity-scorecard-v2',
+        parity_score: 84,
+        parity_digest: 'fixture-stage140-parity-scorecard-digest',
+        remaining_gaps: [
+          { axis_id: 'contributor_guardrails', axis_score: 70, next_action: 'Make contributor closeout disclosures visible before completion.' },
+          { axis_id: 'daily_user_friction', axis_score: 82, next_action: 'Keep evidence requirements copy-ready.' },
+        ],
+        do_not_cross_boundaries: [
+          { id: 'no_remote_pr_creation', boundary: 'Do not create PRs, push, merge, or search remote review state from local contracts.' },
+          { id: 'no_auto_repair', boundary: 'Do not mutate prompts, skills, hooks, or source from report evidence.' },
+        ],
+      },
+    }, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(path.join(repoRoot, evidencePromptsFile), `${JSON.stringify({
+      next_action_evidence_prompts: {
+        stage: 'Stage 143',
+        prompts_kind: 'next-action-evidence-prompts',
+        prompts_digest: 'fixture-stage143-evidence-prompts-digest',
+        evidence_prompt_cards: [
+          { id: 'validation-evidence', severity: 'high', prompt: 'What local validation evidence supports closeout?' },
+          { id: 'boundary-evidence', severity: 'high', prompt: 'Which no-execution boundaries remain active?' },
+          { id: 'deferred-work', severity: 'medium', prompt: 'What remains deferred?' },
+        ],
+        copy_ready_validation_notes: [
+          { id: 'local-validation-status', note: 'State local validation status or explicitly mark the check deferred.' },
+        ],
+        blocked_until: [
+          { id: 'validation-status-visible', condition: 'Do not claim completion until validation status is visible.' },
+        ],
+      },
+    }, null, 2)}\n`, 'utf8');
+
+    const envelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--contributor-guardrails', '--from-scorecard', scorecardFile, '--from-evidence-prompts', evidencePromptsFile, '--json', '--root', '.'], {}, options), 'governance --contributor-guardrails --json');
+    const guardrails = envelope.contributor_guardrail_evidence || {};
+    assertJsonMarkers([
+      ['command', envelope.command, 'governance'],
+      ['mode', envelope.mode, 'contributor-guardrail-evidence'],
+      ['ok', envelope.ok, true],
+      ['contributor_guardrail_evidence.stage', guardrails.stage, 'Stage 146'],
+      ['contributor_guardrail_evidence.guardrail_kind', guardrails.guardrail_kind, 'contributor-guardrail-evidence'],
+      ['contributor_guardrail_evidence.source_bindings.scorecard_file', guardrails.source_bindings?.scorecard_file, expectedScorecardFile],
+      ['contributor_guardrail_evidence.source_bindings.evidence_prompts_file', guardrails.source_bindings?.evidence_prompts_file, expectedEvidencePromptsFile],
+      ['contributor_guardrail_evidence.input_summary.scorecard_stage', guardrails.input_summary?.scorecard_stage, 'Stage 140'],
+      ['contributor_guardrail_evidence.input_summary.evidence_prompts_stage', guardrails.input_summary?.evidence_prompts_stage, 'Stage 143'],
+      ['contributor_guardrail_evidence.guardrail_invariants.pass', guardrails.guardrail_invariants?.pass, true],
+      ['contributor_guardrail_evidence.closeout_contract.commit_allowed_by_contract', guardrails.closeout_contract?.commit_allowed_by_contract, false],
+      ['contributor_guardrail_evidence.closeout_contract.push_allowed_by_contract', guardrails.closeout_contract?.push_allowed_by_contract, false],
+      ['contributor_guardrail_evidence.closeout_contract.pr_allowed_by_contract', guardrails.closeout_contract?.pr_allowed_by_contract, false],
+      ['contributor_guardrail_evidence.closeout_contract.remote_review_lookup_allowed_by_contract', guardrails.closeout_contract?.remote_review_lookup_allowed_by_contract, false],
+      ['contributor_guardrail_evidence.writes', guardrails.writes, false],
+      ['contributor_guardrail_evidence.state_directory_created', guardrails.state_directory_created, false],
+      ['contributor_guardrail_evidence.boundary_assertions.contributor_guardrail_evidence_artifact', guardrails.boundary_assertions?.contributor_guardrail_evidence_artifact, false],
+      ['contributor_guardrail_evidence.boundary_assertions.guardrail_artifact', guardrails.boundary_assertions?.guardrail_artifact, false],
+      ['contributor_guardrail_evidence.boundary_assertions.remote_pr_search', guardrails.boundary_assertions?.remote_pr_search, false],
+      ['contributor_guardrail_evidence.boundary_assertions.remote_review_search', guardrails.boundary_assertions?.remote_review_search, false],
+      ['contributor_guardrail_evidence.boundary_assertions.command_execution', guardrails.boundary_assertions?.command_execution, false],
+      ['contributor_guardrail_evidence.boundary_assertions.check_execution', guardrails.boundary_assertions?.check_execution, false],
+      ['contributor_guardrail_evidence.boundary_assertions.test_execution', guardrails.boundary_assertions?.test_execution, false],
+      ['contributor_guardrail_evidence.boundary_assertions.workflow_execution', guardrails.boundary_assertions?.workflow_execution, false],
+      ['contributor_guardrail_evidence.boundary_assertions.runtime_action', guardrails.boundary_assertions?.runtime_action, false],
+      ['contributor_guardrail_evidence.boundary_assertions.auto_execution', guardrails.boundary_assertions?.auto_execution, false],
+      ['contributor_guardrail_evidence.boundary_assertions.repair_execution', guardrails.boundary_assertions?.repair_execution, false],
+      ['contributor_guardrail_evidence.boundary_assertions.auto_fix', guardrails.boundary_assertions?.auto_fix, false],
+      ['contributor_guardrail_evidence.boundary_assertions.git', guardrails.boundary_assertions?.git, false],
+      ['contributor_guardrail_evidence.boundary_assertions.git_write', guardrails.boundary_assertions?.git_write, false],
+      ['contributor_guardrail_evidence.boundary_assertions.pr', guardrails.boundary_assertions?.pr, false],
+      ['contributor_guardrail_evidence.boundary_assertions.push', guardrails.boundary_assertions?.push, false],
+      ['contributor_guardrail_evidence.boundary_assertions.merge', guardrails.boundary_assertions?.merge, false],
+      ['contributor_guardrail_evidence.boundary_assertions.subagent', guardrails.boundary_assertions?.subagent, false],
+      ['contributor_guardrail_evidence.boundary_assertions.platform_api', guardrails.boundary_assertions?.platform_api, false],
+      ['contributor_guardrail_evidence.boundary_assertions.model_invocation', guardrails.boundary_assertions?.model_invocation, false],
+      ['contributor_guardrail_evidence.boundary_assertions.business_source_write', guardrails.boundary_assertions?.business_source_write, false],
+      ['safety.stage', envelope.safety?.stage, 'Stage 146'],
+      ['safety.remote_pr_search', envelope.safety?.remote_pr_search, false],
+      ['safety.subagent', envelope.safety?.subagent, false],
+    ], 'governance --contributor-guardrails --json');
+    if (!guardrails.guardrail_digest) throw new Error('contributor guardrail evidence missing guardrail_digest');
+    if (!guardrails.guardrail_findings?.some((item) => item.id === 'validation-evidence-required')) throw new Error('contributor guardrails missing validation evidence finding');
+    if (!guardrails.guardrail_findings?.some((item) => item.id === 'no-remote-pr-review-search')) throw new Error('contributor guardrails missing remote PR boundary finding');
+    if (!guardrails.required_disclosures?.some((item) => item.id === 'boundary-disclosure')) throw new Error('contributor guardrails missing boundary disclosure');
+    if (!guardrails.unsafe_closeout_risks?.some((item) => item.id === 'completion-claim-without-evidence')) throw new Error('contributor guardrails missing unsafe closeout risk');
+    if (fs.existsSync(unexpectedState)) throw new Error('governance --contributor-guardrails JSON output created unexpected state directory');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--contributor-guardrails', '--from-scorecard', scorecardFile, '--from-evidence-prompts', evidencePromptsFile, '--root', '.'], {
+      expectOutput: ['Vibecoding Runtime Contributor Guardrail Evidence', 'Stage: Stage 146; Kind: contributor-guardrail-evidence; pass=true', 'Guardrail findings:', 'Required disclosures:', 'Unsafe closeout risks:', 'Closeout contract:', 'Boundary: writes=false; contributor_guardrail_evidence_artifact=false', 'Guardrail digest:', 'Action: contributor guardrail evidence was computed read-only'],
+    }, options);
+    if (fs.existsSync(unexpectedState)) throw new Error('governance --contributor-guardrails 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', '--contributor-guardrails', '--from-scorecard', scorecardFile, '--from-evidence-prompts', evidencePromptsFile, forbidden, '--root', '.'], {
+        allowFailure: true,
+        expectOutput: ['governance --contributor-guardrails is read-only'],
+      }, options);
+    }
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--contributor-guardrails', '--from-evidence-prompts', evidencePromptsFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['governance --contributor-guardrails requires --from-scorecard <local-parity-scorecard-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--contributor-guardrails', '--from-scorecard', scorecardFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['governance --contributor-guardrails requires --from-evidence-prompts <local-evidence-prompts-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--contributor-guardrails', '--from-scorecard', '../outside.json', '--from-evidence-prompts', evidencePromptsFile, '--root', target], {
+      allowFailure: true,
+      expectOutput: ['governance --contributor-guardrails --from-scorecard must stay within --root'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--contributor-guardrails', '--from-scorecard', scorecardFile, '--from-evidence-prompts', evidencePromptsFile, '--from-file', scorecardFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['governance --contributor-guardrails only accepts --from-scorecard, --from-evidence-prompts, --json, and --root'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--superpowers-parity-scorecard', '--from-scorecard', scorecardFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['governance --superpowers-parity-scorecard requires --from-comparison <local-comparison-json>'],
+    }, options);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+export function runSubagentPermissionVisibilitySmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-subagent-permission';
+  const absoluteTarget = path.join(repoRoot, target);
+  const scorecardFile = path.join(target, 'parity-scorecard.json');
+  const guardrailsFile = path.join(target, 'contributor-guardrails.json');
+  const expectedScorecardFile = scorecardFile.replace(/\\/g, '/');
+  const expectedGuardrailsFile = guardrailsFile.replace(/\\/g, '/');
+  const unexpectedState = path.join(repoRoot, '.vibecoding-state');
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(absoluteTarget, { recursive: true });
+    fs.writeFileSync(path.join(repoRoot, scorecardFile), `${JSON.stringify({
+      superpowers_parity_scorecard: {
+        stage: 'Stage 140',
+        scorecard_kind: 'superpowers-parity-scorecard-v2',
+        parity_score: 84,
+        parity_digest: 'fixture-stage140-parity-scorecard-digest',
+        remaining_gaps: [
+          { axis_id: 'subagent_boundary', axis_score: 66, next_action: 'Make subagent permission visible before any handoff.' },
+          { axis_id: 'contributor_guardrails', axis_score: 74, next_action: 'Carry contributor boundaries into delegation requests.' },
+        ],
+        do_not_cross_boundaries: [
+          { id: 'no_auto_subagent_execution', boundary: 'Do not launch subagents without explicit user permission.' },
+          { id: 'no_hidden_dispatch', boundary: 'Do not create hidden dispatches, sessions, or sidecars.' },
+        ],
+      },
+    }, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(path.join(repoRoot, guardrailsFile), `${JSON.stringify({
+      contributor_guardrail_evidence: {
+        stage: 'Stage 146',
+        guardrail_kind: 'contributor-guardrail-evidence',
+        guardrail_digest: 'fixture-stage146-contributor-guardrails-digest',
+        guardrail_findings: [
+          { id: 'validation-evidence-required', severity: 'high', finding: 'Validation evidence must be visible before closeout.' },
+          { id: 'no-remote-pr-review-search', severity: 'high', finding: 'Do not search remote PR/review state from local contracts.' },
+        ],
+        required_disclosures: [
+          { id: 'boundary-disclosure', disclosure: 'No PR, push, merge, remote review lookup, auto-fix, or subagent action is authorized.' },
+          { id: 'evidence-disclosure', disclosure: 'State local evidence and deferred checks before completion.' },
+        ],
+        unsafe_closeout_risks: [
+          { id: 'completion-claim-without-evidence', risk: 'Completion claim lacks visible evidence.' },
+        ],
+      },
+    }, null, 2)}\n`, 'utf8');
+
+    const envelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--subagent-permission', '--from-scorecard', scorecardFile, '--from-guardrails', guardrailsFile, '--json', '--root', '.'], {}, options), 'governance --subagent-permission --json');
+    const visibility = envelope.subagent_permission_visibility || {};
+    assertJsonMarkers([
+      ['command', envelope.command, 'governance'],
+      ['mode', envelope.mode, 'subagent-permission-visibility'],
+      ['ok', envelope.ok, true],
+      ['subagent_permission_visibility.stage', visibility.stage, 'Stage 147'],
+      ['subagent_permission_visibility.permission_kind', visibility.permission_kind, 'subagent-permission-visibility'],
+      ['subagent_permission_visibility.source_bindings.scorecard_file', visibility.source_bindings?.scorecard_file, expectedScorecardFile],
+      ['subagent_permission_visibility.source_bindings.guardrails_file', visibility.source_bindings?.guardrails_file, expectedGuardrailsFile],
+      ['subagent_permission_visibility.input_summary.scorecard_stage', visibility.input_summary?.scorecard_stage, 'Stage 140'],
+      ['subagent_permission_visibility.input_summary.guardrails_stage', visibility.input_summary?.guardrails_stage, 'Stage 146'],
+      ['subagent_permission_visibility.input_summary.permission_gate_count', visibility.input_summary?.permission_gate_count, 5],
+      ['subagent_permission_visibility.input_summary.brief_requirement_count', visibility.input_summary?.brief_requirement_count, 7],
+      ['subagent_permission_visibility.input_summary.must_ask_user_first_count', visibility.input_summary?.must_ask_user_first_count, 3],
+      ['subagent_permission_visibility.permission_invariants.pass', visibility.permission_invariants?.pass, true],
+      ['subagent_permission_visibility.visibility_contract.subagent_allowed_by_contract', visibility.visibility_contract?.subagent_allowed_by_contract, false],
+      ['subagent_permission_visibility.visibility_contract.dispatch_allowed_by_contract', visibility.visibility_contract?.dispatch_allowed_by_contract, false],
+      ['subagent_permission_visibility.visibility_contract.session_allowed_by_contract', visibility.visibility_contract?.session_allowed_by_contract, false],
+      ['subagent_permission_visibility.visibility_contract.auto_dispatch_allowed_by_contract', visibility.visibility_contract?.auto_dispatch_allowed_by_contract, false],
+      ['subagent_permission_visibility.visibility_contract.must_ask_user_first', visibility.visibility_contract?.must_ask_user_first, true],
+      ['subagent_permission_visibility.visibility_contract.dispatch_created', visibility.visibility_contract?.dispatch_created, false],
+      ['subagent_permission_visibility.visibility_contract.session_created', visibility.visibility_contract?.session_created, false],
+      ['subagent_permission_visibility.writes', visibility.writes, false],
+      ['subagent_permission_visibility.state_directory_created', visibility.state_directory_created, false],
+      ['subagent_permission_visibility.boundary_assertions.subagent_permission_visibility_artifact', visibility.boundary_assertions?.subagent_permission_visibility_artifact, false],
+      ['subagent_permission_visibility.boundary_assertions.permission_artifact', visibility.boundary_assertions?.permission_artifact, false],
+      ['subagent_permission_visibility.boundary_assertions.guardrail_artifact', visibility.boundary_assertions?.guardrail_artifact, false],
+      ['subagent_permission_visibility.boundary_assertions.parity_scorecard_artifact', visibility.boundary_assertions?.parity_scorecard_artifact, false],
+      ['subagent_permission_visibility.boundary_assertions.brief_artifact', visibility.boundary_assertions?.brief_artifact, false],
+      ['subagent_permission_visibility.boundary_assertions.dispatch_artifact', visibility.boundary_assertions?.dispatch_artifact, false],
+      ['subagent_permission_visibility.boundary_assertions.session_artifact', visibility.boundary_assertions?.session_artifact, false],
+      ['subagent_permission_visibility.boundary_assertions.subagent', visibility.boundary_assertions?.subagent, false],
+      ['subagent_permission_visibility.boundary_assertions.subagent_dispatch', visibility.boundary_assertions?.subagent_dispatch, false],
+      ['subagent_permission_visibility.boundary_assertions.subagent_session', visibility.boundary_assertions?.subagent_session, false],
+      ['subagent_permission_visibility.boundary_assertions.agent_session', visibility.boundary_assertions?.agent_session, false],
+      ['subagent_permission_visibility.boundary_assertions.session_create', visibility.boundary_assertions?.session_create, false],
+      ['subagent_permission_visibility.boundary_assertions.command_execution', visibility.boundary_assertions?.command_execution, false],
+      ['subagent_permission_visibility.boundary_assertions.check_execution', visibility.boundary_assertions?.check_execution, false],
+      ['subagent_permission_visibility.boundary_assertions.test_execution', visibility.boundary_assertions?.test_execution, false],
+      ['subagent_permission_visibility.boundary_assertions.workflow_execution', visibility.boundary_assertions?.workflow_execution, false],
+      ['subagent_permission_visibility.boundary_assertions.runtime_action', visibility.boundary_assertions?.runtime_action, false],
+      ['subagent_permission_visibility.boundary_assertions.auto_execution', visibility.boundary_assertions?.auto_execution, false],
+      ['subagent_permission_visibility.boundary_assertions.auto_dispatch', visibility.boundary_assertions?.auto_dispatch, false],
+      ['subagent_permission_visibility.boundary_assertions.git', visibility.boundary_assertions?.git, false],
+      ['subagent_permission_visibility.boundary_assertions.git_write', visibility.boundary_assertions?.git_write, false],
+      ['subagent_permission_visibility.boundary_assertions.pr', visibility.boundary_assertions?.pr, false],
+      ['subagent_permission_visibility.boundary_assertions.push', visibility.boundary_assertions?.push, false],
+      ['subagent_permission_visibility.boundary_assertions.merge', visibility.boundary_assertions?.merge, false],
+      ['subagent_permission_visibility.boundary_assertions.platform_api', visibility.boundary_assertions?.platform_api, false],
+      ['subagent_permission_visibility.boundary_assertions.model_invocation', visibility.boundary_assertions?.model_invocation, false],
+      ['subagent_permission_visibility.boundary_assertions.business_source_write', visibility.boundary_assertions?.business_source_write, false],
+      ['safety.stage', envelope.safety?.stage, 'Stage 147'],
+      ['safety.subagent_dispatch', envelope.safety?.subagent_dispatch, false],
+      ['safety.session_create', envelope.safety?.session_create, false],
+      ['safety.git', envelope.safety?.git, false],
+    ], 'governance --subagent-permission --json');
+    if (!visibility.permission_digest) throw new Error('subagent permission visibility missing permission_digest');
+    if (!visibility.permission_gate?.some((item) => item.id === 'explicit-user-permission' && item.dispatch_authorized === false)) throw new Error('subagent permission visibility missing explicit user permission gate');
+    if (!visibility.permission_gate?.some((item) => item.id === 'no-hidden-dispatch' && item.session_authorized === false)) throw new Error('subagent permission visibility missing no hidden dispatch gate');
+    if (!visibility.brief_requirements?.some((item) => item.id === 'forbidden-actions')) throw new Error('subagent permission visibility missing forbidden-actions brief requirement');
+    if (!visibility.must_ask_user_first?.some((item) => item.id === 'permission-question')) throw new Error('subagent permission visibility missing permission question');
+    if (fs.existsSync(unexpectedState)) throw new Error('governance --subagent-permission JSON output created unexpected state directory');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--subagent-permission', '--from-scorecard', scorecardFile, '--from-guardrails', guardrailsFile, '--root', '.'], {
+      expectOutput: ['Vibecoding Runtime Subagent Permission Visibility', 'Stage: Stage 147; Kind: subagent-permission-visibility; pass=true', 'Permission gates:', 'Brief requirements:', 'Must ask user first:', 'Visibility contract: subagent_allowed=false; dispatch_allowed=false; session_allowed=false; must_ask_user_first=true', 'Boundary: writes=false; subagent_permission_visibility_artifact=false', 'Permission digest:', 'Action: subagent permission visibility was computed read-only'],
+    }, options);
+    if (fs.existsSync(unexpectedState)) throw new Error('governance --subagent-permission 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', '--subagent-permission', '--from-scorecard', scorecardFile, '--from-guardrails', guardrailsFile, forbidden, '--root', '.'], {
+        allowFailure: true,
+        expectOutput: ['governance --subagent-permission is read-only and permission-visibility-only'],
+      }, options);
+    }
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--subagent-permission', '--from-guardrails', guardrailsFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['governance --subagent-permission requires --from-scorecard <local-parity-scorecard-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--subagent-permission', '--from-scorecard', scorecardFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['governance --subagent-permission requires --from-guardrails <local-guardrails-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--subagent-permission', '--from-scorecard', '../outside.json', '--from-guardrails', guardrailsFile, '--root', target], {
+      allowFailure: true,
+      expectOutput: ['governance --subagent-permission --from-scorecard must stay within --root'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--subagent-permission', '--from-scorecard', scorecardFile, '--from-guardrails', guardrailsFile, '--from-file', scorecardFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['governance --subagent-permission only accepts --from-scorecard, --from-guardrails, --json, and --root'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--contributor-guardrails', '--from-scorecard', scorecardFile, '--from-guardrails', guardrailsFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['--from-guardrails is only supported by governance --subagent-permission'],
+    }, options);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+export function runAdapterPackagingConsistencySmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-adapter-packaging-consistency';
+  const absoluteTarget = path.join(repoRoot, target);
+  const bootstrapFile = path.join(target, 'bootstrap-matrix.json');
+  const examplesFile = path.join(target, 'session-start-examples.json');
+  const expectedBootstrapFile = bootstrapFile.replace(/\\/g, '/');
+  const expectedExamplesFile = examplesFile.replace(/\\/g, '/');
+  const unexpectedState = path.join(repoRoot, '.vibecoding-state');
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(absoluteTarget, { recursive: true });
+    const adapters = ['claude', 'cursor', 'codex'];
+    fs.writeFileSync(path.join(repoRoot, bootstrapFile), `${JSON.stringify({
+      adapter_bootstrap_matrix: {
+        stage: 'Stage 122',
+        matrix_kind: 'adapter-bootstrap-conformance-matrix',
+        ok: true,
+        matrix_digest: 'fixture-stage122-bootstrap-matrix-digest',
+        expected_adapters: adapters,
+        adapter_rows: adapters.map((adapter) => ({
+          stage: 'Stage 122',
+          adapter,
+          adapter_root: `adapters/${adapter}`,
+          entry_file: adapter === 'claude' ? 'CLAUDE.md' : 'AGENTS.md',
+          expected_entry_file: adapter === 'claude' ? 'CLAUDE.md' : 'AGENTS.md',
+          runtime_bridge: { supported: true, mode: 'manual', canReadDispatchIntent: true, canAutoExecuteSkill: false, canCallSubagent: false, canTouchGit: false },
+          bootstrap_policy: { supported: true, command: `node tools/session-start.mjs --format ${adapter}`, injectsFullSkill: false, writesRuntimeState: false, autoRunsNextSkill: false },
+          gates: [
+            { gate: 'required_adapter_files', pass: true, findings: [] },
+            { gate: 'manifest_parity_gate', pass: true, findings: [] },
+            { gate: 'bootstrap_policy_gate', pass: true, findings: [] },
+            { gate: 'install_doc_bootstrap_gate', pass: true, findings: [] },
+          ],
+          pass: true,
+          blockers: [],
+        })),
+        blockers: [],
+      },
+    }, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(path.join(repoRoot, examplesFile), `${JSON.stringify({
+      session_start_example_pack: {
+        stage: 'Stage 142',
+        pack_kind: 'session-start-example-pack',
+        ok: true,
+        example_pack_digest: 'fixture-stage142-session-start-examples-digest',
+        adapter_examples: adapters.map((adapter) => ({
+          adapter,
+          context_path: adapter === 'cursor' ? 'additional_context' : adapter === 'claude' ? 'hookSpecificOutput.additionalContext' : 'additionalContext',
+          output_shape: adapter === 'cursor' ? 'cursor-session-start-additional_context' : adapter === 'claude' ? 'claude-session-start-hookSpecificOutput' : 'sdk-session-start-additionalContext',
+          copy_ready_json: '{}',
+          source_status: { shape_acceptance_matched: adapter === 'claude', shape_acceptance_ok: adapter === 'claude', install_experience_present: true, install_experience_ok: true },
+          format_notes: ['keep context lightweight and boundary-first'],
+        })),
+        copy_ready_context_shapes: adapters.map((adapter) => ({ adapter, context_path: adapter === 'cursor' ? 'additional_context' : adapter === 'claude' ? 'hookSpecificOutput.additionalContext' : 'additionalContext', additional_context: 'using-vibecoding lightweight routing context only' })),
+        format_warnings: [],
+      },
+    }, null, 2)}\n`, 'utf8');
+
+    const envelope = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--adapter-packaging-consistency', '--from-bootstrap-matrix', bootstrapFile, '--from-session-examples', examplesFile, '--json', '--root', '.'], {}, options), 'platforms --adapter-packaging-consistency --json');
+    const checklist = envelope.adapter_packaging_consistency || {};
+    assertJsonMarkers([
+      ['command', envelope.command, 'platforms'],
+      ['mode', envelope.mode, 'adapter-packaging-consistency-checklist'],
+      ['ok', envelope.ok, true],
+      ['adapter_packaging_consistency.stage', checklist.stage, 'Stage 148'],
+      ['adapter_packaging_consistency.consistency_kind', checklist.consistency_kind, 'adapter-packaging-consistency-checklist'],
+      ['adapter_packaging_consistency.source_bindings.bootstrap_matrix_file', checklist.source_bindings?.bootstrap_matrix_file, expectedBootstrapFile],
+      ['adapter_packaging_consistency.source_bindings.session_examples_file', checklist.source_bindings?.session_examples_file, expectedExamplesFile],
+      ['adapter_packaging_consistency.input_summary.bootstrap_stage', checklist.input_summary?.bootstrap_stage, 'Stage 122'],
+      ['adapter_packaging_consistency.input_summary.session_examples_stage', checklist.input_summary?.session_examples_stage, 'Stage 142'],
+      ['adapter_packaging_consistency.input_summary.adapter_row_count', checklist.input_summary?.adapter_row_count, 3],
+      ['adapter_packaging_consistency.input_summary.missing_install_marker_count', checklist.input_summary?.missing_install_marker_count, 0],
+      ['adapter_packaging_consistency.consistency_invariants.pass', checklist.consistency_invariants?.pass, true],
+      ['adapter_packaging_consistency.writes', checklist.writes, false],
+      ['adapter_packaging_consistency.state_directory_created', checklist.state_directory_created, false],
+      ['adapter_packaging_consistency.boundary_assertions.adapter_packaging_consistency_artifact', checklist.boundary_assertions?.adapter_packaging_consistency_artifact, false],
+      ['adapter_packaging_consistency.boundary_assertions.bootstrap_matrix_artifact', checklist.boundary_assertions?.bootstrap_matrix_artifact, false],
+      ['adapter_packaging_consistency.boundary_assertions.session_start_example_pack_artifact', checklist.boundary_assertions?.session_start_example_pack_artifact, false],
+      ['adapter_packaging_consistency.boundary_assertions.adapter_row_artifact', checklist.boundary_assertions?.adapter_row_artifact, false],
+      ['adapter_packaging_consistency.boundary_assertions.fix_note_artifact', checklist.boundary_assertions?.fix_note_artifact, false],
+      ['adapter_packaging_consistency.boundary_assertions.adapter_install', checklist.boundary_assertions?.adapter_install, false],
+      ['adapter_packaging_consistency.boundary_assertions.adapter_execution', checklist.boundary_assertions?.adapter_execution, false],
+      ['adapter_packaging_consistency.boundary_assertions.hook_execution', checklist.boundary_assertions?.hook_execution, false],
+      ['adapter_packaging_consistency.boundary_assertions.manifest_write', checklist.boundary_assertions?.manifest_write, false],
+      ['adapter_packaging_consistency.boundary_assertions.plugin_manifest_write', checklist.boundary_assertions?.plugin_manifest_write, false],
+      ['adapter_packaging_consistency.boundary_assertions.install_doc_write', checklist.boundary_assertions?.install_doc_write, false],
+      ['adapter_packaging_consistency.boundary_assertions.command_execution', checklist.boundary_assertions?.command_execution, false],
+      ['adapter_packaging_consistency.boundary_assertions.check_execution', checklist.boundary_assertions?.check_execution, false],
+      ['adapter_packaging_consistency.boundary_assertions.test_execution', checklist.boundary_assertions?.test_execution, false],
+      ['adapter_packaging_consistency.boundary_assertions.workflow_execution', checklist.boundary_assertions?.workflow_execution, false],
+      ['adapter_packaging_consistency.boundary_assertions.runtime_action', checklist.boundary_assertions?.runtime_action, false],
+      ['adapter_packaging_consistency.boundary_assertions.auto_execution', checklist.boundary_assertions?.auto_execution, false],
+      ['adapter_packaging_consistency.boundary_assertions.repair_execution', checklist.boundary_assertions?.repair_execution, false],
+      ['adapter_packaging_consistency.boundary_assertions.auto_fix', checklist.boundary_assertions?.auto_fix, false],
+      ['adapter_packaging_consistency.boundary_assertions.git', checklist.boundary_assertions?.git, false],
+      ['adapter_packaging_consistency.boundary_assertions.git_write', checklist.boundary_assertions?.git_write, false],
+      ['adapter_packaging_consistency.boundary_assertions.subagent', checklist.boundary_assertions?.subagent, false],
+      ['adapter_packaging_consistency.boundary_assertions.platform_api', checklist.boundary_assertions?.platform_api, false],
+      ['adapter_packaging_consistency.boundary_assertions.model_invocation', checklist.boundary_assertions?.model_invocation, false],
+      ['adapter_packaging_consistency.boundary_assertions.business_source_write', checklist.boundary_assertions?.business_source_write, false],
+      ['safety.stage', envelope.safety?.stage, 'Stage 148'],
+      ['safety.adapter_install', envelope.safety?.adapter_install, false],
+      ['safety.hook_execution', envelope.safety?.hook_execution, false],
+      ['safety.git', envelope.safety?.git, false],
+    ], 'platforms --adapter-packaging-consistency --json');
+    if (!checklist.consistency_digest) throw new Error('adapter packaging consistency missing consistency_digest');
+    if (!checklist.adapter_rows?.every((row) => row.packaging_consistent === true)) throw new Error('adapter packaging consistency expected every baseline row to be consistent');
+    if (fs.existsSync(unexpectedState)) throw new Error('platforms --adapter-packaging-consistency JSON output created unexpected state directory');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--adapter-packaging-consistency', '--from-bootstrap-matrix', bootstrapFile, '--from-session-examples', examplesFile, '--root', '.'], {
+      expectOutput: ['Vibecoding Runtime Adapter Packaging Consistency', 'Stage: Stage 148; Kind: adapter-packaging-consistency-checklist; pass=true', 'Adapter rows:', 'Missing install markers:', 'Copy-ready fix notes:', 'Boundary: writes=false; adapter_packaging_consistency_artifact=false', 'Consistency digest:', 'Action: adapter packaging consistency read local Stage 122 bootstrap matrix JSON'],
+    }, options);
+    if (fs.existsSync(unexpectedState)) throw new Error('platforms --adapter-packaging-consistency 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', '--adapter-packaging-consistency', '--from-bootstrap-matrix', bootstrapFile, '--from-session-examples', examplesFile, forbidden, '--root', '.'], {
+        allowFailure: true,
+        expectOutput: ['platforms --adapter-packaging-consistency is read-only and checklist-only'],
+      }, options);
+    }
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--adapter-packaging-consistency', '--from-session-examples', examplesFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['platforms --adapter-packaging-consistency requires --from-bootstrap-matrix <local-bootstrap-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--adapter-packaging-consistency', '--from-bootstrap-matrix', bootstrapFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['platforms --adapter-packaging-consistency requires --from-session-examples <local-session-examples-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--adapter-packaging-consistency', '--from-bootstrap-matrix', '../outside.json', '--from-session-examples', examplesFile, '--root', target], {
+      allowFailure: true,
+      expectOutput: ['platforms --adapter-packaging-consistency --from-bootstrap-matrix must stay within --root'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--adapter-packaging-consistency', '--from-bootstrap-matrix', bootstrapFile, '--from-session-examples', examplesFile, '--from-file', bootstrapFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['platforms --adapter-packaging-consistency only accepts --from-bootstrap-matrix, --from-session-examples, --json, and --root'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--install-experience', '--from-bootstrap-matrix', bootstrapFile, '--from-session-examples', examplesFile, '--root', '.'], {
+      allowFailure: true,
+      expectOutput: ['--from-session-examples is only supported by platforms --adapter-packaging-consistency'],
+    }, options);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+export function releaseCheckStage141148SmokeHandlers(deps) {
+  return {
+    runEntryTriggerTighteningSmoke: (options) => runEntryTriggerTighteningSmoke(deps, options),
+    runSessionStartExamplePackSmoke: (options) => runSessionStartExamplePackSmoke(deps, options),
+    runNextActionEvidencePromptsSmoke: (options) => runNextActionEvidencePromptsSmoke(deps, options),
+    runContextBudgetEntryDefaultsSmoke: (options) => runContextBudgetEntryDefaultsSmoke(deps, options),
+    runLocalBehaviorEvalContractsSmoke: (options) => runLocalBehaviorEvalContractsSmoke(deps, options),
+    runContributorGuardrailEvidenceSmoke: (options) => runContributorGuardrailEvidenceSmoke(deps, options),
+    runSubagentPermissionVisibilitySmoke: (options) => runSubagentPermissionVisibilitySmoke(deps, options),
+    runAdapterPackagingConsistencySmoke: (options) => runAdapterPackagingConsistencySmoke(deps, options),
+  };
+}