@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-release-check/release-check-platform-transcript-smoke-fixture.mjs

@@ -0,0 +1,150 @@
+import path from 'node:path';
+
+import { runtimePlatformTranscriptReplay } from '../vibe-runtime/runtime-platform-transcript-replay-model.mjs';
+import {
+  assertNoSmokeState,
+  READ_ONLY_RUNTIME_CONTROL_FLAGS,
+  runForbiddenFlagChecks,
+  writeSmokeJsonFixture,
+} from './release-check-json-assertion-helpers.mjs';
+
+function runTranscriptIntakeJson({ run, parseJsonOutput }, target, transcriptFile, label, options) {
+  return parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--transcript-intake', '--from-file', transcriptFile, '--json', '--root', target], {}, options), `evals --transcript-intake ${label} --json`);
+}
+
+function runBehaviorContractJson({ run, parseJsonOutput }, target, fixtureFile, label, options) {
+  return parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--behavior-contract', '--from-file', fixtureFile, '--json', '--root', target], {}, options), `evals --behavior-contract ${label} --json`);
+}
+
+export function runPlatformTranscriptIntakeReplaySmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, target, options) {
+  const transcriptFile = path.join(target, 'p21-p23-platform-transcript.json');
+  const behaviorFixtureFile = path.join(target, 'p23-platform-transcript-behavior-fixture.json');
+  const unsafeTranscriptFile = path.join(target, 'p21-platform-transcript-unsafe-boundary.json');
+
+  writeSmokeJsonFixture(repoRoot, transcriptFile, platformTranscriptFixture());
+  writeSmokeJsonFixture(repoRoot, unsafeTranscriptFile, unsafePlatformTranscriptFixture());
+
+  const intake = runTranscriptIntakeJson({ run, parseJsonOutput }, target, transcriptFile, 'positive', options);
+  assertJsonMarkers([
+    ['command', intake.command, 'evals'],
+    ['mode', intake.mode, 'platform-transcript-intake'],
+    ['ok', intake.ok, true],
+    ['platform_transcript_intake.stage', intake.platform_transcript_intake?.stage, 'P21'],
+    ['platform_transcript_intake.intake_kind', intake.platform_transcript_intake?.intake_kind, 'platform-transcript-intake'],
+    ['platform_transcript_intake.input_summary.platform', intake.platform_transcript_intake?.input_summary?.platform, 'opencode'],
+    ['platform_transcript_intake.input_summary.turn_count', intake.platform_transcript_intake?.input_summary?.turn_count, 6],
+    ['platform_transcript_intake.boundary_assertions.transcript_intake_artifact', intake.platform_transcript_intake?.boundary_assertions?.transcript_intake_artifact, false],
+    ['platform_transcript_intake.boundary_assertions.normalized_transcript_artifact', intake.platform_transcript_intake?.boundary_assertions?.normalized_transcript_artifact, false],
+    ['platform_transcript_intake.boundary_assertions.command_execution', intake.platform_transcript_intake?.boundary_assertions?.command_execution, false],
+    ['platform_transcript_intake.boundary_assertions.platform_api', intake.platform_transcript_intake?.boundary_assertions?.platform_api, false],
+    ['platform_transcript_intake.boundary_assertions.model_invocation', intake.platform_transcript_intake?.boundary_assertions?.model_invocation, false],
+    ['platform_transcript_intake.boundary_assertions.subagent', intake.platform_transcript_intake?.boundary_assertions?.subagent, false],
+    ['safety.writes', intake.safety?.writes, false],
+    ['safety.platform_api', intake.safety?.platform_api, false],
+    ['safety.model_invocation', intake.safety?.model_invocation, false],
+    ['safety.subagent', intake.safety?.subagent, false],
+  ], 'evals --transcript-intake positive --json');
+  if (!intake.platform_transcript_intake?.intake_digest) throw new Error('platform transcript intake missing digest');
+  if (!intake.platform_transcript_intake?.source_binding?.digest) throw new Error('platform transcript intake missing source digest');
+  assertNoSmokeState(repoRoot, target, 'evals --transcript-intake positive');
+
+  const replay = runtimePlatformTranscriptReplay({ intake: intake.platform_transcript_intake });
+  assertJsonMarkers([
+    ['stage', replay.stage, 'P23'],
+    ['replay_kind', replay.replay_kind, 'platform-transcript-replay'],
+    ['ok', replay.ok, true],
+    ['input_summary.platform', replay.input_summary?.platform, 'opencode'],
+    ['input_summary.turn_count', replay.input_summary?.turn_count, 6],
+    ['behavior_fixture.transcript_kind', replay.behavior_fixture?.transcript_kind, 'platform-transcript-replay'],
+    ['replay_invariants.pass', replay.replay_invariants?.pass, true],
+    ['boundary_assertions.transcript_replay_artifact', replay.boundary_assertions?.transcript_replay_artifact, false],
+    ['boundary_assertions.behavior_fixture_artifact', replay.boundary_assertions?.behavior_fixture_artifact, false],
+    ['boundary_assertions.command_execution', replay.boundary_assertions?.command_execution, false],
+    ['boundary_assertions.platform_api', replay.boundary_assertions?.platform_api, false],
+    ['boundary_assertions.model_invocation', replay.boundary_assertions?.model_invocation, false],
+    ['boundary_assertions.subagent', replay.boundary_assertions?.subagent, false],
+  ], 'platform transcript replay pure model');
+  for (const row of ['entry_route', 'skill_claim_evidence', 'sdd_loop_evidence', 'review_blocker', 'resume_dedupe', 'completion_evidence', 'forbidden_action_boundary']) {
+    if (!replay.gap_matrix?.some((item) => item.row === row && item.pass === true)) throw new Error(`platform transcript replay missing passing row: ${row}`);
+  }
+
+  writeSmokeJsonFixture(repoRoot, behaviorFixtureFile, replay.behavior_fixture);
+  const behavior = runBehaviorContractJson({ run, parseJsonOutput }, target, behaviorFixtureFile, 'platform transcript replay fixture', options);
+  assertJsonMarkers([
+    ['command', behavior.command, 'evals'],
+    ['mode', behavior.mode, 'behavioral-evaluation-contract'],
+    ['ok', behavior.ok, true],
+    ['behavioral_evaluation_contract.behavior_gate.pass', behavior.behavioral_evaluation_contract?.behavior_gate?.pass, true],
+    ['behavioral_evaluation_contract.behavior_gate.failed_count', behavior.behavioral_evaluation_contract?.behavior_gate?.failed_count, 0],
+    ['safety.writes', behavior.safety?.writes, false],
+    ['safety.platform_api', behavior.safety?.platform_api, false],
+    ['safety.model_invocation', behavior.safety?.model_invocation, false],
+    ['safety.subagent', behavior.safety?.subagent, false],
+  ], 'evals --behavior-contract platform transcript replay fixture --json');
+  assertNoSmokeState(repoRoot, target, 'platform transcript replay behavior contract');
+
+  run('node', ['tools/vibe-runtime/index.mjs', 'evals', '--transcript-intake', '--from-file', unsafeTranscriptFile, '--json', '--root', target], {
+    allowFailure: true,
+    expectOutput: ['evals --transcript-intake blocked: boundary assertion must remain false: platform_api'],
+  }, options);
+  assertNoSmokeState(repoRoot, target, 'evals --transcript-intake unsafe boundary');
+
+  runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'evals', '--transcript-intake', '--from-file', transcriptFile], ['--root', target], READ_ONLY_RUNTIME_CONTROL_FLAGS, 'evals --transcript-intake is read-only', options);
+}
+
+function platformTranscriptFixture() {
+  return {
+    platform: 'opencode',
+    source: {
+      adapter: 'opencode',
+      export_kind: 'manual_local_transcript_json',
+      export_note: 'local fixture for release smoke',
+    },
+    turns: [
+      { role: 'system', content: 'Vibecoding bootstrap marker visible; using-vibecoding should route lightly with injectsFullSkill=false.' },
+      { role: 'user', content: 'Continue the accepted P21-P24 plan without re-asking.' },
+      { role: 'assistant', content: 'Route: using-vibecoding L1. Validation strategy: syntax, runtime-check, behavior smoke, architecture. Stop if boundaries expand.' },
+      { role: 'assistant', content: 'Task brief, review package, and implementer artifact are present with test and diff evidence bindings.' },
+      { role: 'reviewer', content: 'Review blocker recorded; do not advance to next task until it is resolved.' },
+      { role: 'assistant', content: 'Resume reads progress ledger once, avoids duplicate dispatch, and completion evidence is bound before claiming done.' },
+    ],
+    observed: {
+      commands: ['node tools/vibe-runtime/index.mjs evals --transcript-intake --from-file local-transcript.json --json'],
+      markers: ['using-vibecoding', 'injectsFullSkill=false', 'continue_without_reasking_required', 'continued_to_next_task=true', 'task_brief_present', 'review_package_present', 'implementer_artifact_present', 'review_blocker_present', 'dedupe_marker_present', 'completion_evidence_present'],
+      blocked_reasons: ['review blocker recorded'],
+      workflow_order: ['using-vibecoding', 'task_brief', 'review_package', 'implementer_artifact'],
+      claims: [{ type: 'completion', evidence: ['syntax_check', 'runtime_check'], skills: ['using-vibecoding'] }],
+    },
+    artifact_refs: [
+      { path: '.vibecoding/transcript-artifacts/sdd/example-task.md', digest: '0'.repeat(64), kind: 'task_brief' },
+      { path: '.vibecoding/transcript-artifacts/evidence/example-check.json', digest: '0'.repeat(64), kind: 'completion_evidence' },
+    ],
+    boundary_assertions: safeTranscriptBoundaries(),
+    export_digest: '1'.repeat(64),
+  };
+}
+
+function unsafePlatformTranscriptFixture() {
+  return {
+    ...platformTranscriptFixture(),
+    boundary_assertions: { ...safeTranscriptBoundaries(), platform_api: true },
+  };
+}
+
+function safeTranscriptBoundaries() {
+  return {
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    git: false,
+    git_write: false,
+    command_execution: false,
+    workflow_execution: false,
+    skill_execution: false,
+    runtime_action: false,
+    source_write: false,
+    business_source_write: false,
+  };
+}

package/tools/vibe-release-check/release-check-readonly-marker-data.mjs

@@ -0,0 +1 @@
+export { readonlySmokeMarkerSpecs } from './release-check-readonly-marker-smoke-specs.mjs';

package/tools/vibe-release-check/release-check-readonly-marker-smoke-specs.mjs

@@ -0,0 +1,170 @@
+export const readonlySmokeMarkerSpecs = {
+  automationReadiness: {
+    payloadKey: 'runtime_automation_readiness', payloadPrefix: 'runtime_automation_readiness', command: 'automation', mode: 'runtime-automation-readiness-matrix', stage: 'Stage 103', label: 'automation --readiness',
+    payloadSpecs: [['stage', 'Stage 103'], ['readiness_kind', 'runtime-automation-readiness-matrix'], ['registry_stage', 'Stage 101'], ['registry_kind', 'runtime-capability-registry'], ['registry_version', 47], ['category_counts.auto_safe', 79], ['category_counts.confirm_required', 23], ['category_counts.forbidden', 7], ['transition_contract.automation_readiness_only', true], ['transition_contract.automation_plan_created', false], ['transition_contract.one_shot_execution_created', false], ['readiness_invariants.pass', true], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['automation_readiness_artifact', 'automation_plan_artifact', 'one_shot_execution_artifact', 'command_execution', 'scheduler', 'daemon', 'subagent', 'business_source_write'],
+    safetyFields: ['automation_plan_artifact', 'one_shot_execution_artifact'],
+  },
+  workflowLoopContract: {
+    payloadKey: 'workflow_loop_contract', payloadPrefix: 'workflow_loop_contract', command: 'workflow', mode: 'workflow-loop-contract', stage: 'Stage 104', label: 'workflow --loop-contract',
+    payloadSpecs: [['stage', 'Stage 104'], ['contract_kind', 'workflow-loop-contract'], ['normalized_intent', 'implementation'], ['loop_phases.0', 'plan'], ['loop_phases.1', 'docs'], ['loop_phases.2', 'code'], ['loop_phases.3', 'self_test'], ['loop_phases.4', 'commit_readiness'], ['phase_contracts.0.phase', 'plan'], ['phase_contracts.4.phase', 'commit_readiness'], ['source_bindings.workflow_start_stage', 'Stage 93'], ['source_bindings.workflow_sequence_stage', 'Stage 94'], ['source_bindings.automation_readiness_stage', 'Stage 103'], ['source_bindings.registry_stage', 'Stage 101'], ['loop_contract_invariants.pass', true], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['workflow_loop_contract_artifact', 'automation_plan_artifact', 'command_execution', 'git', 'push', 'pr', 'merge'],
+    safetyFields: ['command_execution', 'git', 'push', 'pr', 'merge'],
+  },
+  superpowersGap: {
+    payloadKey: 'superpowers_gap_matrix', payloadPrefix: 'superpowers_gap_matrix', command: 'governance', mode: 'superpowers-gap-matrix', stage: 'Stage 115', label: 'governance --superpowers-gap',
+    payloadSpecs: [['stage', 'Stage 115'], ['gap_kind', 'superpowers-gap-matrix'], ['comparison_target', 'fork/superpowers'], ['registry_binding.registry_stage', 'Stage 101'], ['registry_binding.registry_kind', 'runtime-capability-registry'], ['registry_binding.registry_version', 47], ['gap_matrix_invariants.pass', true], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['superpowers_gap_artifact', 'command_execution', 'skill_execution', 'git_write', 'commit', 'pr', 'push', 'merge', 'platform_api', 'external_network', 'model_invocation', 'subagent', 'mcp', 'business_source_write'],
+    safetyFields: ['command_execution', 'subagent'],
+  },
+  progressiveEntryUx: {
+    payloadKey: 'progressive_entry_ux', payloadPrefix: 'progressive_entry_ux', command: 'workflow', mode: 'progressive-entry-ux-contract', stage: 'Stage 116', label: 'workflow --entry-ux',
+    payloadSpecs: [['stage', 'Stage 116'], ['contract_kind', 'progressive-entry-ux-contract'], ['normalized_intent', 'implementation'], ['recommended_workflow', 'vibe-executing-plans -> vibe-review -> vibe-implementation'], ['bootstrap_policy.injectsFullSkill', false], ['bootstrap_policy.marker', 'injectsFullSkill=false'], ['bootstrap_policy.session_create', false], ['bootstrap_policy.skill_execution_claimed', false], ['source_bindings.gap_matrix_provided', false], ['source_bindings.gap_file_status', 'not_provided'], ['entry_ux_invariants.pass', true], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['progressive_entry_ux_artifact', 'command_execution', 'skill_execution', 'workflow_execution', 'runtime_action', 'git_write', 'commit', 'subagent', 'mcp'],
+    safetyFields: ['command_execution', 'skill_execution', 'subagent'],
+  },
+  executablePlan: {
+    payloadKey: 'executable_plan_contract', payloadPrefix: 'executable_plan_contract', command: 'planner', mode: 'executable-plan-quality-contract', stage: 'Stage 117', label: 'planner --executable-plan',
+    payloadSpecs: [['stage', 'Stage 117'], ['contract_kind', 'executable-plan-quality-contract'], ['plan_quality_score', 100], ['plan_quality_pass', true], ['task_quality_contract.pass', true], ['task_quality_contract.blocking_gaps_only', true], ['task_quality_contract.auto_repair', false], ['task_quality_contract.plan_mutation', false], ['failure_mode.blocking_gaps_only', true], ['failure_mode.auto_repair', false], ['failure_mode.plan_mutation', false], ['executable_plan_invariants.pass', true], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['executable_plan_artifact', 'plan_repair_artifact', 'source_write', 'command_execution', 'check_execution', 'test_execution', 'repair_execution', 'action_item_execution', 'git_write', 'commit', 'subagent', 'mcp'],
+    safetyFields: ['command_execution', 'subagent'],
+  },
+  stageRunbook: {
+    payloadKey: 'sequential_stage_runbook', payloadPrefix: 'sequential_stage_runbook', command: 'automation', mode: 'sequential-stage-runbook', stage: 'Stage 118', label: 'automation --stage-runbook',
+    payloadSpecs: [['stage', 'Stage 118'], ['runbook_kind', 'sequential-stage-runbook'], ['source_bindings.executable_plan_stage', 'Stage 117'], ['source_bindings.executable_plan_kind', 'executable-plan-quality-contract'], ['source_bindings.executable_plan_quality_pass', true], ['source_bindings.registry_version', 47], ['ready_for_evidence_binding', true], ['stage_order_gate.gate_kind', 'sequential-stage-order-gate'], ['stage_order_gate.pass', true], ['stage_order_gate.order_is_sequential', true], ['stage_order_gate.auto_execution', false], ['stage_order_gate.command_execution', false], ['stage_order_gate.git_write', false], ['runbook_invariants.pass', true], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['stage_runbook_artifact', 'runbook_artifact', 'source_write', 'plan_mutation', 'command_execution', 'check_execution', 'test_execution', 'runtime_action', 'git_write', 'commit', 'subagent', 'mcp'],
+    safetyFields: ['command_execution', 'subagent'],
+  },
+  adapterBootstrapMatrix: {
+    payloadKey: 'adapter_bootstrap_matrix', payloadPrefix: 'adapter_bootstrap_matrix', command: 'platforms', mode: 'adapter-bootstrap-conformance-matrix', stage: 'Stage 122', label: 'platforms --bootstrap-matrix',
+    payloadSpecs: [['stage', 'Stage 122'], ['matrix_kind', 'adapter-bootstrap-conformance-matrix'], ['ok', true], ['adapter_bootstrap_invariants.pass', true], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['bootstrap_matrix_artifact', 'adapter_install', 'hook_execution', 'git', 'platform_api', 'subagent'],
+    safetyFields: ['writes', 'adapter_install', 'hook_execution', 'git', 'platform_api', 'subagent'],
+  },
+  skillRuntimeTraceability: {
+    payloadKey: 'skill_runtime_traceability_map', payloadPrefix: 'skill_runtime_traceability_map', command: 'governance', mode: 'skill-to-runtime-traceability-map', stage: 'Stage 123', label: 'governance --traceability-map',
+    payloadSpecs: [['stage', 'Stage 123'], ['map_kind', 'skill-to-runtime-traceability-map'], ['ok', true], ['skill_runtime_traceability_invariants.pass', true], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['traceability_map_artifact', 'skill_write', 'command_execution', 'check_execution', 'test_execution', 'git', 'platform_api', 'subagent'],
+    safetyFields: ['writes', 'traceability_map_artifact', 'skill_write', 'command_execution', 'check_execution', 'test_execution', 'git', 'platform_api', 'subagent'],
+  },
+  superpowersRegressionGuard: {
+    payloadKey: 'superpowers_regression_guard', payloadPrefix: 'superpowers_regression_guard', command: 'governance', mode: 'superpowers-regression-guard', stage: 'Stage 125', label: 'governance --superpowers-regression-guard',
+    payloadSpecs: [['stage', 'Stage 125'], ['guard_kind', 'superpowers-regression-guard'], ['comparison_target', 'fork/superpowers'], ['source_bindings.gap_matrix_stage', 'Stage 115'], ['source_bindings.gap_matrix_kind', 'superpowers-gap-matrix'], ['source_bindings.registry_stage', 'Stage 101'], ['source_bindings.registry_kind', 'runtime-capability-registry'], ['source_bindings.registry_version', 47], ['source_bindings.traceability_stage', 'Stage 123'], ['source_bindings.traceability_kind', 'skill-to-runtime-traceability-map'], ['regression_guard_invariants.pass', true], ['superiority_claim', 'guarded-superiority'], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['superpowers_regression_guard_artifact', 'superpowers_gap_artifact', 'traceability_map_artifact', 'automation_readiness_artifact', 'capability_registry_artifact', 'command_execution', 'check_execution', 'test_execution', 'skill_execution', 'git_write', 'platform_api', 'external_network', 'subagent', 'business_source_write'],
+    safetyFields: ['command_execution', 'check_execution', 'test_execution', 'subagent'],
+  },
+  experienceFriction: {
+    payloadKey: 'experience_friction_matrix', payloadPrefix: 'experience_friction_matrix', command: 'governance', mode: 'experience-friction-matrix', stage: 'Stage 126', label: 'governance --experience-friction',
+    payloadSpecs: [['stage', 'Stage 126'], ['matrix_kind', 'experience-friction-matrix'], ['source_bindings.input_file', 'stage126-session-evidence.json'], ['source_bindings.evidence_kind', 'session-evidence'], ['source_bindings.case_id', 'stage126-daily-friction'], ['experience_friction_invariants.pass', true], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['experience_friction_artifact', 'command_execution', 'check_execution', 'test_execution', 'skill_execution', 'runtime_action', 'git', 'git_write', 'commit', 'pr', 'push', 'merge', 'platform_api', 'external_network', 'model_invocation', 'subagent', 'mcp', 'business_source_write'],
+    safetyFields: ['command_execution', 'subagent'],
+  },
+  nextActionConsole: {
+    payloadKey: 'next_action_console', payloadPrefix: 'next_action_console', command: 'workflow', mode: 'one-screen-next-action-console', stage: 'Stage 127', label: 'workflow --next-action-console',
+    payloadSpecs: [['stage', 'Stage 127'], ['console_kind', 'one-screen-next-action-console'], ['source_bindings.friction_file', 'stage126-friction.json'], ['source_bindings.runbook_file', 'stage118-runbook.json'], ['source_bindings.evidence_file', 'stage119-evidence.json'], ['current_position.stage', 'Stage 127'], ['current_position.friction_level', 'high'], ['recommended_next_action.target_stage', 'Stage 127'], ['next_action_console_invariants.pass', true], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['next_action_console_artifact', 'command_execution', 'check_execution', 'test_execution', 'workflow_execution', 'skill_execution', 'runtime_action', 'evidence_write', 'git', 'git_write', 'commit', 'pr', 'push', 'merge', 'platform_api', 'external_network', 'model_invocation', 'subagent', 'mcp', 'business_source_write'],
+    safetyFields: ['command_execution', 'subagent'],
+  },
+  tokenSaviorBudget: {
+    payloadKey: 'token_savior_budget', payloadPrefix: 'token_savior_budget', command: 'tokens', mode: 'token-savior-entry-budget-contract', stage: 'Stage 128', label: 'tokens --savior-budget',
+    payloadSpecs: [['stage', 'Stage 128'], ['budget_kind', 'token-savior-entry-budget-contract'], ['recommended_profile', 'tiny_entry'], ['friction_summary.provided', true], ['friction_summary.top_friction', 'token_overhead'], ['token_savior_budget_invariants.pass', true], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['token_savior_budget_artifact', 'command_execution', 'workflow_execution', 'skill_execution', 'runtime_action', 'dynamic_tool_execution', 'embeddings', 'remote_config', 'shell_interception', 'command_mutation', 'git', 'git_write', 'commit', 'pr', 'push', 'merge', 'platform_api', 'external_network', 'model_invocation', 'subagent', 'mcp', 'business_source_write'],
+    safetyFields: ['command_execution', 'subagent'],
+  },
+  experienceLearningPattern: {
+    payloadKey: 'experience_learning_pattern', payloadPrefix: 'experience_learning_pattern', command: 'learning', mode: 'ecc-learning-experience-pattern-gate', stage: 'Stage 129', label: 'learning --experience-pattern',
+    payloadSpecs: [['stage', 'Stage 129'], ['pattern_kind', 'ecc-learning-experience-pattern-gate'], ['source_bindings.friction_file', 'stage126-friction.json'], ['friction_summary.provided', true], ['friction_summary.top_friction', 'next_action_unclear'], ['observation_summary.provided', false], ['repeat_signal.detected', true], ['promotion_required', true], ['promotion_boundary.automatic_promotion', false], ['promotion_boundary.writes_formal_skills', false], ['experience_pattern_invariants.pass', true], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['experience_pattern_artifact', 'learning_observation_write', 'candidate_instinct_write', 'learning_promotion_write', 'skill_write', 'writes_formal_skills', 'writes_agents_md', 'writes_claude_md', 'prompt_mutation', 'hook_registration', 'command_execution', 'workflow_execution', 'skill_execution', 'runtime_action', 'automatic_promotion', 'agent_first_delegation', 'git', 'git_write', 'commit', 'pr', 'push', 'merge', 'platform_api', 'external_network', 'model_invocation', 'subagent', 'mcp', 'business_source_write'],
+    safetyFields: ['command_execution', 'subagent'],
+  },
+  entryTriggerDiscipline: {
+    payloadKey: 'entry_trigger_discipline', payloadPrefix: 'entry_trigger_discipline', command: 'workflow', mode: 'entry-trigger-discipline-contract', stage: 'Stage 135', label: 'workflow --entry-discipline',
+    payloadSpecs: [['stage', 'Stage 135'], ['discipline_kind', 'entry-trigger-discipline-contract'], ['intent', 'feature'], ['source_bindings.transcript_file', 'good-transcript.json'], ['protocol_layers.l0_lightweight_routing', true], ['protocol_layers.l1_full_workflow_when_risky', true], ['protocol_layers.l2_confirmed_execution_only', true], ['expected_route.first_gate', 'using-vibecoding'], ['pass', true], ['entry_discipline_invariants.pass', true], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['entry_discipline_artifact', 'transcript_write', 'prompt_mutation', 'command_execution', 'check_execution', 'test_execution', 'workflow_execution', 'skill_execution', 'runtime_action', 'auto_execution', 'git', 'git_write', 'commit', 'pr', 'push', 'merge', 'platform_api', 'external_network', 'model_invocation', 'subagent', 'mcp', 'business_source_write'],
+    safetyFields: ['command_execution', 'workflow_execution', 'skill_execution', 'subagent'],
+  },
+  sessionStartShape: {
+    payloadKey: 'session_start_shape_acceptance', payloadPrefix: 'session_start_shape_acceptance', command: 'platforms', mode: 'session-start-shape-acceptance', stage: 'Stage 134', label: 'platforms --session-start-shape',
+    payloadSpecs: [['stage', 'Stage 134'], ['acceptance_kind', 'session-start-shape-acceptance'], ['adapter', 'claude'], ['output_summary.context_path', 'hookSpecificOutput.additionalContext'], ['context_markers.using_vibecoding', true], ['context_markers.lightweight_routing', true], ['context_markers.boundary_declaration', true], ['context_markers.full_skill_injection', false], ['accepted', true], ['session_start_shape_invariants.pass', true], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['session_start_shape_artifact', 'captured_output_write', 'adapter_execution', 'hook_execution', 'command_execution', 'check_execution', 'test_execution', 'workflow_execution', 'skill_execution', 'runtime_action', 'auto_execution', 'platform_api', 'external_network', 'model_invocation', 'subagent', 'mcp', 'git', 'git_write', 'commit', 'pr', 'push', 'merge', 'business_source_write'],
+    safetyFields: ['command_execution', 'hook_execution', 'subagent'],
+  },
+  stageScriptlet: {
+    payloadKey: 'stage_scriptlet', payloadPrefix: 'stage_scriptlet', command: 'automation', mode: 'copy-ready-stage-execution-scriptlet', stage: 'Stage 130', label: 'automation --stage-scriptlet',
+    payloadSpecs: [['stage', 'Stage 130'], ['scriptlet_kind', 'copy-ready-stage-execution-scriptlet'], ['source_bindings.runbook_file', 'stage118-runbook.json'], ['source_bindings.console_file', 'stage127-console.json'], ['target_stage', 'stage130-fixture-01'], ['selected_stage_count', 1], ['runbook_summary.provided', true], ['console_summary.provided', true], ['copy_boundary.copy_ready', true], ['copy_boundary.preview_only', true], ['copy_boundary.execution_authorized', false], ['copy_boundary.commands_executed', false], ['copy_boundary.evidence_written', false], ['copy_boundary.git_write_authorized', false], ['stage_scriptlet_invariants.pass', true], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['stage_scriptlet_artifact', 'evidence_write', 'command_execution', 'check_execution', 'smoke_execution', 'test_execution', 'validation_execution', 'git', 'git_write', 'git_add', 'commit', 'pr', 'push', 'merge', 'platform_api', 'external_network', 'model_invocation', 'subagent', 'mcp', 'business_source_write'],
+    safetyFields: ['command_execution', 'subagent'],
+  },
+  planActionManifest: {
+    payloadKey: 'plan_action_manifest', payloadPrefix: 'plan_action_manifest', command: 'planner', mode: 'plan-action-manifest', stage: 'Stage 105', label: 'planner --action-manifest',
+    payloadSpecs: [['stage', 'Stage 105'], ['manifest_kind', 'plan-to-action-manifest'], ['source_bindings.plan_lint_stage', 'Stage 86'], ['source_bindings.workflow_loop_contract_stage', 'Stage 104'], ['source_bindings.automation_readiness_stage', 'Stage 103'], ['source_bindings.registry_stage', 'Stage 101'], ['action_items.0.execution_authorized', false], ['docs_expectations.0.execution_authorized', false], ['code_expectations.0.execution_authorized', false], ['check_expectations.0.execution_authorized', false], ['manifest_invariants.pass', true], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['plan_action_manifest_artifact', 'automation_plan_artifact', 'command_execution', 'test_execution', 'git', 'push', 'pr', 'merge'],
+    safetyFields: ['command_execution', 'test_execution', 'git', 'push', 'pr', 'merge'],
+  },
+  selfTestProfile: {
+    payloadKey: 'self_test_gate_profile', payloadPrefix: 'self_test_gate_profile', command: 'verification', mode: 'self-test-gate-profile', stage: 'Stage 106', label: 'verification --self-test-profile',
+    payloadSpecs: [['stage', 'Stage 106'], ['profile_kind', 'self-test-gate-profile'], ['source_bindings.plan_action_manifest_stage', 'Stage 105'], ['source_bindings.registry_stage', 'Stage 101'], ['source_bindings.registry_version', 47], ['gate_items.0.status', 'planned_not_run'], ['gate_items.0.execution_authorized', false], ['coverage.has_syntax_gate', true], ['coverage.has_runtime_contract_gate', true], ['coverage.has_release_contract_gate', true], ['coverage.has_diff_hygiene_gate', true], ['evidence_requirements.0.completion_claim_allowed_without_evidence', false], ['profile_invariants.pass', true], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['self_test_gate_profile_artifact', 'test_result_artifact', 'command_execution', 'test_execution', 'git', 'push', 'pr', 'merge'],
+    safetyFields: ['command_execution', 'test_execution', 'git', 'push', 'pr', 'merge'],
+  },
+  commitReadiness: {
+    payloadKey: 'commit_readiness', payloadPrefix: 'commit_readiness', command: 'release', mode: 'commit-readiness-envelope', stage: 'Stage 107', label: 'release --commit-readiness',
+    payloadSpecs: [['stage', 'Stage 107'], ['readiness_kind', 'commit-readiness-envelope'], ['source_bindings.plan_action_manifest_stage', 'Stage 105'], ['source_bindings.self_test_gate_profile_stage', 'Stage 106'], ['source_bindings.commit_guard_stage', 'Stage 98'], ['source_bindings.registry_stage', 'Stage 101'], ['source_bindings.registry_version', 47], ['commit_subject.guard_pass', true], ['commit_subject.subject_count', 1], ['commit_subject.commit_execution_authorized', false], ['worktree_snapshot_requirements.git_command_execution', false], ['worktree_snapshot_requirements.collected_by_stage_107', false], ['readiness_gates.0.status', 'ready'], ['readiness_gates.0.execution_authorized', false], ['readiness_gates.0.commit_execution_authorized', false], ['readiness_gates.3.status', 'evidence_required'], ['evidence_bundle_requirements.evidence_bundle_complete', false], ['evidence_bundle_requirements.completion_claim_allowed_without_evidence', false], ['readiness_state.envelope_valid', true], ['readiness_state.commit_ready', false], ['readiness_state.manual_evidence_required', true], ['readiness_state.commit_execution_authorized', false], ['readiness_invariants.pass', true], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['commit_readiness_artifact', 'commit_artifact', 'command_execution', 'test_execution', 'git', 'git_write', 'commit', 'push', 'pr', 'merge'],
+    safetyFields: ['command_execution', 'test_execution', 'git', 'git_write', 'commit', 'push', 'pr', 'merge'],
+  },
+  confirmedOneShotPlan: {
+    payloadKey: 'confirmed_one_shot_plan', payloadPrefix: 'confirmed_one_shot_plan', command: 'automation', mode: 'confirmed-one-shot-plan', stage: 'Stage 108', label: 'automation --one-shot-plan',
+    payloadSpecs: [['stage', 'Stage 108'], ['plan_kind', 'confirmed-one-shot-execution-plan'], ['source_bindings.commit_readiness_stage', 'Stage 107'], ['source_bindings.automation_readiness_stage', 'Stage 103'], ['source_bindings.registry_stage', 'Stage 101'], ['source_bindings.registry_version', 47], ['confirmation_gate.confirm_plan_received', true], ['confirmation_gate.actions_executed', false], ['confirmation_gate.execution_authorized', false], ['execution_contract.plan_confirmed', true], ['execution_contract.confirmation_does_not_execute', true], ['execution_contract.actions_executed', false], ['execution_contract.execution_authorized', false], ['execution_contract.check_execution_authorized', false], ['execution_contract.git_write_authorized', false], ['planned_steps.0.status', 'planned_not_executed'], ['planned_steps.0.actions_executed', false], ['planned_steps.0.execution_authorized', false], ['preflight_evidence_expectations.0.collected_by_stage_108', false], ['preflight_evidence_expectations.0.execution_authorized', false], ['readiness_state.plan_confirmed', true], ['readiness_state.actions_executed', false], ['readiness_state.execution_authorized', false], ['readiness_state.ready_for_runtime_execution', false], ['plan_invariants.pass', true], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['confirmed_one_shot_plan_artifact', 'one_shot_execution_plan_artifact', 'one_shot_execution_artifact', 'command_execution', 'test_execution', 'git', 'git_write', 'commit', 'push', 'pr', 'merge'],
+    safetyFields: ['command_execution', 'test_execution', 'git', 'git_write', 'commit', 'push', 'pr', 'merge'],
+  },
+  adapterEntryAcceptance: {
+    payloadKey: 'adapter_entry_acceptance', payloadPrefix: 'adapter_entry_acceptance', command: 'platforms', mode: 'adapter-entry-acceptance-contract', stage: 'Stage 131', label: 'platforms --entry-acceptance',
+    payloadSpecs: [['stage', 'Stage 131'], ['acceptance_kind', 'adapter-entry-acceptance-contract'], ['adapter', 'cursor'], ['accepted', true], ['acceptance_score', 100], ['source_bindings.transcript_file', 'stage131-transcript.json'], ['transcript_summary.entry_skill', 'using-vibecoding'], ['adapter_entry_acceptance_invariants.pass', true], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['entry_acceptance_artifact', 'transcript_write', 'adapter_install', 'adapter_execution', 'hook_execution', 'command_execution', 'workflow_execution', 'skill_execution', 'runtime_action', 'auto_execution', 'platform_api', 'external_network', 'model_invocation', 'subagent', 'mcp', 'git', 'git_write', 'business_source_write'],
+    safetyFields: ['adapter_execution', 'hook_execution', 'subagent'],
+  },
+  experienceDashboard: {
+    payloadKey: 'experience_regression_dashboard', payloadPrefix: 'experience_regression_dashboard', command: 'governance', mode: 'experience-regression-dashboard', stage: 'Stage 132', label: 'governance --experience-dashboard',
+    payloadSpecs: [['stage', 'Stage 132'], ['dashboard_kind', 'experience-regression-dashboard'], ['source_bindings.friction_file', 'stage126-friction.json'], ['source_bindings.console_file', 'stage127-console.json'], ['source_bindings.token_budget_file', 'stage128-token-budget.json'], ['source_bindings.learning_pattern_file', 'stage129-learning-pattern.json'], ['experience_scorecard.overall_experience_score', 90], ['experience_scorecard.rating', 'strong'], ['superpowers_comparison_delta.status', 'parity-protected'], ['token_savior_delta.status', 'budget-bound'], ['token_savior_delta.recommended_profile', 'tiny_entry'], ['learning_loop_delta.status', 'candidate-only'], ['daily_user_friction_delta.status', 'reduced'], ['next_bet.id', 'experience-loop-ready'], ['experience_dashboard_invariants.pass', true], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['experience_dashboard_artifact', 'regression_dashboard_artifact', 'command_execution', 'check_execution', 'smoke_execution', 'test_execution', 'workflow_execution', 'skill_execution', 'evidence_write', 'dashboard_write', 'dynamic_tool_execution', 'embeddings', 'remote_config', 'platform_api', 'external_network', 'model_invocation', 'subagent', 'mcp', 'git', 'git_write', 'git_add', 'commit', 'pr', 'push', 'merge', 'business_source_write'],
+    safetyFields: ['command_execution', 'subagent'],
+  },
+  superpowersComparison: {
+    payloadKey: 'superpowers_comparison_matrix', payloadPrefix: 'superpowers_comparison_matrix', command: 'governance', mode: 'superpowers-comparative-evidence-matrix', stage: 'Stage 133', label: 'governance --superpowers-comparison',
+    payloadSpecs: [['stage', 'Stage 133'], ['comparison_kind', 'superpowers-comparative-evidence-matrix'], ['comparison_target', 'fork/superpowers'], ['source_bindings.superpowers_root', 'fork/superpowers'], ['registry_binding.registry_stage', 'Stage 101'], ['registry_binding.registry_kind', 'runtime-capability-registry'], ['registry_binding.registry_version', 47], ['superpowers_comparison_invariants.pass', true], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['superpowers_comparison_artifact', 'comparison_matrix_artifact', 'source_write', 'sidecar_write', 'command_execution', 'check_execution', 'smoke_execution', 'test_execution', 'verification_execution', 'hook_execution', 'workflow_execution', 'skill_execution', 'runtime_action', 'auto_execution', 'repair_execution', 'prompt_mutation', 'hook_registration', 'dynamic_tool_execution', 'embeddings', 'remote_config', 'platform_api', 'external_network', 'model_invocation', 'subagent', 'mcp', 'git', 'git_write', 'git_add', 'commit', 'pr', 'push', 'merge', 'business_source_write'],
+    safetyFields: ['command_execution', 'hook_execution', 'subagent'],
+  },
+  methodologyCoverage: {
+    payloadKey: 'methodology_coverage_map', payloadPrefix: 'methodology_coverage_map', command: 'methodology', mode: 'methodology-coverage-map', stage: 'Stage 136', label: 'methodology --coverage-map',
+    payloadSpecs: [['stage', 'Stage 136'], ['coverage_kind', 'methodology-coverage-map'], ['comparison_target', 'fork/superpowers'], ['source_bindings.superpowers_root', 'fork/superpowers'], ['registry_binding.registry_stage', 'Stage 101'], ['registry_binding.registry_kind', 'runtime-capability-registry'], ['registry_binding.registry_version', 47], ['methodology_coverage_invariants.pass', true], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['methodology_coverage_artifact', 'coverage_map_artifact', 'source_write', 'sidecar_write', 'command_execution', 'check_execution', 'smoke_execution', 'test_execution', 'hook_execution', 'adapter_execution', 'workflow_execution', 'skill_execution', 'runtime_action', 'auto_execution', 'prompt_mutation', 'skill_mutation', 'platform_api', 'external_network', 'model_invocation', 'subagent', 'mcp', 'git', 'git_write', 'git_add', 'commit', 'pr', 'push', 'merge', 'business_source_write'],
+    safetyFields: ['command_execution', 'skill_execution', 'subagent'],
+  },
+  closeLoopDashboard: {
+    payloadKey: 'close_loop_dashboard', payloadPrefix: 'close_loop_dashboard', command: 'workflow', mode: 'close-loop-dashboard', stage: 'Stage 109', label: 'workflow --close-loop-dashboard',
+    payloadSpecs: [['stage', 'Stage 109'], ['dashboard_kind', 'close-loop-dashboard'], ['source_bindings.plan_action_manifest_stage', 'Stage 105'], ['source_bindings.self_test_gate_profile_stage', 'Stage 106'], ['source_bindings.commit_readiness_stage', 'Stage 107'], ['source_bindings.confirmed_one_shot_plan_stage', 'Stage 108'], ['source_bindings.automation_readiness_stage', 'Stage 103'], ['source_bindings.registry_stage', 'Stage 101'], ['source_bindings.registry_version', 47], ['plan_status.pass', true], ['plan_status.execution_authorized', false], ['self_test_status.all_gates_planned_not_run', true], ['self_test_status.test_execution_authorized', false], ['commit_status.subject_guard_pass', true], ['commit_status.commit_ready', false], ['commit_status.commit_execution_authorized', false], ['one_shot_status.confirmation_provided', true], ['one_shot_status.plan_confirmed', true], ['one_shot_status.ready_for_runtime_execution', false], ['one_shot_status.actions_executed', false], ['one_shot_status.execution_authorized', false], ['dashboard_invariants.pass', true], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['close_loop_dashboard_artifact', 'command_execution', 'test_execution', 'check_execution', 'git', 'git_write', 'commit', 'push', 'pr', 'merge'],
+    safetyFields: ['command_execution', 'test_execution', 'git', 'git_write', 'commit', 'push', 'pr', 'merge'],
+  },
+  evidenceIntake: {
+    payloadKey: 'evidence_intake', payloadPrefix: 'evidence_intake', command: 'verification', mode: 'evidence-intake-envelope', stage: 'Stage 110', label: 'verification --evidence-intake',
+    payloadSpecs: [['stage', 'Stage 110'], ['intake_kind', 'evidence-intake-envelope'], ['source_bindings.plan_action_manifest_stage', 'Stage 105'], ['source_bindings.self_test_gate_profile_stage', 'Stage 106'], ['source_bindings.registry_stage', 'Stage 101'], ['source_bindings.registry_version', 47], ['evidence_intake.check_count', 4], ['evidence_intake.structure_valid', true], ['evidence_intake.freshness_valid', true], ['evidence_intake.gate_coverage_complete', true], ['evidence_intake.commands_executed_by_stage_110', false], ['evidence_items.0.command_executed_by_stage_110', false], ['evidence_items.0.execution_authorized', false], ['gate_coverage.coverage_complete', true], ['evidence_intake_invariants.pass', true], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['evidence_intake_artifact', 'evidence_artifact_write', 'command_execution', 'check_execution', 'test_execution', 'git', 'git_write', 'commit', 'push', 'pr', 'merge'],
+    safetyFields: ['command_execution', 'check_execution', 'test_execution', 'git', 'git_write', 'commit', 'push', 'pr', 'merge'],
+  },
+  diffCoverage: {
+    payloadKey: 'diff_coverage', payloadPrefix: 'diff_coverage', command: 'release', mode: 'diff-coverage-envelope', stage: 'Stage 111', label: 'release --diff-coverage',
+    payloadSpecs: [['stage', 'Stage 111'], ['coverage_kind', 'diff-coverage-envelope'], ['source_bindings.plan_action_manifest_stage', 'Stage 105'], ['source_bindings.registry_stage', 'Stage 101'], ['source_bindings.registry_version', 47], ['diff_coverage.expected_file_count', 8], ['diff_coverage.coverage_complete', true], ['diff_coverage.git_executed_by_stage_111', false], ['diff_coverage.diff_generated_by_stage_111', false], ['diff_coverage.execution_authorized', false], ['missing_expected_files.length', 0], ['unexpected_files.length', 0], ['diff_coverage_invariants.pass', true], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['diff_coverage_artifact', 'diff_artifact_write', 'command_execution', 'git', 'git_write', 'commit', 'push', 'pr', 'merge'],
+    safetyFields: ['command_execution', 'git', 'git_write', 'commit', 'push', 'pr', 'merge'],
+  },
+  tddTrace: {
+    payloadKey: 'tdd_trace_contract', payloadPrefix: 'tdd_trace_contract', command: 'verification', mode: 'tdd-trace-contract', stage: 'Stage 113', label: 'verification --tdd-trace',
+    payloadSpecs: [['stage', 'Stage 113'], ['trace_kind', 'tdd-trace-contract'], ['source_bindings.plan_action_manifest_stage', 'Stage 105'], ['source_bindings.registry_stage', 'Stage 101'], ['source_bindings.registry_version', 47], ['tdd_trace_contract.cycle_order_valid', true], ['tdd_trace_contract.red_verified', true], ['tdd_trace_contract.green_verified', true], ['tdd_trace_contract.refactor_verified', true], ['tdd_trace_contract.test_execution_by_stage_113', false], ['tdd_trace_contract.command_execution_by_stage_113', false], ['red_verified.expected_failure', true], ['red_verified.command_executed_by_stage_113', false], ['green_verified.command_executed_by_stage_113', false], ['refactor_verified.command_executed_by_stage_113', false], ['coverage.coverage_complete', true], ['tdd_trace_invariants.pass', true], ['writes', false], ['state_directory_created', false]],
+    boundaryFields: ['tdd_trace_artifact', 'test_result_artifact', 'command_execution', 'check_execution', 'test_execution', 'repair_execution', 'git', 'git_write', 'commit', 'push', 'pr', 'merge'],
+    safetyFields: [],
+  },
+};

package/tools/vibe-release-check/release-check-run-summary.mjs

@@ -0,0 +1,67 @@
+export function commandResultSummary(display, result, startedAt, acceptedFailure = false) {
+  return {
+    display,
+    status: result.status,
+    duration_ms: Date.now() - startedAt,
+    accepted_failure: acceptedFailure,
+    stdout_length: String(result.stdout || '').length,
+    stderr_length: String(result.stderr || '').length,
+  };
+}
+
+export function attachCommandResult(results, display, result, startedAt, acceptedFailure = false) {
+  result.commandResult = commandResultSummary(display, result, startedAt, acceptedFailure);
+  results.push(result.commandResult);
+  return result;
+}
+
+export function timingByRuntimeSuiteLayer(timing = []) {
+  const layers = new Map();
+  for (const entry of timing) {
+    const layer = entry.runtimeSuiteLayer || 'unclassified';
+    const current = layers.get(layer) || { layer, command_count: 0, duration_ms: 0 };
+    current.command_count += 1;
+    current.duration_ms += entry.durationMs || 0;
+    layers.set(layer, current);
+  }
+  return [...layers.values()].sort((left, right) => right.duration_ms - left.duration_ms);
+}
+
+export function releaseCheckDiagnostics(commands = [], timing = []) {
+  const slowestCommands = [...commands]
+    .sort((left, right) => (right.duration_ms || 0) - (left.duration_ms || 0))
+    .slice(0, 10)
+    .map((entry) => ({
+      display: entry.display,
+      status: entry.status,
+      duration_ms: entry.duration_ms,
+      accepted_failure: entry.accepted_failure,
+    }));
+  const slowestTiming = [...timing]
+    .sort((left, right) => (right.durationMs || 0) - (left.durationMs || 0))
+    .slice(0, 10)
+    .map((entry) => ({ label: entry.label, duration_ms: entry.durationMs }));
+
+  return {
+    last_command: commands.at(-1) || null,
+    slowest_commands: slowestCommands,
+    slowest_timing: slowestTiming,
+    runtime_suite_layers: timingByRuntimeSuiteLayer(timing),
+  };
+}
+
+export function releaseCheckSummaryPayload({ summaryId, summary = {}, commands = [] }) {
+  const timing = summary.timing || [];
+  return {
+    schema_version: 1,
+    artifact_kind: 'release-check-run-summary',
+    run_id: summaryId,
+    suite: summary.suite || 'all',
+    result: summary.result || 'unknown',
+    error_message: summary.errorMessage || '',
+    command_count: commands.length,
+    commands,
+    timing,
+    diagnostics: releaseCheckDiagnostics(commands, timing),
+  };
+}

package/tools/vibe-release-check/release-check-runtime-automation-fixtures.mjs

@@ -0,0 +1 @@
+export { buildRuntimeAutomationFixtureContext } from './release-check-runtime-automation-smoke-fixtures.mjs';