@jtf19/vibecoding-kit 0.1.0

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

@@ -0,0 +1,86 @@
+export const runtimeHandoffSmokeSpecs = {
+  idleStatusOutput: ['Vibecoding Runtime State', 'Status: idle', 'State: none', 'Manual action: record a Workflow Handoff explicitly to create local workflow state.'],
+  idleStatusJson: {
+    label: 'status --json idle',
+    markers: [
+      ['schema_version', 1],
+      ['command', 'status'],
+      ['mode', 'read-only'],
+      ['state_present', false],
+    ],
+  },
+  idleDispatchIntentJson: {
+    label: 'next --dry-run --dispatch-intent --json idle',
+    markers: [
+      ['schema_version', 1],
+      ['command', 'next'],
+      ['mode', 'dispatch-intent'],
+      ['state_present', false],
+      ['intent.adapter_ready', false],
+      ['intent.target_skill', 'none'],
+      ['safety.dry_run', true],
+      ['safety.dispatch_event', false],
+      ['adapter_bridge.mode', 'manual'],
+      ['runtimeBridge.mode', 'manual'],
+      ['adapter_bridge.canAutoExecuteSkill', false],
+    ],
+  },
+  idleConfirmDispatchFailureOutput: ['confirm-dispatch gate failed: workflow state is not recorded; next advice status is idle'],
+  idleDispatchListJson: {
+    label: 'dispatches --list --json idle',
+    markers: [
+      ['schema_version', 1],
+      ['command', 'dispatches'],
+      ['mode', 'dispatch-audit-list'],
+      ['ok', true],
+      ['state_present', false],
+      ['summary.count', 0],
+      ['dispatches.length', 0],
+    ],
+  },
+  idleDispatchListOutput: [
+    'Vibecoding Runtime Dispatch Audit',
+    'Mode: list',
+    'Dispatches: 0',
+    'Action: read-only dispatch audit listed dispatch events. No skill execution, platform API, subagent, MCP, daemon, git, worktree, or business source write occurred.',
+  ],
+  dispatchIntentRequiresDryRunOutput: ['next --dispatch-intent requires --dry-run in this stage'],
+  dispatchIntentConfirmUnsupportedOutput: ['next --confirm --dispatch-intent is not supported in Stage 5'],
+  idleNextDryRunOutput: [
+    'Vibecoding Runtime Next Step',
+    'Status: idle',
+    'Manual action: record a Workflow Handoff explicitly before asking for next.',
+    'Action: no skill was executed.',
+  ],
+  artifactsWithoutStateOutput: ['Workflow state not found. Record a handoff before generating artifacts.'],
+  tasksWithoutStateOutput: ['Workflow state not found. Record a handoff before generating task artifacts.'],
+  validateHandoffOutput: [
+    'Vibecoding Runtime Handoff Validation',
+    'Mode: dry-run',
+    'Status: valid',
+    'Current skill: vibe-test-driven-development',
+    'Next skill: vibe-executing-plans',
+    'Tasks: 6 (blocked)',
+    'Task readiness: ready=2, waiting=1, blocked=1, completed=2',
+    'Review: not_started=2, requested=1, clean=1, needs_fix=1, waived=1',
+    'Handoff quality:',
+    'Action: handoff was validated. No workflow state was changed.',
+  ],
+  validateHandoffJson: {
+    label: 'validate-handoff --json',
+    markers: [
+      ['schema_version', 1],
+      ['command', 'validate-handoff'],
+      ['mode', 'dry-run'],
+      ['state_present', false],
+      ['summary.task_readiness', 'ready=2, waiting=1, blocked=1, completed=2'],
+      ['summary.task_readiness_counts.waiting', 1],
+      ['tasks.length', 6],
+      ['quality.length', 5],
+    ],
+  },
+  unsupportedRecordJsonOutput: ['record-handoff does not support --json in this stage'],
+  unsupportedArtifactsJsonOutput: ['artifacts does not support --json in this stage'],
+  unsupportedTasksJsonWriteOutput: ['tasks --json is only supported with dry-run output'],
+  unsupportedResetJsonOutput: ['reset does not support --json in this stage'],
+};

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

@@ -0,0 +1,316 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  assertJsonMarkers,
+  parseJsonOutput,
+  run,
+} from './release-check-runtime.mjs';
+import { runtimeHandoffSmokeSpecs } from './release-check-runtime-handoff-smoke-specs.mjs';
+
+function smokeMarkerValue(source, markerPath) {
+  return markerPath.split('.').reduce((value, key) => value?.[key], source);
+}
+
+function assertSmokeJsonMarkers(source, spec) {
+  assertJsonMarkers(
+    spec.markers.map(([markerPath, expected]) => [markerPath, smokeMarkerValue(source, markerPath), expected]),
+    spec.label,
+  );
+}
+
+function assertStatePathAbsent(file, label) {
+  if (fs.existsSync(file)) throw new Error(`${label}: ${file}`);
+}
+
+function verifyIdleRuntimeState(context, options) {
+  const { target, absoluteTarget } = context;
+  run('node', ['tools/vibe-runtime/index.mjs', 'status', '--root', target], {
+    expectOutput: runtimeHandoffSmokeSpecs.idleStatusOutput,
+  }, options);
+  const idleStatusJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'status', '--json', '--root', target], {}, options), runtimeHandoffSmokeSpecs.idleStatusJson.label);
+  assertSmokeJsonMarkers(idleStatusJson, runtimeHandoffSmokeSpecs.idleStatusJson);
+  const idleDispatchIntentJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'next', '--dry-run', '--dispatch-intent', '--json', '--root', target], {}, options), runtimeHandoffSmokeSpecs.idleDispatchIntentJson.label);
+  assertSmokeJsonMarkers(idleDispatchIntentJson, runtimeHandoffSmokeSpecs.idleDispatchIntentJson);
+  assertStatePathAbsent(path.join(absoluteTarget, '.vibecoding-state'), 'dispatch intent idle created unexpected .vibecoding-state');
+  run('node', ['tools/vibe-runtime/index.mjs', 'next', '--confirm', '--dispatch', '--root', target], {
+    allowFailure: true,
+    expectOutput: runtimeHandoffSmokeSpecs.idleConfirmDispatchFailureOutput,
+  }, options);
+  assertStatePathAbsent(path.join(absoluteTarget, '.vibecoding-state', 'dispatches'), 'idle confirm-dispatch wrote unexpected dispatches directory');
+  const idleDispatchListJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--list', '--json', '--root', target], {}, options), runtimeHandoffSmokeSpecs.idleDispatchListJson.label);
+  assertSmokeJsonMarkers(idleDispatchListJson, runtimeHandoffSmokeSpecs.idleDispatchListJson);
+  run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--list', '--root', target], {
+    expectOutput: runtimeHandoffSmokeSpecs.idleDispatchListOutput,
+  }, options);
+  assertStatePathAbsent(path.join(absoluteTarget, '.vibecoding-state'), 'dispatches --list idle created unexpected .vibecoding-state');
+  run('node', ['tools/vibe-runtime/index.mjs', 'next', '--dispatch-intent', '--root', target], {
+    allowFailure: true,
+    expectOutput: runtimeHandoffSmokeSpecs.dispatchIntentRequiresDryRunOutput,
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'next', '--confirm', '--dispatch-intent', '--root', target], {
+    allowFailure: true,
+    expectOutput: runtimeHandoffSmokeSpecs.dispatchIntentConfirmUnsupportedOutput,
+  }, options);
+  assertStatePathAbsent(path.join(absoluteTarget, '.vibecoding-state'), 'dispatch intent negative smoke created unexpected .vibecoding-state');
+  assertStatePathAbsent(path.join(absoluteTarget, '.vibecoding-state'), 'status --json idle created unexpected .vibecoding-state');
+  run('node', ['tools/vibe-runtime/index.mjs', 'next', '--dry-run', '--root', target], {
+    expectOutput: runtimeHandoffSmokeSpecs.idleNextDryRunOutput,
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'artifacts', '--dry-run', '--root', target], {
+    allowFailure: true,
+    expectOutput: runtimeHandoffSmokeSpecs.artifactsWithoutStateOutput,
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'tasks', '--dry-run', '--root', target], {
+    allowFailure: true,
+    expectOutput: runtimeHandoffSmokeSpecs.tasksWithoutStateOutput,
+  }, options);
+}
+
+function verifyHandoffValidationNoWrite(context, options) {
+  const { target, absoluteTarget, jsonHandoffFile } = context;
+  run('node', ['tools/vibe-runtime/index.mjs', 'validate-handoff', '--from-file', jsonHandoffFile, '--root', target], {
+    expectOutput: runtimeHandoffSmokeSpecs.validateHandoffOutput,
+  }, options);
+  const validateJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'validate-handoff', '--from-file', jsonHandoffFile, '--json', '--root', target], {}, options), runtimeHandoffSmokeSpecs.validateHandoffJson.label);
+  assertSmokeJsonMarkers(validateJson, runtimeHandoffSmokeSpecs.validateHandoffJson);
+  const workflowFileBeforeRecord = path.join(absoluteTarget, '.vibecoding-state', 'workflow.json');
+  assertStatePathAbsent(workflowFileBeforeRecord, 'validate-handoff created unexpected workflow state');
+  run('node', ['tools/vibe-runtime/index.mjs', 'record-handoff', '--from-file', jsonHandoffFile, '--json', '--root', target], {
+    allowFailure: true,
+    expectOutput: runtimeHandoffSmokeSpecs.unsupportedRecordJsonOutput,
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'artifacts', '--dry-run', '--json', '--root', target], {
+    allowFailure: true,
+    expectOutput: runtimeHandoffSmokeSpecs.unsupportedArtifactsJsonOutput,
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'tasks', '--write', '--json', '--root', target], {
+    allowFailure: true,
+    expectOutput: runtimeHandoffSmokeSpecs.unsupportedTasksJsonWriteOutput,
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'reset', '--json', '--confirm', '--root', target], {
+    allowFailure: true,
+    expectOutput: runtimeHandoffSmokeSpecs.unsupportedResetJsonOutput,
+  }, options);
+  assertStatePathAbsent(workflowFileBeforeRecord, 'write command --json smoke created unexpected workflow state');
+  return { workflowFileBeforeRecord };
+}
+
+function verifyInvalidHandoffValidation(context, options) {
+  const {
+    target,
+    workflowFileBeforeRecord,
+    reservedTaskIdHandoffFile,
+    invalidFencedJsonTaskIdHandoffFile,
+    invalidFencedJsonReviewWaiverHandoffFile,
+    duplicateTaskIdHandoffFile,
+    unknownDependencyHandoffFile,
+    selfDependencyHandoffFile,
+    cyclicDependencyHandoffFile,
+  } = context;
+  run('node', ['tools/vibe-runtime/index.mjs', 'validate-handoff', '--from-file', reservedTaskIdHandoffFile, '--root', target], {
+    allowFailure: true,
+    expectOutput: ['Invalid task id: CON.txt'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'validate-handoff', '--from-file', invalidFencedJsonTaskIdHandoffFile, '--root', target], {
+    allowFailure: true,
+    expectOutput: ['Invalid task id: NUL'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'validate-handoff', '--from-file', invalidFencedJsonReviewWaiverHandoffFile, '--root', target], {
+    allowFailure: true,
+    expectOutput: ['Task review waiver required for task-fenced-waived-without-reason when review_status is waived'],
+  }, options);
+  const dependencyCases = [
+    [duplicateTaskIdHandoffFile, 'Duplicate task id: task-dup'],
+    [unknownDependencyHandoffFile, 'Unknown task dependency for task-dependent: missing-task'],
+    [selfDependencyHandoffFile, 'Self task dependency is not allowed for task-self'],
+    [cyclicDependencyHandoffFile, 'Cyclic task dependency detected: task-a -> task-b -> task-a'],
+  ];
+  for (const [file, expected] of dependencyCases) {
+    run('node', ['tools/vibe-runtime/index.mjs', 'validate-handoff', '--from-file', file, '--root', target], {
+      allowFailure: true,
+      expectOutput: [expected],
+    }, options);
+  }
+  assertStatePathAbsent(workflowFileBeforeRecord, 'failed validate-handoff created unexpected workflow state');
+}
+
+function verifyInvalidRecordHandoff(context, options) {
+  const {
+    target,
+    absoluteTarget,
+    workflowFileBeforeRecord,
+    invalidTaskIdHandoffFile,
+    emptyTaskIdHandoffFile,
+    reservedTaskIdHandoffFile,
+    trailingDotTaskIdHandoffFile,
+    invalidFencedJsonTaskIdHandoffFile,
+    invalidFencedJsonReviewWaiverHandoffFile,
+    invalidReviewWaiverHandoffFile,
+    duplicateTaskIdHandoffFile,
+    unknownDependencyHandoffFile,
+    selfDependencyHandoffFile,
+    cyclicDependencyHandoffFile,
+  } = context;
+  const recordCases = [
+    [invalidTaskIdHandoffFile, 'Invalid task id: ..\\escape-review'],
+    [emptyTaskIdHandoffFile, 'Invalid task id: empty'],
+    [reservedTaskIdHandoffFile, 'Invalid task id: CON.txt'],
+    [trailingDotTaskIdHandoffFile, 'Invalid task id: task.'],
+    [invalidFencedJsonTaskIdHandoffFile, 'Invalid task id: NUL'],
+    [invalidFencedJsonReviewWaiverHandoffFile, 'Task review waiver required for task-fenced-waived-without-reason when review_status is waived'],
+    [invalidReviewWaiverHandoffFile, 'Task review waiver required for task-waived-without-reason when review_status is waived'],
+    [duplicateTaskIdHandoffFile, 'Duplicate task id: task-dup'],
+    [unknownDependencyHandoffFile, 'Unknown task dependency for task-dependent: missing-task'],
+    [selfDependencyHandoffFile, 'Self task dependency is not allowed for task-self'],
+    [cyclicDependencyHandoffFile, 'Cyclic task dependency detected: task-a -> task-b -> task-a'],
+  ];
+  for (const [file, expected] of recordCases) {
+    run('node', ['tools/vibe-runtime/index.mjs', 'record-handoff', '--from-file', file, '--root', target], {
+      allowFailure: true,
+      expectOutput: [expected],
+    }, options);
+  }
+  const escapedTaskDirectory = path.join(absoluteTarget, '.vibecoding-state', 'escape-review');
+  assertStatePathAbsent(escapedTaskDirectory, 'invalid task id created escaped directory');
+  for (const unsafeTaskId of ['CON.txt', 'COM1', 'LPT1', 'task.', 'NUL']) {
+    const unsafeTaskDirectory = path.join(absoluteTarget, '.vibecoding-state', 'tasks', unsafeTaskId);
+    assertStatePathAbsent(unsafeTaskDirectory, 'invalid task id created unsafe directory');
+  }
+  assertStatePathAbsent(workflowFileBeforeRecord, 'invalid dependency record-handoff created unexpected workflow state');
+}
+
+function verifyArtifactTaskGuards(context, options) {
+  const { target, artifactFiles, taskArtifactFiles } = context;
+  for (const file of artifactFiles) {
+    if (fs.existsSync(file)) throw new Error(`artifacts without ledger created unexpected file: ${file}`);
+  }
+  for (const file of taskArtifactFiles) {
+    if (fs.existsSync(file)) throw new Error(`tasks without ledger created unexpected file: ${file}`);
+  }
+  run('node', ['tools/vibe-runtime/index.mjs', 'artifacts', '--dry-run', '--write', '--root', target], {
+    allowFailure: true,
+    expectOutput: ['artifacts accepts either --dry-run or --write, not both'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'tasks', '--dry-run', '--write', '--root', target], {
+    allowFailure: true,
+    expectOutput: ['tasks accepts either --dry-run or --write, not both'],
+  }, options);
+}
+
+function verifyLedgerAndDispatchFlow(context, options) {
+  const { target, absoluteTarget, legacyHandoffFile, stoppedHandoffFile, blockedHandoffFile, jsonHandoffFile } = context;
+  run('node', ['tools/vibe-runtime/index.mjs', 'record-handoff', '--from-file', legacyHandoffFile, '--root', target], {}, options);
+  const ledgerWithoutDispatchListJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--list', '--json', '--root', target], {}, options), 'dispatches --list --json ledger without dispatches');
+  assertJsonMarkers([
+    ['mode', ledgerWithoutDispatchListJson.mode, 'dispatch-audit-list'],
+    ['state_present', ledgerWithoutDispatchListJson.state_present, true],
+    ['summary.count', ledgerWithoutDispatchListJson.summary?.count, 0],
+    ['dispatches.length', ledgerWithoutDispatchListJson.dispatches?.length, 0],
+  ], 'dispatches --list --json ledger without dispatches');
+  assertStatePathAbsent(path.join(absoluteTarget, '.vibecoding-state', 'dispatches'), 'dispatches --list with ledger created unexpected dispatches directory');
+  run('node', ['tools/vibe-runtime/index.mjs', 'record-handoff', '--from-file', stoppedHandoffFile, '--root', target], {}, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'next', '--confirm', '--dispatch', '--root', target], {
+    allowFailure: true,
+    expectOutput: ['confirm-dispatch gate failed: next_skill is none; next advice status is stopped'],
+  }, options);
+  assertStatePathAbsent(path.join(absoluteTarget, '.vibecoding-state', 'dispatches'), 'stopped confirm-dispatch wrote unexpected dispatches directory');
+  run('node', ['tools/vibe-runtime/index.mjs', 'record-handoff', '--from-file', blockedHandoffFile, '--root', target], {}, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'next', '--confirm', '--dispatch', '--root', target], {
+    allowFailure: true,
+    expectOutput: ['confirm-dispatch gate failed: stop_condition is set; next advice status is blocked'],
+  }, options);
+  assertStatePathAbsent(path.join(absoluteTarget, '.vibecoding-state', 'dispatches'), 'stop_condition confirm-dispatch wrote unexpected dispatches directory');
+  run('node', ['tools/vibe-runtime/index.mjs', 'record-handoff', '--from-file', legacyHandoffFile, '--root', target], {}, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'status', '--root', target], {}, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'record-handoff', '--from-file', jsonHandoffFile, '--root', target], {}, options);
+}
+
+function verifyRecordedHandoffNext(context, options) {
+  const { target, absoluteTarget } = context;
+  run('node', ['tools/vibe-runtime/index.mjs', 'status', '--root', target], {
+    expectOutput: ['Vibecoding Runtime State', 'Status: handoff-recorded', 'Scope:', 'Risks:', 'Acceptance:', 'Files:', 'Evidence:', 'Tasks: 6 (blocked)', 'Task readiness: ready=2, waiting=1, blocked=1, completed=2', 'Review: not_started=2, requested=1, clean=1, needs_fix=1, waived=1', 'task.alpha_1: release check waived review smoke', 'Action: status is read-only. No workflow state was changed.'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'next', '--dry-run', '--root', target], {
+    expectOutput: ['Vibecoding Runtime Next Step', 'Status: ready', 'Current skill: vibe-test-driven-development', 'Next skill: vibe-executing-plans', 'Task status: blocked', 'Task readiness: ready=2, waiting=1, blocked=1, completed=2', 'Review status: needs_fix', 'Manual action: resolve review feedback explicitly before finishing.', 'Action: no skill was executed.'],
+  }, options);
+  const nextJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'next', '--dry-run', '--json', '--root', target], {}, options), 'next --dry-run --json');
+  assertJsonMarkers([
+    ['schema_version', nextJson.schema_version, 1],
+    ['command', nextJson.command, 'next'],
+    ['mode', nextJson.mode, 'dry-run'],
+    ['state_present', nextJson.state_present, true],
+    ['summary.status', nextJson.summary?.status, 'ready'],
+    ['summary.manual_action', nextJson.summary?.manual_action, 'resolve review feedback explicitly before finishing.'],
+    ['summary.task_readiness', nextJson.summary?.task_readiness, 'ready=2, waiting=1, blocked=1, completed=2'],
+  ], 'next --dry-run --json');
+  const dispatchIntentJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'next', '--dry-run', '--dispatch-intent', '--json', '--root', target], {}, options), 'next --dry-run --dispatch-intent --json');
+  assertJsonMarkers([
+    ['schema_version', dispatchIntentJson.schema_version, 1],
+    ['command', dispatchIntentJson.command, 'next'],
+    ['mode', dispatchIntentJson.mode, 'dispatch-intent'],
+    ['state_present', dispatchIntentJson.state_present, true],
+    ['intent.from_skill', dispatchIntentJson.intent?.from_skill, 'vibe-test-driven-development'],
+    ['intent.target_skill', dispatchIntentJson.intent?.target_skill, 'none'],
+    ['intent.adapter_ready', dispatchIntentJson.intent?.adapter_ready, false],
+    ['gates.transition.allowed', dispatchIntentJson.gates?.transition?.allowed, true],
+    ['gates.review', dispatchIntentJson.gates?.review, 'blocked'],
+    ['gates.task_readiness', dispatchIntentJson.gates?.task_readiness, 'blocked'],
+    ['safety.writes', dispatchIntentJson.safety?.writes, false],
+    ['safety.auto_execution', dispatchIntentJson.safety?.auto_execution, false],
+    ['platform_hints.cursor.entry_file', dispatchIntentJson.platform_hints?.cursor?.entry_file, 'AGENTS.md'],
+  ], 'next --dry-run --dispatch-intent --json');
+  run('node', ['tools/vibe-runtime/index.mjs', 'next', '--dry-run', '--dispatch-intent', '--root', target], {
+    expectOutput: ['Vibecoding Runtime Dispatch Intent', 'Mode: dry-run dispatch-intent', 'Adapter ready: no', 'Transition gate: allowed', 'Review gate: blocked', 'Task readiness gate: blocked', '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);
+  assertStatePathAbsent(path.join(absoluteTarget, '.vibecoding-state', 'dispatches'), 'dispatch intent wrote unexpected dispatches directory');
+}
+
+export function runRuntimeHandoffSmoke(context, options) {
+  verifyIdleRuntimeState(context, options);
+  const { workflowFileBeforeRecord } = verifyHandoffValidationNoWrite(context, options);
+  const validationContext = { ...context, workflowFileBeforeRecord };
+  verifyInvalidHandoffValidation(validationContext, options);
+  verifyInvalidRecordHandoff(validationContext, options);
+  verifyArtifactTaskGuards(context, options);
+  verifyLedgerAndDispatchFlow(context, options);
+  verifyRecordedHandoffNext(context, options);
+}
+
+export function runRuntimeHandoffQualitySmoke(context, options) {
+  const {
+    target,
+    absoluteTarget,
+    blockedHandoffFile,
+    stoppedHandoffFile,
+    qualityHandoffFile,
+    qualityMissingContextHandoffFile,
+    qualityBlockedHandoffFile,
+    qualityStoppedWithoutReasonHandoffFile,
+  } = context;
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'record-handoff', '--from-file', qualityHandoffFile, '--root', target], {
+      expectOutput: ['Handoff quality:', '[warn] risks is empty', '[warn] acceptance is empty', '[warn] evidence is empty', 'Action: handoff was recorded. No next skill was executed.'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'record-handoff', '--from-file', qualityMissingContextHandoffFile, '--root', target], {
+      expectOutput: ['Handoff quality:', '[warn] scope is empty', '[warn] files is empty', 'Action: handoff was recorded. No next skill was executed.'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'record-handoff', '--from-file', qualityBlockedHandoffFile, '--root', target], {
+      expectOutput: ['Handoff quality:', '[warn] stop_condition is set; resolve it before continuing.', 'Action: handoff was recorded. No next skill was executed.'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'record-handoff', '--from-file', qualityStoppedWithoutReasonHandoffFile, '--root', target], {
+      expectOutput: ['Handoff quality:', '[warn] next_skill is none but stop_condition is empty; record why the workflow stops.', 'Action: handoff was recorded. No next skill was executed.'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'record-handoff', '--from-file', blockedHandoffFile, '--root', target], {}, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'next', '--dry-run', '--root', target], {
+      expectOutput: ['Status: blocked', 'Stop condition: waiting for user confirmation', 'Manual action: resolve stop_condition before continuing.'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'record-handoff', '--from-file', stoppedHandoffFile, '--root', target], {}, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'next', '--dry-run', '--root', target], {
+      expectOutput: ['Status: stopped', 'Next skill: none', 'Manual action: no next skill is suggested.'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'reset', '--confirm', '--root', target], {}, options);
+
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) {
+      throw new Error('runtime ledger reset left .vibecoding-state behind');
+    }
+}

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

@@ -0,0 +1,9 @@
+export const RUNTIME_LEDGER_FIXTURE_TARGET = '.tmp/vibe-runtime-ledger';
+
+export const RUNTIME_LEDGER_SIDE_EFFECT_DIRS = Object.freeze([
+  '.tmp/vibe-runtime-task-filter-ledger',
+  '.tmp/vibe-runtime-clean-dispatch-intent-ledger',
+  '.tmp/vibe-runtime-scheduler-once-ledger',
+  '.tmp/vibe-runtime-scheduler-active-lease-ledger',
+  '.tmp/vibe-runtime-invalid-transition-dispatch-ledger',
+]);

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

@@ -0,0 +1,51 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { buildRuntimeDispatchFixtures } from './release-check-runtime-dispatch-fixtures.mjs';
+import { buildRuntimeHandoffFixtures } from './release-check-runtime-handoff-fixtures.mjs';
+import {
+  RUNTIME_LEDGER_FIXTURE_TARGET,
+  RUNTIME_LEDGER_SIDE_EFFECT_DIRS,
+} from './release-check-runtime-ledger-fixture-specs.mjs';
+import { buildRuntimeSchedulerFixtures } from './release-check-runtime-scheduler-fixtures.mjs';
+import { buildRuntimeTaskFixtures } from './release-check-runtime-task-fixtures.mjs';
+import {
+  repoRoot,
+  tmpRoot,
+} from './release-check-runtime.mjs';
+
+export function buildRuntimeLedgerFixtureContext(options) {
+  const target = RUNTIME_LEDGER_FIXTURE_TARGET;
+  const absoluteTarget = path.join(repoRoot, target);
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  fs.mkdirSync(absoluteTarget, { recursive: true });
+  fs.mkdirSync(tmpRoot, { recursive: true });
+
+  const { cleanupFiles: handoffCleanupFiles, ...handoffFixtures } = buildRuntimeHandoffFixtures({ tmpRoot });
+  const { cleanupFiles: dispatchCleanupFiles, ...dispatchFixtures } = buildRuntimeDispatchFixtures({ tmpRoot });
+  const { cleanupFiles: taskCleanupFiles, ...taskFixtures } = buildRuntimeTaskFixtures({ tmpRoot, absoluteTarget });
+  const { buildReadySchedulerFixture } = buildRuntimeSchedulerFixtures({
+    options,
+    cleanDispatchIntentHandoffFile: dispatchFixtures.cleanDispatchIntentHandoffFile,
+  });
+
+  const cleanup = () => {
+    if (options.keepTmp) return;
+    fs.rmSync(absoluteTarget, { recursive: true, force: true });
+    for (const file of [...handoffCleanupFiles, ...dispatchCleanupFiles, ...taskCleanupFiles]) {
+      fs.rmSync(file, { force: true });
+    }
+    for (const directory of RUNTIME_LEDGER_SIDE_EFFECT_DIRS) {
+      fs.rmSync(path.join(repoRoot, directory), { recursive: true, force: true });
+    }
+  };
+
+  return {
+    target,
+    absoluteTarget,
+    ...handoffFixtures,
+    ...dispatchFixtures,
+    ...taskFixtures,
+    buildReadySchedulerFixture,
+    cleanup,
+  };
+}

package/tools/vibe-release-check/release-check-runtime-ledger-suite.mjs

@@ -0,0 +1,24 @@
+import { runRuntimeDaemonSmoke } from './release-check-runtime-daemon-suite.mjs';
+import { runRuntimeDispatchSmoke } from './release-check-runtime-dispatch-suite.mjs';
+import { runRuntimeExecutionSmoke } from './release-check-runtime-execution-suite.mjs';
+import { buildRuntimeLedgerFixtureContext } from './release-check-runtime-ledger-fixtures.mjs';
+import {
+  runRuntimeHandoffQualitySmoke,
+  runRuntimeHandoffSmoke,
+} from './release-check-runtime-handoff-suite.mjs';
+import { runRuntimeTaskArtifactSmoke } from './release-check-runtime-task-artifact-suite.mjs';
+
+export function runRuntimeLedgerSmoke(options) {
+  const context = buildRuntimeLedgerFixtureContext(options);
+
+  try {
+    runRuntimeHandoffSmoke(context, options);
+    const dispatchContext = runRuntimeDispatchSmoke(context, options);
+    runRuntimeExecutionSmoke(context, dispatchContext, options);
+    runRuntimeDaemonSmoke(context, dispatchContext, options);
+    runRuntimeTaskArtifactSmoke(context, options);
+    runRuntimeHandoffQualitySmoke(context, options);
+  } finally {
+    context.cleanup();
+  }
+}

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

@@ -0,0 +1,129 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import {
+  prepareSmokeTmpRoot,
+  writeSmokeJsonFixture,
+} from './release-check-json-assertion-helpers.mjs';
+import { parseJsonOutput, repoRoot, run } from './release-check-runtime.mjs';
+
+const artifactRootDirectoryName = ['.vibecoding', '-state'].join('');
+
+export const runtimeSchedulerFixtureSpec = {
+  contractSurface: 'tools/vibe-release-check',
+  configDirectoryName: '.vibecoding',
+  configFileName: 'config.json',
+  dispatchArtifactSubpath: [artifactRootDirectoryName, 'dispatches'],
+  profileConfig: {
+    automation_profile: 'autopilot-lab',
+    execution_profile: 'execution-enabled',
+    execution_profile_policy: 'controlled-local-runtime',
+  },
+  commands: {
+    recordHandoff: ({ cleanDispatchIntentHandoffFile, root }) => [
+      'tools/vibe-runtime/index.mjs',
+      'record-handoff',
+      '--from-file',
+      cleanDispatchIntentHandoffFile,
+      '--root',
+      root,
+    ],
+    nextDispatch: ({ root }) => [
+      'tools/vibe-runtime/index.mjs',
+      'next',
+      '--confirm',
+      '--dispatch',
+      '--json',
+      '--root',
+      root,
+    ],
+    claimDispatch: ({ dispatchFile, root }) => [
+      'tools/vibe-runtime/index.mjs',
+      'dispatches',
+      '--claim',
+      dispatchFile,
+      '--actor',
+      'release-check',
+      '--json',
+      '--root',
+      root,
+    ],
+    acknowledgeDispatch: ({ dispatchFile, root }) => [
+      'tools/vibe-runtime/index.mjs',
+      'dispatches',
+      '--ack',
+      dispatchFile,
+      '--actor',
+      'release-check',
+      '--status',
+      'picked',
+      '--reason',
+      'scheduler-fixture-ready',
+      '--json',
+      '--root',
+      root,
+    ],
+    candidate: ({ dispatchFile, root }) => [
+      'tools/vibe-runtime/index.mjs',
+      'execute',
+      '--from-dispatch',
+      dispatchFile,
+      '--candidate',
+      '--actor',
+      'release-check',
+      '--confirm',
+      '--json',
+      '--root',
+      root,
+    ],
+    approval: ({ candidateFile, root }) => [
+      'tools/vibe-runtime/index.mjs',
+      'execute',
+      '--approval-package',
+      '--approval',
+      candidateFile,
+      '--confirm',
+      '--json',
+      '--root',
+      root,
+    ],
+  },
+  labels: {
+    nextDispatch: ({ root }) => `scheduler fixture next --confirm --dispatch --json ${root}`,
+    claimDispatch: ({ root }) => `scheduler fixture dispatches --claim --json ${root}`,
+    acknowledgeDispatch: ({ root }) => `scheduler fixture dispatches --ack --json ${root}`,
+    candidate: ({ root }) => `scheduler fixture candidate --json ${root}`,
+    approval: ({ root }) => `scheduler fixture approval --json ${root}`,
+  },
+};
+
+function runSchedulerJsonStep(stepName, context, options) {
+  return parseJsonOutput(
+    run('node', runtimeSchedulerFixtureSpec.commands[stepName](context), {}, options),
+    runtimeSchedulerFixtureSpec.labels[stepName](context),
+  );
+}
+
+export function createRuntimeSchedulerFixtureBuilder({ options, cleanDispatchIntentHandoffFile }) {
+  return (schedulerTarget) => {
+    const absoluteSchedulerTarget = prepareSmokeTmpRoot(repoRoot, schedulerTarget);
+    const context = { cleanDispatchIntentHandoffFile, root: schedulerTarget };
+    writeSmokeJsonFixture(
+      repoRoot,
+      path.join(schedulerTarget, runtimeSchedulerFixtureSpec.configDirectoryName, runtimeSchedulerFixtureSpec.configFileName),
+      runtimeSchedulerFixtureSpec.profileConfig,
+    );
+    run('node', runtimeSchedulerFixtureSpec.commands.recordHandoff(context), {}, options);
+    runSchedulerJsonStep('nextDispatch', context, options);
+    const schedulerDispatchesDirectory = path.join(absoluteSchedulerTarget, ...runtimeSchedulerFixtureSpec.dispatchArtifactSubpath);
+    const schedulerDispatchFiles = fs.existsSync(schedulerDispatchesDirectory) ? fs.readdirSync(schedulerDispatchesDirectory) : [];
+    if (schedulerDispatchFiles.length !== 1) throw new Error(`scheduler fixture expected exactly one dispatch file for ${schedulerTarget}, found ${schedulerDispatchFiles.length}`);
+    const dispatchFile = schedulerDispatchFiles[0];
+    const dispatchContext = { ...context, dispatchFile };
+    runSchedulerJsonStep('claimDispatch', dispatchContext, options);
+    runSchedulerJsonStep('acknowledgeDispatch', dispatchContext, options);
+    const candidateJson = runSchedulerJsonStep('candidate', dispatchContext, options);
+    const approvalJson = runSchedulerJsonStep('approval', { ...context, candidateFile: candidateJson.candidate_file }, options);
+    return { root: schedulerTarget, absoluteRoot: absoluteSchedulerTarget, dispatchFile, candidateFile: candidateJson.candidate_file, approvalFile: approvalJson.approval_file };
+  };
+}

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

@@ -0,0 +1,10 @@
+import { createRuntimeSchedulerFixtureBuilder } from './release-check-runtime-scheduler-fixture-specs.mjs';
+
+export function buildRuntimeSchedulerFixtures({ options, cleanDispatchIntentHandoffFile }) {
+  return {
+    buildReadySchedulerFixture: createRuntimeSchedulerFixtureBuilder({
+      options,
+      cleanDispatchIntentHandoffFile,
+    }),
+  };
+}