@jtf19/vibecoding-kit 0.1.0

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

@@ -0,0 +1,388 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  assertJsonMarkers,
+  parseJsonOutput,
+  run,
+} from './release-check-runtime.mjs';
+
+function writeExecutionProfileConfig(absoluteCleanDispatchTarget) {
+  const executionConfigDirectory = path.join(absoluteCleanDispatchTarget, '.vibecoding');
+  fs.mkdirSync(executionConfigDirectory, { recursive: true });
+  fs.writeFileSync(path.join(executionConfigDirectory, 'config.json'), `${JSON.stringify({
+    automation_profile: 'autopilot-lab',
+    execution_profile: 'execution-enabled',
+    execution_profile_policy: 'controlled-local-runtime',
+  }, null, 2)}\n`, 'utf8');
+}
+
+function assertExecutionDirectoryAbsent(executionsDirectory, label) {
+  if (fs.existsSync(executionsDirectory)) throw new Error(`${label} wrote unexpected executions directory`);
+}
+
+function assertExecutionFileCount(executionsDirectory, expected, label) {
+  const files = fs.readdirSync(executionsDirectory);
+  if (files.length !== expected) throw new Error(`${label} expected ${expected} execution record(s), found ${files.length}`);
+  return files;
+}
+
+function verifyExecutionGateFailures(context, options) {
+  const { cleanDispatchTarget, dispatchFilesAfterText, executionsDirectory } = context;
+  run('node', ['tools/vibe-runtime/index.mjs', 'execute', '--from-dispatch', dispatchFilesAfterText[1], '--confirm', '--actor', 'release-check', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['Dispatch claim not found'],
+  }, options);
+  assertExecutionDirectoryAbsent(executionsDirectory, 'execute missing claim');
+  run('node', ['tools/vibe-runtime/index.mjs', 'execute', '--from-dispatch', dispatchFilesAfterText[0], '--confirm', '--actor', 'release-check-2', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['Dispatch claim actor mismatch: release-check'],
+  }, options);
+  assertExecutionDirectoryAbsent(executionsDirectory, 'execute actor mismatch');
+}
+
+function verifyPreflightAndDryRun(context, options) {
+  const { cleanDispatchTarget, dispatchFilesAfterText, executionsDirectory } = context;
+  const executePreflightJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'execute', '--from-dispatch', dispatchFilesAfterText[0], '--preflight', '--actor', 'release-check', '--json', '--root', cleanDispatchTarget], {}, options), 'execute --preflight --json clean');
+  assertJsonMarkers([
+    ['schema_version', executePreflightJson.schema_version, 1],
+    ['command', executePreflightJson.command, 'execute'],
+    ['mode', executePreflightJson.mode, 'execute-preflight'],
+    ['ok', executePreflightJson.ok, true],
+    ['gates.dispatch', executePreflightJson.gates?.dispatch, 'passed'],
+    ['gates.claim_exists', executePreflightJson.gates?.claim_exists, 'passed'],
+    ['gates.actor_match', executePreflightJson.gates?.actor_match, 'passed'],
+    ['gates.claim_picked', executePreflightJson.gates?.claim_picked, 'passed'],
+    ['gates.target_allowlisted', executePreflightJson.gates?.target_allowlisted, 'passed'],
+    ['policy.name', executePreflightJson.policy?.name, 'stage-9-supervised-executor'],
+    ['write_boundary.git', executePreflightJson.write_boundary?.git, false],
+    ['controlled_execution_gate.stage', executePreflightJson.controlled_execution_gate?.stage, 'stage-2-controlled-execution'],
+    ['controlled_execution_gate.manual_approval_required', executePreflightJson.controlled_execution_gate?.manual_approval_required, true],
+    ['controlled_execution_gate.evidence_audit_required', executePreflightJson.controlled_execution_gate?.evidence_audit_required, true],
+    ['controlled_execution_gate.negative.arbitrary_shell', executePreflightJson.controlled_execution_gate?.negative_fixtures?.find((fixture) => fixture.id === 'arbitrary_shell')?.expected_status, 'blocked before candidate creation'],
+    ['controlled_execution_gate.negative.hidden_background', executePreflightJson.controlled_execution_gate?.negative_fixtures?.find((fixture) => fixture.id === 'hidden_background')?.expected_status, 'blocked by foreground-only policy'],
+    ['controlled_execution_gate.negative.auto_repair', executePreflightJson.controlled_execution_gate?.negative_fixtures?.find((fixture) => fixture.id === 'auto_repair')?.expected_status, 'blocked by no-repair policy'],
+    ['controlled_execution_gate.negative.git_write', executePreflightJson.controlled_execution_gate?.negative_fixtures?.find((fixture) => fixture.id === 'git_write')?.foreground_run_allowed, false],
+    ['controlled_execution_gate.boundary.source_write', executePreflightJson.controlled_execution_gate?.boundary_assertions?.source_write, false],
+    ['controlled_execution_gate.boundary.model_invocation', executePreflightJson.controlled_execution_gate?.boundary_assertions?.model_invocation, false],
+    ['controlled_execution_gate.boundary.subagent', executePreflightJson.controlled_execution_gate?.boundary_assertions?.subagent, false],
+  ], 'execute --preflight --json clean');
+  assertExecutionDirectoryAbsent(executionsDirectory, 'execute --preflight');
+  run('node', ['tools/vibe-runtime/index.mjs', 'execute', '--from-dispatch', dispatchFilesAfterText[0], '--preflight', '--actor', 'release-check', '--root', cleanDispatchTarget], {
+    expectOutput: ['Vibecoding Runtime Execution Preflight', 'Mode: preflight', 'Status: passed', 'Policy: stage-9-supervised-executor@1', 'Gates:', 'target_allowlisted: passed', 'Write boundary: expected_writes=1; git=false; worktree=false; business_source_write=false', 'Action: execution preflight was audited. No execution envelope, skill execution, platform API, subagent, MCP, daemon, git, worktree, or business source write occurred.'],
+  }, options);
+  const executeDryRunJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'execute', '--from-dispatch', dispatchFilesAfterText[0], '--dry-run', '--json', '--root', cleanDispatchTarget], {}, options), 'execute --from-dispatch --dry-run --json clean');
+  assertJsonMarkers([
+    ['schema_version', executeDryRunJson.schema_version, 1],
+    ['command', executeDryRunJson.command, 'execute'],
+    ['mode', executeDryRunJson.mode, 'execute-dry-run'],
+    ['ok', executeDryRunJson.ok, true],
+    ['execution.event_file', executeDryRunJson.execution?.event_file, dispatchFilesAfterText[0]],
+    ['execution.target_skill', executeDryRunJson.execution?.target_skill, 'vibe-verification-before-completion'],
+    ['claim.status', executeDryRunJson.claim?.status, 'picked'],
+    ['safety.dry_run', executeDryRunJson.safety?.dry_run, true],
+    ['safety.writes', executeDryRunJson.safety?.writes, false],
+    ['safety.auto_execution', executeDryRunJson.safety?.auto_execution, false],
+    ['safety.platform_api', executeDryRunJson.safety?.platform_api, false],
+    ['safety.skill_execution', executeDryRunJson.safety?.skill_execution, false],
+  ], 'execute --dry-run --json clean');
+  assertExecutionDirectoryAbsent(executionsDirectory, 'execute --dry-run');
+  run('node', ['tools/vibe-runtime/index.mjs', 'execute', '--from-dispatch', dispatchFilesAfterText[0], '--dry-run', '--root', cleanDispatchTarget], {
+    expectOutput: ['Vibecoding Runtime Supervised Executor', 'Mode: dry-run', 'Target skill: vibe-verification-before-completion', 'Claim: picked by release-check', 'Safety: supervised=true; auto_execution=false; platform_api=false; skill_execution=false; runtime_action=false; subagent=false; mcp=false; daemon=false; git=false; worktree=false.', 'Action: supervised execution plan was previewed. No execution envelope, skill execution, platform API, subagent, MCP, daemon, git, worktree, or business source write occurred.'],
+  }, options);
+}
+
+function verifyConfirmExecution(context, options) {
+  const {
+    cleanDispatchTarget,
+    dispatchesDirectory,
+    dispatchFilesAfterText,
+    dispatchClaimFile,
+    dispatchClaimTextAfterAck,
+    originalDispatchEventText,
+    executionsDirectory,
+  } = context;
+  const executeConfirmJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'execute', '--from-dispatch', dispatchFilesAfterText[0], '--confirm', '--actor', 'release-check', '--json', '--root', cleanDispatchTarget], {}, options), 'execute --confirm --json clean');
+  assertJsonMarkers([
+    ['schema_version', executeConfirmJson.schema_version, 1],
+    ['command', executeConfirmJson.command, 'execute'],
+    ['mode', executeConfirmJson.mode, 'execute-confirm'],
+    ['ok', executeConfirmJson.ok, true],
+    ['execution.event_file', executeConfirmJson.execution?.event_file, dispatchFilesAfterText[0]],
+    ['execution.policy.name', executeConfirmJson.execution?.policy?.name, 'stage-9-supervised-executor'],
+    ['execution.policy.version', executeConfirmJson.execution?.policy?.version, 1],
+    ['execution.idempotency_key', typeof executeConfirmJson.execution?.idempotency_key, 'string'],
+    ['claim.actor', executeConfirmJson.claim?.actor, 'release-check'],
+    ['claim.status', executeConfirmJson.claim?.status, 'picked'],
+    ['safety.confirmed', executeConfirmJson.safety?.confirmed, true],
+    ['safety.writes', executeConfirmJson.safety?.writes, true],
+    ['safety.execution_envelope', executeConfirmJson.safety?.execution_envelope, true],
+    ['safety.dispatch_event_modified', executeConfirmJson.safety?.dispatch_event_modified, false],
+    ['safety.claim_modified', executeConfirmJson.safety?.claim_modified, false],
+    ['safety.auto_execution', executeConfirmJson.safety?.auto_execution, false],
+  ], 'execute --confirm --json clean');
+  const executionFilesAfterJson = assertExecutionFileCount(executionsDirectory, 1, 'execute --confirm');
+  const executionEnvelopeJson = JSON.parse(fs.readFileSync(path.join(executionsDirectory, executionFilesAfterJson[0]), 'utf8'));
+  assertJsonMarkers([
+    ['event.command', executionEnvelopeJson.command, 'execute'],
+    ['event.mode', executionEnvelopeJson.mode, 'execute-confirm'],
+    ['event.safety.auto_execution', executionEnvelopeJson.safety?.auto_execution, false],
+    ['event.safety.runtime_action', executionEnvelopeJson.safety?.runtime_action, false],
+    ['event.safety.skill_execution', executionEnvelopeJson.safety?.skill_execution, false],
+    ['event.safety.dispatch_event_modified', executionEnvelopeJson.safety?.dispatch_event_modified, false],
+    ['event.safety.claim_modified', executionEnvelopeJson.safety?.claim_modified, false],
+    ['event.safety.git', executionEnvelopeJson.safety?.git, false],
+    ['event.safety.worktree', executionEnvelopeJson.safety?.worktree, false],
+  ], 'execute persisted envelope');
+  run('node', ['tools/vibe-runtime/index.mjs', 'execute', '--from-dispatch', dispatchFilesAfterText[0], '--confirm', '--actor', 'release-check', '--root', cleanDispatchTarget], {
+    expectOutput: ['Vibecoding Runtime Supervised Executor', 'Mode: confirm', 'Execution envelope:', 'Target skill: vibe-verification-before-completion', 'Claim: picked by release-check', 'Safety: supervised=true; auto_execution=false; platform_api=false; skill_execution=false; runtime_action=false; subagent=false; mcp=false; daemon=false; git=false; worktree=false.', 'Action: supervised execution envelope was written. No target workflow skill, platform API, subagent, MCP, daemon, git, worktree, or business source write occurred.'],
+  }, options);
+  const executionFilesAfterText = assertExecutionFileCount(executionsDirectory, 2, 'execute text');
+  if (new Set(executionFilesAfterText).size !== 2) throw new Error('execute wrote duplicate execution envelope filenames');
+  if (fs.readFileSync(path.join(dispatchesDirectory, dispatchFilesAfterText[0]), 'utf8') !== originalDispatchEventText) throw new Error('execute modified original dispatch event');
+  if (fs.readFileSync(dispatchClaimFile, 'utf8') !== dispatchClaimTextAfterAck) throw new Error('execute unexpectedly modified claim state');
+  return { executionFilesAfterJson };
+}
+
+function verifySupervisedRun(context, options) {
+  const { cleanDispatchTarget, dispatchFilesAfterText, executionsDirectory } = context;
+  run('node', ['tools/vibe-runtime/index.mjs', 'execute', '--from-dispatch', dispatchFilesAfterText[0], '--run', '--actor', 'release-check', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['execute --run requires --confirm'],
+  }, options);
+  const supervisedRunJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'execute', '--from-dispatch', dispatchFilesAfterText[0], '--confirm', '--actor', 'release-check', '--run', '--json', '--root', cleanDispatchTarget], {}, options), 'execute --confirm --run --json clean');
+  assertJsonMarkers([
+    ['schema_version', supervisedRunJson.schema_version, 1],
+    ['command', supervisedRunJson.command, 'execute'],
+    ['mode', supervisedRunJson.mode, 'supervised-run'],
+    ['ok', supervisedRunJson.ok, true],
+    ['execution.status', supervisedRunJson.execution?.status, 'succeeded'],
+    ['execution.lifecycle.0.status', supervisedRunJson.execution?.lifecycle?.[0]?.status, 'running'],
+    ['execution.lifecycle.1.status', supervisedRunJson.execution?.lifecycle?.[1]?.status, 'succeeded'],
+    ['execution.allowlisted', supervisedRunJson.execution?.allowlisted, true],
+    ['execution.runtime_action', supervisedRunJson.execution?.runtime_action, 'generate-supervised-handoff-package'],
+    ['execution.runtime_action_contract.name', supervisedRunJson.execution?.runtime_action_contract?.name, 'generate-supervised-handoff-package'],
+    ['execution.runtime_action_contract.skill_execution', supervisedRunJson.execution?.runtime_action_contract?.skill_execution, false],
+    ['execution.runtime_action_contract.business_source_write', supervisedRunJson.execution?.runtime_action_contract?.business_source_write, false],
+    ['execution.policy.name', supervisedRunJson.execution?.policy?.name, 'stage-9-supervised-executor'],
+    ['gates.dispatch', supervisedRunJson.gates?.dispatch, 'passed'],
+    ['gates.claim_picked', supervisedRunJson.gates?.claim_picked, 'passed'],
+    ['gates.target_allowlisted', supervisedRunJson.gates?.target_allowlisted, 'passed'],
+    ['write_boundary.git', supervisedRunJson.write_boundary?.git, false],
+    ['claim.status', supervisedRunJson.claim?.status, 'picked'],
+    ['safety.supervised_execution', supervisedRunJson.safety?.supervised_execution, true],
+    ['safety.runtime_action', supervisedRunJson.safety?.runtime_action, true],
+    ['safety.skill_execution', supervisedRunJson.safety?.skill_execution, false],
+    ['safety.platform_api', supervisedRunJson.safety?.platform_api, false],
+    ['safety.git', supervisedRunJson.safety?.git, false],
+    ['safety.worktree', supervisedRunJson.safety?.worktree, false],
+  ], 'execute --confirm --run --json clean');
+  assertExecutionFileCount(executionsDirectory, 3, 'execute --confirm --run');
+  const supervisedRunFile = supervisedRunJson.execution_file;
+  if (!supervisedRunFile || !fs.existsSync(path.join(executionsDirectory, supervisedRunFile))) throw new Error(`execute --confirm --run did not report an existing execution file: ${supervisedRunFile}`);
+  const supervisedRunEnvelopeJson = JSON.parse(fs.readFileSync(path.join(executionsDirectory, supervisedRunFile), 'utf8'));
+  assertJsonMarkers([
+    ['persisted.command', supervisedRunEnvelopeJson.command, 'execute'],
+    ['persisted.mode', supervisedRunEnvelopeJson.mode, 'supervised-run'],
+    ['persisted.execution.status', supervisedRunEnvelopeJson.execution?.status, 'succeeded'],
+    ['persisted.execution.lifecycle.0.status', supervisedRunEnvelopeJson.execution?.lifecycle?.[0]?.status, 'running'],
+    ['persisted.execution.lifecycle.1.status', supervisedRunEnvelopeJson.execution?.lifecycle?.[1]?.status, 'succeeded'],
+    ['persisted.execution.runtime_action_contract.name', supervisedRunEnvelopeJson.execution?.runtime_action_contract?.name, 'generate-supervised-handoff-package'],
+    ['persisted.gates.dispatch', supervisedRunEnvelopeJson.gates?.dispatch, 'passed'],
+    ['persisted.write_boundary.git', supervisedRunEnvelopeJson.write_boundary?.git, false],
+    ['persisted.safety.runtime_action', supervisedRunEnvelopeJson.safety?.runtime_action, true],
+  ], 'execute --confirm --run persisted envelope');
+  run('node', ['tools/vibe-runtime/index.mjs', 'execute', '--from-dispatch', dispatchFilesAfterText[0], '--confirm', '--actor', 'release-check', '--run', '--root', cleanDispatchTarget], {
+    expectOutput: ['Vibecoding Runtime Supervised Executor', 'Mode: run', 'Status: succeeded', 'Allowlisted: yes', 'Lifecycle: running -> succeeded', 'Evidence: Vibecoding Supervised Runtime Action', 'Safety: supervised=true; auto_execution=false; platform_api=false; skill_execution=false; runtime_action=true; subagent=false; mcp=false; daemon=false; git=false; worktree=false.', 'Action: supervised runtime action completed and execution lifecycle was written. No platform API, subagent, MCP, daemon, git, worktree, or business source write occurred.'],
+  }, options);
+  return { supervisedRunFile, supervisedRunEnvelopeJson };
+}
+
+function verifyExecutionAuditHappyPath(context, options) {
+  const { cleanDispatchTarget, supervisedRunFile } = context;
+  const executionAuditListJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'executions', '--list', '--json', '--root', cleanDispatchTarget], {}, options), 'executions --list --json clean');
+  assertJsonMarkers([
+    ['schema_version', executionAuditListJson.schema_version, 1],
+    ['command', executionAuditListJson.command, 'executions'],
+    ['mode', executionAuditListJson.mode, 'executions-audit-list'],
+    ['ok', executionAuditListJson.ok, true],
+    ['summary.count', executionAuditListJson.summary?.count, 4],
+    ['summary.active_count', executionAuditListJson.summary?.active_count, 0],
+    ['summary.stale_count', executionAuditListJson.summary?.stale_count, 0],
+    ['summary.terminal_count', executionAuditListJson.summary?.terminal_count, 2],
+    ['executions.length', executionAuditListJson.executions?.length, 4],
+  ], 'executions --list --json clean');
+  run('node', ['tools/vibe-runtime/index.mjs', 'executions', '--list', '--root', cleanDispatchTarget], {
+    expectOutput: ['Vibecoding Runtime Execution Audit', 'Mode: list', 'Executions: 4', 'succeeded', 'Action: read-only execution audit listed execution records. No skill execution, platform API, subagent, MCP, daemon, git, worktree, or business source write occurred.'],
+  }, options);
+  const executionAuditShowJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'executions', '--show', supervisedRunFile, '--json', '--root', cleanDispatchTarget], {}, options), 'executions --show --json clean');
+  assertJsonMarkers([
+    ['schema_version', executionAuditShowJson.schema_version, 1],
+    ['command', executionAuditShowJson.command, 'executions'],
+    ['mode', executionAuditShowJson.mode, 'executions-audit-show'],
+    ['ok', executionAuditShowJson.ok, true],
+    ['summary.status', executionAuditShowJson.summary?.status, 'succeeded'],
+    ['verification.ok', executionAuditShowJson.verification?.ok, true],
+  ], 'executions --show --json clean');
+  const executionAuditVerifyJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'executions', '--verify', supervisedRunFile, '--json', '--root', cleanDispatchTarget], {}, options), 'executions --verify --json clean');
+  assertJsonMarkers([
+    ['schema_version', executionAuditVerifyJson.schema_version, 1],
+    ['command', executionAuditVerifyJson.command, 'executions'],
+    ['mode', executionAuditVerifyJson.mode, 'executions-audit-verify'],
+    ['ok', executionAuditVerifyJson.ok, true],
+    ['verification.ok', executionAuditVerifyJson.verification?.ok, true],
+  ], 'executions --verify --json clean');
+}
+
+function verifyTerminalStatusAudits(context, options) {
+  const { cleanDispatchTarget, executionsDirectory, supervisedRunEnvelopeJson } = context;
+  for (const terminalStatus of ['failed', 'timed_out', 'cancelled']) {
+    const terminalRunJson = JSON.parse(JSON.stringify(supervisedRunEnvelopeJson));
+    terminalRunJson.execution.status = terminalStatus;
+    terminalRunJson.execution.lifecycle = [
+      { status: 'running', at: terminalRunJson.execution.lifecycle[0].at },
+      { status: terminalStatus, at: new Date().toISOString() },
+    ];
+    terminalRunJson.execution.ended_at = terminalRunJson.execution.lifecycle[1].at;
+    terminalRunJson.execution.exit_code = terminalStatus === 'failed' ? 1 : null;
+    terminalRunJson.evidence.stdout_excerpt = `Vibecoding Supervised Runtime Action ${terminalStatus} audit sample.`;
+    terminalRunJson.evidence.stderr_excerpt = `supervised runtime action ${terminalStatus}`;
+    const terminalRunFile = `${terminalStatus}.execution.json`;
+    fs.writeFileSync(path.join(executionsDirectory, terminalRunFile), `${JSON.stringify(terminalRunJson, null, 2)}\n`, 'utf8');
+    const verifiedTerminalRunJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'executions', '--verify', terminalRunFile, '--json', '--root', cleanDispatchTarget], {}, options), `executions --verify --json ${terminalStatus}`);
+    assertJsonMarkers([
+      ['mode', verifiedTerminalRunJson.mode, 'executions-audit-verify'],
+      ['summary.status', verifiedTerminalRunJson.summary?.status, terminalStatus],
+      ['summary.terminal', verifiedTerminalRunJson.summary?.terminal, true],
+      ['verification.ok', verifiedTerminalRunJson.verification?.ok, true],
+    ], `executions --verify --json ${terminalStatus}`);
+    fs.rmSync(path.join(executionsDirectory, terminalRunFile), { force: true });
+  }
+}
+
+function verifyActiveIdempotencyGuard(context, options) {
+  const { cleanDispatchTarget, dispatchFilesAfterText, executionsDirectory, supervisedRunEnvelopeJson } = context;
+  const activeDuplicateRecord = JSON.parse(JSON.stringify(supervisedRunEnvelopeJson));
+  activeDuplicateRecord.execution.status = 'running';
+  activeDuplicateRecord.execution.lifecycle = [{ status: 'running', at: '2000-01-01T00:00:00.000Z' }];
+  activeDuplicateRecord.execution.started_at = '2000-01-01T00:00:00.000Z';
+  activeDuplicateRecord.execution.ended_at = '';
+  activeDuplicateRecord.execution.exit_code = null;
+  activeDuplicateRecord.evidence.stdout_excerpt = '';
+  activeDuplicateRecord.evidence.stderr_excerpt = '';
+  const activeDuplicateFile = 'active-duplicate.execution.json';
+  fs.writeFileSync(path.join(executionsDirectory, activeDuplicateFile), `${JSON.stringify(activeDuplicateRecord, null, 2)}\n`, 'utf8');
+  const activeExecutionAuditJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'executions', '--list', '--json', '--root', cleanDispatchTarget], {}, options), 'executions --list --json active duplicate');
+  const activeSummary = activeExecutionAuditJson.executions?.find((item) => item.file === activeDuplicateFile);
+  assertJsonMarkers([
+    ['summary.active_count', activeExecutionAuditJson.summary?.active_count, 1],
+    ['summary.stale_count', activeExecutionAuditJson.summary?.stale_count, 1],
+    ['active.status', activeSummary?.status, 'running'],
+    ['active.active', activeSummary?.active, true],
+    ['active.stale', activeSummary?.stale, true],
+    ['active.terminal', activeSummary?.terminal, false],
+  ], 'executions --list --json active duplicate');
+  const executionCountBeforeDuplicateRun = 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: ['Active supervised run already exists for idempotency key: active-duplicate.execution.json'],
+  }, options);
+  if (fs.readdirSync(executionsDirectory).length !== executionCountBeforeDuplicateRun) throw new Error('execute --run wrote execution despite active idempotency guard');
+  fs.rmSync(path.join(executionsDirectory, activeDuplicateFile), { force: true });
+}
+
+function writeCorruptedExecutionFixture(executionsDirectory, baseRecord, fileName, mutate) {
+  const corrupted = JSON.parse(JSON.stringify(baseRecord));
+  mutate(corrupted);
+  fs.writeFileSync(path.join(executionsDirectory, fileName), `${JSON.stringify(corrupted, null, 2)}\n`, 'utf8');
+}
+
+function verifyCorruptedExecutionRecords(context, options) {
+  const { cleanDispatchTarget, executionsDirectory, executionFilesAfterJson, supervisedRunFile } = context;
+  const plannedExecutionBase = JSON.parse(fs.readFileSync(path.join(executionsDirectory, executionFilesAfterJson[0]), 'utf8'));
+  const corruptedPlannedExecutions = [
+    ['planned-bad-runtime-action.execution.json', (record) => { record.safety.runtime_action = true; }, 'safety.runtime_action must be false'],
+    ['planned-bad-skill-execution.execution.json', (record) => { record.safety.skill_execution = true; }, 'safety.skill_execution must be false'],
+    ['planned-bad-auto-execution.execution.json', (record) => { record.safety.auto_execution = true; }, 'safety.auto_execution must be false'],
+  ];
+  for (const [fileName, mutate, expectedFailure] of corruptedPlannedExecutions) {
+    writeCorruptedExecutionFixture(executionsDirectory, plannedExecutionBase, fileName, mutate);
+    run('node', ['tools/vibe-runtime/index.mjs', 'executions', '--verify', fileName, '--root', cleanDispatchTarget], {
+      allowFailure: true,
+      expectOutput: ['execution verification failed:', expectedFailure],
+    }, options);
+  }
+  const corruptedExecutionBase = JSON.parse(fs.readFileSync(path.join(executionsDirectory, supervisedRunFile), 'utf8'));
+  const corruptedExecutions = [
+    ['missing-lifecycle.execution.json', (record) => { delete record.execution.lifecycle; }, 'execution.lifecycle is required'],
+    ['missing-running.execution.json', (record) => { record.execution.lifecycle[0].status = 'succeeded'; }, 'execution.lifecycle must start with running'],
+    ['mismatched-terminal.execution.json', (record) => { record.execution.status = 'failed'; }, 'execution.lifecycle terminal status must match execution.status'],
+    ['invalid-timestamp.execution.json', (record) => { record.execution.lifecycle[1].at = 'not-a-date'; }, 'execution.lifecycle.1.at must be a valid timestamp'],
+    ['timestamp-order.execution.json', (record) => { record.execution.lifecycle[1].at = '2000-01-01T00:00:00.000Z'; }, 'execution.lifecycle timestamps must be monotonic'],
+    ['missing-evidence.execution.json', (record) => { delete record.evidence.stdout_excerpt; }, 'evidence.stdout_excerpt is required'],
+    ['bad-runtime-action.execution.json', (record) => { record.safety.runtime_action = false; }, 'safety.runtime_action must be true'],
+    ['bad-runtime-action-name.execution.json', (record) => { record.execution.runtime_action = 'other-action'; }, 'execution.runtime_action must be generate-supervised-handoff-package'],
+    ['bad-runtime-action-contract.execution.json', (record) => { record.execution.runtime_action_contract.name = 'other-action'; }, 'execution.runtime_action_contract.name must be generate-supervised-handoff-package'],
+    ['bad-policy-name.execution.json', (record) => { record.execution.policy.name = 'other-policy'; }, 'execution.policy.name must be stage-9-supervised-executor'],
+    ['bad-policy-allowlist.execution.json', (record) => { record.execution.policy.allowlisted_skills = []; }, 'execution.policy.allowlisted_skills must match current Stage 11 allowlist snapshot'],
+    ['bad-policy-forbidden-actions.execution.json', (record) => { record.execution.policy.forbidden_actions = []; }, 'execution.policy.forbidden_actions must match forbidden action snapshot'],
+    ['bad-skill-execution.execution.json', (record) => { record.safety.skill_execution = true; }, 'safety.skill_execution must be false'],
+    ['bad-platform-api.execution.json', (record) => { record.safety.platform_api = true; }, 'safety.platform_api must be false'],
+    ['bad-git.execution.json', (record) => { record.safety.git = true; }, 'safety.git must be false'],
+    ['bad-worktree.execution.json', (record) => { record.safety.worktree = true; }, 'safety.worktree must be false'],
+  ];
+  for (const [fileName, mutate, expectedFailure] of corruptedExecutions) {
+    writeCorruptedExecutionFixture(executionsDirectory, corruptedExecutionBase, fileName, mutate);
+    run('node', ['tools/vibe-runtime/index.mjs', 'executions', '--verify', fileName, '--root', cleanDispatchTarget], {
+      allowFailure: true,
+      expectOutput: ['execution verification failed:', expectedFailure],
+    }, options);
+  }
+  return { corruptedExecutionCount: corruptedPlannedExecutions.length + corruptedExecutions.length };
+}
+
+function verifyCorruptedExecutionList(context, options) {
+  const { cleanDispatchTarget, corruptedExecutionCount } = context;
+  const corruptedExecutionAuditListJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'executions', '--list', '--json', '--root', cleanDispatchTarget], {}, options), 'executions --list --json corrupted records');
+  const missingLifecycleSummary = corruptedExecutionAuditListJson.executions?.find((item) => item.file === 'missing-lifecycle.execution.json');
+  const plannedBadRuntimeActionSummary = corruptedExecutionAuditListJson.executions?.find((item) => item.file === 'planned-bad-runtime-action.execution.json');
+  assertJsonMarkers([
+    ['summary.count', corruptedExecutionAuditListJson.summary?.count, 4 + corruptedExecutionCount],
+    ['summary.verified_count', corruptedExecutionAuditListJson.summary?.verified_count, 4],
+    ['summary.failed_count', corruptedExecutionAuditListJson.summary?.failed_count, corruptedExecutionCount],
+    ['missing-lifecycle.verification_ok', missingLifecycleSummary?.verification_ok, false],
+    ['missing-lifecycle.verification_failures.0', missingLifecycleSummary?.verification_failures?.[0], 'execution.lifecycle is required'],
+    ['planned-bad-runtime-action.verification_ok', plannedBadRuntimeActionSummary?.verification_ok, false],
+    ['planned-bad-runtime-action.verification_failures.0', plannedBadRuntimeActionSummary?.verification_failures?.[0], 'safety.runtime_action must be false'],
+  ], 'executions --list --json corrupted records');
+  run('node', ['tools/vibe-runtime/index.mjs', 'executions', '--list', '--root', cleanDispatchTarget], {
+    expectOutput: ['Vibecoding Runtime Execution Audit', `Executions: ${4 + corruptedExecutionCount}`, `Verified: 4; Failed: ${corruptedExecutionCount}`, 'planned-bad-runtime-action.execution.json', 'verification=failed', 'failures: safety.runtime_action must be false', 'missing-lifecycle.execution.json', 'failures: execution.lifecycle is required', 'Warnings', 'one or more execution records failed verification'],
+  }, options);
+}
+
+export function runRuntimeExecutionBaseSmoke(dispatchContext, options) {
+  const {
+    cleanDispatchTarget,
+    absoluteCleanDispatchTarget,
+  } = dispatchContext;
+
+  const executionsDirectory = path.join(absoluteCleanDispatchTarget, '.vibecoding-state', 'executions');
+  const context = { ...dispatchContext, executionsDirectory };
+  writeExecutionProfileConfig(absoluteCleanDispatchTarget);
+  verifyExecutionGateFailures(context, options);
+  verifyPreflightAndDryRun(context, options);
+  const { executionFilesAfterJson } = verifyConfirmExecution(context, options);
+  const { supervisedRunFile, supervisedRunEnvelopeJson } = verifySupervisedRun(context, options);
+  const auditContext = { ...context, executionFilesAfterJson, supervisedRunFile, supervisedRunEnvelopeJson };
+  verifyExecutionAuditHappyPath(auditContext, options);
+  verifyTerminalStatusAudits(auditContext, options);
+  verifyActiveIdempotencyGuard(auditContext, options);
+  const { corruptedExecutionCount } = verifyCorruptedExecutionRecords(auditContext, options);
+  verifyCorruptedExecutionList({ ...auditContext, corruptedExecutionCount }, options);
+
+  return {
+    executionsDirectory,
+    executionFilesAfterJson,
+    supervisedRunFile,
+    supervisedRunEnvelopeJson,
+  };
+}