@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-release-check/release-check-workflow-governance-smoke-suite.mjs

@@ -0,0 +1,768 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import {
+  plannerBriefsConfirmJsonMarkers,
+  plannerPlanConfirmJsonMarkers,
+  plannerRouteConfirmJsonMarkers,
+  plannerRoutePreviewJsonMarkers,
+  plannerVerifyJsonMarkers,
+  prReadinessPreviewJsonMarkers,
+  prReadinessVerifyJsonMarkers,
+  prReviewIntakeEvidenceText,
+  prReviewIntakePreviewJsonMarkers,
+  prReviewIntakeVerifyJsonMarkers,
+  workflowPlannerInputText,
+} from './release-check-workflow-governance-fixtures.mjs';
+import {
+  runBootstrapAcceptanceSmoke as runBootstrapAcceptanceSmokeFromWorkflowEntry,
+  runEntryAdviceSmoke as runEntryAdviceSmokeFromWorkflowEntry,
+  runMethodologyRouteSmoke as runMethodologyRouteSmokeFromWorkflowEntry,
+} from './release-check-workflow-entry-suite.mjs';
+
+export function releaseCheckWorkflowGovernanceSmokeHandlers({ repoRoot, tmpRoot, run, parseJsonOutput, assertJsonMarkers, digestObject }) {
+function runPlannerSmoke(options) {
+  const target = '.tmp/vibe-runtime-ledger';
+  const absoluteTarget = path.join(repoRoot, target);
+  const plannerInputFile = path.join(tmpRoot, 'planner-input.txt');
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  fs.mkdirSync(tmpRoot, { recursive: true });
+  fs.mkdirSync(absoluteTarget, { recursive: true });
+  fs.writeFileSync(plannerInputFile, workflowPlannerInputText, 'utf8');
+
+  const routePreview = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'planner', '--route', '--from-file', plannerInputFile, '--json', '--root', target], {}, options), 'planner --route --json');
+  assertJsonMarkers(plannerRoutePreviewJsonMarkers(routePreview), 'planner --route --json');
+  if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'planner-routes'))) throw new Error('planner route preview created unexpected planner-routes directory');
+
+  const routeConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'planner', '--route', '--from-file', plannerInputFile, '--confirm', '--json', '--root', target], {}, options), 'planner --route --confirm --json');
+  const routeFile = routeConfirm.planner_route_file;
+  assertJsonMarkers(plannerRouteConfirmJsonMarkers(routeConfirm), 'planner --route --confirm --json');
+  if (!routeFile || !fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'planner-routes', routeFile))) throw new Error('planner route confirm did not write route artifact');
+
+  const planConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'planner', '--decompose', '--from-route', routeFile, '--confirm', '--json', '--root', target], {}, options), 'planner --decompose --confirm --json');
+  const planFile = planConfirm.planner_plan_file;
+  assertJsonMarkers(plannerPlanConfirmJsonMarkers(planConfirm), 'planner --decompose --confirm --json');
+  if (!planFile || !fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'planner-plans', planFile))) throw new Error('planner decompose confirm did not write plan artifact');
+
+  const briefsConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'planner', '--briefs', '--from-plan', planFile, '--confirm', '--json', '--root', target], {}, options), 'planner --briefs --confirm --json');
+  const briefsFile = briefsConfirm.planner_briefs_file;
+  assertJsonMarkers(plannerBriefsConfirmJsonMarkers(briefsConfirm), 'planner --briefs --confirm --json');
+  if (!briefsFile || !fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'planner-briefs', briefsFile))) throw new Error('planner briefs confirm did not write briefs artifact');
+
+  const plannerVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'planner', '--verify', briefsFile, '--json', '--root', target], {}, options), 'planner --verify briefs --json');
+  assertJsonMarkers(plannerVerifyJsonMarkers(plannerVerify), 'planner --verify briefs --json');
+
+  const badPlannerPlanPath = path.join(absoluteTarget, '.vibecoding-state', 'planner-plans', 'bad-digest.planner-plan.json');
+  const badPlannerPlan = JSON.parse(fs.readFileSync(path.join(absoluteTarget, '.vibecoding-state', 'planner-plans', planFile), 'utf8'));
+  badPlannerPlan.planner_plan.route_digest = '9'.repeat(64);
+  delete badPlannerPlan.planner_plan.plan_digest;
+  badPlannerPlan.planner_plan.plan_digest = digestObject(badPlannerPlan.planner_plan);
+  fs.writeFileSync(badPlannerPlanPath, `${JSON.stringify(badPlannerPlan, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'planner', '--verify', 'bad-digest.planner-plan.json', '--root', target], {
+    allowFailure: true,
+    expectOutput: ['planner verification failed:', 'planner route digest mismatch'],
+  }, options);
+  fs.rmSync(badPlannerPlanPath, { force: true });
+
+  const plannerTrace = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'traces', '--build', '--confirm', '--json', '--root', target], {}, options), 'traces --build planner --confirm --json');
+  const plannerTraceTypes = plannerTrace.runtime_trace?.source_types || {};
+  if (!plannerTraceTypes.planner_routes || !plannerTraceTypes.planner_plans || !plannerTraceTypes.planner_briefs) throw new Error('planner trace did not include Stage 49 source types');
+  if (!options.keepTmp) fs.rmSync(plannerInputFile, { force: true });
+}
+
+function runPrReadinessSmoke(options) {
+  const target = '.tmp/vibe-pr-readiness-preview';
+  const absoluteTarget = path.join(repoRoot, target);
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(absoluteTarget, { recursive: true });
+    for (const entry of ['AGENTS.md', 'skills', 'fork']) {
+      const source = path.join(repoRoot, entry);
+      const destination = path.join(absoluteTarget, entry);
+      if (fs.existsSync(source)) fs.cpSync(source, destination, { recursive: true });
+    }
+
+    const preview = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--pr-readiness', '--preview', '--json', '--root', target], {}, options), 'governance --pr-readiness --preview --json');
+    assertJsonMarkers(prReadinessPreviewJsonMarkers(preview), 'governance --pr-readiness --preview --json');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('PR readiness preview created unexpected state directory');
+
+    const confirmed = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--pr-readiness', '--confirm', '--json', '--root', target], {}, options), 'governance --pr-readiness --confirm --json');
+    const governanceFile = confirmed.governance_file;
+    if (!governanceFile || !governanceFile.endsWith('.pr-readiness-governance.json')) throw new Error('PR readiness confirm did not return a PR readiness sidecar file');
+    const sidecarPath = path.join(absoluteTarget, '.vibecoding-state', 'governance', governanceFile);
+    if (!fs.existsSync(sidecarPath)) throw new Error('PR readiness confirm did not write governance sidecar');
+    const verified = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--verify', governanceFile, '--json', '--root', target], {}, options), 'governance --verify pr-readiness --json');
+    assertJsonMarkers(prReadinessVerifyJsonMarkers(verified), 'governance --verify pr-readiness --json');
+
+    const badSidecar = JSON.parse(fs.readFileSync(sidecarPath, 'utf8'));
+    badSidecar.pr_readiness.evidence_files[0].path = '../AGENTS.md';
+    const digestPayload = { ...badSidecar.pr_readiness };
+    delete digestPayload.writes;
+    delete digestPayload.pr_readiness_digest;
+    badSidecar.pr_readiness.pr_readiness_digest = digestObject(digestPayload);
+    const badSidecarPath = path.join(absoluteTarget, '.vibecoding-state', 'governance', 'bad-path.pr-readiness-governance.json');
+    fs.writeFileSync(badSidecarPath, `${JSON.stringify(badSidecar, null, 2)}\n`, 'utf8');
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--verify', 'bad-path.pr-readiness-governance.json', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['governance artifact verification failed:', 'pr_readiness.evidence_files[].path must not include traversal'],
+    }, options);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+function runPrReviewIntakeSmoke(options) {
+  const target = '.tmp/vibe-pr-review-intake';
+  const absoluteTarget = path.join(repoRoot, target);
+  const evidenceDirectory = path.join(absoluteTarget, 'evidence');
+  const evidenceFile = path.join(evidenceDirectory, 'pr-review-ci.json');
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(evidenceDirectory, { recursive: true });
+    fs.writeFileSync(evidenceFile, prReviewIntakeEvidenceText, 'utf8');
+
+    const preview = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--pr-review-intake', '--from-file', evidenceFile, '--preview', '--json', '--root', target], {}, options), 'governance --pr-review-intake --preview --json');
+    assertJsonMarkers(prReviewIntakePreviewJsonMarkers(preview), 'governance --pr-review-intake --preview --json');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('PR review intake preview created unexpected state directory');
+
+    const confirmed = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--pr-review-intake', '--from-file', evidenceFile, '--confirm', '--json', '--root', target], {}, options), 'governance --pr-review-intake --confirm --json');
+    const governanceFile = confirmed.governance_file;
+    if (!governanceFile || !governanceFile.endsWith('.pr-review-intake-governance.json')) throw new Error('PR review intake confirm did not return a PR review intake sidecar file');
+    const sidecarPath = path.join(absoluteTarget, '.vibecoding-state', 'governance', governanceFile);
+    if (!fs.existsSync(sidecarPath)) throw new Error('PR review intake confirm did not write governance sidecar');
+
+    const listed = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--list', '--json', '--root', target], {}, options), 'governance --list pr-review-intake --json');
+    if (!listed.attestations?.some((item) => item.file === governanceFile && item.kind === 'pr-review-intake-governance')) throw new Error('PR review intake sidecar is missing from governance list');
+
+    const verified = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--verify', governanceFile, '--json', '--root', target], {}, options), 'governance --verify pr-review-intake --json');
+    assertJsonMarkers(prReviewIntakeVerifyJsonMarkers(verified), 'governance --verify pr-review-intake --json');
+
+    const badPathSidecar = JSON.parse(fs.readFileSync(sidecarPath, 'utf8'));
+    badPathSidecar.pr_review_intake.input_evidence_file = '../evidence/pr-review-ci.json';
+    const badPathDigestPayload = { ...badPathSidecar.pr_review_intake };
+    delete badPathDigestPayload.writes;
+    delete badPathDigestPayload.pr_review_intake_digest;
+    badPathSidecar.pr_review_intake.pr_review_intake_digest = digestObject(badPathDigestPayload);
+    const badPathSidecarPath = path.join(absoluteTarget, '.vibecoding-state', 'governance', 'bad-path.pr-review-intake-governance.json');
+    fs.writeFileSync(badPathSidecarPath, `${JSON.stringify(badPathSidecar, null, 2)}\n`, 'utf8');
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--verify', 'bad-path.pr-review-intake-governance.json', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['governance artifact verification failed:', 'pr_review_intake.input_evidence_file must not include traversal'],
+    }, options);
+
+    const badDigestSidecar = JSON.parse(fs.readFileSync(sidecarPath, 'utf8'));
+    badDigestSidecar.pr_review_intake.input_evidence_digest = '0'.repeat(64);
+    const badDigestPayload = { ...badDigestSidecar.pr_review_intake };
+    delete badDigestPayload.writes;
+    delete badDigestPayload.pr_review_intake_digest;
+    badDigestSidecar.pr_review_intake.pr_review_intake_digest = digestObject(badDigestPayload);
+    const badDigestSidecarPath = path.join(absoluteTarget, '.vibecoding-state', 'governance', 'bad-digest.pr-review-intake-governance.json');
+    fs.writeFileSync(badDigestSidecarPath, `${JSON.stringify(badDigestSidecar, null, 2)}\n`, 'utf8');
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--verify', 'bad-digest.pr-review-intake-governance.json', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['governance artifact verification failed:', 'input evidence digest mismatch'],
+    }, options);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+function runConvergenceSmoke(options) {
+  const target = '.tmp/vibe-convergence-report';
+  const absoluteTarget = path.join(repoRoot, target);
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(absoluteTarget, { recursive: true });
+    const report = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--convergence', '--report', '--json', '--root', target], {}, options), 'governance --convergence --report --json');
+    assertJsonMarkers([
+      ['command', report.command, 'governance'],
+      ['mode', report.mode, 'governance-convergence-report'],
+      ['convergence.stage', report.convergence?.stage, 'Stage 59'],
+      ['convergence.report_kind', report.convergence?.report_kind, 'capability-convergence-gap-report'],
+      ['convergence.writes', report.convergence?.writes, false],
+      ['convergence.state_directory_created', report.convergence?.state_directory_created, false],
+      ['safety.writes', report.safety?.writes, false],
+      ['safety.convergence_report', report.safety?.convergence_report, true],
+      ['safety.skill_mutation', report.safety?.skill_mutation, false],
+      ['safety.hook_registration', report.safety?.hook_registration, false],
+      ['safety.shell_interception', report.safety?.shell_interception, false],
+      ['safety.external_network', report.safety?.external_network, false],
+      ['safety.model_invocation', report.safety?.model_invocation, false],
+      ['safety.platform_api', report.safety?.platform_api, false],
+      ['safety.runtime_action', report.safety?.runtime_action, false],
+      ['safety.git', report.safety?.git, false],
+      ['safety.worktree', report.safety?.worktree, false],
+    ], 'governance --convergence --report --json');
+    const dimensions = report.convergence?.dimensions || [];
+    for (const id of ['workflow-experience', 'learning-model', 'deterministic-token-economy', 'stream-distillation', 'runtime-governance']) {
+      if (!dimensions.some((item) => item.id === id)) throw new Error(`convergence report missing dimension: ${id}`);
+    }
+    if (!report.convergence?.convergence_digest) throw new Error('convergence report missing convergence_digest');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('convergence report created unexpected state directory');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--convergence', '--json', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['governance --convergence requires --report'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--convergence', '--report', '--confirm', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['governance convergence report is read-only'],
+    }, options);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+function runGovernanceAdviceSmoke(options) {
+  const target = '.tmp/vibe-governance-advice';
+  const absoluteTarget = path.join(repoRoot, target);
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(absoluteTarget, { recursive: true });
+    const advice = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--advice', '--intent', 'closeout', '--json', '--root', target], {}, options), 'governance --advice --intent closeout --json');
+    assertJsonMarkers([
+      ['command', advice.command, 'governance'],
+      ['mode', advice.mode, 'runtime-governance-advice'],
+      ['governance_advice.stage', advice.governance_advice?.stage, 'Stage 81'],
+      ['governance_advice.advice_kind', advice.governance_advice?.advice_kind, 'runtime-governance-advice'],
+      ['governance_advice.intent', advice.governance_advice?.intent, 'closeout'],
+      ['governance_advice.recommended_next_governance_step', advice.governance_advice?.recommended_next_governance_step, 'read-only-closeout-scan'],
+      ['governance_advice.writes', advice.governance_advice?.writes, false],
+      ['governance_advice.state_directory_created', advice.governance_advice?.state_directory_created, false],
+      ['governance_advice.closeout_boundary.automatic_pr', advice.governance_advice?.closeout_boundary?.automatic_pr, false],
+      ['governance_advice.closeout_boundary.automatic_merge', advice.governance_advice?.closeout_boundary?.automatic_merge, false],
+      ['safety.writes', advice.safety?.writes, false],
+      ['safety.governance_advice_artifact', advice.safety?.governance_advice_artifact, false],
+      ['safety.sidecar_write', advice.safety?.sidecar_write, false],
+      ['safety.release_gate_write', advice.safety?.release_gate_write, false],
+      ['safety.pr', advice.safety?.pr, false],
+      ['safety.push', advice.safety?.push, false],
+      ['safety.merge', advice.safety?.merge, false],
+      ['safety.platform_api', advice.safety?.platform_api, false],
+      ['safety.external_network', advice.safety?.external_network, false],
+      ['safety.git', advice.safety?.git, false],
+      ['safety.worktree', advice.safety?.worktree, false],
+    ], 'governance --advice --intent closeout --json');
+    if (!advice.governance_advice?.advice_digest) throw new Error('governance advice missing advice_digest');
+    if (!advice.governance_advice?.recommended_command?.includes('governance --convergence --report')) throw new Error('governance closeout advice missing convergence command');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('governance advice JSON output created unexpected state directory');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--advice', '--intent', 'review', '--root', target], {
+      expectOutput: ['Vibecoding Runtime Governance Advice', 'Intent: review', 'Next step: manual-review-intake-boundary', 'Boundary: pr=false; push=false; merge=false; platform_api=false; git=false; worktree=false'],
+    }, options);
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('governance advice text output created unexpected state directory');
+
+    const unknown = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--advice', '--intent', 'unknown-kind', '--json', '--root', target], {}, options), 'governance --advice --intent unknown-kind --json');
+    assertJsonMarkers([
+      ['governance_advice.intent', unknown.governance_advice?.intent, 'unknown'],
+      ['governance_advice.recommended_next_governance_step', unknown.governance_advice?.recommended_next_governance_step, 'read-only-closeout-scan'],
+    ], 'governance --advice --intent unknown-kind --json');
+    if (!unknown.quality?.some((item) => item.includes('unknown governance advice intent'))) throw new Error('governance advice unknown intent did not report quality marker');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('governance advice unknown fallback created unexpected state directory');
+
+    for (const forbidden of ['--confirm', '--preview', '--write', '--preflight', '--dispatch', '--dispatch-intent', '--run', '--once', '--scan']) {
+      run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--advice', '--intent', 'closeout', forbidden, '--root', target], {
+        allowFailure: true,
+        expectOutput: forbidden === '--once' || forbidden === '--scan' || forbidden === '--run' || forbidden === '--write'
+          ? ['governance --advice is read-only']
+          : ['governance --advice is read-only'],
+      }, options);
+    }
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--advice', '--intent', 'closeout', '--pr-readiness', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['governance requires exactly one of'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--advice', '--intent', 'closeout', '--convergence', '--report', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['governance requires exactly one of'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--advice', '--intent', 'closeout', '--from-file', 'evidence.json', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['governance --advice does not accept --report, --from-file, or --from-readiness'],
+    }, options);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+function runUnifiedAdviceSmoke(options) {
+  const target = '.tmp/vibe-unified-advice';
+  const absoluteTarget = path.join(repoRoot, target);
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(absoluteTarget, { recursive: true });
+    const advice = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'advice', '--hub', '--intent', 'feature', '--json', '--root', target], {}, options), 'advice --hub --intent feature --json');
+    assertJsonMarkers([
+      ['command', advice.command, 'advice'],
+      ['mode', advice.mode, 'unified-runtime-advice-hub'],
+      ['advice_hub.stage', advice.advice_hub?.stage, 'Stage 83'],
+      ['advice_hub.advice_kind', advice.advice_hub?.advice_kind, 'unified-runtime-advice-hub'],
+      ['advice_hub.normalized_intent', advice.advice_hub?.normalized_intent, 'feature'],
+      ['advice_hub.primary_lane', advice.advice_hub?.primary_lane, 'entry'],
+      ['advice_hub.writes', advice.advice_hub?.writes, false],
+      ['advice_hub.state_directory_created', advice.advice_hub?.state_directory_created, false],
+      ['advice_hub.lane_recommendations.entry.stage', advice.advice_hub?.lane_recommendations?.entry?.stage, 'Stage 78'],
+      ['advice_hub.lane_recommendations.tokens.stage', advice.advice_hub?.lane_recommendations?.tokens?.stage, 'Stage 79'],
+      ['advice_hub.lane_recommendations.learning.stage', advice.advice_hub?.lane_recommendations?.learning?.stage, 'Stage 80'],
+      ['advice_hub.lane_recommendations.governance.stage', advice.advice_hub?.lane_recommendations?.governance?.stage, 'Stage 81'],
+      ['safety.writes', advice.safety?.writes, false],
+      ['safety.advice_hub_artifact', advice.safety?.advice_hub_artifact, false],
+      ['safety.sidecar_write', advice.safety?.sidecar_write, false],
+      ['safety.command_execution', advice.safety?.command_execution, false],
+      ['safety.pr', advice.safety?.pr, false],
+      ['safety.push', advice.safety?.push, false],
+      ['safety.merge', advice.safety?.merge, false],
+      ['safety.platform_api', advice.safety?.platform_api, false],
+      ['safety.external_network', advice.safety?.external_network, false],
+      ['safety.git', advice.safety?.git, false],
+      ['safety.worktree', advice.safety?.worktree, false],
+    ], 'advice --hub --intent feature --json');
+    if (!advice.advice_hub?.advice_digest) throw new Error('unified advice hub missing advice_digest');
+    if (!advice.advice_hub?.lane_digests?.entry || !advice.advice_hub?.lane_digests?.governance) throw new Error('unified advice hub missing lane digests');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('unified advice hub JSON output created unexpected state directory');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'advice', '--hub', '--intent', 'review', '--root', target], {
+      expectOutput: ['Vibecoding Runtime Advice Hub', 'Primary lane: governance', 'Boundary: writes=false; command_execution=false; pr=false; push=false; merge=false; platform_api=false; git=false; worktree=false'],
+    }, options);
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('unified advice hub text output created unexpected state directory');
+
+    const unknown = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'advice', '--hub', '--intent', 'unknown-kind', '--json', '--root', target], {}, options), 'advice --hub --intent unknown-kind --json');
+    assertJsonMarkers([
+      ['advice_hub.normalized_intent', unknown.advice_hub?.normalized_intent, 'unknown'],
+      ['advice_hub.primary_lane', unknown.advice_hub?.primary_lane, 'entry'],
+      ['advice_hub.lane_recommendations.governance.intent', unknown.advice_hub?.lane_recommendations?.governance?.intent, 'unknown'],
+    ], 'advice --hub --intent unknown-kind --json');
+    if (!unknown.quality?.some((item) => item.includes('unknown unified advice intent'))) throw new Error('unified advice hub unknown intent did not report quality marker');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('unified advice hub unknown fallback created unexpected state directory');
+
+    for (const forbidden of ['--confirm', '--preview', '--write', '--preflight', '--dispatch', '--dispatch-intent', '--run', '--once', '--scan']) {
+      run('node', ['tools/vibe-runtime/index.mjs', 'advice', '--hub', '--intent', 'feature', forbidden, '--root', target], {
+        allowFailure: true,
+        expectOutput: ['advice --hub is read-only'],
+      }, options);
+    }
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'advice', '--intent', 'feature', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['advice requires exactly one mode: --hub'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'advice', '--hub', '--intent', 'feature', '--from-file', 'docs/runtime-roadmap.md', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['advice --hub does not accept concrete evidence or sidecar input files'],
+    }, options);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+function runWorkflowReadinessSmoke(options) {
+  const target = '.tmp/vibe-workflow-readiness';
+  const absoluteTarget = path.join(repoRoot, target);
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(absoluteTarget, { recursive: true });
+    const readiness = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'methodology', '--readiness', '--intent', 'implementation', '--json', '--root', target], {}, options), 'methodology --readiness --intent implementation --json');
+    assertJsonMarkers([
+      ['command', readiness.command, 'methodology'],
+      ['mode', readiness.mode, 'workflow-readiness-gate'],
+      ['workflow_readiness.stage', readiness.workflow_readiness?.stage, 'Stage 85'],
+      ['workflow_readiness.readiness_kind', readiness.workflow_readiness?.readiness_kind, 'workflow-readiness-gate'],
+      ['workflow_readiness.normalized_intent', readiness.workflow_readiness?.normalized_intent, 'implementation'],
+      ['workflow_readiness.route_summary.stage', readiness.workflow_readiness?.route_summary?.stage, 'Stage 60'],
+      ['workflow_readiness.route_summary.first_skill', readiness.workflow_readiness?.route_summary?.first_skill, 'vibe-test-driven-development'],
+      ['workflow_readiness.required_gate_kinds.0', readiness.workflow_readiness?.required_gate_kinds?.[0], 'tdd'],
+      ['workflow_readiness.required_gate_kinds.1', readiness.workflow_readiness?.required_gate_kinds?.[1], 'completion'],
+      ['workflow_readiness.gate_previews.0.kind', readiness.workflow_readiness?.gate_previews?.[0]?.kind, 'tdd'],
+      ['workflow_readiness.gate_previews.0.writes', readiness.workflow_readiness?.gate_previews?.[0]?.writes, false],
+      ['workflow_readiness.gate_previews.0.methodology_gate_artifact', readiness.workflow_readiness?.gate_previews?.[0]?.methodology_gate_artifact, false],
+      ['workflow_readiness.runtime_readiness_summary.stage', readiness.workflow_readiness?.runtime_readiness_summary?.stage, 'Stage 30'],
+      ['workflow_readiness.runtime_readiness_summary.writes', readiness.workflow_readiness?.runtime_readiness_summary?.writes, false],
+      ['workflow_readiness.advice_hub_summary.stage', readiness.workflow_readiness?.advice_hub_summary?.stage, 'Stage 83'],
+      ['workflow_readiness.ready_to_start', readiness.workflow_readiness?.ready_to_start, false],
+      ['workflow_readiness.writes', readiness.workflow_readiness?.writes, false],
+      ['workflow_readiness.state_directory_created', readiness.workflow_readiness?.state_directory_created, false],
+      ['workflow_readiness.boundary_assertions.workflow_readiness_artifact', readiness.workflow_readiness?.boundary_assertions?.workflow_readiness_artifact, false],
+      ['workflow_readiness.boundary_assertions.methodology_gate_write', readiness.workflow_readiness?.boundary_assertions?.methodology_gate_write, false],
+      ['workflow_readiness.boundary_assertions.command_execution', readiness.workflow_readiness?.boundary_assertions?.command_execution, false],
+      ['workflow_readiness.boundary_assertions.runtime_action', readiness.workflow_readiness?.boundary_assertions?.runtime_action, false],
+      ['workflow_readiness.boundary_assertions.pr', readiness.workflow_readiness?.boundary_assertions?.pr, false],
+      ['workflow_readiness.boundary_assertions.push', readiness.workflow_readiness?.boundary_assertions?.push, false],
+      ['workflow_readiness.boundary_assertions.merge', readiness.workflow_readiness?.boundary_assertions?.merge, false],
+      ['workflow_readiness.boundary_assertions.platform_api', readiness.workflow_readiness?.boundary_assertions?.platform_api, false],
+      ['safety.stage', readiness.safety?.stage, 'Stage 85'],
+      ['safety.writes', readiness.safety?.writes, false],
+      ['safety.workflow_readiness_artifact', readiness.safety?.workflow_readiness_artifact, false],
+      ['safety.methodology_gate_write', readiness.safety?.methodology_gate_write, false],
+      ['safety.command_execution', readiness.safety?.command_execution, false],
+      ['safety.runtime_action', readiness.safety?.runtime_action, false],
+      ['safety.git', readiness.safety?.git, false],
+      ['safety.worktree', readiness.safety?.worktree, false],
+    ], 'methodology --readiness --intent implementation --json');
+    if (!readiness.workflow_readiness?.readiness_digest) throw new Error('workflow readiness missing readiness_digest');
+    if (!readiness.workflow_readiness?.blocked_reasons?.some((reason) => reason.includes('tdd:'))) throw new Error('workflow readiness implementation did not expose blocked tdd reasons');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('workflow readiness JSON output created unexpected state directory');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'methodology', '--readiness', '--intent', 'review', '--root', target], {
+      expectOutput: ['Vibecoding Runtime Workflow Readiness', 'Intent: review', 'Required gates: review', 'Boundary: writes=false; workflow_readiness_artifact=false; methodology_gate_write=false'],
+    }, options);
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('workflow readiness text output created unexpected state directory');
+
+    const unknown = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'methodology', '--readiness', '--intent', 'unknown-kind', '--json', '--root', target], {}, options), 'methodology --readiness --intent unknown-kind --json');
+    assertJsonMarkers([
+      ['workflow_readiness.normalized_intent', unknown.workflow_readiness?.normalized_intent, 'unknown'],
+      ['workflow_readiness.ready_to_start', unknown.workflow_readiness?.ready_to_start, false],
+      ['workflow_readiness.required_gate_kinds.length', unknown.workflow_readiness?.required_gate_kinds?.length, 0],
+      ['workflow_readiness.route_summary.first_skill', unknown.workflow_readiness?.route_summary?.first_skill, 'using-vibecoding'],
+    ], 'methodology --readiness --intent unknown-kind --json');
+    if (!unknown.workflow_readiness?.blocked_reasons?.some((reason) => reason.includes('unknown workflow readiness intent'))) throw new Error('workflow readiness unknown fallback did not report clarification blocker');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('workflow readiness unknown fallback created unexpected state directory');
+
+    for (const forbidden of ['--confirm', '--preview', '--write', '--preflight', '--dispatch', '--dispatch-intent', '--run', '--once', '--scan']) {
+      run('node', ['tools/vibe-runtime/index.mjs', 'methodology', '--readiness', '--intent', 'review', forbidden, '--root', target], {
+        allowFailure: true,
+        expectOutput: forbidden === '--write' || forbidden === '--once' || forbidden === '--scan' || forbidden === '--run' || forbidden === '--preflight' || forbidden === '--dispatch' || forbidden === '--dispatch-intent'
+          ? ['methodology supports catalog, route, readiness, gate, and read-only audit only']
+          : ['methodology --readiness is read-only'],
+      }, options);
+    }
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'methodology', '--readiness', '--intent', 'review', '--from-file', 'docs/runtime-roadmap.md', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['methodology --readiness does not accept concrete evidence, gate, or audit input files'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'methodology', '--readiness', '--route', '--intent', 'review', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['methodology requires exactly one of --catalog, --route, --readiness, --gate, --list, --show, or --verify'],
+    }, options);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+function runPlanLintSmoke(options) {
+  const target = '.tmp/vibe-plan-lint';
+  const absoluteTarget = path.join(repoRoot, target);
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(absoluteTarget, { recursive: true });
+    const goodPlan = path.join(absoluteTarget, 'good-plan.md');
+    const badPlan = path.join(absoluteTarget, 'bad-plan.md');
+    fs.writeFileSync(goodPlan, [
+      '# Stage smoke plan',
+      '',
+      '## Stage 1 Task',
+      '- [ ] update `tools/vibe-runtime/index.mjs`',
+      '- [ ] update tools/vibe-runtime/README.md',
+      '',
+      'Interfaces: output `plan_lint` envelope fields and data flow boundaries.',
+      'Verification: run node --check tools/vibe-runtime/index.mjs and runtime-check smoke.',
+      'Acceptance: expected pass when blockers are absent.',
+      'Review gate: run vibe-review before completion.',
+      'Dependencies: first plan, then implement, then verify.',
+      'Completion boundary: no git push, no PR, no external network, done only after verification.',
+    ].join('\n'), 'utf8');
+    fs.writeFileSync(badPlan, '# TODO\n\nImplement later.\n', 'utf8');
+
+    const lint = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'planner', '--lint', '--from-file', `${target}/good-plan.md`, '--json', '--root', target], {}, options), 'planner --lint good plan --json');
+    assertJsonMarkers([
+      ['command', lint.command, 'planner'],
+      ['mode', lint.mode, 'plan-quality-lint'],
+      ['plan_lint.stage', lint.plan_lint?.stage, 'Stage 86'],
+      ['plan_lint.lint_kind', lint.plan_lint?.lint_kind, 'plan-quality-lint'],
+      ['plan_lint.execution_ready', lint.plan_lint?.execution_ready, true],
+      ['plan_lint.summary.blocker_count', lint.plan_lint?.summary?.blocker_count, 0],
+      ['plan_lint.boundary_assertions.plan_lint_artifact', lint.plan_lint?.boundary_assertions?.plan_lint_artifact, false],
+      ['plan_lint.boundary_assertions.command_execution', lint.plan_lint?.boundary_assertions?.command_execution, false],
+      ['safety.stage', lint.safety?.stage, 'Stage 86'],
+      ['safety.writes', lint.safety?.writes, false],
+    ], 'planner --lint good plan --json');
+    if (!lint.plan_lint?.lint_digest) throw new Error('planner lint missing lint_digest');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('planner lint JSON output created unexpected state directory');
+
+    const blocked = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'planner', '--lint', '--from-file', `${target}/bad-plan.md`, '--json', '--root', target], {}, options), 'planner --lint bad plan --json');
+    if (blocked.plan_lint?.execution_ready !== false || !blocked.plan_lint?.blocking_findings?.length) throw new Error('planner lint bad plan did not block');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'planner', '--lint', '--from-file', `${target}/good-plan.md`, '--root', target], {
+      expectOutput: ['Vibecoding Runtime Plan Quality Lint', 'Stage: Stage 86; Ready: true', 'Boundary: writes=false; plan_lint_artifact=false'],
+    }, options);
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('planner lint text output created unexpected state directory');
+
+    for (const forbidden of ['--confirm', '--write', '--preflight', '--run']) {
+      run('node', ['tools/vibe-runtime/index.mjs', 'planner', '--lint', '--from-file', `${target}/good-plan.md`, forbidden, '--root', target], {
+        allowFailure: true,
+        expectOutput: ['planner --lint is read-only'],
+      }, options);
+    }
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+function runWorkflowCockpitSmoke(options) {
+  const target = '.tmp/vibe-workflow-cockpit';
+  const absoluteTarget = path.join(repoRoot, target);
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(absoluteTarget, { recursive: true });
+    fs.writeFileSync(path.join(absoluteTarget, 'plan.md'), [
+      '# Cockpit plan',
+      '## Stage 1 Task',
+      '- [ ] update `tools/vibe-runtime/index.mjs`',
+      'Interfaces: output `workflow_cockpit` envelope fields.',
+      'Verification: run node --check tools/vibe-runtime/index.mjs.',
+      'Acceptance: expected pass for plan lint.',
+      'Review gate: vibe-review before completion.',
+      'Dependencies: plan before implementation.',
+      'Completion boundary: no push, no PR, no merge.',
+    ].join('\n'), 'utf8');
+
+    const cockpit = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--cockpit', '--intent', 'implementation', '--from-file', `${target}/plan.md`, '--json', '--root', target], {}, options), 'workflow --cockpit --json');
+    assertJsonMarkers([
+      ['command', cockpit.command, 'workflow'],
+      ['mode', cockpit.mode, 'workflow-cockpit'],
+      ['workflow_cockpit.stage', cockpit.workflow_cockpit?.stage, 'Stage 87'],
+      ['workflow_cockpit.cockpit_kind', cockpit.workflow_cockpit?.cockpit_kind, 'workflow-cockpit'],
+      ['workflow_cockpit.normalized_intent', cockpit.workflow_cockpit?.normalized_intent, 'implementation'],
+      ['workflow_cockpit.route_summary.stage', cockpit.workflow_cockpit?.route_summary?.stage, 'Stage 60'],
+      ['workflow_cockpit.readiness_summary.ready_to_start', cockpit.workflow_cockpit?.readiness_summary?.ready_to_start, false],
+      ['workflow_cockpit.plan_lint_summary.status', cockpit.workflow_cockpit?.plan_lint_summary?.status, 'ready'],
+      ['workflow_cockpit.boundary_assertions.workflow_cockpit_artifact', cockpit.workflow_cockpit?.boundary_assertions?.workflow_cockpit_artifact, false],
+      ['workflow_cockpit.boundary_assertions.command_execution', cockpit.workflow_cockpit?.boundary_assertions?.command_execution, false],
+      ['safety.stage', cockpit.safety?.stage, 'Stage 87'],
+      ['safety.writes', cockpit.safety?.writes, false],
+    ], 'workflow --cockpit --json');
+    if (!cockpit.workflow_cockpit?.cockpit_digest) throw new Error('workflow cockpit missing cockpit_digest');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('workflow cockpit JSON output created unexpected state directory');
+
+    const unknown = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--cockpit', '--intent', 'unknown-kind', '--json', '--root', target], {}, options), 'workflow --cockpit unknown --json');
+    assertJsonMarkers([
+      ['workflow_cockpit.normalized_intent', unknown.workflow_cockpit?.normalized_intent, 'unknown'],
+      ['workflow_cockpit.current_phase', unknown.workflow_cockpit?.current_phase, 'clarify'],
+      ['workflow_cockpit.plan_lint_summary.status', unknown.workflow_cockpit?.plan_lint_summary?.status, 'not_provided'],
+    ], 'workflow --cockpit unknown --json');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--cockpit', '--intent', 'review', '--root', target], {
+      expectOutput: ['Vibecoding Runtime Workflow Cockpit', 'Stage: Stage 87', 'Boundary: writes=false; workflow_cockpit_artifact=false'],
+    }, options);
+
+    for (const forbidden of ['--confirm', '--write', '--preflight', '--run']) {
+      run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--cockpit', '--intent', 'review', forbidden, '--root', target], {
+        allowFailure: true,
+        expectOutput: ['workflow read-only modes do not accept'],
+      }, options);
+    }
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+function runBootstrapAcceptanceSmoke(options) {
+  return runBootstrapAcceptanceSmokeFromWorkflowEntry(options);
+}
+
+function runMethodologyRouteSmoke(options) {
+  return runMethodologyRouteSmokeFromWorkflowEntry(options);
+}
+
+function runEntryAdviceSmoke(options) {
+  return runEntryAdviceSmokeFromWorkflowEntry(options);
+}
+
+function runCommitGuardSmoke(options) {
+  const target = '.tmp/vibe-commit-guard';
+  const absoluteTarget = path.join(repoRoot, target);
+  const evidenceDirectory = path.join(absoluteTarget, 'evidence');
+  const evidenceFile = path.join(evidenceDirectory, 'commit-subjects.txt');
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(evidenceDirectory, { recursive: true });
+    fs.writeFileSync(evidenceFile, [
+      'cf2587c ``` feat(runtime): 添加 Stage 91-95 workflow 入口体验强化功能',
+      '3588a75 feat(runtime): 添加 Stage 78 入口建议命令',
+      'abc1234 update release hygiene without conventional prefix',
+      '',
+    ].join('\n'), 'utf8');
+
+    const clean = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'release', '--commit-guard', '--subject', 'feat(runtime): add commit guard', '--json', '--root', target], {}, options), 'release --commit-guard --subject clean --json');
+    assertJsonMarkers([
+      ['command', clean.command, 'release'],
+      ['mode', clean.mode, 'commit-title-guard'],
+      ['ok', clean.ok, true],
+      ['commit_guard.stage', clean.commit_guard?.stage, 'Stage 98'],
+      ['commit_guard.artifact_kind', clean.commit_guard?.artifact_kind, 'commit-title-guard'],
+      ['commit_guard.guard_kind', clean.commit_guard?.guard_kind, 'deterministic-commit-title-guard'],
+      ['commit_guard.input_kind', clean.commit_guard?.input_kind, 'subject'],
+      ['commit_guard.guard_pass', clean.commit_guard?.guard_pass, true],
+      ['safety.writes', clean.safety?.writes, false],
+      ['safety.commit_guard_artifact', clean.safety?.commit_guard_artifact, false],
+      ['safety.git', clean.safety?.git, false],
+      ['safety.git_write', clean.safety?.git_write, false],
+      ['safety.history_rewrite', clean.safety?.history_rewrite, false],
+      ['safety.push', clean.safety?.push, false],
+      ['safety.pr', clean.safety?.pr, false],
+      ['safety.release_gate_required', clean.safety?.release_gate_required, false],
+    ], 'release --commit-guard --subject clean --json');
+    if (!clean.commit_guard?.commit_guard_digest) throw new Error('commit guard clean output missing digest');
+    if (clean.commit_guard?.findings?.length !== 0) throw new Error('commit guard clean subject produced findings');
+
+    const evidence = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'release', '--commit-guard', '--from-file', 'evidence/commit-subjects.txt', '--json', '--root', target], {}, options), 'release --commit-guard --from-file --json');
+    assertJsonMarkers([
+      ['mode', evidence.mode, 'commit-title-guard'],
+      ['ok', evidence.ok, false],
+      ['commit_guard.stage', evidence.commit_guard?.stage, 'Stage 98'],
+      ['commit_guard.input_kind', evidence.commit_guard?.input_kind, 'local-evidence-file'],
+      ['commit_guard.source_file', evidence.commit_guard?.source_file, 'evidence/commit-subjects.txt'],
+      ['commit_guard.subject_count', evidence.commit_guard?.subject_count, 3],
+      ['commit_guard.guard_pass', evidence.commit_guard?.guard_pass, false],
+    ], 'release --commit-guard --from-file --json');
+    if (!evidence.commit_guard?.findings?.some((finding) => finding.finding_type === 'markdown-fence-token' && finding.severity === 'error')) throw new Error('commit guard evidence missing markdown fence token error');
+    if (!evidence.commit_guard?.findings?.some((finding) => finding.finding_type === 'non-conventional-subject' && finding.severity === 'warning')) throw new Error('commit guard evidence missing non-conventional warning');
+    if (!evidence.commit_guard?.blocked_reasons?.some((reason) => reason.includes('markdown-fence-token'))) throw new Error('commit guard evidence missing blocked reason');
+    if (!evidence.commit_guard?.source_digest) throw new Error('commit guard evidence missing source digest');
+    if (!evidence.commit_guard?.commit_guard_digest) throw new Error('commit guard evidence missing digest');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('release --commit-guard created state directory');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'release', '--commit-guard', '--subject', 'feat(runtime): add commit guard', '--confirm', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['release --commit-guard is read-only'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'release', '--commit-guard', '--subject', 'feat(runtime): add commit guard', '--from-file', 'evidence/commit-subjects.txt', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['release --commit-guard accepts either --subject or --from-file'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'release', '--commit-guard', '--from-file', '../outside.txt', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['commit guard evidence file must not include traversal'],
+    }, options);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+function runReleaseNotesSmoke(options) {
+  const target = '.tmp/vibe-release-notes';
+  const absoluteTarget = path.join(repoRoot, target);
+  const evidenceDirectory = path.join(absoluteTarget, 'evidence');
+  const evidenceFile = path.join(evidenceDirectory, 'stage52-67-release-evidence.txt');
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(evidenceDirectory, { recursive: true });
+    fs.writeFileSync(evidenceFile, [
+      'range: add644b..HEAD',
+      'Stage 52-65 release audit evidence',
+      '606d3de docs(release-guide): 添加 Stage 52-65 能力收敛发布审计文档',
+      '```3c976f0 feat(runtime): 添加 Stage 65 治理收敛门控功能',
+      'abc1234 update release hygiene without conventional prefix',
+      'Stage 68 release notes evidence sidecar smoke',
+      'tools/vibe-runtime/index.mjs | 42 ++++++++++++++++++++++++++',
+      '',
+    ].join('\n'), 'utf8');
+
+    const preview = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'release', '--notes', '--from-file', 'evidence/stage52-67-release-evidence.txt', '--preview', '--json', '--root', target], {}, options), 'release --notes --preview --json');
+    assertJsonMarkers([
+      ['command', preview.command, 'release'],
+      ['mode', preview.mode, 'release-notes'],
+      ['release_notes.stage', preview.release_notes?.stage, 'Stage 68'],
+      ['release_notes.artifact_kind', preview.release_notes?.artifact_kind, 'release-notes'],
+      ['release_notes.source_file', preview.release_notes?.source_file, 'evidence/stage52-67-release-evidence.txt'],
+      ['release_notes.optional', preview.release_notes?.optional, true],
+      ['release_notes.sidecar_only', preview.release_notes?.sidecar_only, true],
+      ['release_notes.default_enabled', preview.release_notes?.default_enabled, false],
+      ['release_notes.release_chain_required', preview.release_notes?.release_chain_required, false],
+      ['release_notes.deterministic', preview.release_notes?.deterministic, true],
+      ['release_notes.pure_function', preview.release_notes?.pure_function, true],
+      ['safety.writes', preview.safety?.writes, false],
+      ['safety.release_notes_artifact', preview.safety?.release_notes_artifact, false],
+      ['safety.git_write', preview.safety?.git_write, false],
+      ['safety.history_rewrite', preview.safety?.history_rewrite, false],
+      ['safety.push', preview.safety?.push, false],
+      ['safety.pr', preview.safety?.pr, false],
+      ['safety.platform_api', preview.safety?.platform_api, false],
+      ['safety.external_network', preview.safety?.external_network, false],
+      ['safety.model_invocation', preview.safety?.model_invocation, false],
+      ['safety.release_gate_required', preview.safety?.release_gate_required, false],
+    ], 'release --notes --preview --json');
+    if (preview.release_notes?.commit_count !== 3) throw new Error('release notes preview commit count mismatch');
+    if (!preview.release_notes?.stage_coverage?.includes('Stage 52')) throw new Error('release notes preview missing Stage 52 coverage');
+    if (!preview.release_notes?.stage_coverage?.includes('Stage 68')) throw new Error('release notes preview missing Stage 68 coverage');
+    if (!preview.release_notes?.commit_hygiene_findings?.some((finding) => finding.finding_type === 'markdown-fence-prefix')) throw new Error('release notes preview missing markdown fence hygiene finding');
+    if (!preview.release_notes?.commit_hygiene_findings?.some((finding) => finding.finding_type === 'non-conventional-subject')) throw new Error('release notes preview missing non-conventional hygiene finding');
+    if (!preview.release_notes?.release_notes_digest) throw new Error('release notes preview missing digest');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('release --notes preview created state directory');
+
+    const confirmed = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'release', '--notes', '--from-file', 'evidence/stage52-67-release-evidence.txt', '--confirm', '--json', '--root', target], {}, options), 'release --notes --confirm --json');
+    const releaseNotesFile = confirmed.release_notes_file;
+    if (!releaseNotesFile || !releaseNotesFile.endsWith('.release-notes.json')) throw new Error('release --notes confirm did not return release notes sidecar file');
+    const releaseNotesPath = path.join(absoluteTarget, '.vibecoding-state', 'release-notes', releaseNotesFile);
+    if (!fs.existsSync(releaseNotesPath)) throw new Error('release --notes confirm did not write release notes sidecar');
+    const extraStateEntries = fs.readdirSync(path.join(absoluteTarget, '.vibecoding-state')).filter((entry) => entry !== 'release-notes');
+    if (extraStateEntries.length > 0) throw new Error(`release notes smoke wrote unexpected state entries: ${extraStateEntries.join(', ')}`);
+
+    const verified = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'release', '--verify-notes', releaseNotesFile, '--json', '--root', target], {}, options), `release --verify-notes ${releaseNotesFile} --json`);
+    if (verified.verification?.ok !== true) throw new Error(`release notes verify failed for ${releaseNotesFile}`);
+
+    fs.appendFileSync(evidenceFile, 'Stage 68 source digest drift\n', 'utf8');
+    run('node', ['tools/vibe-runtime/index.mjs', 'release', '--verify-notes', releaseNotesFile, '--root', target], {
+      allowFailure: true,
+      expectOutput: ['release notes verification failed:', 'release_notes.source_digest drift', 'release_notes.release_notes_digest drift'],
+    }, options);
+    fs.writeFileSync(evidenceFile, [
+      'range: add644b..HEAD',
+      'Stage 52-65 release audit evidence',
+      '606d3de docs(release-guide): 添加 Stage 52-65 能力收敛发布审计文档',
+      '```3c976f0 feat(runtime): 添加 Stage 65 治理收敛门控功能',
+      'abc1234 update release hygiene without conventional prefix',
+      'Stage 68 release notes evidence sidecar smoke',
+      'tools/vibe-runtime/index.mjs | 42 ++++++++++++++++++++++++++',
+      '',
+    ].join('\n'), 'utf8');
+
+    const badBoundary = JSON.parse(fs.readFileSync(releaseNotesPath, 'utf8'));
+    badBoundary.release_notes.boundary_assertions.push = true;
+    const badBoundaryPayload = { ...badBoundary.release_notes };
+    delete badBoundaryPayload.writes;
+    delete badBoundaryPayload.release_notes_digest;
+    badBoundary.release_notes.release_notes_digest = digestObject(badBoundaryPayload);
+    fs.writeFileSync(path.join(absoluteTarget, '.vibecoding-state', 'release-notes', 'bad-boundary.release-notes.json'), `${JSON.stringify(badBoundary, null, 2)}\n`, 'utf8');
+    run('node', ['tools/vibe-runtime/index.mjs', 'release', '--verify-notes', 'bad-boundary.release-notes.json', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['release notes verification failed:', 'release_notes.boundary_assertions.push must be false'],
+    }, options);
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'release', '--notes', '--from-file', '../outside.txt', '--preview', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['release notes evidence file must not include traversal'],
+    }, options);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+  return {
+    runPlannerSmoke,
+    runPrReadinessSmoke,
+    runPrReviewIntakeSmoke,
+    runConvergenceSmoke,
+    runGovernanceAdviceSmoke,
+    runUnifiedAdviceSmoke,
+    runWorkflowReadinessSmoke,
+    runPlanLintSmoke,
+    runWorkflowCockpitSmoke,
+    runBootstrapAcceptanceSmoke,
+    runMethodologyRouteSmoke,
+    runEntryAdviceSmoke,
+    runCommitGuardSmoke,
+    runReleaseNotesSmoke,
+  };
+}