@jtf19/vibecoding-kit 0.1.0

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

@@ -0,0 +1,132 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+function assertContains(text, marker, label) {
+  if (!String(text || '').includes(marker)) throw new Error(`${label} missing marker: ${marker}`);
+}
+
+function assertArrayContains(values, marker, label) {
+  if (!Array.isArray(values) || !values.some((value) => String(value).includes(marker))) {
+    throw new Error(`${label} missing array marker: ${marker}`);
+  }
+}
+
+function writeJson(file, payload) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+}
+
+export function runAgentSessionStartBehaviorSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const root = path.join(repoRoot, '.tmp', 'vibe-stage15-agent-session-start');
+  fs.rmSync(root, { recursive: true, force: true });
+  fs.mkdirSync(root, { recursive: true });
+  try {
+    const defaultStart = parseJsonOutput(run('node', [
+      'tools/vibe-runtime/index.mjs',
+      'workflow',
+      '--start',
+      '--prompt',
+      '我想给这个项目加一个小功能，请先判断下一步。',
+      '--json',
+      '--root',
+      root,
+    ], {}, options), 'workflow --start default');
+    const defaultContract = defaultStart.workflow_start?.start_here_contract;
+    assertJsonMarkers([
+      ['stage15.default.command', defaultStart.command, 'workflow'],
+      ['stage15.default.mode', defaultStart.mode, 'unified-workflow-start'],
+      ['stage15.default.profile', defaultContract?.automation_profile, 'vibe-guided'],
+      ['stage15.default.profile_source', defaultContract?.profile_source, 'vibe-guided-no-config'],
+      ['stage15.default.first_skill', defaultContract?.expected_first_skill, 'using-vibecoding'],
+      ['stage15.default.skill_path', defaultContract?.skill_path, '.vibecoding/skills/using-vibecoding/SKILL.md'],
+      ['stage15.default.registry_fallback', defaultContract?.registry_fallback_to_file_path, true],
+      ['stage15.default.tiny_context', defaultContract?.context_policy?.default_context, 'tiny_context'],
+      ['stage15.default.full_skill_injection', defaultContract?.context_policy?.full_skill_injection, false],
+      ['stage15.default.route_required', defaultContract?.route_required_before_implementation, true],
+      ['stage15.default.validation_required', defaultContract?.validation_strategy_required_before_change, true],
+      ['stage15.default.skill_execution', defaultContract?.boundary_assertions?.skill_execution, false],
+      ['stage15.default.command_execution', defaultContract?.boundary_assertions?.command_execution, false],
+      ['stage15.default.subagent', defaultContract?.boundary_assertions?.subagent, false],
+      ['stage15.default.git', defaultContract?.boundary_assertions?.git, false],
+      ['stage15.default.source_write', defaultContract?.boundary_assertions?.source_write, false],
+      ['stage15.default.start_alias', defaultStart.workflow_start?.agent_session_start_contract?.contract_digest, defaultContract?.contract_digest],
+      ['stage15.default.workflow_claim', defaultStart.workflow_start?.workflow_discipline_summary?.visible_claims?.workflow_execution_claimed, false],
+      ['stage15.default.command_claim', defaultStart.workflow_start?.workflow_discipline_summary?.visible_claims?.command_execution_claimed, false],
+    ], 'workflow --start default');
+    assertArrayContains(defaultContract?.forbidden_actions, 'real subagent session creation', 'default start contract');
+    assertArrayContains(defaultContract?.stop_conditions, 'validation strategy is missing', 'default stop conditions');
+
+    writeJson(path.join(root, '.vibecoding', 'config.json'), {
+      version: 1,
+      automation_profile: 'superpowers-parity',
+      interaction: 'strict-skill-first',
+    });
+    const parityStart = parseJsonOutput(run('node', [
+      'tools/vibe-runtime/index.mjs',
+      'workflow',
+      '--start',
+      '--prompt',
+      '实现一个小功能',
+      '--json',
+      '--root',
+      root,
+    ], {}, options), 'workflow --start installed parity');
+    const parityContract = parityStart.workflow_start?.start_here_contract;
+    assertJsonMarkers([
+      ['stage15.parity.profile', parityContract?.automation_profile, 'superpowers-parity'],
+      ['stage15.parity.profile_source', parityContract?.profile_source, 'installed-config'],
+      ['stage15.parity.discipline', parityContract?.discipline_level, 'strict-skill-first-visible-route'],
+      ['stage15.parity.plan_todo', parityContract?.plan_or_todo_required_when_planning, true],
+      ['stage15.parity.profile_summary', parityStart.workflow_start?.profile_contract_summary?.profile, 'superpowers-parity'],
+      ['stage15.parity.skill_first', parityStart.workflow_start?.profile_contract_summary?.policy?.skill_first, true],
+      ['stage15.parity.receipt_claim', parityStart.workflow_start?.profile_contract_summary?.skill_first_receipt?.skill_execution_claimed, false],
+    ], 'workflow --start installed parity');
+    assertContains(parityContract?.visible_first_sentence, '.vibecoding/skills/using-vibecoding/SKILL.md', 'parity visible first sentence');
+
+    const explicitDefault = parseJsonOutput(run('node', [
+      'tools/vibe-runtime/index.mjs',
+      'workflow',
+      '--start',
+      '--prompt',
+      '实现一个小功能',
+      '--profile',
+      'default',
+      '--json',
+      '--root',
+      root,
+    ], {}, options), 'workflow --start explicit default');
+    assertJsonMarkers([
+      ['stage15.explicit.profile', explicitDefault.workflow_start?.start_here_contract?.automation_profile, 'vibe-guided'],
+      ['stage15.explicit.source', explicitDefault.workflow_start?.start_here_contract?.profile_source, 'explicit-cli-profile'],
+    ], 'workflow --start explicit default');
+
+    for (const [file, label] of [
+      ['templates/AGENTS.md', 'AGENTS template'],
+      ['templates/CLAUDE.md', 'CLAUDE template'],
+      ['templates/VIBE-CODING.md', 'VIBE-CODING template'],
+      ['skills/using-vibecoding/SKILL.md', 'using-vibecoding skill'],
+    ]) {
+      const text = fs.readFileSync(path.join(repoRoot, file), 'utf8');
+      assertContains(text, 'Start Here Contract', label);
+      assertContains(text, '.vibecoding/skills/using-vibecoding/SKILL.md', label);
+      assertContains(text, '不注入完整', label);
+      assertContains(text, '不执行命令', label);
+      assertContains(text, 'subagent', label);
+      assertContains(text, 'git', label);
+    }
+
+    const manifestText = fs.readFileSync(path.join(repoRoot, 'tools/vibe-init/init-install-manifest-model.mjs'), 'utf8');
+    assertContains(manifestText, 'runtimeInstallFirstTurnAcceptance', 'install manifest model');
+    assertContains(manifestText, 'installedAgentExperienceContract', 'install manifest model');
+    const experienceText = fs.readFileSync(path.join(repoRoot, 'tools/vibe-init/init-installed-agent-experience-contract.mjs'), 'utf8');
+    for (const marker of ['runtimeInstallFirstTurnAcceptance', 'expected_first_skill', 'fallback_to_file_path', 'first_turn_acceptance_prompt', 'expected_first_turn_behavior', 'installed-agent-experience-contract-v2', 'completion_closeout']) {
+      assertContains(experienceText, marker, 'installed agent experience contract model');
+    }
+    const presentationText = fs.readFileSync(path.join(repoRoot, 'tools/vibe-init/init-presentation.mjs'), 'utf8');
+    assertContains(presentationText, 'First-turn acceptance prompt', 'init presentation');
+    assertContains(presentationText, 'Completion closeout acceptance prompt', 'init presentation');
+    assertContains(presentationText, 'Vibe Guided lightweight routing', 'init presentation');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}

package/tools/vibe-release-check/release-check-stage50-53-smoke.mjs

@@ -0,0 +1,429 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  assertJsonMarkers,
+  digestObject,
+  parseJsonOutput,
+  repoRoot,
+  run,
+  tmpRoot,
+} from './release-check-runtime.mjs';
+
+function buildRouterSmokeDispatchPlan({ target, absoluteTarget, plannerInputFile, options }) {
+  const routeConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'planner', '--route', '--from-file', plannerInputFile, '--confirm', '--json', '--root', target], {}, options), 'planner route confirm for router smoke');
+  const routeFile = routeConfirm.planner_route_file;
+  const planConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'planner', '--decompose', '--from-route', routeFile, '--confirm', '--json', '--root', target], {}, options), 'planner plan confirm for router smoke');
+  const planFile = planConfirm.planner_plan_file;
+  const briefsConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'planner', '--briefs', '--from-plan', planFile, '--confirm', '--json', '--root', target], {}, options), 'planner briefs confirm for router smoke');
+  const briefsFile = briefsConfirm.planner_briefs_file;
+
+  const routerPreview = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'router', '--plan', '--from-briefs', briefsFile, '--json', '--root', target], {}, options), 'router --plan --json');
+  assertJsonMarkers([
+    ['command', routerPreview.command, 'router'],
+    ['mode', routerPreview.mode, 'router-plan'],
+    ['router_plan.stage', routerPreview.router_plan?.stage, 'Stage 50'],
+    ['router_plan.writes', routerPreview.router_plan?.writes, false],
+    ['router_plan.dispatch', routerPreview.router_plan?.dispatch, false],
+    ['router_plan.session_create', routerPreview.router_plan?.session_create, false],
+  ], 'router --plan --json');
+  if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'router-plans'))) throw new Error('router preview created unexpected router-plans directory');
+
+  const routerConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'router', '--plan', '--from-briefs', briefsFile, '--confirm', '--json', '--root', target], {}, options), 'router --plan --confirm --json');
+  const routerPlanFile = routerConfirm.router_plan_file;
+  assertJsonMarkers([
+    ['mode', routerConfirm.mode, 'router-plan'],
+    ['router_plan.allowed_followup.0', routerConfirm.router_plan?.allowed_followup?.[0], 'router-approval-only'],
+    ['safety.router_artifact', routerConfirm.safety?.router_artifact, true],
+  ], 'router --plan --confirm --json');
+  if (!routerPlanFile || !fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'router-plans', routerPlanFile))) throw new Error('router plan confirm did not write router plan artifact');
+
+  const routerApproval = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'router', '--approve', routerPlanFile, '--confirm', '--json', '--root', target], {}, options), 'router --approve --confirm --json');
+  const routerApprovalFile = routerApproval.router_approval_file;
+  assertJsonMarkers([
+    ['mode', routerApproval.mode, 'router-approval'],
+    ['router_approval.allowed_followup.0', routerApproval.router_approval?.allowed_followup?.[0], 'orchestrator-plan-only'],
+    ['safety.router_artifact', routerApproval.safety?.router_artifact, true],
+  ], 'router --approve --confirm --json');
+  if (!routerApprovalFile || !fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'router-approvals', routerApprovalFile))) throw new Error('router approval confirm did not write router approval artifact');
+
+  const orchestratorPlan = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'orchestrator', '--plan', '--from-router', routerApprovalFile, '--confirm', '--json', '--root', target], {}, options), 'orchestrator --plan --confirm --json');
+  const orchestratorPlanFile = orchestratorPlan.orchestrator_plan_file;
+  assertJsonMarkers([
+    ['mode', orchestratorPlan.mode, 'orchestrator-plan'],
+    ['orchestrator_plan.allowed_followup.0', orchestratorPlan.orchestrator_plan?.allowed_followup?.[0], 'orchestrator-dispatch-plan-only'],
+    ['safety.orchestrator_artifact', orchestratorPlan.safety?.orchestrator_artifact, true],
+  ], 'orchestrator --plan --confirm --json');
+  if (!orchestratorPlanFile || !fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'orchestrator-plans', orchestratorPlanFile))) throw new Error('orchestrator plan confirm did not write orchestrator plan artifact');
+
+  const dispatchPlan = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'orchestrator', '--dispatch-plan', orchestratorPlanFile, '--confirm', '--json', '--root', target], {}, options), 'orchestrator --dispatch-plan --confirm --json');
+  const dispatchPlanFile = dispatchPlan.orchestrator_dispatch_plan_file;
+  assertJsonMarkers([
+    ['mode', dispatchPlan.mode, 'orchestrator-dispatch-plan'],
+    ['orchestrator_dispatch_plan.allowed_followup.0', dispatchPlan.orchestrator_dispatch_plan?.allowed_followup?.[0], 'scheduler-dispatch-plan-only'],
+    ['orchestrator_dispatch_plan.allowed_followup.1', dispatchPlan.orchestrator_dispatch_plan?.allowed_followup?.[1], 'session-approval-only'],
+    ['safety.orchestrator_artifact', dispatchPlan.safety?.orchestrator_artifact, true],
+  ], 'orchestrator --dispatch-plan --confirm --json');
+  if (!dispatchPlanFile || !fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'orchestrator-dispatch-plans', dispatchPlanFile))) throw new Error('orchestrator dispatch plan confirm did not write dispatch plan artifact');
+
+  const routerVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'router', '--verify', routerApprovalFile, '--json', '--root', target], {}, options), 'router --verify approval --json');
+  assertJsonMarkers([
+    ['mode', routerVerify.mode, 'router-artifact-verify'],
+    ['verification.ok', routerVerify.verification?.ok, true],
+  ], 'router --verify approval --json');
+
+  const orchestratorVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'orchestrator', '--verify', dispatchPlanFile, '--json', '--root', target], {}, options), 'orchestrator --verify dispatch plan --json');
+  assertJsonMarkers([
+    ['mode', orchestratorVerify.mode, 'orchestrator-artifact-verify'],
+    ['verification.ok', orchestratorVerify.verification?.ok, true],
+  ], 'orchestrator --verify dispatch plan --json');
+
+  return { dispatchPlanFile, routerPlanFile };
+}
+
+export function runRouterSmoke(options) {
+  const target = '.tmp/vibe-runtime-ledger';
+  const absoluteTarget = path.join(repoRoot, target);
+  const plannerInputFile = path.join(tmpRoot, 'router-input.txt');
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  fs.mkdirSync(tmpRoot, { recursive: true });
+  fs.mkdirSync(absoluteTarget, { recursive: true });
+  fs.writeFileSync(
+    plannerInputFile,
+    [
+      'Implement routing strategy for multiple planner briefs.',
+      '- runtime command surface changes',
+      '- docs synchronization',
+      '- verification and release smoke updates',
+      'Need platform ranking, concurrency lanes, mutex, and escalation.',
+    ].join('\n'),
+    'utf8',
+  );
+
+  const { dispatchPlanFile, routerPlanFile } = buildRouterSmokeDispatchPlan({ target, absoluteTarget, plannerInputFile, options });
+
+  const bridgeEligibility = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--eligibility', '--from-orchestrator', dispatchPlanFile, '--task', 'implement-core', '--confirm', '--json', '--root', target], {}, options), 'subagents --eligibility --from-orchestrator --confirm --json');
+  const bridgeEligibilityFile = bridgeEligibility.subagent_eligibility_file;
+  assertJsonMarkers([
+    ['command', bridgeEligibility.command, 'subagents'],
+    ['mode', bridgeEligibility.mode, 'subagent-eligibility'],
+    ['subagent_eligibility.stage', bridgeEligibility.subagent_eligibility?.stage, 'Stage 35'],
+    ['subagent_eligibility.source.kind', bridgeEligibility.subagent_eligibility?.source?.kind, 'orchestrator-dispatch-plan'],
+    ['subagent_eligibility.gates.0.source', bridgeEligibility.subagent_eligibility?.gates?.[0]?.source, 'stage-50-orchestrator-dispatch-plan'],
+    ['subagent_eligibility.eligible', bridgeEligibility.subagent_eligibility?.eligible, true],
+    ['safety.subagent_eligibility_artifact', bridgeEligibility.safety?.subagent_eligibility_artifact, true],
+    ['safety.session_create', bridgeEligibility.safety?.session_create, false],
+  ], 'subagents --eligibility --from-orchestrator --confirm --json');
+  if (!bridgeEligibilityFile || !fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'subagent-eligibility', bridgeEligibilityFile))) throw new Error('Stage 50 bridge eligibility did not write subagent eligibility artifact');
+
+  const bridgeDispatch = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--dispatch', '--from-orchestrator', dispatchPlanFile, '--eligibility', bridgeEligibilityFile, '--confirm', '--json', '--root', target], {}, options), 'subagents --dispatch --from-orchestrator --confirm --json');
+  const bridgeDispatchFile = bridgeDispatch.subagent_dispatch_file;
+  assertJsonMarkers([
+    ['command', bridgeDispatch.command, 'subagents'],
+    ['mode', bridgeDispatch.mode, 'subagent-dispatch'],
+    ['subagent_dispatch.stage', bridgeDispatch.subagent_dispatch?.stage, 'Stage 36'],
+    ['subagent_dispatch.dispatch_status', bridgeDispatch.subagent_dispatch?.dispatch_status, 'approved-dispatch-artifact-only'],
+    ['subagent_dispatch.orchestrator_dispatch_plan_file', bridgeDispatch.subagent_dispatch?.orchestrator_dispatch_plan_file, dispatchPlanFile],
+    ['subagent_dispatch.no_session_create', bridgeDispatch.subagent_dispatch?.no_session_create, true],
+    ['subagent_dispatch.no_platform_api', bridgeDispatch.subagent_dispatch?.no_platform_api, true],
+    ['safety.subagent_dispatch_artifact', bridgeDispatch.safety?.subagent_dispatch_artifact, true],
+  ], 'subagents --dispatch --from-orchestrator --confirm --json');
+  if (!bridgeDispatchFile || !fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'subagent-dispatches', bridgeDispatchFile))) throw new Error('Stage 50 bridge dispatch did not write subagent dispatch artifact');
+
+  const bridgeDispatchVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', bridgeDispatchFile, '--json', '--root', target], {}, options), 'subagents --verify bridge dispatch --json');
+  assertJsonMarkers([
+    ['mode', bridgeDispatchVerify.mode, 'subagent-dispatch-verify'],
+    ['verification.ok', bridgeDispatchVerify.verification?.ok, true],
+  ], 'subagents --verify bridge dispatch --json');
+
+  const bridgeCapability = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--probe', 'cursor', '--confirm', '--json', '--root', target], {}, options), 'platforms --probe cursor for bridge --confirm --json');
+  const bridgeCapabilityFile = bridgeCapability.platform_capability_file;
+  const bridgeApproval = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--session-approval', '--from-dispatch', bridgeDispatchFile, '--capability', bridgeCapabilityFile, '--confirm', '--json', '--root', target], {}, options), 'subagents --session-approval from bridge dispatch --confirm --json');
+  assertJsonMarkers([
+    ['mode', bridgeApproval.mode, 'platform-session-approval'],
+    ['platform_session_approval.stage', bridgeApproval.platform_session_approval?.stage, 'Stage 42'],
+    ['platform_session_approval.dispatch_file', bridgeApproval.platform_session_approval?.dispatch_file, bridgeDispatchFile],
+    ['platform_session_approval.session_create', bridgeApproval.platform_session_approval?.session_create, false],
+    ['platform_session_approval.platform_api', bridgeApproval.platform_session_approval?.platform_api, false],
+  ], 'subagents --session-approval from bridge dispatch --confirm --json');
+
+  const badRouterPlanPath = path.join(absoluteTarget, '.vibecoding-state', 'router-plans', 'bad-briefs-digest.router-plan.json');
+  const badRouterPlan = JSON.parse(fs.readFileSync(path.join(absoluteTarget, '.vibecoding-state', 'router-plans', routerPlanFile), 'utf8'));
+  badRouterPlan.router_plan.briefs_digest = '8'.repeat(64);
+  delete badRouterPlan.router_plan.plan_digest;
+  badRouterPlan.router_plan.plan_digest = digestObject(badRouterPlan.router_plan);
+  fs.writeFileSync(badRouterPlanPath, `${JSON.stringify(badRouterPlan, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'router', '--verify', 'bad-briefs-digest.router-plan.json', '--root', target], {
+    allowFailure: true,
+    expectOutput: ['router verification failed:', 'router_plan briefs digest mismatch'],
+  }, options);
+  fs.rmSync(badRouterPlanPath, { force: true });
+
+  const routerTrace = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'traces', '--build', '--confirm', '--json', '--root', target], {}, options), 'traces --build router --confirm --json');
+  const routerTraceTypes = routerTrace.runtime_trace?.source_types || {};
+  if (!routerTraceTypes.router_plans || !routerTraceTypes.router_approvals || !routerTraceTypes.orchestrator_plans || !routerTraceTypes.orchestrator_dispatch_plans) throw new Error('router/orchestrator trace did not include Stage 50 source types');
+  if (!options.keepTmp) fs.rmSync(plannerInputFile, { force: true });
+}
+
+
+
+export function runEvalsSmoke(options) {
+  const target = '.tmp/vibe-runtime-evals';
+  const absoluteTarget = path.join(repoRoot, target);
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  fs.mkdirSync(absoluteTarget, { recursive: true });
+
+  try {
+    const catalog = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--catalog', '--json', '--root', target], {}, options), 'evals --catalog --json');
+    assertJsonMarkers([
+      ['command', catalog.command, 'evals'],
+      ['mode', catalog.mode, 'evals-catalog'],
+      ['ok', catalog.ok, true],
+      ['catalog.suite_count', catalog.catalog?.suite_count, 4],
+      ['artifacts.suite_count', catalog.artifacts?.suite_count, 0],
+      ['artifacts.run_count', catalog.artifacts?.run_count, 0],
+      ['artifacts.report_count', catalog.artifacts?.report_count, 0],
+      ['safety.writes', catalog.safety?.writes, false],
+    ], 'evals --catalog --json');
+
+    const contractPreview = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--run-contract', 'contract-core', '--json', '--root', target], {}, options), 'evals --run-contract --json');
+    assertJsonMarkers([
+      ['command', contractPreview.command, 'evals'],
+      ['mode', contractPreview.mode, 'eval-bundle-preview'],
+      ['eval_suite.stage', contractPreview.eval_suite?.stage, 'Stage 51'],
+      ['eval_run.stage', contractPreview.eval_run?.stage, 'Stage 51'],
+      ['eval_report.stage', contractPreview.eval_report?.stage, 'Stage 51'],
+      ['eval_suite.allowed_followup.0', contractPreview.eval_suite?.allowed_followup?.[0], 'eval-run-only'],
+      ['eval_run.allowed_followup.0', contractPreview.eval_run?.allowed_followup?.[0], 'eval-report-only'],
+      ['eval_report.report_status', contractPreview.eval_report?.report_status, 'behavioral-eval-completed'],
+      ['safety.writes', contractPreview.safety?.writes, false],
+    ], 'evals --run-contract --json');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('eval preview created unexpected state directory');
+
+    const scenarioConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--run-scenario', 'scenario-routing', '--confirm', '--json', '--root', target], {}, options), 'evals --run-scenario --confirm --json');
+    const suiteFile = scenarioConfirm.files?.eval_suite;
+    const runFile = scenarioConfirm.files?.eval_run;
+    const reportFile = scenarioConfirm.files?.eval_report;
+    const scenarioReportFile = reportFile;
+    assertJsonMarkers([
+      ['command', scenarioConfirm.command, 'evals'],
+      ['mode', scenarioConfirm.mode, 'eval-bundle'],
+      ['eval_suite.stage', scenarioConfirm.eval_suite?.stage, 'Stage 51'],
+      ['eval_run.stage', scenarioConfirm.eval_run?.stage, 'Stage 51'],
+      ['eval_report.stage', scenarioConfirm.eval_report?.stage, 'Stage 51'],
+      ['eval_run.eval_kind', scenarioConfirm.eval_run?.eval_kind, 'scenario'],
+      ['eval_run.summary.behavior_judge_summary.transcript_judge_count', scenarioConfirm.eval_run?.summary?.behavior_judge_summary?.transcript_judge_count, 6],
+      ['eval_run.summary.behavior_pack_coverage.covered_case_count', scenarioConfirm.eval_run?.summary?.behavior_pack_coverage?.covered_case_count, 3],
+      ['eval_report.report_status', scenarioConfirm.eval_report?.report_status, 'behavioral-eval-completed'],
+      ['safety.eval_artifact', scenarioConfirm.safety?.eval_artifact, true],
+      ['safety.writes', scenarioConfirm.safety?.writes, true],
+    ], 'evals --run-scenario --confirm --json');
+    if (!scenarioConfirm.eval_run?.case_results?.some((item) => item.fixture?.fixture_type === 'transcript' && item.transcript_judge?.judge_type === 'transcript-behavioral-judge')) throw new Error('scenario eval did not include transcript behavioral judge evidence');
+    if (!suiteFile || !fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'eval-suites', suiteFile))) throw new Error('eval confirm did not write eval suite artifact');
+    if (!runFile || !fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'eval-runs', runFile))) throw new Error('eval confirm did not write eval run artifact');
+    if (!reportFile || !fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'eval-reports', reportFile))) throw new Error('eval confirm did not write eval report artifact');
+
+    const behaviorConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--run-behavior', 'behavior-workflow', '--confirm', '--json', '--root', target], {}, options), 'evals --run-behavior --confirm --json');
+    const behaviorReportFile = behaviorConfirm.files?.eval_report;
+    assertJsonMarkers([
+      ['command', behaviorConfirm.command, 'evals'],
+      ['mode', behaviorConfirm.mode, 'eval-bundle'],
+      ['eval_run.eval_kind', behaviorConfirm.eval_run?.eval_kind, 'behavior'],
+      ['eval_run.summary.behavior_judge_summary.sandbox_replay_count', behaviorConfirm.eval_run?.summary?.behavior_judge_summary?.sandbox_replay_count, 1],
+      ['eval_run.summary.behavior_pack_coverage.covered_case_count', behaviorConfirm.eval_run?.summary?.behavior_pack_coverage?.covered_case_count, 2],
+      ['eval_suite.fixture_policy.sandbox_replay', behaviorConfirm.eval_suite?.fixture_policy?.sandbox_replay, true],
+      ['eval_report.report_status', behaviorConfirm.eval_report?.report_status, 'behavioral-eval-completed'],
+      ['safety.eval_artifact', behaviorConfirm.safety?.eval_artifact, true],
+    ], 'evals --run-behavior --confirm --json');
+    if (!behaviorConfirm.eval_run?.case_results?.some((item) => item.replay_trace?.trace_type === 'sandbox-replay' && item.transcript_judge?.judge_type === 'sandbox-replay-judge')) throw new Error('behavior eval did not include sandbox replay judge evidence');
+
+    const contractConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--run-contract', 'contract-core', '--confirm', '--json', '--root', target], {}, options), 'evals --run-contract --confirm --json');
+    const contractReportFile = contractConfirm.files?.eval_report;
+    assertJsonMarkers([
+      ['command', contractConfirm.command, 'evals'],
+      ['mode', contractConfirm.mode, 'eval-bundle'],
+      ['eval_run.eval_kind', contractConfirm.eval_run?.eval_kind, 'contract'],
+      ['eval_report.outcome', contractConfirm.eval_report?.outcome, 'passed'],
+    ], 'evals --run-contract --confirm --json');
+
+    const adversarialConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--run-adversarial', 'adversarial-guardrails', '--confirm', '--json', '--root', target], {}, options), 'evals --run-adversarial --confirm --json');
+    const adversarialReportFile = adversarialConfirm.files?.eval_report;
+    assertJsonMarkers([
+      ['command', adversarialConfirm.command, 'evals'],
+      ['mode', adversarialConfirm.mode, 'eval-bundle'],
+      ['eval_run.eval_kind', adversarialConfirm.eval_run?.eval_kind, 'adversarial'],
+      ['eval_report.outcome', adversarialConfirm.eval_report?.outcome, 'passed'],
+      ['eval_run.summary.behavior_judge_summary.transcript_judge_count', adversarialConfirm.eval_run?.summary?.behavior_judge_summary?.transcript_judge_count, 7],
+      ['eval_run.summary.behavior_pack_coverage.covered_case_count', adversarialConfirm.eval_run?.summary?.behavior_pack_coverage?.covered_case_count, 3],
+    ], 'evals --run-adversarial --confirm --json');
+
+    const releasePreview = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'release', '--gate', '--from-evals', contractReportFile, scenarioReportFile, behaviorReportFile, adversarialReportFile, '--json', '--root', target], {}, options), 'release --gate preview --json');
+    assertJsonMarkers([
+      ['command', releasePreview.command, 'release'],
+      ['mode', releasePreview.mode, 'release-gate'],
+      ['ok', releasePreview.ok, true],
+      ['release_gate.stage', releasePreview.release_gate?.stage, 'Stage 52'],
+      ['release_gate.gate_status', releasePreview.release_gate?.gate_status, 'passed'],
+      ['safety.writes', releasePreview.safety?.writes, false],
+    ], 'release --gate preview --json');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'release-gates'))) throw new Error('release preview created unexpected release-gates directory');
+
+    const releaseConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'release', '--gate', '--from-evals', contractReportFile, scenarioReportFile, behaviorReportFile, adversarialReportFile, '--confirm', '--json', '--root', target], {}, options), 'release --gate --confirm --json');
+    const releaseGateFile = releaseConfirm.files?.release_gate;
+    assertJsonMarkers([
+      ['command', releaseConfirm.command, 'release'],
+      ['mode', releaseConfirm.mode, 'release-gate'],
+      ['ok', releaseConfirm.ok, true],
+      ['release_gate.stage', releaseConfirm.release_gate?.stage, 'Stage 52'],
+      ['release_gate.gate_status', releaseConfirm.release_gate?.gate_status, 'passed'],
+      ['release_gate.evidence.artifact_contract_pass_does_not_imply_behavior_pass', releaseConfirm.release_gate?.evidence?.artifact_contract_pass_does_not_imply_behavior_pass, true],
+      ['safety.release_gate_artifact', releaseConfirm.safety?.release_gate_artifact, true],
+      ['safety.git', releaseConfirm.safety?.git, false],
+    ], 'release --gate --confirm --json');
+    if (!releaseGateFile || !fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'release-gates', releaseGateFile))) throw new Error('release gate confirm did not write release gate artifact');
+
+    const releaseVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'release', '--verify-gate', releaseGateFile, '--json', '--root', target], {}, options), 'release --verify-gate --json');
+    assertJsonMarkers([
+      ['command', releaseVerify.command, 'release'],
+      ['mode', releaseVerify.mode, 'release-gate-verify'],
+      ['verification.ok', releaseVerify.verification?.ok, true],
+      ['summary.gate_status', releaseVerify.summary?.gate_status, 'passed'],
+    ], 'release --verify-gate --json');
+
+    const releaseConvergencePreview = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'release', '--gate', '--from-evals', contractReportFile, scenarioReportFile, behaviorReportFile, adversarialReportFile, '--with-convergence', '--json', '--root', target], {}, options), 'release --gate --with-convergence preview --json');
+    assertJsonMarkers([
+      ['command', releaseConvergencePreview.command, 'release'],
+      ['mode', releaseConvergencePreview.mode, 'release-gate'],
+      ['ok', releaseConvergencePreview.ok, true],
+      ['release_gate.evidence.convergence_evidence_bound', releaseConvergencePreview.release_gate?.evidence?.convergence_evidence_bound, true],
+      ['release_gate.convergence_evidence.stage', releaseConvergencePreview.release_gate?.convergence_evidence?.stage, 'Stage 65'],
+      ['release_gate.convergence_evidence.evidence_kind', releaseConvergencePreview.release_gate?.convergence_evidence?.evidence_kind, 'governance-convergence-report'],
+      ['release_gate.convergence_evidence.optional', releaseConvergencePreview.release_gate?.convergence_evidence?.optional, true],
+      ['release_gate.convergence_evidence.release_chain_required', releaseConvergencePreview.release_gate?.convergence_evidence?.release_chain_required, false],
+      ['release_gate.convergence_evidence.writes', releaseConvergencePreview.release_gate?.convergence_evidence?.writes, false],
+      ['safety.writes', releaseConvergencePreview.safety?.writes, false],
+    ], 'release --gate --with-convergence preview --json');
+    if (!releaseConvergencePreview.release_gate?.convergence_evidence?.evidence_digest) throw new Error('release convergence preview missing convergence evidence digest');
+
+    const releaseConvergenceConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'release', '--gate', '--from-evals', contractReportFile, scenarioReportFile, behaviorReportFile, adversarialReportFile, '--with-convergence', '--confirm', '--json', '--root', target], {}, options), 'release --gate --with-convergence --confirm --json');
+    const releaseConvergenceGateFile = releaseConvergenceConfirm.files?.release_gate;
+    assertJsonMarkers([
+      ['command', releaseConvergenceConfirm.command, 'release'],
+      ['mode', releaseConvergenceConfirm.mode, 'release-gate'],
+      ['ok', releaseConvergenceConfirm.ok, true],
+      ['release_gate.evidence.convergence_evidence_bound', releaseConvergenceConfirm.release_gate?.evidence?.convergence_evidence_bound, true],
+      ['release_gate.convergence_evidence.stage', releaseConvergenceConfirm.release_gate?.convergence_evidence?.stage, 'Stage 65'],
+      ['release_gate.convergence_evidence.report_kind', releaseConvergenceConfirm.release_gate?.convergence_evidence?.report_kind, 'capability-convergence-gap-report'],
+      ['release_gate.convergence_evidence.release_chain_required', releaseConvergenceConfirm.release_gate?.convergence_evidence?.release_chain_required, false],
+      ['safety.release_gate_artifact', releaseConvergenceConfirm.safety?.release_gate_artifact, true],
+    ], 'release --gate --with-convergence --confirm --json');
+    if (!releaseConvergenceGateFile || !fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'release-gates', releaseConvergenceGateFile))) throw new Error('release convergence gate confirm did not write release gate artifact');
+
+    const releaseConvergenceVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'release', '--verify-gate', releaseConvergenceGateFile, '--json', '--root', target], {}, options), 'release --verify-gate convergence --json');
+    assertJsonMarkers([
+      ['command', releaseConvergenceVerify.command, 'release'],
+      ['mode', releaseConvergenceVerify.mode, 'release-gate-verify'],
+      ['verification.ok', releaseConvergenceVerify.verification?.ok, true],
+      ['release_gate.evidence.convergence_evidence_bound', releaseConvergenceVerify.release_gate?.evidence?.convergence_evidence_bound, true],
+    ], 'release --verify-gate convergence --json');
+
+    const badConvergenceGatePath = path.join(absoluteTarget, '.vibecoding-state', 'release-gates', 'bad-convergence-drift.release-gate.json');
+    const badConvergenceGate = JSON.parse(fs.readFileSync(path.join(absoluteTarget, '.vibecoding-state', 'release-gates', releaseConvergenceGateFile), 'utf8'));
+    badConvergenceGate.release_gate.convergence_evidence.convergence_digest = '6'.repeat(64);
+    badConvergenceGate.release_gate.convergence_evidence.evidence_digest = '7'.repeat(64);
+    delete badConvergenceGate.release_gate.gate_digest;
+    badConvergenceGate.release_gate.gate_digest = digestObject(badConvergenceGate.release_gate);
+    fs.writeFileSync(badConvergenceGatePath, `${JSON.stringify(badConvergenceGate, null, 2)}\n`, 'utf8');
+    run('node', ['tools/vibe-runtime/index.mjs', 'release', '--verify-gate', 'bad-convergence-drift.release-gate.json', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['release gate verification failed:', 'release_gate convergence evidence digest mismatch', 'release_gate convergence report digest drift'],
+    }, options);
+    fs.rmSync(badConvergenceGatePath, { force: true });
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'release', '--verify-gate', releaseConvergenceGateFile, '--with-convergence', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['release --verify-gate does not accept --with-convergence'],
+    }, options);
+
+    const feedbackPreview = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'feedback', '--ledger', '--from-evals', contractReportFile, scenarioReportFile, behaviorReportFile, adversarialReportFile, '--from-release-gate', releaseGateFile, '--json', '--root', target], {}, options), 'feedback --ledger preview --json');
+    assertJsonMarkers([
+      ['command', feedbackPreview.command, 'feedback'],
+      ['mode', feedbackPreview.mode, 'feedback-ledger'],
+      ['ok', feedbackPreview.ok, true],
+      ['feedback_ledger.stage', feedbackPreview.feedback_ledger?.stage, 'Stage 53'],
+      ['feedback_ledger.ledger_kind', feedbackPreview.feedback_ledger?.ledger_kind, 'runtime-feedback-ledger'],
+      ['safety.writes', feedbackPreview.safety?.writes, false],
+    ], 'feedback --ledger preview --json');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'feedback-ledgers'))) throw new Error('feedback preview created unexpected feedback-ledgers directory');
+
+    const feedbackConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'feedback', '--ledger', '--from-evals', contractReportFile, scenarioReportFile, behaviorReportFile, adversarialReportFile, '--from-release-gate', releaseGateFile, '--confirm', '--json', '--root', target], {}, options), 'feedback --ledger --confirm --json');
+    const feedbackLedgerFile = feedbackConfirm.files?.feedback_ledger;
+    assertJsonMarkers([
+      ['command', feedbackConfirm.command, 'feedback'],
+      ['mode', feedbackConfirm.mode, 'feedback-ledger'],
+      ['ok', feedbackConfirm.ok, true],
+      ['feedback_ledger.stage', feedbackConfirm.feedback_ledger?.stage, 'Stage 53'],
+      ['feedback_ledger.ledger_kind', feedbackConfirm.feedback_ledger?.ledger_kind, 'runtime-feedback-ledger'],
+      ['safety.feedback_ledger_artifact', feedbackConfirm.safety?.feedback_ledger_artifact, true],
+      ['safety.git', feedbackConfirm.safety?.git, false],
+    ], 'feedback --ledger --confirm --json');
+    if (!feedbackLedgerFile || !fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'feedback-ledgers', feedbackLedgerFile))) throw new Error('feedback ledger confirm did not write feedback ledger artifact');
+
+    const feedbackVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'feedback', '--verify-ledger', feedbackLedgerFile, '--json', '--root', target], {}, options), 'feedback --verify-ledger --json');
+    assertJsonMarkers([
+      ['command', feedbackVerify.command, 'feedback'],
+      ['mode', feedbackVerify.mode, 'feedback-ledger-verify'],
+      ['verification.ok', feedbackVerify.verification?.ok, true],
+      ['summary.source_count', feedbackVerify.summary?.source_count, 5],
+    ], 'feedback --verify-ledger --json');
+
+    const badFeedbackLedgerPath = path.join(absoluteTarget, '.vibecoding-state', 'feedback-ledgers', 'bad-source-drift.feedback-ledger.json');
+    const badFeedbackLedger = JSON.parse(fs.readFileSync(path.join(absoluteTarget, '.vibecoding-state', 'feedback-ledgers', feedbackLedgerFile), 'utf8'));
+    badFeedbackLedger.feedback_ledger.sources[0].digest = '8'.repeat(64);
+    delete badFeedbackLedger.feedback_ledger.ledger_digest;
+    badFeedbackLedger.feedback_ledger.ledger_digest = digestObject(badFeedbackLedger.feedback_ledger);
+    fs.writeFileSync(badFeedbackLedgerPath, `${JSON.stringify(badFeedbackLedger, null, 2)}\n`, 'utf8');
+    run('node', ['tools/vibe-runtime/index.mjs', 'feedback', '--verify-ledger', 'bad-source-drift.feedback-ledger.json', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['feedback ledger verification failed:', 'source list drift'],
+    }, options);
+    fs.rmSync(badFeedbackLedgerPath, { force: true });
+
+    const badReleaseGatePath = path.join(absoluteTarget, '.vibecoding-state', 'release-gates', 'bad-source-drift.release-gate.json');
+    const badReleaseGate = JSON.parse(fs.readFileSync(path.join(absoluteTarget, '.vibecoding-state', 'release-gates', releaseGateFile), 'utf8'));
+    badReleaseGate.release_gate.sources[0].file_digest = '7'.repeat(64);
+    delete badReleaseGate.release_gate.gate_digest;
+    badReleaseGate.release_gate.gate_digest = digestObject(badReleaseGate.release_gate);
+    fs.writeFileSync(badReleaseGatePath, `${JSON.stringify(badReleaseGate, null, 2)}\n`, 'utf8');
+    run('node', ['tools/vibe-runtime/index.mjs', 'release', '--verify-gate', 'bad-source-drift.release-gate.json', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['release gate verification failed:', 'eval report digest drift'],
+    }, options);
+    fs.rmSync(badReleaseGatePath, { force: true });
+
+    const evalVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--verify', reportFile, '--json', '--root', target], {}, options), 'evals --verify report --json');
+    assertJsonMarkers([
+      ['command', evalVerify.command, 'evals'],
+      ['mode', evalVerify.mode, 'eval-artifact-verify'],
+      ['verification.ok', evalVerify.verification?.ok, true],
+      ['summary.artifact_mode', evalVerify.summary?.artifact_mode, 'eval-report'],
+    ], 'evals --verify report --json');
+
+    const badEvalRunPath = path.join(absoluteTarget, '.vibecoding-state', 'eval-runs', 'bad-followup.eval-run.json');
+    const badEvalRun = JSON.parse(fs.readFileSync(path.join(absoluteTarget, '.vibecoding-state', 'eval-runs', runFile), 'utf8'));
+    badEvalRun.eval_run.allowed_followup = ['eval-report-only', 'merge'];
+    delete badEvalRun.eval_run.run_digest;
+    badEvalRun.eval_run.run_digest = digestObject(badEvalRun.eval_run);
+    fs.writeFileSync(badEvalRunPath, `${JSON.stringify(badEvalRun, null, 2)}\n`, 'utf8');
+    run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--verify', 'bad-followup.eval-run.json', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['eval verification failed:', 'eval_run.allowed_followup must equal eval-report-only'],
+    }, options);
+    fs.rmSync(badEvalRunPath, { force: true });
+
+    const evalTrace = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'traces', '--build', '--confirm', '--json', '--root', target], {}, options), 'traces --build evals --confirm --json');
+    const evalTraceTypes = evalTrace.runtime_trace?.source_types || {};
+    if (!evalTraceTypes.eval_suites || !evalTraceTypes.eval_runs || !evalTraceTypes.eval_reports || !evalTraceTypes.release_gates || !evalTraceTypes.feedback_ledgers) throw new Error('eval trace did not include Stage 51/52/53 source types');
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}