@jtf19/vibecoding-kit 0.1.0

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

@@ -0,0 +1,412 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  assertJsonMarkers,
+  parseJsonOutput,
+  run,
+} from './release-check-runtime.mjs';
+
+function writeJsonFixture(directory, fileName, value) {
+  fs.writeFileSync(path.join(directory, fileName), `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}
+
+function verifyApprovalNegativeFixtures(context, options) {
+  const { cleanDispatchTarget, dispatchFilesAfterText, candidatesDirectory, approvalsDirectory, candidateFile, approvalFile } = context;
+  const missingCandidatePolicyDigest = JSON.parse(fs.readFileSync(path.join(candidatesDirectory, candidateFile), 'utf8'));
+  delete missingCandidatePolicyDigest.policy_evaluation.policy_digest;
+  writeJsonFixture(candidatesDirectory, 'missing-policy-digest.candidate.json', missingCandidatePolicyDigest);
+  run('node', ['tools/vibe-runtime/index.mjs', 'executions', '--verify', 'missing-policy-digest.candidate.json', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['execution verification failed:', 'candidate.policy_evaluation.policy_digest is required'],
+  }, options);
+  const badPolicyApproval = JSON.parse(fs.readFileSync(path.join(approvalsDirectory, approvalFile), 'utf8'));
+  badPolicyApproval.approval.policy_digest = 'bad-policy-digest';
+  writeJsonFixture(approvalsDirectory, 'bad-policy.approval.json', badPolicyApproval);
+  run('node', ['tools/vibe-runtime/index.mjs', 'execute', '--from-dispatch', dispatchFilesAfterText[0], '--confirm', '--actor', 'release-check', '--run', '--auto-run', '--approval', 'bad-policy.approval.json', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['approval policy digest mismatch'],
+  }, options);
+  const missingApprovalPolicyDigest = JSON.parse(fs.readFileSync(path.join(approvalsDirectory, approvalFile), 'utf8'));
+  delete missingApprovalPolicyDigest.approval.policy_digest;
+  writeJsonFixture(approvalsDirectory, 'missing-policy-digest.approval.json', missingApprovalPolicyDigest);
+  run('node', ['tools/vibe-runtime/index.mjs', 'execute', '--from-dispatch', dispatchFilesAfterText[0], '--confirm', '--actor', 'release-check', '--run', '--auto-run', '--approval', 'missing-policy-digest.approval.json', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['approval verification failed:', 'approval.policy_digest is required'],
+  }, options);
+  const unknownActionCandidate = JSON.parse(fs.readFileSync(path.join(candidatesDirectory, candidateFile), 'utf8'));
+  unknownActionCandidate.candidate.runtime_action = 'unknown-runtime-action';
+  unknownActionCandidate.candidate.runtime_action_catalog.action_id = 'unknown-runtime-action';
+  writeJsonFixture(candidatesDirectory, 'unknown-action.candidate.json', unknownActionCandidate);
+  run('node', ['tools/vibe-runtime/index.mjs', 'executions', '--verify', 'unknown-action.candidate.json', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['execution verification failed:', 'candidate runtime action is not in catalog'],
+  }, options);
+  const revokedApprovalJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'execute', '--approval-package', '--approval', candidateFile, '--confirm', '--json', '--root', cleanDispatchTarget], {}, options), 'execute --approval-package revoked fixture --json clean');
+  const revokedApprovalFile = revokedApprovalJson.approval_file;
+  run('node', ['tools/vibe-runtime/index.mjs', 'approvals', '--transition', revokedApprovalFile, '--status', 'revoked', '--actor', 'release-check', '--reason', 'negative-smoke-revoked-approval', '--confirm', '--root', cleanDispatchTarget], {
+    expectOutput: ['Vibecoding Runtime Approval Lifecycle', 'Lifecycle state: revoked', 'Action: approval lifecycle transition was written. Approval artifact was not modified and no runtime action occurred.'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'execute', '--from-dispatch', dispatchFilesAfterText[0], '--confirm', '--actor', 'release-check', '--run', '--auto-run', '--approval', revokedApprovalFile, '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['approval lifecycle gate failed:', 'approval lifecycle state is revoked'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'execute', '--from-dispatch', dispatchFilesAfterText[0], '--confirm', '--actor', 'release-check', '--run', '--auto-run', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['execute --auto-run requires --approval <approval-file>'],
+  }, options);
+}
+
+function verifyControlledAutoRun(context, options) {
+  const { cleanDispatchTarget, dispatchFilesAfterText, autoRunLocksDirectory, approvalFile } = context;
+  const controlledAutoRunJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'execute', '--from-dispatch', dispatchFilesAfterText[0], '--confirm', '--actor', 'release-check', '--run', '--auto-run', '--approval', approvalFile, '--json', '--root', cleanDispatchTarget], {}, options), 'execute --auto-run --json clean');
+  assertJsonMarkers([
+    ['mode', controlledAutoRunJson.mode, 'controlled-auto-run'],
+    ['execution.status', controlledAutoRunJson.execution?.status, 'succeeded'],
+    ['execution.auto_controlled', controlledAutoRunJson.execution?.auto_controlled, true],
+    ['execution.approval_file', controlledAutoRunJson.execution?.approval_file, approvalFile],
+    ['execution.approval_digest.type', typeof controlledAutoRunJson.execution?.approval_digest, 'string'],
+    ['execution.lock_digest.type', typeof controlledAutoRunJson.execution?.lock_digest, 'string'],
+    ['safety.auto_execution', controlledAutoRunJson.safety?.auto_execution, true],
+    ['safety.controlled_auto_execution', controlledAutoRunJson.safety?.controlled_auto_execution, true],
+    ['safety.runtime_action', controlledAutoRunJson.safety?.runtime_action, true],
+    ['safety.skill_execution', controlledAutoRunJson.safety?.skill_execution, false],
+    ['safety.business_source_write', controlledAutoRunJson.safety?.business_source_write, false],
+  ], 'execute --auto-run --json clean');
+  if (!fs.existsSync(autoRunLocksDirectory) || fs.readdirSync(autoRunLocksDirectory).length !== 1) throw new Error('controlled auto-run did not create exactly one lock');
+  const controlledAutoRunFile = controlledAutoRunJson.execution_file;
+  const consumedApprovalLifecycleJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'approvals', '--verify', approvalFile, '--json', '--root', cleanDispatchTarget], {}, options), 'approvals --verify consumed --json clean');
+  assertJsonMarkers([
+    ['consumedApproval.mode', consumedApprovalLifecycleJson.mode, 'approval-lifecycle-verify'],
+    ['consumedApproval.lifecycle_state', consumedApprovalLifecycleJson.lifecycle_state, 'consumed'],
+    ['consumedApproval.verification.ok', consumedApprovalLifecycleJson.verification?.ok, true],
+  ], 'approvals --verify consumed --json clean');
+  const controlledAutoVerifyJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'executions', '--verify', controlledAutoRunFile, '--json', '--root', cleanDispatchTarget], {}, options), 'executions --verify controlled auto-run');
+  assertJsonMarkers([
+    ['summary.status', controlledAutoVerifyJson.summary?.status, 'succeeded'],
+    ['summary.mode', controlledAutoVerifyJson.summary?.mode, 'controlled-auto-run'],
+    ['verification.ok', controlledAutoVerifyJson.verification?.ok, true],
+  ], 'executions --verify controlled auto-run');
+  return { controlledAutoRunFile };
+}
+
+function verifyLeaseAuditAndPreview(context, options) {
+  const { cleanDispatchTarget, autoRunLocksDirectory, recoveryPackagesDirectory } = context;
+  const leasesListJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'leases', '--list', '--json', '--root', cleanDispatchTarget], {}, options), 'leases --list --json clean');
+  assertJsonMarkers([
+    ['leases.command', leasesListJson.command, 'leases'],
+    ['leases.mode', leasesListJson.mode, 'lease-audit-list'],
+    ['leases.summary.count', leasesListJson.summary?.count, 1],
+    ['leases.summary.active_count', leasesListJson.summary?.active_count, 1],
+    ['leases.leases.0.status', leasesListJson.leases?.[0]?.status, 'active'],
+    ['leases.leases.0.heartbeat_present', leasesListJson.leases?.[0]?.heartbeat_present, false],
+  ], 'leases --list --json clean');
+  const leaseFile = leasesListJson.leases?.[0]?.file;
+  const leaseShowJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'leases', '--show', leaseFile, '--json', '--root', cleanDispatchTarget], {}, options), 'leases --show --json clean');
+  assertJsonMarkers([
+    ['leaseShow.mode', leaseShowJson.mode, 'lease-audit-show'],
+    ['leaseShow.verification.ok', leaseShowJson.verification?.ok, true],
+    ['leaseShow.lease.file', leaseShowJson.lease?.file, leaseFile],
+  ], 'leases --show --json clean');
+  fs.writeFileSync(path.join(autoRunLocksDirectory, 'corrupt.lock.json'), '{ invalid json', 'utf8');
+  const corruptLeaseListJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'leases', '--list', '--json', '--root', cleanDispatchTarget], {}, options), 'leases --list --json corrupt lock');
+  const corruptLease = corruptLeaseListJson.leases?.find((lease) => lease.file === 'corrupt.lock.json');
+  assertJsonMarkers([
+    ['corruptLease.status', corruptLease?.status, 'invalid'],
+    ['corruptLease.verification_ok', corruptLease?.verification_ok, false],
+  ], 'leases --list corrupt lock is isolated');
+  run('node', ['tools/vibe-runtime/index.mjs', 'leases', '--verify', 'corrupt.lock.json', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['lease verification failed:', 'Auto-run lock JSON is invalid: corrupt.lock.json'],
+  }, options);
+  if (fs.existsSync(recoveryPackagesDirectory)) throw new Error('leases audit wrote unexpected recovery-packages directory');
+  const recoveryPreviewJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'recovery', '--preview', '--json', '--root', cleanDispatchTarget], {}, options), 'recovery --preview --json clean');
+  assertJsonMarkers([
+    ['recovery.command', recoveryPreviewJson.command, 'recovery'],
+    ['recovery.mode', recoveryPreviewJson.mode, 'recovery-package'],
+    ['recovery.recovery.retry_allowed', recoveryPreviewJson.recovery?.retry_allowed, false],
+    ['recovery.recovery.automatic_retry', recoveryPreviewJson.recovery?.automatic_retry, false],
+    ['recovery.safety.stage', recoveryPreviewJson.safety?.stage, 'Stage 19'],
+    ['recovery.safety.writes', recoveryPreviewJson.safety?.writes, false],
+  ], 'recovery --preview --json clean');
+  if (fs.existsSync(recoveryPackagesDirectory)) throw new Error('recovery --preview wrote unexpected recovery package');
+}
+
+function verifyRecoveryPackage(context, options) {
+  const { cleanDispatchTarget, executionsDirectory, recoveryPackagesDirectory, controlledAutoRunFile, approvalFile } = context;
+  const failedRecoveryFixtureFile = `failed-${controlledAutoRunFile}`;
+  const failedRecoveryFixture = JSON.parse(fs.readFileSync(path.join(executionsDirectory, controlledAutoRunFile), 'utf8'));
+  failedRecoveryFixture.execution.status = 'failed';
+  failedRecoveryFixture.execution.lifecycle = [
+    failedRecoveryFixture.execution.lifecycle[0],
+    { status: 'failed', at: new Date().toISOString() },
+  ];
+  failedRecoveryFixture.execution.ended_at = failedRecoveryFixture.execution.lifecycle[1].at;
+  failedRecoveryFixture.execution.exit_code = 1;
+  failedRecoveryFixture.evidence.stdout_excerpt = 'Vibecoding Supervised Runtime Action failed before producing a package.';
+  failedRecoveryFixture.evidence.stderr_excerpt = 'release check failed execution fixture';
+  writeJsonFixture(executionsDirectory, failedRecoveryFixtureFile, failedRecoveryFixture);
+  const recoveryConfirmJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'recovery', '--preview', '--confirm', '--json', '--root', cleanDispatchTarget], {}, options), 'recovery --preview --confirm --json clean');
+  const failedRetryCandidate = recoveryConfirmJson.recovery?.retry_candidates?.find((item) => item.execution_file === failedRecoveryFixtureFile);
+  assertJsonMarkers([
+    ['recoveryConfirm.mode', recoveryConfirmJson.mode, 'recovery-package'],
+    ['recoveryConfirm.safety.recovery_package', recoveryConfirmJson.safety?.recovery_package, true],
+    ['recoveryConfirm.recovery_file.type', typeof recoveryConfirmJson.recovery_file, 'string'],
+    ['recoveryConfirm.retryCandidate.execution_file', failedRetryCandidate?.execution_file, failedRecoveryFixtureFile],
+    ['recoveryConfirm.retryCandidate.approval_file', failedRetryCandidate?.approval_file, approvalFile],
+    ['recoveryConfirm.retryCandidate.approval_digest.type', typeof failedRetryCandidate?.approval_digest, 'string'],
+    ['recoveryConfirm.retryCandidate.policy_digest.type', typeof failedRetryCandidate?.policy_digest, 'string'],
+    ['recoveryConfirm.retryCandidate.action_catalog_digest.type', typeof failedRetryCandidate?.action_catalog_digest, 'string'],
+  ], 'recovery --preview --confirm --json clean');
+  const recoveryFile = recoveryConfirmJson.recovery_file;
+  if (!recoveryFile || !fs.existsSync(path.join(recoveryPackagesDirectory, recoveryFile))) throw new Error(`recovery package missing: ${recoveryFile}`);
+  const recoveryVerifyJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'recovery', '--verify', recoveryFile, '--json', '--root', cleanDispatchTarget], {}, options), 'recovery --verify --json clean');
+  assertJsonMarkers([
+    ['recoveryVerify.mode', recoveryVerifyJson.mode, 'recovery-audit-verify'],
+    ['recoveryVerify.verification.ok', recoveryVerifyJson.verification?.ok, true],
+  ], 'recovery --verify --json clean');
+  const badRecoveryDigest = JSON.parse(fs.readFileSync(path.join(recoveryPackagesDirectory, recoveryFile), 'utf8'));
+  const badRecoveryDigestIndex = badRecoveryDigest.recovery.retry_candidates.findIndex((item) => item.execution_file === failedRecoveryFixtureFile);
+  if (badRecoveryDigestIndex < 0) throw new Error('failed recovery fixture missing from recovery package');
+  badRecoveryDigest.recovery.retry_candidates[badRecoveryDigestIndex].execution_digest = 'bad-execution-digest';
+  writeJsonFixture(recoveryPackagesDirectory, 'bad-digest.recovery.json', badRecoveryDigest);
+  run('node', ['tools/vibe-runtime/index.mjs', 'recovery', '--verify', 'bad-digest.recovery.json', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['recovery verification failed:', `recovery.retry_candidates.${badRecoveryDigestIndex}.execution_digest mismatch`],
+  }, options);
+  return { failedRecoveryFixtureFile, recoveryFile };
+}
+
+function verifyRecoveryClassificationAndApply(context, options) {
+  const { cleanDispatchTarget, recoveryClassificationsDirectory, recoveryRunsDirectory, retryPackagesDirectory, failedRecoveryFixtureFile, approvalFile } = context;
+  const recoveryClassifyJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'recovery', '--classify', '--json', '--root', cleanDispatchTarget], {}, options), 'recovery --classify --json clean');
+  const failedFinding = recoveryClassifyJson.recovery_classification?.findings?.find((finding) => finding.source_file === failedRecoveryFixtureFile && finding.category === 'execution_failed');
+  assertJsonMarkers([
+    ['recoveryClassify.mode', recoveryClassifyJson.mode, 'recovery-classification'],
+    ['recoveryClassify.safety.stage', recoveryClassifyJson.safety?.stage, 'Stage 24'],
+    ['recoveryClassify.safety.writes', recoveryClassifyJson.safety?.writes, false],
+    ['recoveryClassify.failedFinding.eligible', failedFinding?.eligible, true],
+    ['recoveryClassify.failedFinding.recovery_action', failedFinding?.recovery_action, 'package_retry_candidate'],
+    ['recoveryClassify.recovery_policy.stage', recoveryClassifyJson.recovery_policy?.stage, 'Stage 25'],
+    ['recoveryClassify.runtime_budget.recovery_apply_allowed', recoveryClassifyJson.runtime_budget?.recovery_apply_allowed, false],
+  ], 'recovery --classify --json clean');
+  if (fs.existsSync(recoveryClassificationsDirectory)) throw new Error('recovery --classify preview wrote unexpected recovery-classifications directory');
+  const recoveryClassifyConfirmJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'recovery', '--classify', '--confirm', '--json', '--root', cleanDispatchTarget], {}, options), 'recovery --classify --confirm --json clean');
+  assertJsonMarkers([
+    ['recoveryClassifyConfirm.mode', recoveryClassifyConfirmJson.mode, 'recovery-classification'],
+    ['recoveryClassifyConfirm.safety.recovery_classification_artifact', recoveryClassifyConfirmJson.safety?.recovery_classification_artifact, true],
+    ['recoveryClassifyConfirm.recovery_classification_file.type', typeof recoveryClassifyConfirmJson.recovery_classification_file, 'string'],
+  ], 'recovery --classify --confirm --json clean');
+  const recoveryClassificationFile = recoveryClassifyConfirmJson.recovery_classification_file;
+  if (!recoveryClassificationFile || !fs.existsSync(path.join(recoveryClassificationsDirectory, recoveryClassificationFile))) throw new Error(`recovery classification missing: ${recoveryClassificationFile}`);
+  const recoveryClassificationVerifyJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'recovery', '--verify-classification', recoveryClassificationFile, '--json', '--root', cleanDispatchTarget], {}, options), 'recovery --verify-classification --json clean');
+  assertJsonMarkers([
+    ['recoveryClassificationVerify.mode', recoveryClassificationVerifyJson.mode, 'recovery-classification-verify'],
+    ['recoveryClassificationVerify.verification.ok', recoveryClassificationVerifyJson.verification?.ok, true],
+  ], 'recovery --verify-classification --json clean');
+  const recoveryApplyPreviewJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'recovery', '--apply', recoveryClassificationFile, '--json', '--root', cleanDispatchTarget], {}, options), 'recovery --apply --json clean');
+  assertJsonMarkers([
+    ['recoveryApplyPreview.mode', recoveryApplyPreviewJson.mode, 'recovery-apply'],
+    ['recoveryApplyPreview.recovery_run.writes', recoveryApplyPreviewJson.recovery_run?.writes, false],
+    ['recoveryApplyPreview.recovery_run.retry_allowed', recoveryApplyPreviewJson.recovery_run?.retry_allowed, false],
+    ['recoveryApplyPreview.safety.recovery_apply', recoveryApplyPreviewJson.safety?.recovery_apply, false],
+  ], 'recovery --apply --json clean');
+  if (fs.existsSync(recoveryRunsDirectory)) throw new Error('recovery --apply preview wrote unexpected recovery-runs directory');
+  const recoveryApplyConfirmJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'recovery', '--apply', recoveryClassificationFile, '--confirm', '--json', '--root', cleanDispatchTarget], {}, options), 'recovery --apply --confirm --json clean');
+  assertJsonMarkers([
+    ['recoveryApplyConfirm.mode', recoveryApplyConfirmJson.mode, 'recovery-apply'],
+    ['recoveryApplyConfirm.recovery_run.writes', recoveryApplyConfirmJson.recovery_run?.writes, true],
+    ['recoveryApplyConfirm.safety.stage', recoveryApplyConfirmJson.safety?.stage, 'Stage 25'],
+    ['recoveryApplyConfirm.safety.recovery_run_artifact', recoveryApplyConfirmJson.safety?.recovery_run_artifact, true],
+    ['recoveryApplyConfirm.recovery_run_file.type', typeof recoveryApplyConfirmJson.recovery_run_file, 'string'],
+    ['recoveryApplyConfirm.retry_package_file.type', typeof recoveryApplyConfirmJson.retry_package_file, 'string'],
+  ], 'recovery --apply --confirm --json clean');
+  if (!fs.existsSync(path.join(recoveryRunsDirectory, recoveryApplyConfirmJson.recovery_run_file))) throw new Error(`recovery run missing: ${recoveryApplyConfirmJson.recovery_run_file}`);
+  if (!fs.existsSync(path.join(retryPackagesDirectory, recoveryApplyConfirmJson.retry_package_file))) throw new Error(`retry package missing: ${recoveryApplyConfirmJson.retry_package_file}`);
+  run('node', ['tools/vibe-runtime/index.mjs', 'recovery', '--apply', recoveryClassificationFile, '--confirm', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['recovery finding was already applied'],
+  }, options);
+  const badClassification = JSON.parse(fs.readFileSync(path.join(recoveryClassificationsDirectory, recoveryClassificationFile), 'utf8'));
+  badClassification.recovery_classification.findings[0].source_digest = 'bad-source-digest';
+  writeJsonFixture(recoveryClassificationsDirectory, 'bad-digest.recovery-classification.json', badClassification);
+  run('node', ['tools/vibe-runtime/index.mjs', 'recovery', '--verify-classification', 'bad-digest.recovery-classification.json', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['recovery classification verification failed:', 'recovery classification digest mismatch'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'recovery', '--verify-classification', '..\\escape.recovery-classification.json', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['Recovery classification file must not include path separators'],
+  }, options);
+  return { recoveryClassificationFile };
+}
+
+function verifyReadinessAndRecoveryGuards(context, options) {
+  const { cleanDispatchTarget, observabilityDirectory, recoveryPackagesDirectory, recoveryFile } = context;
+  const readinessJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'readiness', '--score', '--json', '--root', cleanDispatchTarget], {}, options), 'readiness --score --json clean');
+  assertJsonMarkers([
+    ['readiness.command', readinessJson.command, 'observability'],
+    ['readiness.mode', readinessJson.mode, 'observability-readiness-score'],
+    ['readiness.readiness.deterministic', readinessJson.readiness?.deterministic, true],
+    ['readiness.readiness.dimensions.length', readinessJson.readiness?.dimensions?.length, 11],
+    ['readiness.observability.retry_health.packages.count', readinessJson.observability?.retry_health?.packages?.count, 1],
+    ['readiness.observability.loop_health.loops.count', readinessJson.observability?.loop_health?.loops?.count, 0],
+    ['readiness.observability.reply_health.send_disabled', readinessJson.observability?.reply_health?.send_disabled, true],
+    ['readiness.safety.stage', readinessJson.safety?.stage, 'Stage 30'],
+    ['readiness.safety.writes', readinessJson.safety?.writes, false],
+  ], 'readiness --score --json clean');
+  if (fs.existsSync(observabilityDirectory)) throw new Error('readiness --score wrote unexpected observability snapshot');
+  const readinessConfirmJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'readiness', '--score', '--confirm', '--json', '--root', cleanDispatchTarget], {}, options), 'readiness --score --confirm --json clean');
+  assertJsonMarkers([
+    ['readinessConfirm.mode', readinessConfirmJson.mode, 'observability-readiness-score'],
+    ['readinessConfirm.safety.observability_snapshot', readinessConfirmJson.safety?.observability_snapshot, true],
+    ['readinessConfirm.observability_file.type', typeof readinessConfirmJson.observability_file, 'string'],
+  ], 'readiness --score --confirm --json clean');
+  const observabilityFile = readinessConfirmJson.observability_file;
+  if (!observabilityFile || !fs.existsSync(path.join(observabilityDirectory, observabilityFile))) throw new Error(`observability snapshot missing: ${observabilityFile}`);
+  run('node', ['tools/vibe-runtime/index.mjs', 'recovery', '--verify', '..\\escape.recovery.json', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['Recovery file must not include path separators'],
+  }, options);
+  const badRecovery = JSON.parse(fs.readFileSync(path.join(recoveryPackagesDirectory, recoveryFile), 'utf8'));
+  badRecovery.safety.recovery_package = false;
+  writeJsonFixture(recoveryPackagesDirectory, 'bad.recovery.json', badRecovery);
+  run('node', ['tools/vibe-runtime/index.mjs', 'recovery', '--verify', 'bad.recovery.json', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['recovery verification failed:', 'safety.recovery_package must be true'],
+  }, options);
+}
+
+function verifyExecutionRunGuards(context, options) {
+  const {
+    cleanDispatchTarget,
+    dispatchesDirectory,
+    dispatchFilesAfterText,
+    originalDispatchEventText,
+    dispatchClaimFile,
+    dispatchClaimTextAfterAck,
+    executionsDirectory,
+    candidatesDirectory,
+    approvalsDirectory,
+    candidateFile,
+    approvalFile,
+  } = context;
+  const executionCountBeforeLockedAutoRun = fs.readdirSync(executionsDirectory).length;
+  run('node', ['tools/vibe-runtime/index.mjs', 'execute', '--from-dispatch', dispatchFilesAfterText[0], '--confirm', '--actor', 'release-check', '--run', '--auto-run', '--approval', approvalFile, '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['approval lifecycle gate failed:', 'approval lifecycle state is consumed'],
+  }, options);
+  if (fs.readdirSync(executionsDirectory).length !== executionCountBeforeLockedAutoRun) throw new Error('locked controlled auto-run wrote unexpected execution');
+  const corruptedCandidate = JSON.parse(fs.readFileSync(path.join(candidatesDirectory, candidateFile), 'utf8'));
+  corruptedCandidate.safety.runtime_action = true;
+  writeJsonFixture(candidatesDirectory, 'bad-safety.candidate.json', corruptedCandidate);
+  run('node', ['tools/vibe-runtime/index.mjs', 'executions', '--verify', 'bad-safety.candidate.json', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['execution verification failed:', 'safety.runtime_action must be false'],
+  }, options);
+  const corruptedApproval = JSON.parse(fs.readFileSync(path.join(approvalsDirectory, approvalFile), 'utf8'));
+  corruptedApproval.simulation.runtime_action = 'other-action';
+  writeJsonFixture(approvalsDirectory, 'bad-action.approval.json', corruptedApproval);
+  run('node', ['tools/vibe-runtime/index.mjs', 'executions', '--verify', 'bad-action.approval.json', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['execution verification failed:', 'simulation.runtime_action must be generate-supervised-handoff-package'],
+  }, options);
+  const badDigestApproval = JSON.parse(fs.readFileSync(path.join(approvalsDirectory, approvalFile), 'utf8'));
+  badDigestApproval.approval.candidate_digest = 'bad-digest';
+  writeJsonFixture(approvalsDirectory, 'bad-digest.approval.json', badDigestApproval);
+  run('node', ['tools/vibe-runtime/index.mjs', 'execute', '--from-dispatch', dispatchFilesAfterText[0], '--confirm', '--actor', 'release-check', '--run', '--auto-run', '--approval', 'bad-digest.approval.json', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['approval candidate digest mismatch'],
+  }, options);
+  for (const blockedStatus of ['skipped', 'failed']) {
+    const blockedClaim = JSON.parse(dispatchClaimTextAfterAck);
+    blockedClaim.status = blockedStatus;
+    blockedClaim.ack.status = blockedStatus;
+    fs.writeFileSync(dispatchClaimFile, `${JSON.stringify(blockedClaim, null, 2)}\n`, 'utf8');
+    const executionCountBeforeBlockedClaim = fs.readdirSync(executionsDirectory).length;
+    run('node', ['tools/vibe-runtime/index.mjs', 'execute', '--from-dispatch', dispatchFilesAfterText[0], '--confirm', '--actor', 'release-check', '--run', '--root', cleanDispatchTarget], {
+      allowFailure: true,
+      expectOutput: [`Dispatch claim must be picked before execution: ${blockedStatus}`],
+    }, options);
+    if (fs.readdirSync(executionsDirectory).length !== executionCountBeforeBlockedClaim) throw new Error(`execute --run wrote execution for ${blockedStatus} claim`);
+  }
+  fs.writeFileSync(dispatchClaimFile, dispatchClaimTextAfterAck, 'utf8');
+  verifyDispatchAndClaimGuards(context, options);
+}
+
+function verifyDispatchAndClaimGuards(context, options) {
+  const { cleanDispatchTarget, dispatchesDirectory, dispatchFilesAfterText, originalDispatchEventText, dispatchClaimFile, dispatchClaimTextAfterAck, executionsDirectory } = context;
+  const nonAllowlistedDispatch = JSON.parse(originalDispatchEventText);
+  nonAllowlistedDispatch.dispatch.target_skill = 'vibe-brainstorming';
+  writeJsonFixture(dispatchesDirectory, dispatchFilesAfterText[0], nonAllowlistedDispatch);
+  const executionCountBeforeNonAllowlisted = fs.readdirSync(executionsDirectory).length;
+  run('node', ['tools/vibe-runtime/index.mjs', 'execute', '--from-dispatch', dispatchFilesAfterText[0], '--confirm', '--actor', 'release-check', '--run', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['Execution target skill is not allowlisted for supervised run: vibe-brainstorming'],
+  }, options);
+  if (fs.readdirSync(executionsDirectory).length !== executionCountBeforeNonAllowlisted) throw new Error('execute --run wrote execution for non-allowlisted target');
+  fs.writeFileSync(path.join(dispatchesDirectory, dispatchFilesAfterText[0]), originalDispatchEventText, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'executions', '--verify', '..\\escape.execution.json', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['Execution audit file must not include path separators'],
+    // Compatibility marker: Execution file must not include path separators
+  }, options);
+  if (fs.readFileSync(path.join(dispatchesDirectory, dispatchFilesAfterText[0]), 'utf8') !== originalDispatchEventText) throw new Error('execute --run modified original dispatch event');
+  if (fs.readFileSync(dispatchClaimFile, 'utf8') !== dispatchClaimTextAfterAck) throw new Error('execute --run unexpectedly modified claim state');
+  fs.writeFileSync(dispatchClaimFile, `${JSON.stringify({ ...JSON.parse(dispatchClaimTextAfterAck), status: 'claimed', ack: { status: 'claimed', actor: 'release-check', reason: 'dry-run-preflight-claim-not-picked' } }, null, 2)}\n`, 'utf8');
+  const executionCountBeforeClaimedDryRun = fs.readdirSync(executionsDirectory).length;
+  run('node', ['tools/vibe-runtime/index.mjs', 'execute', '--from-dispatch', dispatchFilesAfterText[0], '--dry-run', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['Dispatch claim must be picked before execution: claimed'],
+  }, options);
+  if (fs.readdirSync(executionsDirectory).length !== executionCountBeforeClaimedDryRun) throw new Error('execute --dry-run wrote execution for non-picked claim');
+  fs.writeFileSync(dispatchClaimFile, dispatchClaimTextAfterAck, 'utf8');
+  const nonAllowlistedDryRunDispatch = JSON.parse(originalDispatchEventText);
+  nonAllowlistedDryRunDispatch.dispatch.target_skill = 'vibe-brainstorming';
+  writeJsonFixture(dispatchesDirectory, dispatchFilesAfterText[0], nonAllowlistedDryRunDispatch);
+  const executionCountBeforeNonAllowlistedDryRun = fs.readdirSync(executionsDirectory).length;
+  run('node', ['tools/vibe-runtime/index.mjs', 'execute', '--from-dispatch', dispatchFilesAfterText[0], '--dry-run', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['Execution target skill is not allowlisted for supervised run: vibe-brainstorming'],
+  }, options);
+  if (fs.readdirSync(executionsDirectory).length !== executionCountBeforeNonAllowlistedDryRun) throw new Error('execute --dry-run wrote execution for non-allowlisted target');
+  fs.writeFileSync(path.join(dispatchesDirectory, dispatchFilesAfterText[0]), originalDispatchEventText, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'execute', '--from-dispatch', '..\\escape.json', '--dry-run', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['Dispatch event file must not include path separators'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'execute', '--from-dispatch', dispatchFilesAfterText[0], '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['execute requires --preflight, --candidate, --approval-package, --dry-run, or --confirm'],
+  }, options);
+}
+
+export function runRuntimeExecutionRecoverySmoke(dispatchContext, executionBaseContext, approvalContext, options) {
+  const { cleanDispatchTarget, absoluteCleanDispatchTarget } = dispatchContext;
+  const { executionsDirectory } = executionBaseContext;
+  const recoveryPackagesDirectory = path.join(absoluteCleanDispatchTarget, '.vibecoding-state', 'recovery-packages');
+  const observabilityDirectory = path.join(absoluteCleanDispatchTarget, '.vibecoding-state', 'observability');
+  const recoveryClassificationsDirectory = path.join(absoluteCleanDispatchTarget, '.vibecoding-state', 'recovery-classifications');
+  const recoveryRunsDirectory = path.join(absoluteCleanDispatchTarget, '.vibecoding-state', 'recovery-runs');
+  const retryPackagesDirectory = path.join(absoluteCleanDispatchTarget, '.vibecoding-state', 'retry-packages');
+  const context = {
+    ...dispatchContext,
+    ...approvalContext,
+    cleanDispatchTarget,
+    absoluteCleanDispatchTarget,
+    executionsDirectory,
+    recoveryPackagesDirectory,
+    observabilityDirectory,
+    recoveryClassificationsDirectory,
+    recoveryRunsDirectory,
+    retryPackagesDirectory,
+  };
+
+  verifyApprovalNegativeFixtures(context, options);
+  const { controlledAutoRunFile } = verifyControlledAutoRun(context, options);
+  const recoveryContext = { ...context, controlledAutoRunFile };
+  verifyLeaseAuditAndPreview(recoveryContext, options);
+  const { failedRecoveryFixtureFile, recoveryFile } = verifyRecoveryPackage(recoveryContext, options);
+  verifyRecoveryClassificationAndApply({ ...recoveryContext, failedRecoveryFixtureFile }, options);
+  verifyReadinessAndRecoveryGuards({ ...recoveryContext, recoveryFile }, options);
+  verifyExecutionRunGuards(recoveryContext, options);
+}