@jtf19/vibecoding-kit 0.1.0

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

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+
+import process from 'node:process';
+import { parseArgs, usage } from './release-check-cli.mjs';
+import { releaseCheckCommands } from './release-check-command-manifest.mjs';
+import {
+  filterReleaseCheckCommands,
+  releaseCheckSuiteDescription,
+} from './release-check-suites.mjs';
+import { createReleaseCheckTiming } from './release-check-timing.mjs';
+import {
+  dispatchReleaseCheckCommand,
+  releaseCheckCommandHandlers,
+} from './release-check-dispatch.mjs';
+import {
+  assertJsonMarkers,
+  digestObject,
+  parseJsonOutput,
+  removeTmp,
+  repoRoot,
+  run,
+  runCheckNotIgnored,
+  tmpRoot,
+  writeReleaseCheckRunSummary,
+} from './release-check-runtime.mjs';
+import { runPackageBoundarySmoke } from './release-check-package-boundary-smoke.mjs';
+import { runRouterSmoke, runEvalsSmoke } from './release-check-stage50-53-smoke.mjs';
+import { runRuntimeSurfaceSmoke } from './release-check-runtime-surface-smoke.mjs';
+import {
+  runExecutionEvidenceSmoke,
+  runStagedCommitReadinessSmoke,
+} from './release-check-stage119-120-smoke.mjs';
+import { runTestRunSmoke } from './release-check-test-run-smoke.mjs';
+import { runSuitePlanSmoke } from './release-check-suite-plan-smoke.mjs';
+import { releaseCheckStage137140SmokeHandlers } from './release-check-stage137-140-smoke.mjs';
+import { releaseCheckStage141148SmokeHandlers } from './release-check-stage141-148-smoke.mjs';
+import { releaseCheckStage103118SmokeHandlers } from './release-check-stage103-118-smoke.mjs';
+import { releaseCheckStage121136SmokeHandlers } from './release-check-stage121-136-smoke.mjs';
+import { runWorkflowEntryExperienceSmoke } from './release-check-workflow-ux-smoke.mjs';
+import {
+  runCompletionEvidenceBundleSmoke,
+  runCompletionReadinessSmoke,
+  runReadinessGateSplitSmoke,
+} from './release-check-completion-suite.mjs';
+import { runFullChainDemoSmoke } from './release-check-full-chain-suite.mjs';
+import { runGoldenPathDemoSmoke } from './release-check-golden-path-suite.mjs';
+import {
+  runMethodologyDeliveryGateSmoke,
+  runMethodologyImplementationGateSmoke,
+  runMethodologyProductGateSmoke,
+} from './release-check-methodology-suite.mjs';
+import { releaseCheckLearningSuiteHandlers } from './release-check-learning-suite.mjs';
+import { releaseCheckTokenSuiteHandlers } from './release-check-token-suite.mjs';
+import { runRuntimeLedgerSmoke } from './release-check-runtime-ledger-suite.mjs';
+import { runRuntimeAutomationSmoke } from './release-check-runtime-automation-suite.mjs';
+import { runSinglePlatformSmoke } from './release-check-install-suite.mjs';
+import { releaseCheckWorkflowGovernanceSmokeHandlers } from './release-check-workflow-governance-smoke-suite.mjs';
+import { runPatchQueueSourceApplyGateSmoke } from './release-check-stage11-smoke.mjs';
+import { runVerificationDrivenRepairLoopSmoke } from './release-check-stage12-smoke.mjs';
+import { runLocalCommitAutomationGateSmoke } from './release-check-stage13-smoke.mjs';
+import { runLeasedForegroundWorkerSmoke } from './release-check-stage14-smoke.mjs';
+import { runAgentSessionStartBehaviorSmoke } from './release-check-stage15-smoke.mjs';
+
+let options;
+let timing;
+
+try {
+  options = parseArgs(process.argv.slice(2));
+
+  if (options.help) {
+    console.log(usage());
+    process.exit(0);
+  }
+
+  const commands = filterReleaseCheckCommands(releaseCheckCommands(), options.suite);
+  timing = createReleaseCheckTiming(options.timing, (line) => console.log(line));
+  if (options.suite !== 'all' && !options.quiet) {
+    console.log(`Release check suite: ${options.suite} (${releaseCheckSuiteDescription(options.suite)})`);
+  }
+
+  removeTmp();
+
+  const handlers = releaseCheckCommandHandlers({
+    run,
+    runPackageBoundarySmoke: (options) => runPackageBoundarySmoke({ repoRoot, run }, options),
+    runCheckNotIgnored,
+    runSinglePlatformSmoke,
+    runRuntimeLedgerSmoke,
+    runRuntimeAutomationSmoke,
+    runPatchQueueSourceApplyGateSmoke: (options) => runPatchQueueSourceApplyGateSmoke({
+      repoRoot,
+      run,
+      parseJsonOutput,
+      assertJsonMarkers,
+    }, options),
+    runVerificationDrivenRepairLoopSmoke: (options) => runVerificationDrivenRepairLoopSmoke({
+      repoRoot,
+      run,
+      parseJsonOutput,
+      assertJsonMarkers,
+    }, options),
+    runLocalCommitAutomationGateSmoke: (options) => runLocalCommitAutomationGateSmoke({
+      repoRoot,
+      run,
+      parseJsonOutput,
+      assertJsonMarkers,
+    }, options),
+    runLeasedForegroundWorkerSmoke: (options) => runLeasedForegroundWorkerSmoke({
+      repoRoot,
+      run,
+      parseJsonOutput,
+      assertJsonMarkers,
+    }, options),
+    runAgentSessionStartBehaviorSmoke: (options) => runAgentSessionStartBehaviorSmoke({
+      repoRoot,
+      run,
+      parseJsonOutput,
+      assertJsonMarkers,
+    }, options),
+    ...releaseCheckWorkflowGovernanceSmokeHandlers({
+      repoRoot,
+      tmpRoot,
+      run,
+      parseJsonOutput,
+      assertJsonMarkers,
+      digestObject,
+    }),
+    runRouterSmoke,
+    runEvalsSmoke,
+    runRuntimeSurfaceSmoke,
+    ...releaseCheckStage103118SmokeHandlers({
+      repoRoot,
+      run,
+      parseJsonOutput,
+      assertJsonMarkers,
+    }),
+    ...releaseCheckStage121136SmokeHandlers({
+      repoRoot,
+      run,
+      parseJsonOutput,
+      assertJsonMarkers,
+    }),
+    ...releaseCheckStage137140SmokeHandlers({
+      repoRoot,
+      run,
+      parseJsonOutput,
+      assertJsonMarkers,
+    }),
+    ...releaseCheckStage141148SmokeHandlers({
+      repoRoot,
+      run,
+      parseJsonOutput,
+      assertJsonMarkers,
+    }),
+    runExecutionEvidenceSmoke,
+    runStagedCommitReadinessSmoke,
+    runTestRunSmoke: (options) => runTestRunSmoke({
+      repoRoot,
+      run,
+      parseJsonOutput,
+      assertJsonMarkers,
+    }, options),
+    runSuitePlanSmoke: (options) => runSuitePlanSmoke({
+      repoRoot,
+      run,
+      parseJsonOutput,
+      assertJsonMarkers,
+    }, options),
+    runWorkflowEntryExperienceSmoke,
+    runCompletionReadinessSmoke,
+    runReadinessGateSplitSmoke,
+    runCompletionEvidenceBundleSmoke,
+    runFullChainDemoSmoke,
+    runGoldenPathDemoSmoke,
+    runMethodologyProductGateSmoke,
+    runMethodologyDeliveryGateSmoke,
+    runMethodologyImplementationGateSmoke,
+    ...releaseCheckLearningSuiteHandlers({
+      repoRoot,
+      run,
+      parseJsonOutput,
+      assertJsonMarkers,
+      digestObject,
+    }),
+    ...releaseCheckTokenSuiteHandlers({
+      repoRoot,
+      run,
+      parseJsonOutput,
+      assertJsonMarkers,
+    }),
+  });
+
+  for (const entry of commands) {
+    timing.run(entry, () => dispatchReleaseCheckCommand(entry, handlers, options));
+  }
+
+  const summaryFile = writeReleaseCheckRunSummary({ suite: options.suite, timing: timing.records, result: 'passed' });
+
+  if (!options.keepTmp) removeTmp();
+  else console.log(`Release check run summary: ${summaryFile}`);
+
+  timing.print();
+
+  console.log('\nResult: passed');
+} catch (error) {
+  let summaryFile = '';
+  if (options) {
+    try {
+      summaryFile = writeReleaseCheckRunSummary({
+        suite: options.suite,
+        timing: timing?.records || [],
+        result: 'failed',
+        errorMessage: error.message,
+      });
+    } catch {
+      summaryFile = '';
+    }
+  }
+  console.error(`\nResult: failed`);
+  console.error(`Error: ${error.message}`);
+  if (summaryFile) console.error(`Release check run summary: ${summaryFile}`);
+  process.exit(1);
+}

package/tools/vibe-release-check/release-check-behavior-smoke.mjs

@@ -0,0 +1,177 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import {
+  assertLiveBehaviorTranscriptResults,
+  behaviorContractNegativeCases,
+  prepareLiveBehaviorTranscript,
+} from './release-check-live-behavior-smoke-fixture.mjs';
+import { runPlatformTranscriptIntakeReplaySmoke } from './release-check-platform-transcript-smoke-fixture.mjs';
+
+import {
+  assertNoSmokeState,
+  cleanupSmokeTmpRoot,
+  prepareSmokeTmpRoot,
+  READ_ONLY_RUNTIME_CONTROL_FLAGS_WITH_PREVIEW,
+  runForbiddenFlagChecks,
+  writeSmokeJsonFixture,
+} from './release-check-json-assertion-helpers.mjs';
+import {
+  stage121ParityAutomationTranscriptFixture,
+  stage121StrongBehaviorTranscriptFixture,
+  stage121WeakBehaviorTranscriptFixture,
+} from './release-check-stage121-136-fixtures.mjs';
+
+function runBehaviorContractJson({ run, parseJsonOutput }, target, transcriptFile, label, options) {
+  return parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--behavior-contract', '--from-file', transcriptFile, '--json', '--root', target], {}, options), `evals --behavior-contract ${label} --json`);
+}
+
+function assertBehaviorNegativeCase({ envelope, label, failedCaseId, blockerText }) {
+  if (envelope.ok !== false) throw new Error(`${label} fixture should fail behavior contract`);
+  if (!envelope.behavioral_evaluation_contract?.case_results?.some((item) => item.case_id === failedCaseId && item.passed === false)) throw new Error(`${label} fixture missing failed ${failedCaseId} case`);
+  if (!envelope.behavioral_evaluation_contract?.behavior_gate?.blockers?.some((item) => item.includes(blockerText))) throw new Error(`${label} fixture missing blocker: ${blockerText}`);
+  const matrix = envelope.behavioral_evaluation_contract?.negative_violation_matrix;
+  if (matrix?.pass !== false) throw new Error(`${label} fixture missing failed Stage 17 negative violation matrix`);
+  if (!matrix?.stable_blocker_codes?.some((code) => String(code || '').startsWith('behavior.'))) throw new Error(`${label} fixture missing stable Stage 17 blocker code`);
+  if (!matrix?.blockers?.every((blocker) => blocker?.code && blocker?.gate_id)) throw new Error(`${label} fixture has malformed Stage 17 blocker entries`);
+}
+
+export function runBehavioralEvaluationContractSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-behavioral-evaluation-contract';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+  const strongTranscriptFile = path.join(target, 'stage121-strong-transcript.json');
+  const parityTranscriptFile = path.join(target, 'stage121-parity-automation-transcript.json');
+  const liveTranscriptFile = path.join(target, 'p20-live-ish-transcript.json');
+  const liveReviewAdvanceFile = path.join(target, 'p20-live-ish-review-advance.json');
+  const weakTranscriptFile = path.join(target, 'stage121-weak-transcript.json');
+  const negativeCases = behaviorContractNegativeCases(target);
+
+  try {
+    writeSmokeJsonFixture(repoRoot, strongTranscriptFile, stage121StrongBehaviorTranscriptFixture());
+    writeSmokeJsonFixture(repoRoot, parityTranscriptFile, stage121ParityAutomationTranscriptFixture());
+    const liveTranscript = prepareLiveBehaviorTranscript({ repoRoot, run, parseJsonOutput }, target, options);
+    writeSmokeJsonFixture(repoRoot, liveTranscriptFile, liveTranscript.fixture);
+    writeSmokeJsonFixture(repoRoot, liveReviewAdvanceFile, liveTranscript.negative);
+    writeSmokeJsonFixture(repoRoot, weakTranscriptFile, stage121WeakBehaviorTranscriptFixture());
+    for (const behaviorCase of negativeCases) writeSmokeJsonFixture(repoRoot, behaviorCase.file, behaviorCase.fixture());
+
+    const strong = runBehaviorContractJson({ run, parseJsonOutput }, target, strongTranscriptFile, 'strong', options);
+    assertJsonMarkers([
+      ['command', strong.command, 'evals'],
+      ['mode', strong.mode, 'behavioral-evaluation-contract'],
+      ['ok', strong.ok, true],
+      ['behavioral_evaluation_contract.stage', strong.behavioral_evaluation_contract?.stage, 'Stage 121'],
+      ['behavioral_evaluation_contract.contract_kind', strong.behavioral_evaluation_contract?.contract_kind, 'behavioral-evaluation-contract'],
+      ['behavioral_evaluation_contract.behavior_gate.pass', strong.behavioral_evaluation_contract?.behavior_gate?.pass, true],
+      ['behavioral_evaluation_contract.behavior_gate.failed_count', strong.behavioral_evaluation_contract?.behavior_gate?.failed_count, 0],
+      ['behavioral_evaluation_contract.negative_violation_matrix.stage', strong.behavioral_evaluation_contract?.negative_violation_matrix?.stage, 'Stage 17'],
+      ['behavioral_evaluation_contract.negative_violation_matrix.matrix_kind', strong.behavioral_evaluation_contract?.negative_violation_matrix?.matrix_kind, 'negative-violation-gate-matrix'],
+      ['behavioral_evaluation_contract.negative_violation_matrix.pass', strong.behavioral_evaluation_contract?.negative_violation_matrix?.pass, true],
+      ['behavioral_evaluation_contract.negative_violation_matrix.fixture_matrix_contract.negative_fixtures_must_fail', strong.behavioral_evaluation_contract?.negative_violation_matrix?.fixture_matrix_contract?.negative_fixtures_must_fail, true],
+      ['behavioral_evaluation_contract.negative_violation_matrix.boundary_assertions.negative_gate_artifact', strong.behavioral_evaluation_contract?.negative_violation_matrix?.boundary_assertions?.negative_gate_artifact, false],
+      ['behavioral_evaluation_contract.behavior_contract_invariants.pass', strong.behavioral_evaluation_contract?.behavior_contract_invariants?.pass, true],
+      ['behavioral_evaluation_contract.writes', strong.behavioral_evaluation_contract?.writes, false],
+      ['behavioral_evaluation_contract.state_directory_created', strong.behavioral_evaluation_contract?.state_directory_created, false],
+      ['behavioral_evaluation_contract.boundary_assertions.behavior_contract_artifact', strong.behavioral_evaluation_contract?.boundary_assertions?.behavior_contract_artifact, false],
+      ['behavioral_evaluation_contract.boundary_assertions.eval_sidecar_artifact', strong.behavioral_evaluation_contract?.boundary_assertions?.eval_sidecar_artifact, false],
+      ['behavioral_evaluation_contract.boundary_assertions.command_execution', strong.behavioral_evaluation_contract?.boundary_assertions?.command_execution, false],
+      ['behavioral_evaluation_contract.boundary_assertions.git', strong.behavioral_evaluation_contract?.boundary_assertions?.git, false],
+      ['behavioral_evaluation_contract.boundary_assertions.platform_api', strong.behavioral_evaluation_contract?.boundary_assertions?.platform_api, false],
+      ['behavioral_evaluation_contract.boundary_assertions.model_invocation', strong.behavioral_evaluation_contract?.boundary_assertions?.model_invocation, false],
+      ['behavioral_evaluation_contract.boundary_assertions.subagent', strong.behavioral_evaluation_contract?.boundary_assertions?.subagent, false],
+      ['safety.stage', strong.safety?.stage, 'Stage 121'],
+      ['safety.writes', strong.safety?.writes, false],
+      ['safety.eval_artifact', strong.safety?.eval_artifact, false],
+      ['safety.behavior_contract_artifact', strong.safety?.behavior_contract_artifact, false],
+      ['safety.git', strong.safety?.git, false],
+      ['safety.platform_api', strong.safety?.platform_api, false],
+      ['safety.model_invocation', strong.safety?.model_invocation, false],
+      ['safety.subagent', strong.safety?.subagent, false],
+    ], 'evals --behavior-contract strong --json');
+    if (!strong.behavioral_evaluation_contract?.behavior_contract_digest) throw new Error('behavioral evaluation contract missing digest');
+    if (!strong.behavioral_evaluation_contract?.source_digest) throw new Error('behavioral evaluation contract missing source digest');
+    if (!strong.behavioral_evaluation_contract?.case_results?.some((item) => item.case_id === 'lightweight-bootstrap' && item.passed === true)) throw new Error('behavioral evaluation contract missing lightweight bootstrap case');
+    if (!strong.behavioral_evaluation_contract?.case_results?.some((item) => item.case_id === 'false-skill-claim' && item.passed === true)) throw new Error('behavioral evaluation contract missing false skill claim case');
+    if (!strong.behavioral_evaluation_contract?.case_results?.some((item) => item.case_id === 'over-workflow-discipline' && item.passed === true)) throw new Error('behavioral evaluation contract missing over-workflow discipline case');
+    if (!strong.behavioral_evaluation_contract?.case_results?.some((item) => item.case_id === 'commit-claims-readiness-bound' && item.passed === true)) throw new Error('behavioral evaluation contract missing commit readiness case');
+    if (!strong.behavioral_evaluation_contract?.case_results?.some((item) => item.case_id === 'plan-todo-trace-required' && item.passed === true)) throw new Error('behavioral evaluation contract missing plan/todo trace gate case');
+    if (!strong.behavioral_evaluation_contract?.case_results?.some((item) => item.case_id === 'validation-strategy-before-change' && item.passed === true)) throw new Error('behavioral evaluation contract missing validation strategy gate case');
+    if (!strong.behavioral_evaluation_contract?.case_results?.some((item) => item.case_id === 'bug-reproduction-before-fix' && item.passed === true)) throw new Error('behavioral evaluation contract missing bug reproduction gate case');
+    if (!strong.behavioral_evaluation_contract?.case_results?.some((item) => item.case_id === 'hidden-execution-boundary' && item.passed === true)) throw new Error('behavioral evaluation contract missing hidden execution gate case');
+    if (!strong.behavioral_evaluation_contract?.case_results?.some((item) => item.case_id === 'closeout-readiness-evidence-bound' && item.passed === true)) throw new Error('behavioral evaluation contract missing closeout readiness case');
+    assertNoSmokeState(repoRoot, target, 'evals --behavior-contract JSON output');
+
+    const parity = runBehaviorContractJson({ run, parseJsonOutput }, target, parityTranscriptFile, 'parity automation', options);
+    assertJsonMarkers([
+      ['command', parity.command, 'evals'],
+      ['mode', parity.mode, 'behavioral-evaluation-contract'],
+      ['ok', parity.ok, true],
+      ['behavioral_evaluation_contract.behavior_gate.pass', parity.behavioral_evaluation_contract?.behavior_gate?.pass, true],
+      ['behavioral_evaluation_contract.behavior_gate.failed_count', parity.behavioral_evaluation_contract?.behavior_gate?.failed_count, 0],
+      ['safety.writes', parity.safety?.writes, false],
+      ['safety.subagent', parity.safety?.subagent, false],
+    ], 'evals --behavior-contract parity automation --json');
+    for (const caseId of ['plan-continuation-without-repeat-ask', 'sdd-loop-roles-and-review-evidence', 'review-blocker-stops-next-task', 'resume-no-duplicate-dispatch']) {
+      if (!parity.behavioral_evaluation_contract?.case_results?.some((item) => item.case_id === caseId && item.passed === true)) throw new Error(`parity automation behavior contract missing passing ${caseId} case`);
+    }
+    assertNoSmokeState(repoRoot, target, 'parity automation evals --behavior-contract');
+
+    const live = runBehaviorContractJson({ run, parseJsonOutput }, target, liveTranscriptFile, 'P20 live-ish', options);
+    assertNoSmokeState(repoRoot, target, 'P20 live-ish evals --behavior-contract');
+    const liveNegative = runBehaviorContractJson({ run, parseJsonOutput }, target, liveReviewAdvanceFile, 'P20 live-ish review advance', options);
+    assertLiveBehaviorTranscriptResults({ live, liveNegative, assertJsonMarkers });
+    assertNoSmokeState(repoRoot, target, 'P20 live-ish negative evals --behavior-contract');
+
+    runPlatformTranscriptIntakeReplaySmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, target, options);
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--behavior-contract', '--from-file', strongTranscriptFile, '--root', target], {
+      expectOutput: ['Vibecoding Runtime Behavioral Evaluation Contract', 'Stage: Stage 121; Kind: behavioral-evaluation-contract; pass=true', 'Negative gates:', 'Boundary: writes=false; behavior_contract_artifact=false; git=false; platform_api=false; model_invocation=false; subagent=false', 'Behavior contract digest:'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'evals --behavior-contract text output');
+
+    const weak = runBehaviorContractJson({ run, parseJsonOutput }, target, weakTranscriptFile, 'weak', options);
+    assertJsonMarkers([
+      ['command', weak.command, 'evals'],
+      ['mode', weak.mode, 'behavioral-evaluation-contract'],
+      ['ok', weak.ok, false],
+      ['behavioral_evaluation_contract.stage', weak.behavioral_evaluation_contract?.stage, 'Stage 121'],
+      ['behavioral_evaluation_contract.behavior_gate.pass', weak.behavioral_evaluation_contract?.behavior_gate?.pass, false],
+      ['behavioral_evaluation_contract.behavior_contract_invariants.pass', weak.behavioral_evaluation_contract?.behavior_contract_invariants?.pass, false],
+      ['safety.writes', weak.safety?.writes, false],
+      ['safety.git', weak.safety?.git, false],
+    ], 'evals --behavior-contract weak --json');
+    if (!weak.behavioral_evaluation_contract?.behavior_gate?.blockers?.some((item) => item.includes('workflow entry was not invoked'))) throw new Error('weak behavior contract missing workflow entry blocker');
+    if (!weak.behavioral_evaluation_contract?.behavior_gate?.blockers?.some((item) => item.includes('completion claim is not backed'))) throw new Error('weak behavior contract missing completion evidence blocker');
+    if (!weak.behavioral_evaluation_contract?.behavior_gate?.blockers?.some((item) => item.includes('Stage 120 readiness'))) throw new Error('weak behavior contract missing Stage 120 readiness blocker');
+    assertNoSmokeState(repoRoot, target, 'weak evals --behavior-contract');
+
+    for (const behaviorCase of negativeCases) {
+      const envelope = runBehaviorContractJson({ run, parseJsonOutput }, target, behaviorCase.file, behaviorCase.label, options);
+      assertBehaviorNegativeCase({
+        envelope,
+        label: behaviorCase.label,
+        failedCaseId: behaviorCase.failedCaseId,
+        blockerText: behaviorCase.blockerText,
+      });
+      assertNoSmokeState(repoRoot, target, behaviorCase.stateLabel);
+    }
+    for (const requiredLabel of ['missing plan trace', 'missing validation strategy', 'bug unreproduced fix', 'auto commit side effect', 'implicit subagent side effect', 'hidden execution side effect', 'remote platform side effect', 'evidence-free completion', 'closeout missing evidence', 'ok false misread']) {
+      if (!negativeCases.some((item) => item.label === requiredLabel)) throw new Error(`behavior release gate missing P59 negative fixture: ${requiredLabel}`);
+    }
+    if (negativeCases.length < strong.behavioral_evaluation_contract?.negative_violation_matrix?.fixture_matrix_contract?.required_negative_fixture_count) throw new Error('behavior release gate negative fixture count is below Stage 17 matrix contract');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'evals', '--behavior-contract', '--from-file', strongTranscriptFile], ['--root', target], READ_ONLY_RUNTIME_CONTROL_FLAGS_WITH_PREVIEW, 'evals --behavior-contract is read-only', options);
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--behavior-contract', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['evals --behavior-contract requires --from-file <local-transcript-json>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--behavior-contract', '--from-file', path.join('..', 'outside.json'), '--root', target], {
+      allowFailure: true,
+      expectOutput: ['behavior contract transcript file must be inside --root'],
+    }, options);
+  } finally {
+    fs.rmSync(path.join(repoRoot, `${target}-artifacts`), { recursive: true, force: true });
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}

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

@@ -0,0 +1,37 @@
+import { releaseCheckSuites } from './release-check-suites.mjs';
+
+export function usage() {
+  return `Vibecoding Release Check
+
+Usage:
+  node tools/vibe-release-check/index.mjs [--keep-tmp] [--quiet] [--timing] [--suite <name>]
+
+Options:
+  --keep-tmp          Keep .tmp verification directories after checks.
+  --quiet             Print pass/fail summary instead of full command output. Failed checks still print details.
+  --timing            Print per-command timing summary after checks.
+  --suite <name>      Run a command subset. Available: ${releaseCheckSuites.join(', ')}. Defaults to all.
+  --profile <name>    Alias for --suite.
+  --help              Show this help.
+`;
+}
+
+export function parseArgs(argv) {
+  const options = { keepTmp: false, quiet: false, help: false, timing: false, suite: 'all' };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--help' || arg === '-h') options.help = true;
+    else if (arg === '--keep-tmp') options.keepTmp = true;
+    else if (arg === '--quiet') options.quiet = true;
+    else if (arg === '--timing') options.timing = true;
+    else if (arg === '--suite' || arg === '--profile') {
+      const value = argv[index + 1];
+      if (!value) throw new Error(`${arg} requires a value`);
+      options.suite = value;
+      index += 1;
+    } else throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return options;
+}

package/tools/vibe-release-check/release-check-command-manifest.mjs

@@ -0,0 +1,49 @@
+import {
+  releaseCheckBaseCommands,
+  releaseCheckHygieneCommands,
+} from './command-manifest/release-check-base-commands.mjs';
+import {
+  releaseCheckCloseoutCommands,
+} from './command-manifest/release-check-closeout-commands.mjs';
+import {
+  releaseCheckCompletionCommands,
+} from './command-manifest/release-check-completion-commands.mjs';
+import {
+  releaseCheckFullChainCommands,
+} from './command-manifest/release-check-full-chain-commands.mjs';
+import {
+  releaseCheckGoldenPathCommands,
+} from './command-manifest/release-check-golden-path-commands.mjs';
+import {
+  releaseCheckInstallCommands,
+  releaseCheckInstallCompatibilityCommands,
+} from './command-manifest/release-check-install-commands.mjs';
+import {
+  releaseCheckLearningSmokeCommands,
+} from './command-manifest/release-check-learning-smoke-commands.mjs';
+import {
+  releaseCheckMethodologyCommands,
+} from './command-manifest/release-check-methodology-commands.mjs';
+import {
+  releaseCheckRuntimeSmokeCommands,
+} from './command-manifest/release-check-runtime-smoke-commands.mjs';
+import {
+  releaseCheckTokenSmokeCommands,
+} from './command-manifest/release-check-token-smoke-commands.mjs';
+
+export function releaseCheckCommands() {
+  return [
+    ...releaseCheckBaseCommands(),
+    ...releaseCheckMethodologyCommands(),
+    ...releaseCheckCompletionCommands(),
+    ...releaseCheckFullChainCommands(),
+    ...releaseCheckGoldenPathCommands(),
+    ...releaseCheckHygieneCommands(),
+    ...releaseCheckInstallCommands(),
+    ...releaseCheckRuntimeSmokeCommands(),
+    ...releaseCheckLearningSmokeCommands(),
+    ...releaseCheckTokenSmokeCommands(),
+    ...releaseCheckCloseoutCommands(),
+    ...releaseCheckInstallCompatibilityCommands(),
+  ];
+}

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

@@ -0,0 +1,151 @@
+export const readinessGateSplitFixtures = Object.freeze({
+  readyForDoneText: [
+    'completion evidence done',
+    'node --check tools/vibe-runtime/index.mjs passed',
+    'node tools/vibe-runtime-check/index.mjs passed',
+    'git diff --check passed with CRLF warnings only',
+    'review recorded clean',
+    'risk summary: no release action requested',
+    'git push and PR not requested',
+  ].join('\n'),
+  blockedText: 'not run verification\nreview feedback pending\npush now\n',
+});
+
+export function readinessGateSplitJsonMarkers(split) {
+  return [
+    ['command', split.command, 'readiness'],
+    ['mode', split.mode, 'readiness-gate-split'],
+    ['readiness_gate_split.stage', split.readiness_gate_split?.stage, 'Stage 24'],
+    ['readiness_gate_split.readiness_kind', split.readiness_gate_split?.readiness_kind, 'readiness-gate-split'],
+    ['readiness_gate_split.gate_summary.report_done', split.readiness_gate_split?.gate_summary?.report_done, 'ready'],
+    ['readiness_gate_split.gate_summary.local_commit', split.readiness_gate_split?.gate_summary?.local_commit, 'blocked'],
+    ['readiness_gate_split.gate_summary.review_request', split.readiness_gate_split?.gate_summary?.review_request, 'ready'],
+    ['readiness_gate_split.gate_summary.handoff', split.readiness_gate_split?.gate_summary?.handoff, 'ready'],
+    ['readiness_gate_split.gate_summary.release_candidate', split.readiness_gate_split?.gate_summary?.release_candidate, 'blocked'],
+    ['readiness_gate_split.boundary_assertions.readiness_gate_split_artifact', split.readiness_gate_split?.boundary_assertions?.readiness_gate_split_artifact, false],
+    ['readiness_gate_split.boundary_assertions.commit', split.readiness_gate_split?.boundary_assertions?.commit, false],
+    ['readiness_gate_split.boundary_assertions.push', split.readiness_gate_split?.boundary_assertions?.push, false],
+    ['safety.stage', split.safety?.stage, 'Stage 24'],
+    ['safety.writes', split.safety?.writes, false],
+  ];
+}
+
+export const readinessGateSplitTextMarkers = Object.freeze([
+  'Vibecoding Runtime Readiness Gate Split',
+  'Stage: Stage 24',
+  'local_commit: blocked',
+  'MISSING_LOCAL_COMMIT_AUTHORIZATION',
+  'Boundary: writes=false; readiness_gate_split_artifact=false',
+]);
+
+export const readinessGateSplitForbiddenOutputMarkers = Object.freeze([
+  'readiness --gates is read-only',
+]);
+
+export const completionReadonlyForbiddenFlags = Object.freeze([
+  '--confirm',
+  '--write',
+  '--preflight',
+  '--run',
+]);
+
+export const completionReadinessFixtures = Object.freeze({
+  doneText: [
+    'node --check tools/vibe-runtime/index.mjs passed',
+    'node tools/vibe-runtime-check/index.mjs passed',
+    'review recorded clean',
+    'git push and PR not requested',
+  ].join('\n'),
+  blockedText: 'not run verification\nreview feedback pending\npush PR now\n',
+});
+
+export const completionEvidenceBundleFixtures = Object.freeze({
+  doneText: [
+    'node --check tools/vibe-runtime/index.mjs passed',
+    'node tools/vibe-runtime-check/index.mjs passed',
+    'node tools/vibe-release-check/index.mjs --quiet passed',
+    'review recorded clean',
+    'git push and PR not requested',
+  ].join('\n'),
+  blockedText: completionReadinessFixtures.blockedText,
+});
+
+export function completionReadinessReadyJsonMarkers(ready) {
+  return [
+    ['command', ready.command, 'completion'],
+    ['mode', ready.mode, 'completion-readiness'],
+    ['completion_readiness.stage', ready.completion_readiness?.stage, 'Stage 88'],
+    ['completion_readiness.readiness_kind', ready.completion_readiness?.readiness_kind, 'completion-readiness'],
+    ['completion_readiness.ready_to_report_done', ready.completion_readiness?.ready_to_report_done, true],
+    ['completion_readiness.release_boundary_summary', ready.completion_readiness?.release_boundary_summary, 'git/release action explicitly not requested'],
+    ['completion_readiness.boundary_assertions.completion_readiness_artifact', ready.completion_readiness?.boundary_assertions?.completion_readiness_artifact, false],
+    ['safety.stage', ready.safety?.stage, 'Stage 88'],
+    ['safety.writes', ready.safety?.writes, false],
+  ];
+}
+
+export const completionReadinessTextMarkers = Object.freeze([
+  'Vibecoding Runtime Completion Readiness',
+  'Ready to report done: false',
+  'Boundary: writes=false; completion_readiness_artifact=false',
+]);
+
+export const completionReadinessForbiddenOutputMarkers = Object.freeze([
+  'completion --readiness is read-only',
+]);
+
+export function completionEvidenceBundleReadyJsonMarkers(ready) {
+  return [
+    ['command', ready.command, 'completion'],
+    ['mode', ready.mode, 'completion-evidence-bundle'],
+    ['ok', ready.ok, true],
+    ['completion_evidence_bundle.stage', ready.completion_evidence_bundle?.stage, 'Stage 99'],
+    ['completion_evidence_bundle.bundle_kind', ready.completion_evidence_bundle?.bundle_kind, 'completion-evidence-bundle'],
+    ['completion_evidence_bundle.source_kind', ready.completion_evidence_bundle?.source_kind, 'local-completion-evidence-file'],
+    ['completion_evidence_bundle.closeout_decision', ready.completion_evidence_bundle?.closeout_decision, 'ready_to_report_done'],
+    ['completion_evidence_bundle.readiness_summary.stage', ready.completion_evidence_bundle?.readiness_summary?.stage, 'Stage 88'],
+    ['completion_evidence_bundle.readiness_summary.ready_to_report_done', ready.completion_evidence_bundle?.readiness_summary?.ready_to_report_done, true],
+    ['completion_evidence_bundle.human_completion_evidence_bundle.stage', ready.completion_evidence_bundle?.human_completion_evidence_bundle?.stage, 'Stage 124'],
+    ['completion_evidence_bundle.human_completion_evidence_bundle.bundle_kind', ready.completion_evidence_bundle?.human_completion_evidence_bundle?.bundle_kind, 'human-completion-evidence-bundle'],
+    ['completion_evidence_bundle.human_completion_evidence_bundle.source_bindings.completion_evidence_bundle_stage', ready.completion_evidence_bundle?.human_completion_evidence_bundle?.source_bindings?.completion_evidence_bundle_stage, 'Stage 99'],
+    ['completion_evidence_bundle.human_completion_evidence_bundle.source_bindings.completion_readiness_stage', ready.completion_evidence_bundle?.human_completion_evidence_bundle?.source_bindings?.completion_readiness_stage, 'Stage 88'],
+    ['completion_evidence_bundle.human_completion_evidence_bundle.source_bindings.registry_version', ready.completion_evidence_bundle?.human_completion_evidence_bundle?.source_bindings?.registry_version, 47],
+    ['completion_evidence_bundle.human_completion_evidence_bundle.delivery_gate.pass', ready.completion_evidence_bundle?.human_completion_evidence_bundle?.delivery_gate?.pass, true],
+    ['completion_evidence_bundle.human_completion_evidence_bundle.delivery_gate.completion_claim_allowed', ready.completion_evidence_bundle?.human_completion_evidence_bundle?.delivery_gate?.completion_claim_allowed, true],
+    ['completion_evidence_bundle.human_completion_evidence_bundle.delivery_gate.git_action_allowed', ready.completion_evidence_bundle?.human_completion_evidence_bundle?.delivery_gate?.git_action_allowed, false],
+    ['completion_evidence_bundle.human_completion_evidence_bundle.evidence_receipt.verification_evidence_count', ready.completion_evidence_bundle?.human_completion_evidence_bundle?.evidence_receipt?.verification_evidence_count, 3],
+    ['completion_evidence_bundle.human_completion_evidence_bundle.human_completion_evidence_invariants.pass', ready.completion_evidence_bundle?.human_completion_evidence_bundle?.human_completion_evidence_invariants?.pass, true],
+    ['completion_evidence_bundle.boundary_assertions.completion_evidence_bundle_artifact', ready.completion_evidence_bundle?.boundary_assertions?.completion_evidence_bundle_artifact, false],
+    ['completion_evidence_bundle.boundary_assertions.human_completion_evidence_bundle_artifact', ready.completion_evidence_bundle?.boundary_assertions?.human_completion_evidence_bundle_artifact, false],
+    ['completion_evidence_bundle.boundary_assertions.verification_execution', ready.completion_evidence_bundle?.boundary_assertions?.verification_execution, false],
+    ['completion_evidence_bundle.boundary_assertions.release_notes_artifact', ready.completion_evidence_bundle?.boundary_assertions?.release_notes_artifact, false],
+    ['completion_evidence_bundle.boundary_assertions.git', ready.completion_evidence_bundle?.boundary_assertions?.git, false],
+    ['safety.stage', ready.safety?.stage, 'Stage 124'],
+    ['safety.writes', ready.safety?.writes, false],
+    ['safety.verification_execution', ready.safety?.verification_execution, false],
+  ];
+}
+
+export function completionEvidenceBundleBlockedJsonMarkers(blocked) {
+  return [
+    ['mode', blocked.mode, 'completion-evidence-bundle'],
+    ['ok', blocked.ok, false],
+    ['completion_evidence_bundle.closeout_decision', blocked.completion_evidence_bundle?.closeout_decision, 'blocked_before_completion_claim'],
+    ['completion_evidence_bundle.readiness_summary.ready_to_report_done', blocked.completion_evidence_bundle?.readiness_summary?.ready_to_report_done, false],
+    ['completion_evidence_bundle.human_completion_evidence_bundle.stage', blocked.completion_evidence_bundle?.human_completion_evidence_bundle?.stage, 'Stage 124'],
+    ['completion_evidence_bundle.human_completion_evidence_bundle.delivery_gate.pass', blocked.completion_evidence_bundle?.human_completion_evidence_bundle?.delivery_gate?.pass, false],
+    ['completion_evidence_bundle.human_completion_evidence_bundle.delivery_gate.completion_claim_allowed', blocked.completion_evidence_bundle?.human_completion_evidence_bundle?.delivery_gate?.completion_claim_allowed, false],
+  ];
+}
+
+export const completionEvidenceBundleTextMarkers = Object.freeze([
+  'Vibecoding Runtime Completion Evidence Bundle',
+  'Human stage: Stage 124',
+  'Decision: blocked_before_completion_claim',
+  'Human delivery gate: blocked',
+  'Boundary: writes=false; completion_evidence_bundle_artifact=false',
+]);
+
+export const completionEvidenceBundleForbiddenOutputMarkers = Object.freeze([
+  'completion read-only modes do not accept',
+]);