@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-release-check/release-check-completion-suite.mjs

@@ -0,0 +1,110 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  completionEvidenceBundleBlockedJsonMarkers,
+  completionEvidenceBundleFixtures,
+  completionEvidenceBundleForbiddenOutputMarkers,
+  completionEvidenceBundleReadyJsonMarkers,
+  completionEvidenceBundleTextMarkers,
+  completionReadinessFixtures,
+  completionReadinessForbiddenOutputMarkers,
+  completionReadinessReadyJsonMarkers,
+  completionReadinessTextMarkers,
+  completionReadonlyForbiddenFlags,
+  readinessGateSplitFixtures,
+  readinessGateSplitForbiddenOutputMarkers,
+  readinessGateSplitJsonMarkers,
+  readinessGateSplitTextMarkers,
+} from './release-check-completion-fixtures.mjs';
+import {
+  assertJsonMarkers,
+  parseJsonOutput,
+  run,
+  withSuiteTmp,
+} from './release-check-runtime.mjs';
+
+export function runReadinessGateSplitSmoke(options) {
+  return withSuiteTmp('vibe-readiness-gate-split', options, ({ target, absoluteTarget }) => {
+    fs.writeFileSync(path.join(absoluteTarget, 'ready-for-done.md'), readinessGateSplitFixtures.readyForDoneText, 'utf8');
+    fs.writeFileSync(path.join(absoluteTarget, 'blocked.md'), readinessGateSplitFixtures.blockedText, 'utf8');
+
+    const split = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'readiness', '--gates', '--from-file', `${target}/ready-for-done.md`, '--json', '--root', target], {}, options), 'readiness --gates ready-for-done --json');
+    assertJsonMarkers(readinessGateSplitJsonMarkers(split), 'readiness --gates ready-for-done --json');
+    if (!split.readiness_gate_split?.readiness_gate_split_digest) throw new Error('readiness gate split missing digest');
+    const localCommitGate = split.readiness_gate_split?.gates?.find((gate) => gate.gate === 'local_commit');
+    if (!localCommitGate?.blocked_reasons?.includes('MISSING_LOCAL_COMMIT_AUTHORIZATION')) throw new Error('local commit gate must stay blocked without explicit local commit authorization');
+    if (split.readiness_gate_split?.blocked_gates?.length < 1 || split.readiness_gate_split?.ready_gates?.length < 1) throw new Error('readiness gate split must allow different conclusions from the same evidence');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('readiness gate split JSON output created unexpected state directory');
+
+    const blocked = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'readiness', '--gates', '--from-file', `${target}/blocked.md`, '--json', '--root', target], {}, options), 'readiness --gates blocked --json');
+    if (!blocked.readiness_gate_split?.blocked_reasons?.some((reason) => reason.includes('MISSING_TEST_EVIDENCE'))) throw new Error('readiness gate split did not produce stable missing test blocker');
+    if (!blocked.readiness_gate_split?.blocked_reasons?.some((reason) => reason.includes('UNSAFE_RELEASE_ACTION_CLAIM'))) throw new Error('readiness gate split did not flag unsafe release action claim');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'readiness', '--gates', '--from-file', `${target}/ready-for-done.md`, '--root', target], {
+      expectOutput: readinessGateSplitTextMarkers,
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'readiness', '--score', '--json', '--root', target], {}, options);
+    for (const forbidden of ['--confirm', '--write', '--run', '--preflight']) {
+      run('node', ['tools/vibe-runtime/index.mjs', 'readiness', '--gates', '--from-file', `${target}/ready-for-done.md`, forbidden, '--root', target], {
+        allowFailure: true,
+        expectOutput: readinessGateSplitForbiddenOutputMarkers,
+      }, options);
+    }
+  });
+}
+
+export function runCompletionReadinessSmoke(options) {
+  return withSuiteTmp('vibe-completion-readiness', options, ({ target, absoluteTarget }) => {
+    fs.writeFileSync(path.join(absoluteTarget, 'done.md'), completionReadinessFixtures.doneText, 'utf8');
+    fs.writeFileSync(path.join(absoluteTarget, 'blocked.md'), completionReadinessFixtures.blockedText, 'utf8');
+
+    const ready = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'completion', '--readiness', '--from-file', `${target}/done.md`, '--json', '--root', target], {}, options), 'completion --readiness pass --json');
+    assertJsonMarkers(completionReadinessReadyJsonMarkers(ready), 'completion --readiness pass --json');
+    if (!ready.completion_readiness?.readiness_digest) throw new Error('completion readiness missing readiness_digest');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('completion readiness JSON output created unexpected state directory');
+
+    const blocked = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'completion', '--readiness', '--from-file', `${target}/blocked.md`, '--json', '--root', target], {}, options), 'completion --readiness blocked --json');
+    if (blocked.completion_readiness?.ready_to_report_done !== false || !blocked.completion_readiness?.blocked_reasons?.length) throw new Error('completion readiness blocked evidence did not block');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'completion', '--readiness', '--root', target], {
+      expectOutput: completionReadinessTextMarkers,
+    }, options);
+
+    for (const forbidden of completionReadonlyForbiddenFlags) {
+      run('node', ['tools/vibe-runtime/index.mjs', 'completion', '--readiness', forbidden, '--root', target], {
+        allowFailure: true,
+        expectOutput: completionReadinessForbiddenOutputMarkers,
+      }, options);
+    }
+  });
+}
+
+export function runCompletionEvidenceBundleSmoke(options) {
+  return withSuiteTmp('vibe-completion-evidence-bundle', options, ({ target, absoluteTarget }) => {
+    fs.writeFileSync(path.join(absoluteTarget, 'done.md'), completionEvidenceBundleFixtures.doneText, 'utf8');
+    fs.writeFileSync(path.join(absoluteTarget, 'blocked.md'), completionEvidenceBundleFixtures.blockedText, 'utf8');
+
+    const ready = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'completion', '--evidence-bundle', '--from-file', `${target}/done.md`, '--json', '--root', target], {}, options), 'completion --evidence-bundle pass --json');
+    assertJsonMarkers(completionEvidenceBundleReadyJsonMarkers(ready), 'completion --evidence-bundle pass --json');
+    if (!ready.completion_evidence_bundle?.bundle_digest) throw new Error('completion evidence bundle missing bundle_digest');
+    if (!ready.completion_evidence_bundle?.human_completion_evidence_bundle?.human_completion_evidence_digest) throw new Error('completion evidence bundle missing Stage 124 human_completion_evidence_digest');
+    if (ready.completion_evidence_bundle?.human_completion_evidence_bundle?.one_screen_sections?.length !== 5) throw new Error('completion evidence bundle must expose five human one-screen sections');
+    if (!ready.completion_evidence_bundle?.readiness_summary?.readiness_digest) throw new Error('completion evidence bundle missing readiness digest binding');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('completion evidence bundle JSON output created unexpected state directory');
+
+    const blocked = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'completion', '--evidence-bundle', '--from-file', `${target}/blocked.md`, '--json', '--root', target], {}, options), 'completion --evidence-bundle blocked --json');
+    assertJsonMarkers(completionEvidenceBundleBlockedJsonMarkers(blocked), 'completion --evidence-bundle blocked --json');
+    if (!blocked.completion_evidence_bundle?.readiness_summary?.blocked_reasons?.length) throw new Error('completion evidence bundle blocked evidence did not include blocked reasons');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'completion', '--evidence-bundle', '--root', target], {
+      expectOutput: completionEvidenceBundleTextMarkers,
+    }, options);
+
+    for (const forbidden of completionReadonlyForbiddenFlags) {
+      run('node', ['tools/vibe-runtime/index.mjs', 'completion', '--evidence-bundle', forbidden, '--root', target], {
+        allowFailure: true,
+        expectOutput: completionEvidenceBundleForbiddenOutputMarkers,
+      }, options);
+    }
+  });
+}

package/tools/vibe-release-check/release-check-dispatch.mjs

@@ -0,0 +1,116 @@
+import { commandEntryHandler } from './command-manifest/release-check-command-metadata.mjs';
+
+const optionOnlyCommandHandlers = [
+  ['package-boundary-check', 'runPackageBoundarySmoke'],
+  ['runtime-ledger-smoke', 'runRuntimeLedgerSmoke'],
+  ['runtime-automation-smoke', 'runRuntimeAutomationSmoke'],
+  ['planner-smoke', 'runPlannerSmoke'],
+  ['router-smoke', 'runRouterSmoke'],
+  ['evals-smoke', 'runEvalsSmoke'],
+  ['pr-readiness-smoke', 'runPrReadinessSmoke'],
+  ['pr-review-intake-smoke', 'runPrReviewIntakeSmoke'],
+  ['convergence-smoke', 'runConvergenceSmoke'],
+  ['governance-advice-smoke', 'runGovernanceAdviceSmoke'],
+  ['runtime-surface-smoke', 'runRuntimeSurfaceSmoke'],
+  ['automation-readiness-smoke', 'runAutomationReadinessSmoke'],
+  ['workflow-loop-contract-smoke', 'runWorkflowLoopContractSmoke'],
+  ['plan-action-manifest-smoke', 'runPlanActionManifestSmoke'],
+  ['self-test-profile-smoke', 'runSelfTestProfileSmoke'],
+  ['commit-readiness-smoke', 'runCommitReadinessSmoke'],
+  ['confirmed-one-shot-plan-smoke', 'runConfirmedOneShotPlanSmoke'],
+  ['close-loop-dashboard-smoke', 'runCloseLoopDashboardSmoke'],
+  ['evidence-intake-smoke', 'runEvidenceIntakeSmoke'],
+  ['diff-coverage-smoke', 'runDiffCoverageSmoke'],
+  ['review-envelope-smoke', 'runReviewEnvelopeSmoke'],
+  ['tdd-trace-smoke', 'runTddTraceSmoke'],
+  ['human-friendly-alias-smoke', 'runHumanFriendlyAliasSmoke'],
+  ['superpowers-gap-smoke', 'runSuperpowersGapSmoke'],
+  ['superpowers-regression-guard-smoke', 'runSuperpowersRegressionGuardSmoke'],
+  ['experience-friction-smoke', 'runExperienceFrictionSmoke'],
+  ['next-action-console-smoke', 'runNextActionConsoleSmoke'],
+  ['token-savior-budget-smoke', 'runTokenSaviorBudgetSmoke'],
+  ['experience-learning-pattern-smoke', 'runExperienceLearningPatternSmoke'],
+  ['stage-scriptlet-smoke', 'runStageScriptletSmoke'],
+  ['adapter-entry-acceptance-smoke', 'runAdapterEntryAcceptanceSmoke'],
+  ['installed-multiround-ux-smoke', 'runInstalledMultiroundUxSmoke'],
+  ['session-start-shape-smoke', 'runSessionStartShapeSmoke'],
+  ['entry-trigger-discipline-smoke', 'runEntryTriggerDisciplineSmoke'],
+  ['experience-regression-dashboard-smoke', 'runExperienceRegressionDashboardSmoke'],
+  ['superpowers-comparison-smoke', 'runSuperpowersComparisonSmoke'],
+  ['methodology-coverage-map-smoke', 'runMethodologyCoverageMapSmoke'],
+  ['install-experience-smoke', 'runInstallExperienceSmoke'],
+  ['superpowers-style-eval-pack-smoke', 'runSuperpowersStyleEvalPackSmoke'],
+  ['experience-upgrade-prioritizer-smoke', 'runExperienceUpgradePrioritizerSmoke'],
+  ['superpowers-parity-scorecard-smoke', 'runSuperpowersParityScorecardSmoke'],
+  ['entry-trigger-tightening-smoke', 'runEntryTriggerTighteningSmoke'],
+  ['session-start-example-pack-smoke', 'runSessionStartExamplePackSmoke'],
+  ['next-action-evidence-prompts-smoke', 'runNextActionEvidencePromptsSmoke'],
+  ['context-budget-entry-defaults-smoke', 'runContextBudgetEntryDefaultsSmoke'],
+  ['local-behavior-eval-contracts-smoke', 'runLocalBehaviorEvalContractsSmoke'],
+  ['contributor-guardrail-evidence-smoke', 'runContributorGuardrailEvidenceSmoke'],
+  ['subagent-permission-visibility-smoke', 'runSubagentPermissionVisibilitySmoke'],
+  ['adapter-packaging-consistency-smoke', 'runAdapterPackagingConsistencySmoke'],
+  ['progressive-entry-ux-smoke', 'runProgressiveEntryUxSmoke'],
+  ['executable-plan-smoke', 'runExecutablePlanSmoke'],
+  ['stage-runbook-smoke', 'runStageRunbookSmoke'],
+  ['execution-evidence-smoke', 'runExecutionEvidenceSmoke'],
+  ['staged-commit-readiness-smoke', 'runStagedCommitReadinessSmoke'],
+  ['test-run-smoke', 'runTestRunSmoke'],
+  ['suite-plan-smoke', 'runSuitePlanSmoke'],
+  ['behavioral-evaluation-contract-smoke', 'runBehavioralEvaluationContractSmoke'],
+  ['adapter-bootstrap-matrix-smoke', 'runAdapterBootstrapMatrixSmoke'],
+  ['skill-runtime-traceability-smoke', 'runSkillRuntimeTraceabilitySmoke'],
+  ['unified-advice-smoke', 'runUnifiedAdviceSmoke'],
+  ['workflow-readiness-smoke', 'runWorkflowReadinessSmoke'],
+  ['plan-lint-smoke', 'runPlanLintSmoke'],
+  ['workflow-cockpit-smoke', 'runWorkflowCockpitSmoke'],
+  ['workflow-entry-experience-smoke', 'runWorkflowEntryExperienceSmoke'],
+  ['completion-readiness-smoke', 'runCompletionReadinessSmoke'],
+  ['readiness-gate-split-smoke', 'runReadinessGateSplitSmoke'],
+  ['completion-evidence-bundle-smoke', 'runCompletionEvidenceBundleSmoke'],
+  ['full-chain-demo-smoke', 'runFullChainDemoSmoke'],
+  ['golden-path-demo-smoke', 'runGoldenPathDemoSmoke'],
+  ['methodology-product-gate-smoke', 'runMethodologyProductGateSmoke'],
+  ['methodology-delivery-gate-smoke', 'runMethodologyDeliveryGateSmoke'],
+  ['methodology-implementation-gate-smoke', 'runMethodologyImplementationGateSmoke'],
+  ['bootstrap-acceptance-smoke', 'runBootstrapAcceptanceSmoke'],
+  ['methodology-route-smoke', 'runMethodologyRouteSmoke'],
+  ['entry-advice-smoke', 'runEntryAdviceSmoke'],
+  ['patch-queue-source-apply-gate-smoke', 'runPatchQueueSourceApplyGateSmoke'],
+  ['verification-driven-repair-loop-smoke', 'runVerificationDrivenRepairLoopSmoke'],
+  ['local-commit-automation-gate-smoke', 'runLocalCommitAutomationGateSmoke'],
+  ['leased-foreground-worker-smoke', 'runLeasedForegroundWorkerSmoke'],
+  ['agent-session-start-contract-smoke', 'runAgentSessionStartBehaviorSmoke'],
+  ['learning-observation-smoke', 'runLearningObservationSmoke'],
+  ['learning-instinct-smoke', 'runLearningInstinctSmoke'],
+  ['learning-advice-smoke', 'runLearningAdviceSmoke'],
+  ['token-compaction-smoke', 'runTokenCompactionSmoke'],
+  ['token-metrics-smoke', 'runTokenMetricsSmoke'],
+  ['token-advice-smoke', 'runTokenAdviceSmoke'],
+  ['commit-guard-smoke', 'runCommitGuardSmoke'],
+  ['release-notes-smoke', 'runReleaseNotesSmoke'],
+];
+
+function optionOnlyHandler(deps, methodName) {
+  return (_args, options) => deps[methodName](options);
+}
+
+export function releaseCheckCommandHandlers(deps) {
+  return {
+    run: deps.run,
+    'check-not-ignored': (args, options) => deps.runCheckNotIgnored(args, options),
+    'single-platform-smoke': (args, options) => deps.runSinglePlatformSmoke(args[0], options),
+    ...Object.fromEntries(optionOnlyCommandHandlers.map(([command, methodName]) => [command, optionOnlyHandler(deps, methodName)])),
+  };
+}
+
+export function dispatchReleaseCheckCommand(entry, handlers, options) {
+  const [command, args = [], settings = {}] = entry;
+  const handlerName = commandEntryHandler(entry) || command;
+  const handler = handlers[handlerName];
+  if (handler) {
+    handler(args, options, settings);
+    return;
+  }
+  handlers.run(command, args, settings, options);
+}

package/tools/vibe-release-check/release-check-full-chain-suite.mjs

@@ -0,0 +1,55 @@
+import {
+  assertJsonMarkers,
+  parseJsonOutput,
+  run,
+} from './release-check-runtime.mjs';
+
+const fullChainInputs = [
+  '--from-product-discovery', 'examples/full-chain/product-discovery.md',
+  '--from-product-spec', 'examples/full-chain/product-spec.md',
+  '--from-ui-design', 'examples/full-chain/ui-design-contract.md',
+  '--from-architecture', 'examples/full-chain/architecture-design.md',
+  '--from-traceability', 'examples/full-chain/delivery-traceability.yaml',
+  '--from-plan', 'examples/full-chain/implementation-plan.md',
+  '--from-scenarios', 'examples/full-chain/scenario-acceptance.yaml',
+  '--from-product-acceptance', 'examples/full-chain/product-acceptance.md',
+  '--from-test-evidence', 'examples/full-chain/test-evidence.json',
+  '--from-diff-coverage', 'examples/full-chain/diff-coverage.json',
+  '--from-commit-readiness', 'examples/full-chain/commit-readiness.json',
+  '--from-evidence', 'examples/full-chain/evidence.json',
+];
+
+export function runFullChainDemoSmoke(options) {
+  const bundle = parseJsonOutput(run('node', [
+    'tools/vibe-runtime/index.mjs',
+    'completion',
+    '--evidence-bundle',
+    ...fullChainInputs,
+    '--json',
+  ], {}, options), 'full-chain completion evidence bundle --json');
+
+  assertJsonMarkers([
+    ['command', bundle.command, 'completion'],
+    ['mode', bundle.mode, 'product-completion-evidence-bundle'],
+    ['ok', bundle.ok, true],
+    ['completion_evidence_bundle.bundle_kind', bundle.completion_evidence_bundle?.bundle_kind, 'product-completion-evidence-bundle'],
+    ['completion_evidence_bundle.expanded_delivery_chain', bundle.completion_evidence_bundle?.expanded_delivery_chain, true],
+    ['completion_evidence_bundle.architecture_chain', typeof bundle.completion_evidence_bundle?.architecture_chain, 'object'],
+    ['completion_evidence_bundle.traceability_chain', typeof bundle.completion_evidence_bundle?.traceability_chain, 'object'],
+    ['completion_evidence_bundle.implementation_chain', typeof bundle.completion_evidence_bundle?.implementation_chain, 'object'],
+    ['completion_evidence_bundle.release_readiness_chain', typeof bundle.completion_evidence_bundle?.release_readiness_chain, 'object'],
+    ['completion_evidence_bundle.traceability_readiness.cross_artifact_ref_validation_ok', bundle.completion_evidence_bundle?.traceability_readiness?.cross_artifact_ref_validation_ok, true],
+    ['completion_evidence_bundle.implementation_chain.test_evidence_readiness.test_evidence_gate_ok', bundle.completion_evidence_bundle?.implementation_chain?.test_evidence_readiness?.test_evidence_gate_ok, true],
+    ['completion_evidence_bundle.implementation_chain.diff_coverage_readiness.diff_coverage_gate_ok', bundle.completion_evidence_bundle?.implementation_chain?.diff_coverage_readiness?.diff_coverage_gate_ok, true],
+    ['completion_evidence_bundle.implementation_chain.implementation_alignment_readiness.implementation_plan_gate_ok', bundle.completion_evidence_bundle?.implementation_chain?.implementation_alignment_readiness?.implementation_plan_gate_ok, true],
+    ['completion_evidence_bundle.implementation_chain.implementation_alignment_readiness.implementation_alignment_ok', bundle.completion_evidence_bundle?.implementation_chain?.implementation_alignment_readiness?.implementation_alignment_ok, true],
+    ['completion_evidence_bundle.release_readiness_chain.commit_readiness_gate.summary.commit_boundary_ok', bundle.completion_evidence_bundle?.release_readiness_chain?.commit_readiness_gate?.summary?.commit_boundary_ok, true],
+    ['completion_evidence_bundle.release_readiness_chain.commit_readiness_gate.summary.commit_execution_authorized', bundle.completion_evidence_bundle?.release_readiness_chain?.commit_readiness_gate?.summary?.commit_execution_authorized, false],
+    ['completion_evidence_bundle.boundary_assertions.git_write', bundle.completion_evidence_bundle?.boundary_assertions?.git_write, false],
+    ['completion_evidence_bundle.boundary_assertions.commit', bundle.completion_evidence_bundle?.boundary_assertions?.commit, false],
+    ['completion_evidence_bundle.boundary_assertions.push', bundle.completion_evidence_bundle?.boundary_assertions?.push, false],
+    ['completion_evidence_bundle.boundary_assertions.pr', bundle.completion_evidence_bundle?.boundary_assertions?.pr, false],
+    ['completion_evidence_bundle.boundary_assertions.merge', bundle.completion_evidence_bundle?.boundary_assertions?.merge, false],
+    ['completion_evidence_bundle.bundle_digest', typeof bundle.completion_evidence_bundle?.bundle_digest, 'string'],
+  ], 'full-chain completion evidence bundle --json');
+}

package/tools/vibe-release-check/release-check-golden-path-suite.mjs

@@ -0,0 +1,85 @@
+import {
+  assertJsonMarkers,
+  parseJsonOutput,
+  run,
+} from './release-check-runtime.mjs';
+
+const goldenPathProductSpec = 'examples/golden-path/product-spec.md';
+const goldenPathPlan = 'examples/golden-path/implementation-plan.md';
+const goldenPathTestEvidence = 'examples/golden-path/test-evidence.json';
+const goldenPathDiffCoverage = 'examples/golden-path/diff-coverage.json';
+
+export function runGoldenPathDemoSmoke(options) {
+  const productSpec = parseJsonOutput(run('node', [
+    'tools/vibe-runtime/index.mjs',
+    'methodology',
+    '--gate',
+    '--kind',
+    'product-spec',
+    '--from-file',
+    goldenPathProductSpec,
+    '--json',
+  ], {}, options), 'golden path product-spec gate --json');
+  assertJsonMarkers([
+    ['command', productSpec.command, 'methodology'],
+    ['mode', productSpec.mode, 'product-methodology-gate'],
+    ['ok', productSpec.ok, true],
+    ['product_methodology_gate.gate_kind', productSpec.product_methodology_gate?.gate_kind, 'product-spec'],
+    ['product_methodology_gate.gate_outcome', productSpec.product_methodology_gate?.gate_outcome, 'pass'],
+    ['product_methodology_gate.invariants.pass', productSpec.product_methodology_gate?.invariants?.pass, true],
+    ['safety.writes', productSpec.safety?.writes, false],
+  ], 'golden path product-spec gate --json');
+
+  const implementationPlan = parseJsonOutput(run('node', [
+    'tools/vibe-runtime/index.mjs',
+    'methodology',
+    '--gate',
+    '--kind',
+    'implementation-plan',
+    '--from-file',
+    goldenPathPlan,
+    '--json',
+  ], {}, options), 'golden path implementation-plan gate --json');
+  assertJsonMarkers([
+    ['command', implementationPlan.command, 'methodology'],
+    ['mode', implementationPlan.mode, 'implementation-methodology-gate'],
+    ['ok', implementationPlan.ok, true],
+    ['implementation_methodology_gate.gate_kind', implementationPlan.implementation_methodology_gate?.gate_kind, 'implementation-plan'],
+    ['implementation_methodology_gate.gate_outcome', implementationPlan.implementation_methodology_gate?.gate_outcome, 'pass'],
+    ['implementation_methodology_gate.implementation_task_registry_gate.ok', implementationPlan.implementation_methodology_gate?.implementation_task_registry_gate?.ok, true],
+    ['safety.writes', implementationPlan.safety?.writes, false],
+  ], 'golden path implementation-plan gate --json');
+
+  const bundle = parseJsonOutput(run('node', [
+    'tools/vibe-runtime/index.mjs',
+    'completion',
+    '--evidence-bundle',
+    '--from-product-spec',
+    goldenPathProductSpec,
+    '--from-plan',
+    goldenPathPlan,
+    '--from-test-evidence',
+    goldenPathTestEvidence,
+    '--from-diff-coverage',
+    goldenPathDiffCoverage,
+    '--json',
+  ], {}, options), 'golden path completion evidence bundle --json');
+  assertJsonMarkers([
+    ['command', bundle.command, 'completion'],
+    ['mode', bundle.mode, 'product-completion-evidence-bundle'],
+    ['ok', bundle.ok, false],
+    ['completion_evidence_bundle.bundle_kind', bundle.completion_evidence_bundle?.bundle_kind, 'product-completion-evidence-bundle'],
+    ['completion_evidence_bundle.implementation_chain.test_evidence_readiness.test_evidence_gate_ok', bundle.completion_evidence_bundle?.implementation_chain?.test_evidence_readiness?.test_evidence_gate_ok, true],
+    ['completion_evidence_bundle.implementation_chain.diff_coverage_readiness.diff_coverage_gate_ok', bundle.completion_evidence_bundle?.implementation_chain?.diff_coverage_readiness?.diff_coverage_gate_ok, true],
+    ['completion_evidence_bundle.implementation_chain.implementation_alignment_readiness.implementation_plan_gate_ok', bundle.completion_evidence_bundle?.implementation_chain?.implementation_alignment_readiness?.implementation_plan_gate_ok, true],
+    ['completion_evidence_bundle.implementation_chain.implementation_alignment_readiness.implementation_alignment_ok', bundle.completion_evidence_bundle?.implementation_chain?.implementation_alignment_readiness?.implementation_alignment_ok, true],
+    ['completion_evidence_bundle.task_completion_summary.readiness_classification', bundle.completion_evidence_bundle?.task_completion_summary?.readiness_classification, 'team_mode_evidence_ready'],
+    ['completion_evidence_bundle.task_completion_summary.local_task_ready', bundle.completion_evidence_bundle?.task_completion_summary?.local_task_ready, true],
+    ['completion_evidence_bundle.task_completion_summary.minimum_local_evidence_missing.length', bundle.completion_evidence_bundle?.task_completion_summary?.minimum_local_evidence_missing?.length, 0],
+    ['completion_evidence_bundle.task_completion_summary.full_compliance_evidence_missing.length', bundle.completion_evidence_bundle?.task_completion_summary?.full_compliance_evidence_missing?.length > 0, true],
+    ['completion_evidence_bundle.task_completion_summary.unsafe_release_actions_detected.length', bundle.completion_evidence_bundle?.task_completion_summary?.unsafe_release_actions_detected?.length, 0],
+    ['completion_evidence_bundle.boundary_assertions.git_write', bundle.completion_evidence_bundle?.boundary_assertions?.git_write, false],
+    ['completion_evidence_bundle.boundary_assertions.commit', bundle.completion_evidence_bundle?.boundary_assertions?.commit, false],
+    ['completion_evidence_bundle.bundle_digest', typeof bundle.completion_evidence_bundle?.bundle_digest, 'string'],
+  ], 'golden path completion evidence bundle --json');
+}

package/tools/vibe-release-check/release-check-install-marker-specs.mjs

@@ -0,0 +1,133 @@
+const installedExperienceContractMarkers = Object.freeze([
+  'installed-agent-experience-contract-v2',
+  'Installed Agent Experience Contract v2',
+  'first_turn',
+  'continue_task',
+  'bug_debug',
+  'completion_closeout',
+  'review_feedback',
+  'installed_business_ux_regression_pack',
+  'tiny_context',
+  'completion_evidence.task_completion_summary',
+  'hidden_execution=false',
+  'command_execution=false',
+  'skill_execution_claimed=false',
+  'subagent_dispatch_claimed=false',
+  'business_source_write=false',
+  'git_write_claimed=false',
+  'platform_api=false',
+  'model_invocation=false',
+]);
+
+const installedSummaryMarkers = Object.freeze([
+  'workflow_start.entry_summary',
+  'entry_summary.state_gap_is_expected=true',
+  'completion_evidence.task_completion_summary',
+  'blocked_reasons',
+  'readiness gates',
+  'subagent',
+  '平台 API',
+  'git',
+  'push',
+  'PR',
+  'merge',
+]);
+
+export const installedEntrySummaryMarkers = Object.freeze([
+  '受控 agent 沙盒',
+  'using-vibecoding',
+  ...installedSummaryMarkers,
+  ...installedExperienceContractMarkers,
+  '业务项目降级交互协议',
+  '轻量产品体验',
+  '首次会话验收',
+  '可见下一步人工动作',
+  '不注入完整 skill 内容',
+  '不授权自动执行命令',
+  'execution_profile',
+  'manual',
+  'execution-enabled',
+  'controlled-local-runtime',
+  'source/git/subagent',
+  '.vibecoding/VIBE-CODING.md',
+]);
+
+export const installedFullRuleSummaryMarkers = Object.freeze([
+  '受控 agent 沙盒',
+  ...installedSummaryMarkers,
+  ...installedExperienceContractMarkers,
+  'Vibe Guided',
+  'automation_profile: "vibe-guided"',
+  '不授权隐藏执行',
+  '业务项目使用降级交互协议',
+  '轻量分流',
+  'execution_profile: "manual"',
+  'execution-enabled',
+  'controlled-local-runtime',
+  'source/git/subagent',
+  '默认交互协议',
+  '任务分流',
+  'Architecture-first coding',
+  '质量底线',
+  '升级到完整 workflow 的条件',
+]);
+
+export const installedAdapterSummaryMarkers = Object.freeze([
+  ...installedSummaryMarkers,
+  '摘要优先入口',
+  '业务项目降级交互协议',
+  '轻量产品体验',
+  '首次会话验收',
+  'session-start shape',
+  'transcript',
+  'injectsFullSkill=false',
+  'no_auto_execution',
+  '不授予隐藏执行',
+  '自动写入',
+  '自动测试',
+]);
+
+export const installedConfigManifestMarkers = Object.freeze([
+  '"installed_agent_experience_contract"',
+  '"contract_kind": "installed-agent-experience-contract-v2"',
+  '"stage": "Stage 18"',
+  '"first_turn"',
+  '"continue_task"',
+  '"bug_debug"',
+  '"completion_closeout"',
+  '"closeout_summary_entry": "completion_evidence.task_completion_summary"',
+  '"hidden_execution=false"',
+  '"command_execution=false"',
+  '"skill_execution_claimed=false"',
+  '"subagent_dispatch_claimed=false"',
+  '"business_source_write=false"',
+  '"git_write_claimed=false"',
+  '"platform_api=false"',
+  '"model_invocation=false"',
+]);
+
+export const repositoryParityDocMarkers = Object.freeze([
+  ['README.md', ['受控 agent 沙盒', '快速开始', 'docs/quick-recipes.md', 'docs/user-guide.md', 'docs/maintainer-guide.md', 'VIBE-CODING.md']],
+  ['docs/install.md', ['快速安装', '受控 agent 沙盒', '.vibecoding/VIBE-CODING.md', 'Health summary', 'Impact summary', 'Safety boundary']],
+  ['docs/user-guide.md', ['小任务', 'bug', '交付前检查']],
+  ['docs/quick-recipes.md', ['workflow --start', 'profile --explain', 'automation --readiness', 'writes=false', 'state_directory_created=false', 'cmd /c "node --check', 'execution-enabled']],
+  ['docs/team-adoption.md', ['Team adoption', '最小资产', 'completion_evidence.task_completion_summary']],
+  ['docs/golden-path.md', ['safe governance mode', 'legacy-workflow-discipline mode', '本地 sidecar', '不自动创建 git worktree']],
+  ['docs/runtime-roadmap.md', ['Legacy Workflow Discipline product expression', '独立 gate', '不自动 commit/push/PR/merge', 'execution-enabled', 'controlled-local-runtime', 'source/git/subagent not authorized']],
+  ['tools/vibe-runtime/README.md', ['safe governance mode', 'legacy-workflow-discipline', 'sdd --run-loop', 'evals --behavior-contract', '不真实调用 subagent/model/platform API', 'execution-enabled', 'config write boundary', 'evidence audit']],
+  ['templates/CLAUDE.md', ['受控 agent 沙盒', 'using-vibecoding', 'workflow_start.entry_summary', '业务项目降级交互协议', '首次会话验收', 'Installed Agent Experience Contract v2', 'completion_closeout', '可见下一步人工动作', '.vibecoding/VIBE-CODING.md']],
+  ['templates/AGENTS.md', ['受控 agent 沙盒', 'using-vibecoding', 'workflow_start.entry_summary', '业务项目降级交互协议', '首次会话验收', 'Installed Agent Experience Contract v2', 'completion_closeout', '可见下一步人工动作', '.vibecoding/VIBE-CODING.md']],
+  ['templates/VIBE-CODING.md', ['Vibe Guided', 'automation_profile: "vibe-guided"', '不授权隐藏执行', 'execution_profile: "manual"', 'controlled-local-runtime', 'installed-agent-experience-contract-v2', 'completion_closeout', '默认交互协议', '业务项目使用降级交互协议']],
+]);
+
+export function installedEntryFileForPlatform(platform) {
+  if (platform === 'claude') return 'CLAUDE.md';
+  if (platform === 'codex' || platform === 'cursor') return 'AGENTS.md';
+  return null;
+}
+
+export function installedAdapterSampleForPlatform(platform) {
+  if (platform === 'opencode') return ['.vibecoding/adapters/opencode/plugin.js', ['skills:', '.vibecoding/skills', 'using-vibecoding', 'additional_context', 'strictBootstrapAcceptance', 'bootstrap_marker', 'dedupe_marker', 'session_compact_reinjects', 'tool_mapping', 'hiddenExecution: false', 'platformApi: false']];
+  if (platform === 'pi') return ['.vibecoding/adapters/pi/extension.ts', ['resources_discover', 'skillPaths', '.vibecoding/skills', 'using-vibecoding', 'hookSpecificOutput.additionalContext', 'strictBootstrapAcceptance', 'bootstrap_marker', 'dedupe_marker', 'session_compact_reinjects', 'tool_mapping', 'platformApi: false']];
+  return null;
+}

package/tools/vibe-release-check/release-check-install-suite.mjs

@@ -0,0 +1,112 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { repoRoot, run } from './release-check-runtime.mjs';
+import {
+  installedAdapterSampleForPlatform,
+  installedAdapterSummaryMarkers,
+  installedConfigManifestMarkers,
+  installedEntryFileForPlatform,
+  installedEntrySummaryMarkers,
+  installedFullRuleSummaryMarkers,
+  repositoryParityDocMarkers,
+} from './release-check-install-marker-specs.mjs';
+
+function assertInstalledFileMarkers(absoluteTarget, relativeFile, markers) {
+  const filePath = path.join(absoluteTarget, ...relativeFile.split('/'));
+  if (!fs.existsSync(filePath)) throw new Error(`installed project missing ${relativeFile}`);
+
+  const text = fs.readFileSync(filePath, 'utf8');
+  const missing = markers.filter((marker) => !text.includes(marker));
+  if (missing.length > 0) {
+    throw new Error(`${relativeFile} missing installed summary marker(s): ${missing.join(', ')}`);
+  }
+}
+
+function assertInstalledSourceBundleMarkers(absoluteTarget, relativeFiles, label, markers) {
+  const text = relativeFiles.map((relativeFile) => {
+    const filePath = path.join(absoluteTarget, ...relativeFile.split('/'));
+    if (!fs.existsSync(filePath)) throw new Error(`installed project missing ${relativeFile}`);
+    return fs.readFileSync(filePath, 'utf8');
+  }).join('\n');
+
+  const expandedText = text.includes('stateDirectoryName') && text.includes('Do not create or modify')
+    ? `${text}\nDo not create or modify .vibecoding-state/`
+    : text;
+  const missing = markers.filter((marker) => !expandedText.includes(marker));
+  if (missing.length > 0) {
+    throw new Error(`${label} missing installed summary marker(s): ${missing.join(', ')}`);
+  }
+}
+
+function assertRepositoryParityDocs() {
+  for (const [relativeFile, markers] of repositoryParityDocMarkers) {
+    assertInstalledFileMarkers(repoRoot, relativeFile, markers);
+  }
+}
+
+function assertCommandOutputMarkers(result, label, markers) {
+  const output = result.stdout || '';
+  const missing = markers.filter((marker) => !output.includes(marker));
+  if (missing.length > 0) throw new Error(`${label} output missing marker(s): ${missing.join(', ')}`);
+}
+
+function assertBootstrapContextShape(platform, absoluteTarget, options) {
+  const result = run('node', [path.join(absoluteTarget, '.vibecoding/hooks/session-start/session-start.mjs'), '--format', platform, '--root', absoluteTarget], {}, options);
+  const output = JSON.parse(result.stdout || '{}');
+  const context = platform === 'opencode'
+    ? output.additional_context
+    : platform === 'pi'
+      ? output.hookSpecificOutput?.additionalContext
+      : output.additional_context || output.additionalContext || output.hookSpecificOutput?.additionalContext;
+
+  if (typeof context !== 'string') throw new Error(`${platform} bootstrap context missing expected string shape`);
+  const markers = ['Vibecoding Kit is installed', '.vibecoding/skills/using-vibecoding/SKILL.md', 'selected_skill=using-vibecoding', 'visible_route=', 'next_manual_action=', 'context_policy=tiny_context', 'Do not inject the full skill content', 'Do not create or modify .vibecoding-state/', 'Do not auto-run next_skill', 'hidden_execution=false', 'command_execution=false', 'skill_execution_claimed=false', 'subagent_dispatch_claimed=false', 'git_write_claimed=false', 'platform_api=false', 'model_invocation=false', 'business_source_write=false'];
+  const missing = markers.filter((marker) => !context.includes(marker));
+  if (missing.length > 0) throw new Error(`${platform} bootstrap context missing marker(s): ${missing.join(', ')}`);
+  if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error(`${platform} bootstrap context created unexpected state directory`);
+}
+
+function assertInstalledSummaryAdoption(platform, absoluteTarget, options) {
+  const entryFile = installedEntryFileForPlatform(platform);
+  const strictBootstrapPlatforms = new Set(['opencode', 'pi']);
+  const strictBootstrapMarkers = ['strictBootstrapAcceptance', 'bootstrap_marker', 'dedupe_marker', 'session_compact_reinjects=true', 'tool_mapping', 'injectsFullSkill=false'];
+  if (entryFile) assertInstalledFileMarkers(absoluteTarget, entryFile, installedEntrySummaryMarkers);
+  assertInstalledFileMarkers(absoluteTarget, '.vibecoding/config.json', installedConfigManifestMarkers);
+  assertInstalledFileMarkers(absoluteTarget, '.vibecoding/VIBE-CODING.md', installedFullRuleSummaryMarkers);
+  assertInstalledFileMarkers(absoluteTarget, `.vibecoding/adapters/${platform}/install.md`, strictBootstrapPlatforms.has(platform) ? [...installedAdapterSummaryMarkers, ...strictBootstrapMarkers] : installedAdapterSummaryMarkers);
+  const sample = installedAdapterSampleForPlatform(platform);
+  if (sample) assertInstalledFileMarkers(absoluteTarget, sample[0], sample[1]);
+  const manifestMarkers = ['.vibecoding/skills/', '.vibecoding/hooks/session-start/session-start.mjs', '"injectsFullSkill": false', '"writesRuntimeState": false', '"autoRunsNextSkill": false'];
+  const strictManifestMarkers = ['"strictBootstrapAcceptance"', '"bootstrap_marker"', '"dedupe_marker"', '"session_compact_reinjects": true', '"tool_mapping"'];
+  assertInstalledFileMarkers(absoluteTarget, `.vibecoding/adapters/${platform}/plugin.json`, strictBootstrapPlatforms.has(platform) ? [...manifestMarkers, ...strictManifestMarkers] : manifestMarkers);
+  assertInstalledFileMarkers(absoluteTarget, '.vibecoding/skills/using-vibecoding/SKILL.md', ['using-vibecoding', 'workflow --start', 'legacy-workflow-discipline', '本地合同、ledger 或 sidecar', '不执行 skill', '不调用 subagent', '不修改源码']);
+  assertInstalledSourceBundleMarkers(absoluteTarget, [
+    '.vibecoding/hooks/session-start/session-start.mjs',
+    '.vibecoding/hooks/session-start/session-start-state-boundary-contract.mjs',
+  ], 'installed session-start hook bundle', ['session-start', 'cursor-sdk', 'selected_skill=using-vibecoding', 'visible_route=', 'next_manual_action=', 'context_policy=', 'hidden_execution=false', 'command_execution=false', 'skill_execution_claimed=false', 'subagent_dispatch_claimed=false', 'git_write_claimed=false', 'platform_api=false', 'model_invocation=false', 'business_source_write=false', 'Do not create or modify .vibecoding-state/', 'Do not auto-run next_skill, runtime, subagents, MCP, daemon, platform APIs, git, or worktree actions']);
+  assertBootstrapContextShape(platform, absoluteTarget, options);
+  assertRepositoryParityDocs();
+}
+
+export function runSinglePlatformSmoke(platform, options) {
+  const target = `.tmp/vibe-init-${platform}`;
+  const absoluteTarget = path.join(repoRoot, target);
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    const initResult = run('node', ['tools/vibe-init/index.mjs', '--target', target, '--platform', platform], {}, options);
+    assertCommandOutputMarkers(initResult, `${platform} init`, ['First-turn acceptance prompt', 'Completion closeout acceptance prompt', 'Installed agent experience contract v2', 'installed-agent-experience-contract-v2']);
+    const doctorResult = run('node', ['tools/vibe-doctor/index.mjs', target], {}, options);
+    assertCommandOutputMarkers(doctorResult, `${platform} doctor`, ['Health summary:', 'Next manual action:', 'Info:', 'Result: passed']);
+    if (platform === 'cursor') {
+      const repairPreview = run('node', ['bin/vibe.mjs', 'repair', '--root', target, '--dry-run'], {}, options);
+      assertCommandOutputMarkers(repairPreview, 'lifecycle repair dry-run', ['Impact summary:', 'Safety boundary:', '[planned]', 'Next manual action:', 'Dry-run only. No files were changed by this lifecycle plan.']);
+      const uninstallPreview = run('node', ['bin/vibe.mjs', 'uninstall', '--root', target, '--dry-run'], {}, options);
+      assertCommandOutputMarkers(uninstallPreview, 'lifecycle uninstall dry-run', ['Impact summary:', 'Safety boundary:', '[planned]', 'preserved/skipped', 'Next manual action:']);
+    }
+    assertInstalledSummaryAdoption(platform, absoluteTarget, options);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}