@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-release-check/release-check-runtime-execution-scheduler-suite.mjs

@@ -0,0 +1,261 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  assertJsonMarkers,
+  parseJsonOutput,
+  run,
+} from './release-check-runtime.mjs';
+
+function runSchedulerPolicySmoke(cleanDispatchTarget, options) {
+  const schedulerPoliciesJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'scheduler-policies', '--list', '--json', '--root', cleanDispatchTarget], {}, options), 'scheduler-policies --list --json clean');
+  assertJsonMarkers([
+    ['schedulerPolicies.command', schedulerPoliciesJson.command, 'scheduler-policies'],
+    ['schedulerPolicies.mode', schedulerPoliciesJson.mode, 'scheduler-policy-list'],
+    ['schedulerPolicies.ok', schedulerPoliciesJson.ok, true],
+    ['schedulerPolicies.policies.length', schedulerPoliciesJson.policies?.length, 4],
+    ['schedulerPolicies.runtime_budget.max_runs_per_invocation', schedulerPoliciesJson.runtime_budget?.max_runs_per_invocation, 1],
+    ['schedulerPolicies.runtime_budget.kill_switch', schedulerPoliciesJson.runtime_budget?.kill_switch, false],
+  ], 'scheduler-policies --list --json clean');
+  const schedulerPolicyShowJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'scheduler-policies', '--show', 'single-local-auto-run', '--json', '--root', cleanDispatchTarget], {}, options), 'scheduler-policies --show --json clean');
+  assertJsonMarkers([
+    ['schedulerPolicyShow.mode', schedulerPolicyShowJson.mode, 'scheduler-policy-show'],
+    ['schedulerPolicyShow.policy.stage', schedulerPolicyShowJson.policy?.stage, 'Stage 22'],
+    ['schedulerPolicyShow.policy.profile', schedulerPolicyShowJson.policy?.profile, 'single-local-auto-run'],
+    ['schedulerPolicyShow.policy.default_enabled', schedulerPolicyShowJson.policy?.default_enabled, false],
+    ['schedulerPolicyShow.policy.auto_run_allowed', schedulerPolicyShowJson.policy?.auto_run_allowed, true],
+    ['schedulerPolicyShow.runtime_budget.retry_allowed', schedulerPolicyShowJson.runtime_budget?.retry_allowed, false],
+    ['schedulerPolicyShow.verification.ok', schedulerPolicyShowJson.verification?.ok, true],
+  ], 'scheduler-policies --show --json clean');
+  run('node', ['tools/vibe-runtime/index.mjs', 'scheduler-policies', '--show', 'unknown-scheduler-profile', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['Unknown scheduler policy profile: unknown-scheduler-profile'],
+  }, options);
+}
+
+function runSchedulerPlanSmoke(dispatchContext, approvalContext, options) {
+  const { cleanDispatchTarget, absoluteCleanDispatchTarget } = dispatchContext;
+  const { candidateFile } = approvalContext;
+  const schedulerPlansDirectory = path.join(absoluteCleanDispatchTarget, '.vibecoding-state', 'scheduler-plans');
+  const schedulerRunsDirectory = path.join(absoluteCleanDispatchTarget, '.vibecoding-state', 'scheduler-runs');
+  const schedulerLeasesDirectory = path.join(absoluteCleanDispatchTarget, '.vibecoding-state', 'scheduler-leases');
+  const schedulerPlanJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'scheduler', '--plan', '--json', '--root', cleanDispatchTarget], {}, options), 'scheduler --plan --json clean');
+  assertJsonMarkers([
+    ['schedulerPlan.command', schedulerPlanJson.command, 'scheduler'],
+    ['schedulerPlan.mode', schedulerPlanJson.mode, 'scheduler-plan'],
+    ['schedulerPlan.ok', schedulerPlanJson.ok, true],
+    ['schedulerPlan.scheduler.default_enabled', schedulerPlanJson.scheduler?.default_enabled, false],
+    ['schedulerPlan.scheduler.worker', schedulerPlanJson.scheduler?.worker, false],
+    ['schedulerPlan.scheduler.loop', schedulerPlanJson.scheduler?.loop, false],
+    ['schedulerPlan.scheduler.writes', schedulerPlanJson.scheduler?.writes, false],
+    ['schedulerPlan.scheduler.eligible.length', schedulerPlanJson.scheduler?.eligible?.length, 1],
+    ['schedulerPlan.scheduler.blocked.length', schedulerPlanJson.scheduler?.blocked?.length, 0],
+    ['schedulerPlan.scheduler.selected.candidate_file', schedulerPlanJson.scheduler?.selected?.candidate_file, candidateFile],
+    ['schedulerPlan.scheduler.recovery_hints.eligible_count.type', typeof schedulerPlanJson.scheduler?.recovery_hints?.eligible_count, 'number'],
+    ['schedulerPlan.scheduler.recovery_classification_digest.type', typeof schedulerPlanJson.scheduler?.recovery_classification_digest, 'string'],
+    ['schedulerPlan.policy.profile', schedulerPlanJson.policy?.profile, 'single-local-auto-run'],
+    ['schedulerPlan.runtime_budget.max_runs_per_invocation', schedulerPlanJson.runtime_budget?.max_runs_per_invocation, 1],
+    ['schedulerPlan.safety.stage', schedulerPlanJson.safety?.stage, 'Stage 21'],
+    ['schedulerPlan.safety.writes', schedulerPlanJson.safety?.writes, false],
+    ['schedulerPlan.safety.scheduler_plan_artifact', schedulerPlanJson.safety?.scheduler_plan_artifact, false],
+    ['schedulerPlan.safety.skill_execution', schedulerPlanJson.safety?.skill_execution, false],
+  ], 'scheduler --plan --json clean');
+  if (fs.existsSync(schedulerPlansDirectory)) throw new Error('scheduler --plan preview wrote unexpected scheduler-plans directory');
+  if (fs.existsSync(schedulerRunsDirectory)) throw new Error('scheduler --plan preview wrote unexpected scheduler-runs directory');
+  if (fs.existsSync(schedulerLeasesDirectory)) throw new Error('scheduler --plan preview wrote unexpected scheduler-leases directory');
+  const schedulerPlanConfirmJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'scheduler', '--plan', '--confirm', '--json', '--root', cleanDispatchTarget], {}, options), 'scheduler --plan --confirm --json clean');
+  assertJsonMarkers([
+    ['schedulerPlanConfirm.mode', schedulerPlanConfirmJson.mode, 'scheduler-plan'],
+    ['schedulerPlanConfirm.scheduler.writes', schedulerPlanConfirmJson.scheduler?.writes, true],
+    ['schedulerPlanConfirm.safety.scheduler_plan_artifact', schedulerPlanConfirmJson.safety?.scheduler_plan_artifact, true],
+    ['schedulerPlanConfirm.scheduler_plan_file.type', typeof schedulerPlanConfirmJson.scheduler_plan_file, 'string'],
+  ], 'scheduler --plan --confirm --json clean');
+  const schedulerPlanFile = schedulerPlanConfirmJson.scheduler_plan_file;
+  if (!schedulerPlanFile || !fs.existsSync(path.join(schedulerPlansDirectory, schedulerPlanFile))) throw new Error(`scheduler plan artifact missing: ${schedulerPlanFile}`);
+  const schedulerVerifyPlanJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'scheduler', '--verify-plan', schedulerPlanFile, '--json', '--root', cleanDispatchTarget], {}, options), 'scheduler --verify-plan --json clean');
+  assertJsonMarkers([
+    ['schedulerVerifyPlan.mode', schedulerVerifyPlanJson.mode, 'scheduler-plan-verify'],
+    ['schedulerVerifyPlan.ok', schedulerVerifyPlanJson.ok, true],
+    ['schedulerVerifyPlan.verification.ok', schedulerVerifyPlanJson.verification?.ok, true],
+  ], 'scheduler --verify-plan --json clean');
+  const schedulerListPlansJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'scheduler', '--list-plans', '--json', '--root', cleanDispatchTarget], {}, options), 'scheduler --list-plans --json clean');
+  assertJsonMarkers([
+    ['schedulerListPlans.mode', schedulerListPlansJson.mode, 'scheduler-plan-list'],
+    ['schedulerListPlans.summary.count', schedulerListPlansJson.summary?.count, 1],
+    ['schedulerListPlans.summary.failed_count', schedulerListPlansJson.summary?.failed_count, 0],
+  ], 'scheduler --list-plans --json clean');
+  const corruptedSchedulerPlan = JSON.parse(fs.readFileSync(path.join(schedulerPlansDirectory, schedulerPlanFile), 'utf8'));
+  corruptedSchedulerPlan.scheduler.scheduler_policy_digest = 'bad-scheduler-policy-digest';
+  fs.writeFileSync(path.join(schedulerPlansDirectory, 'bad-digest.scheduler-plan.json'), `${JSON.stringify(corruptedSchedulerPlan, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'scheduler', '--verify-plan', 'bad-digest.scheduler-plan.json', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['scheduler plan verification failed:', 'scheduler policy digest mismatch'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'scheduler', '--verify-plan', '..\\escape.scheduler-plan.json', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['Scheduler plan file must not include path separators'],
+  }, options);
+  const schedulerOncePreviewJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'scheduler', '--once', '--json', '--root', cleanDispatchTarget], {}, options), 'scheduler --once --json clean');
+  assertJsonMarkers([
+    ['schedulerOncePreview.mode', schedulerOncePreviewJson.mode, 'scheduler-once-preview'],
+    ['schedulerOncePreview.scheduler_run.writes', schedulerOncePreviewJson.scheduler_run?.writes, false],
+    ['schedulerOncePreview.scheduler_run.selected_candidate', schedulerOncePreviewJson.scheduler_run?.selected_candidate, candidateFile],
+    ['schedulerOncePreview.scheduler_run.execution_file', schedulerOncePreviewJson.scheduler_run?.execution_file, ''],
+    ['schedulerOncePreview.safety.writes', schedulerOncePreviewJson.safety?.writes, false],
+    ['schedulerOncePreview.safety.scheduler_run_artifact', schedulerOncePreviewJson.safety?.scheduler_run_artifact, false],
+    ['schedulerOncePreview.safety.scheduler_lease_artifact', schedulerOncePreviewJson.safety?.scheduler_lease_artifact, false],
+  ], 'scheduler --once --json clean');
+  if (fs.existsSync(schedulerRunsDirectory)) throw new Error('scheduler --once preview wrote unexpected scheduler-runs directory');
+  if (fs.existsSync(schedulerLeasesDirectory)) throw new Error('scheduler --once preview wrote unexpected scheduler-leases directory');
+}
+
+function runSchedulerOnceSmoke(buildReadySchedulerFixture, options) {
+  const schedulerOnceFixture = buildReadySchedulerFixture('.tmp/vibe-runtime-scheduler-once-ledger');
+  const schedulerOnceRunsDirectory = path.join(schedulerOnceFixture.absoluteRoot, '.vibecoding-state', 'scheduler-runs');
+  const schedulerOnceLeasesDirectory = path.join(schedulerOnceFixture.absoluteRoot, '.vibecoding-state', 'scheduler-leases');
+  const schedulerOnceExecutionsDirectory = path.join(schedulerOnceFixture.absoluteRoot, '.vibecoding-state', 'executions');
+  const schedulerOnceJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'scheduler', '--once', '--confirm', '--json', '--root', schedulerOnceFixture.root], {}, options), 'scheduler --once --confirm --json fixture');
+  assertJsonMarkers([
+    ['schedulerOnce.command', schedulerOnceJson.command, 'scheduler'],
+    ['schedulerOnce.mode', schedulerOnceJson.mode, 'scheduler-once-run'],
+    ['schedulerOnce.ok', schedulerOnceJson.ok, true],
+    ['schedulerOnce.scheduler_run.selected_candidate', schedulerOnceJson.scheduler_run?.selected_candidate, schedulerOnceFixture.candidateFile],
+    ['schedulerOnce.scheduler_run.selected_approval', schedulerOnceJson.scheduler_run?.selected_approval, schedulerOnceFixture.approvalFile],
+    ['schedulerOnce.scheduler_run.execution_status', schedulerOnceJson.scheduler_run?.execution_status, 'succeeded'],
+    ['schedulerOnce.scheduler_run.retry_allowed', schedulerOnceJson.scheduler_run?.retry_allowed, false],
+    ['schedulerOnce.scheduler_run.recovery_apply_allowed', schedulerOnceJson.scheduler_run?.recovery_apply_allowed, false],
+    ['schedulerOnce.scheduler_run.loop', schedulerOnceJson.scheduler_run?.loop, false],
+    ['schedulerOnce.scheduler_run.daemon', schedulerOnceJson.scheduler_run?.daemon, false],
+    ['schedulerOnce.safety.stage', schedulerOnceJson.safety?.stage, 'Stage 23'],
+    ['schedulerOnce.safety.scheduler_run_artifact', schedulerOnceJson.safety?.scheduler_run_artifact, true],
+    ['schedulerOnce.safety.scheduler_lease_artifact', schedulerOnceJson.safety?.scheduler_lease_artifact, true],
+    ['schedulerOnce.safety.skill_execution', schedulerOnceJson.safety?.skill_execution, false],
+    ['schedulerOnce.scheduler_run_file.type', typeof schedulerOnceJson.scheduler_run_file, 'string'],
+  ], 'scheduler --once --confirm --json fixture');
+  if (!fs.existsSync(path.join(schedulerOnceRunsDirectory, schedulerOnceJson.scheduler_run_file))) throw new Error(`scheduler once run artifact missing: ${schedulerOnceJson.scheduler_run_file}`);
+  if (!fs.existsSync(path.join(schedulerOnceExecutionsDirectory, schedulerOnceJson.scheduler_run?.execution_file || ''))) throw new Error(`scheduler once execution artifact missing: ${schedulerOnceJson.scheduler_run?.execution_file}`);
+  const schedulerOnceLease = JSON.parse(fs.readFileSync(path.join(schedulerOnceLeasesDirectory, schedulerOnceJson.scheduler_run.scheduler_lease_file), 'utf8'));
+  assertJsonMarkers([
+    ['schedulerOnceLease.command', schedulerOnceLease.command, 'scheduler'],
+    ['schedulerOnceLease.mode', schedulerOnceLease.mode, 'scheduler-lease'],
+    ['schedulerOnceLease.lease.active', schedulerOnceLease.lease?.active, false],
+    ['schedulerOnceLease.lease.status', schedulerOnceLease.lease?.status, 'completed'],
+  ], 'scheduler once completed lease');
+  run('node', ['tools/vibe-runtime/index.mjs', 'scheduler', '--once', '--confirm', '--root', schedulerOnceFixture.root], {
+    allowFailure: true,
+    expectOutput: ['scheduler once found no ready queue item'],
+  }, options);
+  fs.rmSync(schedulerOnceFixture.absoluteRoot, { recursive: true, force: true });
+}
+
+function runSchedulerRecoverySmoke(buildReadySchedulerFixture, options) {
+  const schedulerRecoveryFixture = buildReadySchedulerFixture('.tmp/vibe-runtime-scheduler-recovery-once-ledger');
+  const schedulerRecoveryRunsDirectory = path.join(schedulerRecoveryFixture.absoluteRoot, '.vibecoding-state', 'scheduler-runs');
+  const schedulerRecoveryExecutionsDirectory = path.join(schedulerRecoveryFixture.absoluteRoot, '.vibecoding-state', 'executions');
+  const schedulerRecoveryClassificationsDirectory = path.join(schedulerRecoveryFixture.absoluteRoot, '.vibecoding-state', 'recovery-classifications');
+  const schedulerRecoveryRecoveryRunsDirectory = path.join(schedulerRecoveryFixture.absoluteRoot, '.vibecoding-state', 'recovery-runs');
+  const schedulerRecoveryRetryPackagesDirectory = path.join(schedulerRecoveryFixture.absoluteRoot, '.vibecoding-state', 'retry-packages');
+  const schedulerRecoverySeedJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'scheduler', '--once', '--confirm', '--json', '--root', schedulerRecoveryFixture.root], {}, options), 'scheduler recovery seed once --json fixture');
+  const schedulerRecoverySeedExecution = JSON.parse(fs.readFileSync(path.join(schedulerRecoveryExecutionsDirectory, schedulerRecoverySeedJson.scheduler_run?.execution_file || ''), 'utf8'));
+  schedulerRecoverySeedExecution.execution.status = 'failed';
+  schedulerRecoverySeedExecution.execution.lifecycle = [
+    schedulerRecoverySeedExecution.execution.lifecycle[0],
+    { status: 'failed', at: new Date().toISOString() },
+  ];
+  schedulerRecoverySeedExecution.execution.ended_at = schedulerRecoverySeedExecution.execution.lifecycle[1].at;
+  schedulerRecoverySeedExecution.execution.exit_code = 1;
+  schedulerRecoverySeedExecution.evidence.stdout_excerpt = 'scheduler recovery seed failed execution';
+  schedulerRecoverySeedExecution.evidence.stderr_excerpt = 'release check scheduler recovery fixture';
+  fs.writeFileSync(path.join(schedulerRecoveryExecutionsDirectory, `failed-${schedulerRecoverySeedJson.scheduler_run.execution_file}`), `${JSON.stringify(schedulerRecoverySeedExecution, null, 2)}\n`, 'utf8');
+  const schedulerRecoveryPreviewJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'scheduler', '--once', '--recover', '--json', '--root', schedulerRecoveryFixture.root], {}, options), 'scheduler --once --recover --json fixture');
+  assertJsonMarkers([
+    ['schedulerRecoveryPreview.mode', schedulerRecoveryPreviewJson.mode, 'scheduler-recovery-once-preview'],
+    ['schedulerRecoveryPreview.scheduler_run.writes', schedulerRecoveryPreviewJson.scheduler_run?.writes, false],
+    ['schedulerRecoveryPreview.scheduler_run.recovery_mode', schedulerRecoveryPreviewJson.scheduler_run?.recovery_mode, true],
+    ['schedulerRecoveryPreview.scheduler_run.recovery_apply_allowed', schedulerRecoveryPreviewJson.scheduler_run?.recovery_apply_allowed, true],
+    ['schedulerRecoveryPreview.scheduler_run.recovery_run_file', schedulerRecoveryPreviewJson.scheduler_run?.recovery_run_file, ''],
+    ['schedulerRecoveryPreview.scheduler_run.retry_package_file', schedulerRecoveryPreviewJson.scheduler_run?.retry_package_file, ''],
+    ['schedulerRecoveryPreview.safety.writes', schedulerRecoveryPreviewJson.safety?.writes, false],
+    ['schedulerRecoveryPreview.safety.recovery_apply', schedulerRecoveryPreviewJson.safety?.recovery_apply, false],
+  ], 'scheduler --once --recover --json fixture');
+  if (fs.existsSync(schedulerRecoveryClassificationsDirectory)) throw new Error('scheduler --once --recover preview wrote unexpected recovery-classifications directory');
+  if (fs.existsSync(schedulerRecoveryRecoveryRunsDirectory)) throw new Error('scheduler --once --recover preview wrote unexpected recovery-runs directory');
+  if (fs.existsSync(schedulerRecoveryRetryPackagesDirectory)) throw new Error('scheduler --once --recover preview wrote unexpected retry-packages directory');
+  const schedulerRecoveryOnceJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'scheduler', '--once', '--recover', '--confirm', '--json', '--root', schedulerRecoveryFixture.root], {}, options), 'scheduler --once --recover --confirm --json fixture');
+  assertJsonMarkers([
+    ['schedulerRecoveryOnce.command', schedulerRecoveryOnceJson.command, 'scheduler'],
+    ['schedulerRecoveryOnce.mode', schedulerRecoveryOnceJson.mode, 'scheduler-recovery-once-run'],
+    ['schedulerRecoveryOnce.ok', schedulerRecoveryOnceJson.ok, true],
+    ['schedulerRecoveryOnce.scheduler_run.recovery_mode', schedulerRecoveryOnceJson.scheduler_run?.recovery_mode, true],
+    ['schedulerRecoveryOnce.scheduler_run.recovery_apply_allowed', schedulerRecoveryOnceJson.scheduler_run?.recovery_apply_allowed, true],
+    ['schedulerRecoveryOnce.scheduler_run.retry_allowed', schedulerRecoveryOnceJson.scheduler_run?.retry_allowed, false],
+    ['schedulerRecoveryOnce.safety.stage', schedulerRecoveryOnceJson.safety?.stage, 'Stage 26'],
+    ['schedulerRecoveryOnce.safety.recovery_apply', schedulerRecoveryOnceJson.safety?.recovery_apply, true],
+    ['schedulerRecoveryOnce.safety.auto_retry', schedulerRecoveryOnceJson.safety?.auto_retry, false],
+    ['schedulerRecoveryOnce.scheduler_run_file.type', typeof schedulerRecoveryOnceJson.scheduler_run_file, 'string'],
+  ], 'scheduler --once --recover --confirm --json fixture');
+  if (!fs.existsSync(path.join(schedulerRecoveryRunsDirectory, schedulerRecoveryOnceJson.scheduler_run_file))) throw new Error(`scheduler recovery run artifact missing: ${schedulerRecoveryOnceJson.scheduler_run_file}`);
+  if (!fs.existsSync(path.join(schedulerRecoveryClassificationsDirectory, schedulerRecoveryOnceJson.scheduler_run?.recovery_classification_file || ''))) throw new Error(`scheduler recovery classification missing: ${schedulerRecoveryOnceJson.scheduler_run?.recovery_classification_file}`);
+  if (!fs.existsSync(path.join(schedulerRecoveryRecoveryRunsDirectory, schedulerRecoveryOnceJson.scheduler_run?.recovery_run_file || ''))) throw new Error(`scheduler recovery apply run missing: ${schedulerRecoveryOnceJson.scheduler_run?.recovery_run_file}`);
+  if (!fs.existsSync(path.join(schedulerRecoveryRetryPackagesDirectory, schedulerRecoveryOnceJson.scheduler_run?.retry_package_file || ''))) throw new Error(`scheduler recovery retry package missing: ${schedulerRecoveryOnceJson.scheduler_run?.retry_package_file}`);
+  run('node', ['tools/vibe-runtime/index.mjs', 'scheduler', '--once', '--recover', '--confirm', '--root', schedulerRecoveryFixture.root], {
+    allowFailure: true,
+    expectOutput: ['recovery finding was already applied'],
+  }, options);
+  fs.rmSync(schedulerRecoveryFixture.absoluteRoot, { recursive: true, force: true });
+}
+
+function runActiveSchedulerLeaseSmoke(buildReadySchedulerFixture, options) {
+  const schedulerBlockedFixture = buildReadySchedulerFixture('.tmp/vibe-runtime-scheduler-active-lease-ledger');
+  const activeSchedulerLeaseDirectory = path.join(schedulerBlockedFixture.absoluteRoot, '.vibecoding-state', 'scheduler-leases');
+  fs.mkdirSync(activeSchedulerLeaseDirectory, { recursive: true });
+  fs.writeFileSync(path.join(activeSchedulerLeaseDirectory, 'active.scheduler-lease.json'), `${JSON.stringify({ schema_version: 1, command: 'scheduler', mode: 'scheduler-lease', lease: { active: true, status: 'active' } }, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'scheduler', '--once', '--confirm', '--root', schedulerBlockedFixture.root], {
+    allowFailure: true,
+    expectOutput: ['active scheduler lease already exists'],
+  }, options);
+  fs.rmSync(schedulerBlockedFixture.absoluteRoot, { recursive: true, force: true });
+}
+
+function runQueueValidationSmoke(dispatchContext, approvalContext, options) {
+  const { cleanDispatchTarget } = dispatchContext;
+  const { candidatesDirectory, executionQueueDirectory, candidateFile, queueFile } = approvalContext;
+  const corruptedQueue = JSON.parse(fs.readFileSync(path.join(executionQueueDirectory, queueFile), 'utf8'));
+  corruptedQueue.safety.queue_artifact = false;
+  fs.writeFileSync(path.join(executionQueueDirectory, 'bad-queue.queue.json'), `${JSON.stringify(corruptedQueue, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'queue', '--verify', 'bad-queue.queue.json', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['queue verification failed:', 'safety.queue_artifact must be true'],
+  }, options);
+  const badItemQueue = JSON.parse(fs.readFileSync(path.join(executionQueueDirectory, queueFile), 'utf8'));
+  badItemQueue.queue.items[0].status = 'runnable';
+  fs.writeFileSync(path.join(executionQueueDirectory, 'bad-item.queue.json'), `${JSON.stringify(badItemQueue, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'queue', '--verify', 'bad-item.queue.json', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['queue verification failed:', 'queue.items.0.status must be ready or blocked'],
+  }, options);
+  const badCandidateQueueScan = JSON.parse(fs.readFileSync(path.join(candidatesDirectory, candidateFile), 'utf8'));
+  badCandidateQueueScan.schema_version = 999;
+  fs.writeFileSync(path.join(candidatesDirectory, 'bad-schema.candidate.json'), `${JSON.stringify(badCandidateQueueScan, null, 2)}\n`, 'utf8');
+  const blockedQueueScanJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'queue', '--scan', '--json', '--root', cleanDispatchTarget], {}, options), 'queue --scan --json corrupted candidate');
+  const blockedBadCandidate = blockedQueueScanJson.queue?.blocked?.find((item) => item.candidate_file === 'bad-schema.candidate.json');
+  assertJsonMarkers([
+    ['blockedQueue.mode', blockedQueueScanJson.mode, 'queue-scan'],
+    ['blockedQueue.badCandidate.status', blockedBadCandidate?.status, 'blocked'],
+    ['blockedQueue.badCandidate.reason', blockedBadCandidate?.blocked_reasons?.[0], 'schema_version must be 1'],
+    ['blockedQueue.safety.runtime_action', blockedQueueScanJson.safety?.runtime_action, false],
+  ], 'queue --scan corrupted candidate is isolated');
+  run('node', ['tools/vibe-runtime/index.mjs', 'queue', '--verify', '..\\escape.queue.json', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['Queue file must not include path separators'],
+  }, options);
+}
+
+export function runRuntimeExecutionSchedulerSmoke(context, dispatchContext, approvalContext, options) {
+  const { buildReadySchedulerFixture } = context;
+  runSchedulerPolicySmoke(dispatchContext.cleanDispatchTarget, options);
+  runSchedulerPlanSmoke(dispatchContext, approvalContext, options);
+  runSchedulerOnceSmoke(buildReadySchedulerFixture, options);
+  runSchedulerRecoverySmoke(buildReadySchedulerFixture, options);
+  runActiveSchedulerLeaseSmoke(buildReadySchedulerFixture, options);
+  runQueueValidationSmoke(dispatchContext, approvalContext, options);
+}

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

@@ -0,0 +1,11 @@
+import { runRuntimeExecutionApprovalSmoke } from './release-check-runtime-execution-approval-suite.mjs';
+import { runRuntimeExecutionBaseSmoke } from './release-check-runtime-execution-base-suite.mjs';
+import { runRuntimeExecutionRecoverySmoke } from './release-check-runtime-execution-recovery-suite.mjs';
+import { runRuntimeExecutionSchedulerSmoke } from './release-check-runtime-execution-scheduler-suite.mjs';
+
+export function runRuntimeExecutionSmoke(context, dispatchContext, options) {
+  const executionBaseContext = runRuntimeExecutionBaseSmoke(dispatchContext, options);
+  const approvalContext = runRuntimeExecutionApprovalSmoke(dispatchContext, executionBaseContext, options);
+  runRuntimeExecutionSchedulerSmoke(context, dispatchContext, approvalContext, options);
+  runRuntimeExecutionRecoverySmoke(dispatchContext, executionBaseContext, approvalContext, options);
+}