@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-release-check/release-check-runtime-flow-smoke.mjs

@@ -0,0 +1,347 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { writeSmokeJsonFixture } from './release-check-json-assertion-helpers.mjs';
+import {
+  assertJsonMarkers,
+  parseJsonOutput,
+  repoRoot,
+  run,
+} from './release-check-runtime.mjs';
+
+const cleanDispatchRootConfig = {
+  automation_profile: 'autopilot-lab',
+  execution_profile: 'execution-enabled',
+  execution_profile_policy: 'controlled-local-runtime',
+};
+
+function createConfirmedDispatchAudit(context, options) {
+  const { cleanDispatchIntentHandoffFile } = context;
+  const cleanDispatchTarget = '.tmp/vibe-runtime-clean-dispatch-intent-ledger';
+  const absoluteCleanDispatchTarget = path.join(repoRoot, cleanDispatchTarget);
+  fs.rmSync(absoluteCleanDispatchTarget, { recursive: true, force: true });
+  fs.mkdirSync(absoluteCleanDispatchTarget, { recursive: true });
+  writeSmokeJsonFixture(repoRoot, path.join(cleanDispatchTarget, '.vibecoding', 'config.json'), cleanDispatchRootConfig);
+  run('node', ['tools/vibe-runtime/index.mjs', 'record-handoff', '--from-file', cleanDispatchIntentHandoffFile, '--root', cleanDispatchTarget], {}, options);
+  const cleanDispatchIntentJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'next', '--dry-run', '--dispatch-intent', '--json', '--root', cleanDispatchTarget], {}, options), 'next --dry-run --dispatch-intent --json clean');
+  assertJsonMarkers([
+    ['schema_version', cleanDispatchIntentJson.schema_version, 1],
+    ['command', cleanDispatchIntentJson.command, 'next'],
+    ['mode', cleanDispatchIntentJson.mode, 'dispatch-intent'],
+    ['state_present', cleanDispatchIntentJson.state_present, true],
+    ['intent.from_skill', cleanDispatchIntentJson.intent?.from_skill, 'vibe-implementation'],
+    ['intent.target_skill', cleanDispatchIntentJson.intent?.target_skill, 'vibe-verification-before-completion'],
+    ['intent.adapter_ready', cleanDispatchIntentJson.intent?.adapter_ready, true],
+    ['gates.transition.allowed', cleanDispatchIntentJson.gates?.transition?.allowed, true],
+    ['gates.review', cleanDispatchIntentJson.gates?.review, 'passed'],
+    ['gates.task_readiness', cleanDispatchIntentJson.gates?.task_readiness, 'passed'],
+    ['gates.dispatchable', cleanDispatchIntentJson.gates?.dispatchable, true],
+    ['safety.dispatch_event', cleanDispatchIntentJson.safety?.dispatch_event, false],
+  ], 'next --dry-run --dispatch-intent --json clean');
+  run('node', ['tools/vibe-runtime/index.mjs', 'next', '--dry-run', '--dispatch-intent', '--root', cleanDispatchTarget], {
+    expectOutput: ['Vibecoding Runtime Dispatch Intent', 'Mode: dry-run dispatch-intent', 'Adapter ready: yes', 'Current skill: vibe-implementation', 'Target skill: vibe-verification-before-completion', 'Transition gate: allowed', 'Review gate: passed', 'Task readiness gate: passed', 'Safety: dry_run=true; writes=false; dispatch_event=false; auto_execution=false; subagent=false; git=false; worktree=false.', 'Action: dispatch intent was previewed. No workflow state was changed. No skill was executed.'],
+  }, options);
+  if (fs.existsSync(path.join(absoluteCleanDispatchTarget, '.vibecoding-state', 'dispatches'))) throw new Error('clean dispatch intent wrote unexpected dispatches directory');
+
+  run('node', ['tools/vibe-runtime/index.mjs', 'next', '--dispatch', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['next --dispatch requires --confirm'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'next', '--confirm', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['next --confirm requires --dispatch'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'next', '--dry-run', '--dispatch', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['next --dispatch does not support --dry-run'],
+  }, options);
+  if (fs.existsSync(path.join(absoluteCleanDispatchTarget, '.vibecoding-state', 'dispatches'))) throw new Error('confirm-dispatch negative argument smoke wrote unexpected dispatches directory');
+
+  const cleanDispatchJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'next', '--confirm', '--dispatch', '--json', '--root', cleanDispatchTarget], {}, options), 'next --confirm --dispatch --json clean');
+  assertJsonMarkers([
+    ['schema_version', cleanDispatchJson.schema_version, 1],
+    ['command', cleanDispatchJson.command, 'next'],
+    ['mode', cleanDispatchJson.mode, 'confirm-dispatch'],
+    ['ok', cleanDispatchJson.ok, true],
+    ['state_present', cleanDispatchJson.state_present, true],
+    ['dispatch.from_skill', cleanDispatchJson.dispatch?.from_skill, 'vibe-implementation'],
+    ['dispatch.target_skill', cleanDispatchJson.dispatch?.target_skill, 'vibe-verification-before-completion'],
+    ['dispatch.adapter_ready', cleanDispatchJson.dispatch?.adapter_ready, true],
+    ['safety.confirmed', cleanDispatchJson.safety?.confirmed, true],
+    ['safety.allowed_transition', cleanDispatchJson.safety?.allowed_transition, true],
+    ['safety.review_gate', cleanDispatchJson.safety?.review_gate, 'passed'],
+    ['safety.task_readiness_gate', cleanDispatchJson.safety?.task_readiness_gate, 'passed'],
+    ['safety.dispatch_event', cleanDispatchJson.safety?.dispatch_event, true],
+  ], 'next --confirm --dispatch --json clean');
+  const dispatchesDirectory = path.join(absoluteCleanDispatchTarget, '.vibecoding-state', 'dispatches');
+  const dispatchFilesAfterJson = fs.readdirSync(dispatchesDirectory);
+  if (dispatchFilesAfterJson.length !== 1) throw new Error(`confirm-dispatch --json expected exactly one dispatch event, found ${dispatchFilesAfterJson.length}`);
+  const dispatchEventJson = JSON.parse(fs.readFileSync(path.join(dispatchesDirectory, dispatchFilesAfterJson[0]), 'utf8'));
+  assertJsonMarkers([
+    ['event.mode', dispatchEventJson.mode, 'confirm-dispatch'],
+    ['event.dispatch.target_skill', dispatchEventJson.dispatch?.target_skill, 'vibe-verification-before-completion'],
+    ['event.safety.dispatch_event', dispatchEventJson.safety?.dispatch_event, true],
+  ], 'confirm-dispatch persisted event');
+
+  fs.rmSync(dispatchesDirectory, { recursive: true, force: true });
+  run('node', ['tools/vibe-runtime/index.mjs', 'next', '--confirm', '--dispatch', '--root', cleanDispatchTarget], {
+    expectOutput: ['Vibecoding Runtime Confirm Dispatch', 'Mode: confirm-dispatch', 'Adapter ready: yes', 'Current skill: vibe-implementation', 'Target skill: vibe-verification-before-completion', 'Dispatch event:', 'Safety: confirmed=true; writes=true; dispatch_event=true; auto_execution=false; subagent=false; mcp=false; daemon=false; git=false; worktree=false.', 'Action: dispatch envelope was created. No git, worktree, subagent, daemon, MCP, or business source file was modified.'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'next', '--confirm', '--dispatch', '--root', cleanDispatchTarget], {
+    expectOutput: ['Vibecoding Runtime Confirm Dispatch', 'Mode: confirm-dispatch', 'Dispatch event:'],
+  }, options);
+  const dispatchFilesAfterText = fs.readdirSync(dispatchesDirectory);
+  if (dispatchFilesAfterText.length !== 2) throw new Error(`confirm-dispatch text expected two distinct dispatch events, found ${dispatchFilesAfterText.length}`);
+  if (new Set(dispatchFilesAfterText).size !== 2) throw new Error('confirm-dispatch text wrote duplicate dispatch event filenames');
+
+  const dispatchListJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--list', '--json', '--root', cleanDispatchTarget], {}, options), 'dispatches --list --json clean');
+  assertJsonMarkers([
+    ['schema_version', dispatchListJson.schema_version, 1],
+    ['command', dispatchListJson.command, 'dispatches'],
+    ['mode', dispatchListJson.mode, 'dispatch-audit-list'],
+    ['ok', dispatchListJson.ok, true],
+    ['summary.count', dispatchListJson.summary?.count, 2],
+    ['dispatches.length', dispatchListJson.dispatches?.length, 2],
+    ['dispatches.0.target_skill', dispatchListJson.dispatches?.[0]?.target_skill, 'vibe-verification-before-completion'],
+  ], 'dispatches --list --json clean');
+  run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--list', '--root', cleanDispatchTarget], {
+    expectOutput: ['Vibecoding Runtime Dispatch Audit', 'Mode: list', 'Dispatches: 2', 'vibe-implementation -> vibe-verification-before-completion', 'Action: read-only dispatch audit listed dispatch events. No skill execution, platform API, subagent, MCP, daemon, git, worktree, or business source write occurred.'],
+  }, options);
+  const dispatchShowJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--show', dispatchFilesAfterText[0], '--json', '--root', cleanDispatchTarget], {}, options), 'dispatches --show --json clean');
+  assertJsonMarkers([
+    ['schema_version', dispatchShowJson.schema_version, 1],
+    ['command', dispatchShowJson.command, 'dispatches'],
+    ['mode', dispatchShowJson.mode, 'dispatch-audit-show'],
+    ['ok', dispatchShowJson.ok, true],
+    ['summary.target_skill', dispatchShowJson.summary?.target_skill, 'vibe-verification-before-completion'],
+    ['verification.ok', dispatchShowJson.verification?.ok, true],
+    ['safety.auto_execution', dispatchShowJson.safety?.auto_execution, false],
+  ], 'dispatches --show --json clean');
+  run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--show', dispatchFilesAfterText[0], '--root', cleanDispatchTarget], {
+    expectOutput: ['Vibecoding Runtime Dispatch Audit', 'Mode: show', 'Target skill: vibe-verification-before-completion', 'Verification: passed', 'Action: read-only dispatch audit inspected a dispatch event. No skill execution, platform API, subagent, MCP, daemon, git, worktree, or business source write occurred.'],
+  }, options);
+  const dispatchVerifyJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--verify', dispatchFilesAfterText[0], '--json', '--root', cleanDispatchTarget], {}, options), 'dispatches --verify --json clean');
+  assertJsonMarkers([
+    ['schema_version', dispatchVerifyJson.schema_version, 1],
+    ['command', dispatchVerifyJson.command, 'dispatches'],
+    ['mode', dispatchVerifyJson.mode, 'dispatch-audit-verify'],
+    ['ok', dispatchVerifyJson.ok, true],
+    ['verification.ok', dispatchVerifyJson.verification?.ok, true],
+  ], 'dispatches --verify --json clean');
+  run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--verify', dispatchFilesAfterText[0], '--root', cleanDispatchTarget], {
+    expectOutput: ['Vibecoding Runtime Dispatch Audit', 'Mode: verify', 'Verification: passed'],
+  }, options);
+  const originalDispatchEventText = fs.readFileSync(path.join(dispatchesDirectory, dispatchFilesAfterText[0]), 'utf8');
+  return { cleanDispatchTarget, absoluteCleanDispatchTarget, dispatchesDirectory, dispatchFilesAfterText, dispatchEventJson, originalDispatchEventText };
+}
+
+function runDispatchClaimLifecycle(dispatchState, options) {
+  const { cleanDispatchTarget, absoluteCleanDispatchTarget, dispatchesDirectory, dispatchFilesAfterText, originalDispatchEventText } = dispatchState;
+  const claimWithoutEventTarget = '.tmp/vibe-runtime-claim-without-event';
+  const absoluteClaimWithoutEventTarget = path.join(repoRoot, claimWithoutEventTarget);
+  fs.rmSync(absoluteClaimWithoutEventTarget, { recursive: true, force: true });
+  fs.mkdirSync(absoluteClaimWithoutEventTarget, { recursive: true });
+  run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--claim', 'missing.json', '--actor', 'release-check', '--root', claimWithoutEventTarget], {
+    allowFailure: true,
+    expectOutput: ['Dispatch event not found: missing.json'],
+  }, options);
+  if (fs.existsSync(path.join(absoluteClaimWithoutEventTarget, '.vibecoding-state', 'dispatch-claims'))) throw new Error('claim without event created unexpected dispatch-claims directory');
+  fs.rmSync(absoluteClaimWithoutEventTarget, { recursive: true, force: true });
+  run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--claim', dispatchFilesAfterText[0], '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['dispatches --claim requires --actor'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--claim', dispatchFilesAfterText[0], '--actor', 'CON', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['Invalid dispatch actor: CON'],
+  }, options);
+  const dispatchClaimJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--claim', dispatchFilesAfterText[0], '--actor', 'release-check', '--json', '--root', cleanDispatchTarget], {}, options), 'dispatches --claim --json clean');
+  assertJsonMarkers([
+    ['schema_version', dispatchClaimJson.schema_version, 1],
+    ['command', dispatchClaimJson.command, 'dispatches'],
+    ['mode', dispatchClaimJson.mode, 'dispatch-claim'],
+    ['ok', dispatchClaimJson.ok, true],
+    ['claim.event_file', dispatchClaimJson.claim?.event_file, dispatchFilesAfterText[0]],
+    ['claim.actor', dispatchClaimJson.claim?.actor, 'release-check'],
+    ['claim.status', dispatchClaimJson.claim?.status, 'claimed'],
+    ['safety.dispatch_event_modified', dispatchClaimJson.safety?.dispatch_event_modified, false],
+    ['safety.auto_execution', dispatchClaimJson.safety?.auto_execution, false],
+  ], 'dispatches --claim --json clean');
+  const dispatchClaimFile = path.join(absoluteCleanDispatchTarget, '.vibecoding-state', 'dispatch-claims', `${dispatchFilesAfterText[0]}.claim.json`);
+  if (!fs.existsSync(dispatchClaimFile)) throw new Error(`dispatches --claim did not create expected claim file: ${dispatchClaimFile}`);
+  const dispatchClaimTextAfterClaim = fs.readFileSync(dispatchClaimFile, 'utf8');
+  if (fs.readFileSync(path.join(dispatchesDirectory, dispatchFilesAfterText[0]), 'utf8') !== originalDispatchEventText) throw new Error('dispatches --claim modified original dispatch event');
+  run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--claim', dispatchFilesAfterText[0], '--actor', 'release-check-2', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['Dispatch event already has an active claim'],
+  }, options);
+  const claimsListJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--claims', '--json', '--root', cleanDispatchTarget], {}, options), 'dispatches --claims --json clean');
+  assertJsonMarkers([
+    ['schema_version', claimsListJson.schema_version, 1],
+    ['command', claimsListJson.command, 'dispatches'],
+    ['mode', claimsListJson.mode, 'dispatch-claims-list'],
+    ['ok', claimsListJson.ok, true],
+    ['summary.count', claimsListJson.summary?.count, 1],
+    ['summary.stale_count', claimsListJson.summary?.stale_count, 0],
+    ['summary.digest_mismatch_count', claimsListJson.summary?.digest_mismatch_count, 0],
+    ['claims.0.event_file', claimsListJson.claims?.[0]?.event_file, dispatchFilesAfterText[0]],
+    ['claims.0.status', claimsListJson.claims?.[0]?.status, 'claimed'],
+    ['claims.0.audit.event_digest_matches', claimsListJson.claims?.[0]?.audit?.event_digest_matches, true],
+    ['claims.0.recovery.reassign_allowed', claimsListJson.claims?.[0]?.recovery?.reassign_allowed, false],
+  ], 'dispatches --claims --json clean');
+  run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--claims', '--root', cleanDispatchTarget], {
+    expectOutput: ['Vibecoding Runtime Dispatch Claims', 'Claims: 1', 'release-check', 'claimed', 'stale=false', 'digest=matched', 'reassign_allowed=false', 'Action: dispatch claim state was listed with stale/recovery audit. No skill execution, platform API, subagent, MCP, daemon, git, worktree, or business source write occurred.'],
+  }, options);
+  const staleClaim = JSON.parse(fs.readFileSync(dispatchClaimFile, 'utf8'));
+  staleClaim.claimed_at = '2000-01-01T00:00:00.000Z';
+  staleClaim.updated_at = '2000-01-01T00:00:00.000Z';
+  staleClaim.event_sha256 = 'stale-digest-mismatch';
+  fs.writeFileSync(dispatchClaimFile, `${JSON.stringify(staleClaim, null, 2)}\n`, 'utf8');
+  const staleClaimsListJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--claims', '--json', '--root', cleanDispatchTarget], {}, options), 'dispatches --claims --json stale claim');
+  assertJsonMarkers([
+    ['summary.stale_count', staleClaimsListJson.summary?.stale_count, 1],
+    ['summary.digest_mismatch_count', staleClaimsListJson.summary?.digest_mismatch_count, 1],
+    ['claims.0.audit.stale', staleClaimsListJson.claims?.[0]?.audit?.stale, true],
+    ['claims.0.audit.event_digest_matches', staleClaimsListJson.claims?.[0]?.audit?.event_digest_matches, false],
+    ['claims.0.recovery.reassign_allowed', staleClaimsListJson.claims?.[0]?.recovery?.reassign_allowed, false],
+  ], 'dispatches --claims --json stale claim');
+  fs.writeFileSync(dispatchClaimFile, dispatchClaimTextAfterClaim, 'utf8');
+  const corruptedClaimFile = path.join(absoluteCleanDispatchTarget, '.vibecoding-state', 'dispatch-claims', 'corrupted.claim.json');
+  fs.writeFileSync(corruptedClaimFile, '{ invalid json', 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--claims', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['Dispatch claim JSON is invalid: corrupted.claim.json'],
+  }, options);
+  fs.rmSync(corruptedClaimFile, { force: true });
+  run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--ack', dispatchFilesAfterText[0], '--actor', 'release-check-2', '--status', 'picked', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['Dispatch claim actor mismatch: release-check'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--ack', dispatchFilesAfterText[1], '--actor', 'release-check', '--status', 'picked', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['Dispatch claim not found'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--ack', dispatchFilesAfterText[0], '--actor', 'release-check', '--status', 'consumed', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['Invalid dispatch ack status: consumed'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--ack', dispatchFilesAfterText[0], '--actor', 'release-check', '--status', 'skipped', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['dispatches --ack --status skipped requires --reason'],
+  }, options);
+
+  const digestMismatchClaim = JSON.parse(fs.readFileSync(dispatchClaimFile, 'utf8'));
+  digestMismatchClaim.event_sha256 = 'ack-digest-mismatch';
+  fs.writeFileSync(dispatchClaimFile, `${JSON.stringify(digestMismatchClaim, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--ack', dispatchFilesAfterText[0], '--actor', 'release-check', '--status', 'picked', '--reason', 'manual-pickup-recorded', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['Dispatch claim event digest mismatch'],
+  }, options);
+  fs.writeFileSync(dispatchClaimFile, dispatchClaimTextAfterClaim, 'utf8');
+  const dispatchAckJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--ack', dispatchFilesAfterText[0], '--actor', 'release-check', '--status', 'picked', '--reason', 'manual-pickup-recorded', '--json', '--root', cleanDispatchTarget], {}, options), 'dispatches --ack --json clean');
+  assertJsonMarkers([
+    ['schema_version', dispatchAckJson.schema_version, 1],
+    ['command', dispatchAckJson.command, 'dispatches'],
+    ['mode', dispatchAckJson.mode, 'dispatch-ack'],
+    ['ok', dispatchAckJson.ok, true],
+    ['claim.event_file', dispatchAckJson.claim?.event_file, dispatchFilesAfterText[0]],
+    ['claim.actor', dispatchAckJson.claim?.actor, 'release-check'],
+    ['claim.status', dispatchAckJson.claim?.status, 'picked'],
+    ['claim.ack.reason', dispatchAckJson.claim?.ack?.reason, 'manual-pickup-recorded'],
+    ['safety.auto_execution', dispatchAckJson.safety?.auto_execution, false],
+  ], 'dispatches --ack --json clean');
+  if (fs.readFileSync(path.join(dispatchesDirectory, dispatchFilesAfterText[0]), 'utf8') !== originalDispatchEventText) throw new Error('dispatches --ack modified original dispatch event');
+  return { ...dispatchState, dispatchClaimFile, dispatchClaimTextAfterAck: fs.readFileSync(dispatchClaimFile, 'utf8') };
+}
+
+function runDispatchPickupLifecycle(dispatchState, options) {
+  const { cleanDispatchTarget, dispatchesDirectory, dispatchFilesAfterText, originalDispatchEventText, dispatchClaimFile, dispatchClaimTextAfterAck } = dispatchState;
+  run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--pickup', dispatchFilesAfterText[0], '--platform', 'gemini', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['Invalid pickup platform: gemini'],
+  }, options);
+  const dispatchPickupJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--pickup', dispatchFilesAfterText[0], '--platform', 'claude', '--json', '--root', cleanDispatchTarget], {}, options), 'dispatches --pickup --json clean');
+  assertJsonMarkers([
+    ['schema_version', dispatchPickupJson.schema_version, 1],
+    ['command', dispatchPickupJson.command, 'dispatches'],
+    ['mode', dispatchPickupJson.mode, 'dispatch-pickup'],
+    ['ok', dispatchPickupJson.ok, true],
+    ['pickup.platform', dispatchPickupJson.pickup?.platform, 'claude'],
+    ['pickup.entry_file', dispatchPickupJson.pickup?.entry_file, 'CLAUDE.md'],
+    ['pickup.event_file', dispatchPickupJson.pickup?.event_file, dispatchFilesAfterText[0]],
+    ['pickup.dispatch_event_path', dispatchPickupJson.pickup?.dispatch_event_path, `.vibecoding-state/dispatches/${dispatchFilesAfterText[0]}`],
+    ['pickup.claim_state_path', dispatchPickupJson.pickup?.claim_state_path, `.vibecoding-state/dispatch-claims/${dispatchFilesAfterText[0]}.claim.json`],
+    ['pickup.workflow_state_path', dispatchPickupJson.pickup?.workflow_state_path, '.vibecoding-state/workflow.json'],
+    ['pickup.from_skill', dispatchPickupJson.pickup?.from_skill, 'vibe-implementation'],
+    ['pickup.target_skill', dispatchPickupJson.pickup?.target_skill, 'vibe-verification-before-completion'],
+    ['readiness.ready_for_adapter', dispatchPickupJson.readiness?.ready_for_adapter, true],
+    ['readiness.claim_picked', dispatchPickupJson.readiness?.claim_picked, true],
+    ['digests.event_sha256', typeof dispatchPickupJson.digests?.event_sha256, 'string'],
+    ['digests.claim_sha256', typeof dispatchPickupJson.digests?.claim_sha256, 'string'],
+    ['digests.workflow_sha256', typeof dispatchPickupJson.digests?.workflow_sha256, 'string'],
+    ['digests.handoff_sha256', typeof dispatchPickupJson.digests?.handoff_sha256, 'string'],
+    ['pickup_verification.ok', dispatchPickupJson.pickup_verification?.ok, true],
+    ['platform_capability.session_create', dispatchPickupJson.platform_capability?.session_create, false],
+    ['platform_capability.platform_api', dispatchPickupJson.platform_capability?.platform_api, false],
+    ['adapter_dry_run.no_session', dispatchPickupJson.adapter_dry_run?.no_session, true],
+    ['adapter_dry_run.would_write', dispatchPickupJson.adapter_dry_run?.would_write, false],
+    ['verification.ok', dispatchPickupJson.verification?.ok, true],
+    ['claim.status', dispatchPickupJson.claim?.status, 'picked'],
+    ['safety.read_only', dispatchPickupJson.safety?.read_only, true],
+    ['safety.writes', dispatchPickupJson.safety?.writes, false],
+    ['safety.auto_claim', dispatchPickupJson.safety?.auto_claim, false],
+    ['safety.platform_api', dispatchPickupJson.safety?.platform_api, false],
+    ['safety.session_create', dispatchPickupJson.safety?.session_create, false],
+  ], 'dispatches --pickup --json clean');
+  run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--pickup', dispatchFilesAfterText[0], '--platform', 'claude', '--root', cleanDispatchTarget], {
+    expectOutput: ['Vibecoding Runtime Dispatch Pickup', 'Mode: pickup', 'Platform: claude', 'Entry file: CLAUDE.md', 'Target skill: vibe-verification-before-completion', 'Claim: picked by release-check', 'Readiness: ready_for_adapter=true', 'Digests: event=', 'Pickup verification: passed', 'Platform capability: mode=manual; session_create=false; platform_api=false; stdin_automation=false', 'Adapter dry-run: simulated=true; no_session=true; would_write=false', 'Verification: passed', 'Safety: read_only=true; writes=false; auto_claim=false; auto_execution=false; platform_api=false; session_create=false; subagent=false; mcp=false; daemon=false; git=false; worktree=false.', 'Action: dispatch pickup package was generated for manual use. No claim was created, no skill execution, platform API, session creation, subagent, MCP, daemon, git, worktree, or business source write occurred.'],
+  }, options);
+  const pickupVerifyJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--pickup-verify', dispatchFilesAfterText[0], '--platform', 'claude', '--json', '--root', cleanDispatchTarget], {}, options), 'dispatches --pickup-verify --json clean');
+  assertJsonMarkers([
+    ['mode', pickupVerifyJson.mode, 'dispatch-pickup-verify'],
+    ['ok', pickupVerifyJson.ok, true],
+    ['pickup_verification.ok', pickupVerifyJson.pickup_verification?.ok, true],
+    ['digests.handoff_sha256', typeof pickupVerifyJson.digests?.handoff_sha256, 'string'],
+  ], 'dispatches --pickup-verify --json clean');
+  run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--pickup-verify', dispatchFilesAfterText[0], '--platform', 'claude', '--root', cleanDispatchTarget], {
+    expectOutput: ['Vibecoding Runtime Dispatch Pickup Verification', 'Mode: pickup-verify', 'Status: passed', 'Readiness: ready_for_adapter=true', 'Action: pickup package was verified read-only. No claim, session, adapter call, skill execution, platform API, subagent, MCP, daemon, git, worktree, or business source write occurred.'],
+  }, options);
+  const pickupDryRunJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--pickup-dry-run', dispatchFilesAfterText[0], '--platform', 'cursor', '--json', '--root', cleanDispatchTarget], {}, options), 'dispatches --pickup-dry-run --json clean');
+  assertJsonMarkers([
+    ['mode', pickupDryRunJson.mode, 'dispatch-pickup-dry-run'],
+    ['adapter_dry_run.simulated', pickupDryRunJson.adapter_dry_run?.simulated, true],
+    ['adapter_dry_run.no_session', pickupDryRunJson.adapter_dry_run?.no_session, true],
+    ['adapter_dry_run.would_call_platform_api', pickupDryRunJson.adapter_dry_run?.would_call_platform_api, false],
+    ['platform_capability.entry_file', pickupDryRunJson.platform_capability?.entry_file, 'AGENTS.md'],
+  ], 'dispatches --pickup-dry-run --json clean');
+  run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--pickup-dry-run', dispatchFilesAfterText[0], '--platform', 'cursor', '--root', cleanDispatchTarget], {
+    expectOutput: ['Vibecoding Runtime Adapter Pickup Dry Run', 'Mode: pickup-dry-run', 'Platform: cursor', 'Entry file: AGENTS.md', 'No session: true', 'Would call platform API: false', 'Would create session: false', 'Would write: false', 'Handoff digest:', 'Action: adapter pickup was simulated without session creation. No claim, adapter call, skill execution, platform API, subagent, MCP, daemon, git, worktree, or business source write occurred.'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--pickup', dispatchFilesAfterText[1], '--platform', 'codex', '--root', cleanDispatchTarget], {
+    expectOutput: ['Vibecoding Runtime Dispatch Pickup', 'Mode: pickup', 'Platform: codex', 'Entry file: AGENTS.md', 'Target skill: vibe-verification-before-completion', 'Claim: not claimed', 'Warnings:', 'dispatch event has no claim state', 'Safety: read_only=true; writes=false; auto_claim=false; auto_execution=false; platform_api=false; session_create=false; subagent=false; mcp=false; daemon=false; git=false; worktree=false.', 'Action: dispatch pickup package was generated for manual use. No claim was created, no skill execution, platform API, session creation, subagent, MCP, daemon, git, worktree, or business source write occurred.'],
+  }, options);
+  const skippedPickupClaim = JSON.parse(dispatchClaimTextAfterAck);
+  skippedPickupClaim.status = 'skipped';
+  skippedPickupClaim.ack.status = 'skipped';
+  fs.writeFileSync(dispatchClaimFile, `${JSON.stringify(skippedPickupClaim, null, 2)}\n`, 'utf8');
+  const skippedDispatchPickupJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--pickup', dispatchFilesAfterText[0], '--platform', 'cursor', '--json', '--root', cleanDispatchTarget], {}, options), 'dispatches --pickup --json skipped claim');
+  assertJsonMarkers([
+    ['claim.status', skippedDispatchPickupJson.claim?.status, 'skipped'],
+    ['readiness.ready_for_adapter', skippedDispatchPickupJson.readiness?.ready_for_adapter, false],
+    ['readiness.claim_picked', skippedDispatchPickupJson.readiness?.claim_picked, false],
+    ['quality.0', skippedDispatchPickupJson.quality?.[0], 'dispatch claim status is skipped; pickup package is read-only and does not imply execution readiness'],
+    ['safety.read_only', skippedDispatchPickupJson.safety?.read_only, true],
+    ['safety.auto_claim', skippedDispatchPickupJson.safety?.auto_claim, false],
+    ['safety.session_create', skippedDispatchPickupJson.safety?.session_create, false],
+  ], 'dispatches --pickup --json skipped claim');
+  fs.writeFileSync(dispatchClaimFile, dispatchClaimTextAfterAck, 'utf8');
+  if (fs.readFileSync(path.join(dispatchesDirectory, dispatchFilesAfterText[0]), 'utf8') !== originalDispatchEventText) throw new Error('dispatches --pickup modified original dispatch event');
+  if (fs.readFileSync(dispatchClaimFile, 'utf8') !== dispatchClaimTextAfterAck) throw new Error('dispatches --pickup unexpectedly modified claim state');
+}
+
+export function runRuntimeDispatchFlowSmoke(context, options) {
+  const auditState = createConfirmedDispatchAudit(context, options);
+  const claimState = runDispatchClaimLifecycle(auditState, options);
+  runDispatchPickupLifecycle(claimState, options);
+  return claimState;
+}

package/tools/vibe-release-check/release-check-runtime-handoff-fixture-specs.mjs

@@ -0,0 +1,211 @@
+export const runtimeHandoffFixtureSpecs = [
+  {
+    key: 'legacyHandoffFile',
+    fileName: 'runtime-legacy-handoff.md',
+    content: `current_skill: vibe-writing-plans
+next_skill: vibe-test-driven-development
+reason: release check runtime legacy ledger smoke
+handoff:
+  scope:
+    - runtime ledger legacy smoke
+  risks:
+    - none
+  acceptance:
+    - status can read recorded legacy handoff
+  files:
+    - tools/vibe-runtime/index.mjs
+  evidence:
+    - release-check
+stop_condition: none
+`,
+  },
+  {
+    key: 'jsonHandoffFile',
+    fileName: 'runtime-json-handoff.md',
+    content: `## Workflow Handoff
+
+\`\`\`json
+{
+  "current_skill": "vibe-test-driven-development",
+  "next_skill": "vibe-executing-plans",
+  "reason": "release check runtime JSON handoff smoke",
+  "handoff": {
+    "goal": "release check JSON handoff",
+    "scope": ["runtime ledger JSON smoke"],
+    "key_decisions": ["JSON handoff is supported"],
+    "files": ["tools/vibe-runtime/index.mjs"],
+    "risks": ["none"],
+    "acceptance": ["status can read recorded JSON handoff"],
+    "evidence": ["release-check"],
+    "tasks": [
+      {
+        "id": "task-1",
+        "title": "release check task artifact smoke",
+        "status": "pending",
+        "review_status": "not_started",
+        "files": ["tools/vibe-runtime/index.mjs"],
+        "depends_on": [],
+        "acceptance": ["task artifacts can be previewed and written"],
+        "evidence": ["release-check"],
+        "risks": ["none"],
+        "notes": ["task artifact smoke"]
+      },
+      {
+        "id": "task-2",
+        "title": "release check requested review smoke",
+        "status": "in_progress",
+        "review_status": "requested",
+        "depends_on": ["task-3"],
+        "review_notes": ["review requested smoke"],
+        "review_evidence": ["review request recorded"],
+        "review_risks": ["review pending"]
+      },
+      {
+        "id": "task-3",
+        "title": "release check clean review smoke",
+        "status": "completed",
+        "review_status": "clean",
+        "review_evidence": ["review clean smoke"]
+      },
+      {
+        "id": "task-4",
+        "title": "release check needs fix review smoke",
+        "status": "blocked",
+        "review_status": "needs_fix",
+        "review_notes": ["fix required before finishing"],
+        "review_risks": ["important feedback remains"]
+      },
+      {
+        "id": "task-5",
+        "title": "release check waiting dependency smoke",
+        "status": "pending",
+        "review_status": "not_started",
+        "depends_on": ["task-1"],
+        "acceptance": ["waiting readiness reports blocked dependency"]
+      },
+      {
+        "id": "task.alpha_1",
+        "title": "release check waived review smoke",
+        "status": "completed",
+        "review_status": "waived",
+        "review_waiver": "user accepted documented review risk",
+        "review_risks": ["waived review risk"]
+      }
+    ]
+  },
+  "stop_condition": "none"
+}
+\`\`\`
+`,
+  },
+  {
+    key: 'blockedHandoffFile',
+    fileName: 'runtime-blocked-handoff.md',
+    content: `current_skill: vibe-brainstorming
+next_skill: vibe-planning
+reason: release check blocked dry-run smoke
+handoff:
+  scope:
+    - runtime blocked smoke
+  risks:
+    - waiting on user direction
+  acceptance:
+    - dry-run reports blocked status
+  files:
+    - tools/vibe-runtime/index.mjs
+  evidence:
+    - release-check
+stop_condition: waiting for user confirmation
+`,
+  },
+  {
+    key: 'stoppedHandoffFile',
+    fileName: 'runtime-stopped-handoff.md',
+    content: `current_skill: vibe-verification-before-completion
+next_skill: none
+reason: release check stopped dry-run smoke
+handoff:
+  scope:
+    - runtime stopped smoke
+  risks:
+    - none
+  acceptance:
+    - dry-run reports stopped status
+  files:
+    - tools/vibe-runtime/index.mjs
+  evidence:
+    - release-check
+stop_condition: none
+`,
+  },
+  {
+    key: 'qualityHandoffFile',
+    fileName: 'runtime-quality-handoff.md',
+    content: `current_skill: vibe-planning
+next_skill: vibe-writing-plans
+reason: release check handoff quality warning smoke
+handoff:
+  scope:
+    - runtime quality hint smoke
+  files:
+    - tools/vibe-runtime/index.mjs
+stop_condition: none
+`,
+  },
+  {
+    key: 'qualityMissingContextHandoffFile',
+    fileName: 'runtime-quality-missing-context-handoff.md',
+    content: `current_skill: vibe-planning
+next_skill: vibe-writing-plans
+reason: release check missing context quality warning smoke
+handoff:
+  risks:
+    - none
+  acceptance:
+    - missing context warnings are reported
+  evidence:
+    - release-check
+stop_condition: none
+`,
+  },
+  {
+    key: 'qualityBlockedHandoffFile',
+    fileName: 'runtime-quality-blocked-handoff.md',
+    content: `current_skill: vibe-planning
+next_skill: vibe-writing-plans
+reason: release check stop condition quality warning smoke
+handoff:
+  scope:
+    - runtime quality blocked smoke
+  risks:
+    - waiting on user direction
+  acceptance:
+    - stop condition warning is reported
+  files:
+    - tools/vibe-runtime/index.mjs
+  evidence:
+    - release-check
+stop_condition: waiting for user confirmation
+`,
+  },
+  {
+    key: 'qualityStoppedWithoutReasonHandoffFile',
+    fileName: 'runtime-quality-stopped-without-reason-handoff.md',
+    content: `current_skill: vibe-verification-before-completion
+next_skill: none
+reason: release check missing stop reason quality warning smoke
+handoff:
+  scope:
+    - runtime quality stopped smoke
+  risks:
+    - none
+  acceptance:
+    - missing stop reason warning is reported
+  files:
+    - tools/vibe-runtime/index.mjs
+  evidence:
+    - release-check
+stop_condition: none
+`,
+  },
+];

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

@@ -0,0 +1,11 @@
+import { writeSmokeTextFixtures } from './release-check-json-assertion-helpers.mjs';
+import { runtimeHandoffFixtureSpecs } from './release-check-runtime-handoff-fixture-specs.mjs';
+
+export function buildRuntimeHandoffFixtures({ tmpRoot }) {
+  const fixtureFiles = writeSmokeTextFixtures(tmpRoot, runtimeHandoffFixtureSpecs);
+
+  return {
+    ...fixtureFiles,
+    cleanupFiles: runtimeHandoffFixtureSpecs.map(({ key }) => fixtureFiles[key]),
+  };
+}