@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-release-check/release-check-runtime-automation-source-candidate-smoke-helpers.mjs

@@ -0,0 +1,506 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  assertJsonMarkers,
+  digestObject,
+  parseJsonOutput,
+  run,
+} from './release-check-runtime.mjs';
+
+function runSourcePatchPlanSmoke(context, options) {
+  const {
+    subagentsTarget,
+    absoluteSubagentsTarget,
+  } = context;
+
+const sourcePatchTaskFile = 'p9-source-task.json';
+fs.writeFileSync(path.join(absoluteSubagentsTarget, sourcePatchTaskFile), `${JSON.stringify({ id: 'p9-source-task', title: 'P9 source patch plan smoke', files: ['docs/runtime-auto-merge-ledger.md'] }, null, 2)}\n`, 'utf8');
+const sourcePatchPlan = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'source', '--patch-plan', '--from-task', sourcePatchTaskFile, '--json', '--root', subagentsTarget], {}, options), 'source --patch-plan --json');
+assertJsonMarkers([
+  ['command', sourcePatchPlan.command, 'source'],
+  ['mode', sourcePatchPlan.mode, 'source-patch-plan'],
+  ['source_patch_plan.stage', sourcePatchPlan.source_patch_plan?.stage, 'P9'],
+  ['source_patch_plan.plan_kind', sourcePatchPlan.source_patch_plan?.plan_kind, 'sandbox-patch-plan'],
+  ['source_patch_plan.path_allowlist.0', sourcePatchPlan.source_patch_plan?.path_allowlist?.[0], 'docs/runtime-auto-merge-ledger.md'],
+  ['source_patch_plan.approval_required', sourcePatchPlan.source_patch_plan?.approval_required, true],
+  ['source_patch_plan.sandbox_required', sourcePatchPlan.source_patch_plan?.sandbox_required, true],
+  ['source_patch_plan.business_source_write', sourcePatchPlan.source_patch_plan?.business_source_write, false],
+  ['source_patch_plan.git', sourcePatchPlan.source_patch_plan?.git, false],
+  ['safety.writes', sourcePatchPlan.safety?.writes, false],
+  ['safety.business_source_write', sourcePatchPlan.safety?.business_source_write, false],
+], 'source --patch-plan --json');
+const sourcePatchPlanStatePath = path.join(absoluteSubagentsTarget, '.vibecoding-state', 'source-patch-plans');
+if (fs.existsSync(sourcePatchPlanStatePath)) throw new Error('source patch plan preview created unexpected state directory');
+run('node', ['tools/vibe-runtime/index.mjs', 'source', '--patch-plan', '--from-task', sourcePatchTaskFile, '--confirm', '--root', subagentsTarget], {
+  allowFailure: true,
+  expectOutput: ['source --patch-plan is read-only and does not support --confirm'],
+}, options);
+fs.rmSync(path.join(absoluteSubagentsTarget, sourcePatchTaskFile), { force: true });
+}
+
+function runSourceCandidateSandboxSmoke(context, platformContext, options) {
+  const {
+    subagentsTarget,
+    absoluteSubagentsTarget,
+  } = context;
+  const { sessionReviewFile } = platformContext;
+
+const sourceCandidateConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'source', '--candidate', '--from-session-review', sessionReviewFile, '--confirm', '--json', '--root', subagentsTarget], {}, options), 'source --candidate --confirm --json');
+const sourceCandidateFile = sourceCandidateConfirm.source_change_candidate_file;
+assertJsonMarkers([
+  ['command', sourceCandidateConfirm.command, 'source'],
+  ['mode', sourceCandidateConfirm.mode, 'source-change-candidate'],
+  ['source_change_candidate.stage', sourceCandidateConfirm.source_change_candidate?.stage, 'Stage 45'],
+  ['source_change_candidate.allowed_followup.0', sourceCandidateConfirm.source_change_candidate?.allowed_followup?.[0], 'source-sandbox-apply-only'],
+  ['source_change_candidate.business_source_write', sourceCandidateConfirm.source_change_candidate?.business_source_write, false],
+  ['safety.source_change_candidate_artifact', sourceCandidateConfirm.safety?.source_change_candidate_artifact, true],
+  ['source_change_candidate_file.type', typeof sourceCandidateFile, 'string'],
+], 'source --candidate --confirm --json');
+if (!sourceCandidateFile || !fs.existsSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'source-change-candidates', sourceCandidateFile))) throw new Error('source candidate did not write source change candidate artifact');
+const sourceCandidateVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'source', '--verify', sourceCandidateFile, '--json', '--root', subagentsTarget], {}, options), 'source --verify candidate --json');
+assertJsonMarkers([
+  ['mode', sourceCandidateVerify.mode, 'source-change-candidate-verify'],
+  ['verification.ok', sourceCandidateVerify.verification?.ok, true],
+], 'source --verify candidate --json');
+const sourceCandidateAliasPath = path.join(absoluteSubagentsTarget, '.vibecoding-state', 'source-change-candidates', 'bad-alias.source-change-candidate.json');
+fs.copyFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'source-change-candidates', sourceCandidateFile), sourceCandidateAliasPath);
+run('node', ['tools/vibe-runtime/index.mjs', 'source', '--verify', 'bad-alias.source-change-candidate.json', '--root', subagentsTarget], {
+  allowFailure: true,
+  expectOutput: ['source artifact verification failed:', 'Stage 45 source change candidate file identity mismatch'],
+}, options);
+fs.rmSync(sourceCandidateAliasPath, { force: true });
+const badSourceCandidate = JSON.parse(fs.readFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'source-change-candidates', sourceCandidateFile), 'utf8'));
+badSourceCandidate.source_change_candidate.business_source_write = true;
+badSourceCandidate.source_change_candidate.source_merge = true;
+badSourceCandidate.source_change_candidate.git = true;
+badSourceCandidate.source_change_candidate.worktree = true;
+badSourceCandidate.source_change_candidate.allowed_followup = ['source-sandbox-apply-only', 'merge'];
+delete badSourceCandidate.source_change_candidate.candidate_digest;
+badSourceCandidate.source_change_candidate.candidate_digest = digestObject(badSourceCandidate.source_change_candidate);
+fs.writeFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'source-change-candidates', 'bad-resigned.source-change-candidate.json'), `${JSON.stringify(badSourceCandidate, null, 2)}\n`, 'utf8');
+run('node', ['tools/vibe-runtime/index.mjs', 'source', '--verify', 'bad-resigned.source-change-candidate.json', '--root', subagentsTarget], {
+  allowFailure: true,
+  expectOutput: ['source artifact verification failed:', 'source_change_candidate.allowed_followup must equal source-sandbox-apply-only', 'source_change_candidate.business_source_write must be false', 'source_change_candidate.source_merge must be false', 'source_change_candidate.git must be false', 'source_change_candidate.worktree must be false'],
+}, options);
+fs.rmSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'source-change-candidates', 'bad-resigned.source-change-candidate.json'), { force: true });
+const sourceSandboxConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'source', '--apply-sandbox', sourceCandidateFile, '--confirm', '--json', '--root', subagentsTarget], {}, options), 'source --apply-sandbox --confirm --json');
+const sourceSandboxFile = sourceSandboxConfirm.source_sandbox_run_file;
+assertJsonMarkers([
+  ['command', sourceSandboxConfirm.command, 'source'],
+  ['mode', sourceSandboxConfirm.mode, 'source-sandbox-apply'],
+  ['source_sandbox_run.stage', sourceSandboxConfirm.source_sandbox_run?.stage, 'Stage 45'],
+  ['source_sandbox_run.allowed_followup.0', sourceSandboxConfirm.source_sandbox_run?.allowed_followup?.[0], 'source-verification-only'],
+  ['source_sandbox_run.business_source_write', sourceSandboxConfirm.source_sandbox_run?.business_source_write, false],
+  ['safety.source_sandbox_run_artifact', sourceSandboxConfirm.safety?.source_sandbox_run_artifact, true],
+  ['source_sandbox_run_file.type', typeof sourceSandboxFile, 'string'],
+], 'source --apply-sandbox --confirm --json');
+if (!sourceSandboxFile || !fs.existsSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'source-sandbox-runs', sourceSandboxFile))) throw new Error('source apply sandbox did not write sandbox run artifact');
+const sourceSandboxVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'source', '--verify', sourceSandboxFile, '--json', '--root', subagentsTarget], {}, options), 'source --verify sandbox --json');
+assertJsonMarkers([
+  ['mode', sourceSandboxVerify.mode, 'source-sandbox-run-verify'],
+  ['verification.ok', sourceSandboxVerify.verification?.ok, true],
+], 'source --verify sandbox --json');
+const sourceSandboxAliasPath = path.join(absoluteSubagentsTarget, '.vibecoding-state', 'source-sandbox-runs', 'bad-alias.source-sandbox-run.json');
+fs.copyFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'source-sandbox-runs', sourceSandboxFile), sourceSandboxAliasPath);
+run('node', ['tools/vibe-runtime/index.mjs', 'source', '--verify', 'bad-alias.source-sandbox-run.json', '--root', subagentsTarget], {
+  allowFailure: true,
+  expectOutput: ['source artifact verification failed:', 'Stage 45 source sandbox run file identity mismatch'],
+}, options);
+fs.rmSync(sourceSandboxAliasPath, { force: true });
+const badSourceSandbox = JSON.parse(fs.readFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'source-sandbox-runs', sourceSandboxFile), 'utf8'));
+badSourceSandbox.source_sandbox_run.git = true;
+badSourceSandbox.source_sandbox_run.worktree = true;
+badSourceSandbox.source_sandbox_run.allowed_followup = ['source-verification-only', 'merge'];
+delete badSourceSandbox.source_sandbox_run.sandbox_digest;
+badSourceSandbox.source_sandbox_run.sandbox_digest = digestObject(badSourceSandbox.source_sandbox_run);
+fs.writeFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'source-sandbox-runs', 'bad-resigned.source-sandbox-run.json'), `${JSON.stringify(badSourceSandbox, null, 2)}\n`, 'utf8');
+run('node', ['tools/vibe-runtime/index.mjs', 'source', '--verify', 'bad-resigned.source-sandbox-run.json', '--root', subagentsTarget], {
+  allowFailure: true,
+  expectOutput: ['source artifact verification failed:', 'source_sandbox_run.allowed_followup must equal source-verification-only', 'source_sandbox_run.git must be false', 'source_sandbox_run.worktree must be false'],
+}, options);
+fs.rmSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'source-sandbox-runs', 'bad-resigned.source-sandbox-run.json'), { force: true });
+const sourceTrace = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'traces', '--build', '--confirm', '--json', '--root', subagentsTarget], {}, options), 'traces --build source sandbox --confirm --json');
+const sourceTraceTypes = sourceTrace.runtime_trace?.source_types || {};
+if (!sourceTraceTypes.source_change_candidates || !sourceTraceTypes.source_sandbox_runs) throw new Error('source trace did not include Stage 45 source types');
+
+return { sourceCandidateFile, sourceSandboxFile };
+}
+
+function runSourceVerificationSmoke(context, options, sourceSandboxFile) {
+  const {
+    subagentsTarget,
+    absoluteSubagentsTarget,
+  } = context;
+
+const sourceVerificationConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'source', '--verify-change', sourceSandboxFile, '--confirm', '--json', '--root', subagentsTarget], {}, options), 'source --verify-change --confirm --json');
+const sourceVerificationFile = sourceVerificationConfirm.source_verification_file;
+assertJsonMarkers([
+  ['command', sourceVerificationConfirm.command, 'source'],
+  ['mode', sourceVerificationConfirm.mode, 'source-verification-gate'],
+  ['source_verification.stage', sourceVerificationConfirm.source_verification?.stage, 'Stage 46'],
+  ['source_verification.verification_status', sourceVerificationConfirm.source_verification?.verification_status, 'verification-passed-merge-readiness-required'],
+  ['source_verification.allowed_followup.0', sourceVerificationConfirm.source_verification?.allowed_followup?.[0], 'merge-readiness-only'],
+  ['source_verification.business_source_write', sourceVerificationConfirm.source_verification?.business_source_write, false],
+  ['source_verification.command_execution', sourceVerificationConfirm.source_verification?.command_execution, true],
+  ['evidence_policy.foreground_execution', sourceVerificationConfirm.evidence_policy?.foreground_execution, true],
+  ['safety.source_verification_artifact', sourceVerificationConfirm.safety?.source_verification_artifact, true],
+  ['source_verification_file.type', typeof sourceVerificationFile, 'string'],
+], 'source --verify-change --confirm --json');
+if (!sourceVerificationFile || !fs.existsSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'source-verifications', sourceVerificationFile))) throw new Error('source verify-change did not write source verification artifact');
+const sourceVerificationVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'source', '--verify', sourceVerificationFile, '--json', '--root', subagentsTarget], {}, options), 'source --verify verification --json');
+assertJsonMarkers([
+  ['mode', sourceVerificationVerify.mode, 'source-verification-verify'],
+  ['verification.ok', sourceVerificationVerify.verification?.ok, true],
+], 'source --verify verification --json');
+const sourceVerificationAliasPath = path.join(absoluteSubagentsTarget, '.vibecoding-state', 'source-verifications', 'bad-alias.source-verification.json');
+fs.copyFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'source-verifications', sourceVerificationFile), sourceVerificationAliasPath);
+run('node', ['tools/vibe-runtime/index.mjs', 'source', '--verify', 'bad-alias.source-verification.json', '--root', subagentsTarget], {
+  allowFailure: true,
+  expectOutput: ['source artifact verification failed:', 'Stage 46 source verification file identity mismatch'],
+}, options);
+fs.rmSync(sourceVerificationAliasPath, { force: true });
+const badSourceVerification = JSON.parse(fs.readFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'source-verifications', sourceVerificationFile), 'utf8'));
+badSourceVerification.source_verification.source_merge = true;
+badSourceVerification.source_verification.git = true;
+badSourceVerification.source_verification.worktree = true;
+badSourceVerification.source_verification.command_execution = false;
+badSourceVerification.source_verification.allowed_followup = ['merge-readiness-only', 'merge'];
+badSourceVerification.source_verification.missing_evidence = ['runtime-check'];
+delete badSourceVerification.source_verification.verification_digest;
+badSourceVerification.source_verification.verification_digest = digestObject(badSourceVerification.source_verification);
+fs.writeFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'source-verifications', 'bad-resigned.source-verification.json'), `${JSON.stringify(badSourceVerification, null, 2)}\n`, 'utf8');
+run('node', ['tools/vibe-runtime/index.mjs', 'source', '--verify', 'bad-resigned.source-verification.json', '--root', subagentsTarget], {
+  allowFailure: true,
+  expectOutput: ['source artifact verification failed:', 'source_verification.allowed_followup must equal merge-readiness-only', 'source_verification.missing_evidence must be empty', 'source_verification.command_execution must be true', 'source_verification.source_merge must be false', 'source_verification.git must be false', 'source_verification.worktree must be false'],
+}, options);
+fs.rmSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'source-verifications', 'bad-resigned.source-verification.json'), { force: true });
+const sourceVerificationTrace = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'traces', '--build', '--confirm', '--json', '--root', subagentsTarget], {}, options), 'traces --build source verification --confirm --json');
+const sourceVerificationTraceTypes = sourceVerificationTrace.runtime_trace?.source_types || {};
+if (!sourceVerificationTraceTypes.source_verifications) throw new Error('source trace did not include Stage 46 source verification types');
+
+return { sourceVerificationFile };
+}
+
+function runMergeReadinessSmoke(context, options, sourceVerificationFile) {
+  const {
+    subagentsTarget,
+    absoluteSubagentsTarget,
+  } = context;
+
+const mergeReadinessPreview = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'merge', '--readiness', '--from-verification', sourceVerificationFile, '--json', '--root', subagentsTarget], {}, options), 'merge --readiness --json');
+assertJsonMarkers([
+  ['command', mergeReadinessPreview.command, 'merge'],
+  ['mode', mergeReadinessPreview.mode, 'merge-readiness'],
+  ['merge_readiness.stage', mergeReadinessPreview.merge_readiness?.stage, 'Stage 47'],
+  ['merge_readiness.writes', mergeReadinessPreview.merge_readiness?.writes, false],
+  ['merge_readiness.source_merge', mergeReadinessPreview.merge_readiness?.source_merge, false],
+  ['merge_readiness.auto_apply', mergeReadinessPreview.merge_readiness?.auto_apply, false],
+  ['safety.writes', mergeReadinessPreview.safety?.writes, false],
+], 'merge --readiness --json');
+const mergeReadinessPreviewPath = path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-readiness');
+if (fs.existsSync(mergeReadinessPreviewPath)) throw new Error('merge readiness preview created unexpected readiness directory');
+run('node', ['tools/vibe-runtime/index.mjs', 'merge', '--readiness', '--from-verification', sourceVerificationFile, '--confirm', '--json', '--root', subagentsTarget], {
+  allowFailure: true,
+  expectOutput: ['merge readiness verification failed:', 'merge_readiness.readiness_status must be merge-readiness-passed-approval-required', 'merge_readiness.governance_file is required'],
+}, options);
+const mergeReadinessReadiness = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'readiness', '--score', '--confirm', '--json', '--root', subagentsTarget], {}, options), 'readiness --score merge readiness --confirm --json');
+assertJsonMarkers([
+  ['command', mergeReadinessReadiness.command, 'observability'],
+  ['mode', mergeReadinessReadiness.mode, 'observability-readiness-score'],
+  ['safety.observability_snapshot', mergeReadinessReadiness.safety?.observability_snapshot, true],
+], 'readiness --score merge readiness --confirm --json');
+const mergeReadinessTrace = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'traces', '--build', '--confirm', '--json', '--root', subagentsTarget], {}, options), 'traces --build merge readiness baseline --confirm --json');
+const mergeReadinessTraceTypes = mergeReadinessTrace.runtime_trace?.source_types || {};
+if (!mergeReadinessTraceTypes.source_verifications) throw new Error('merge readiness baseline trace did not include Stage 46 verification source type');
+const mergeReadinessGovernance = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--attest', '--confirm', '--json', '--root', subagentsTarget], {}, options), 'governance --attest merge readiness --confirm --json');
+assertJsonMarkers([
+  ['command', mergeReadinessGovernance.command, 'governance'],
+  ['mode', mergeReadinessGovernance.mode, 'governance-attest'],
+  ['governance_attestation.violations.length', mergeReadinessGovernance.governance_attestation?.violations?.length, 0],
+  ['safety.governance_artifact', mergeReadinessGovernance.safety?.governance_artifact, true],
+], 'governance --attest merge readiness --confirm --json');
+const mergeReadinessMethodology = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'methodology', '--gate', '--kind', 'automation', '--confirm', '--json', '--root', subagentsTarget], {}, options), 'methodology --gate automation merge readiness --confirm --json');
+assertJsonMarkers([
+  ['command', mergeReadinessMethodology.command, 'methodology'],
+  ['mode', mergeReadinessMethodology.mode, 'methodology-gate'],
+  ['methodology_gate.kind', mergeReadinessMethodology.methodology_gate?.kind, 'automation'],
+  ['methodology_gate.outcome', mergeReadinessMethodology.methodology_gate?.outcome, 'passed'],
+], 'methodology --gate automation merge readiness --confirm --json');
+const mergeReadinessConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'merge', '--readiness', '--from-verification', sourceVerificationFile, '--confirm', '--json', '--root', subagentsTarget], {}, options), 'merge --readiness --confirm --json');
+const mergeReadinessFile = mergeReadinessConfirm.merge_readiness_file;
+assertJsonMarkers([
+  ['command', mergeReadinessConfirm.command, 'merge'],
+  ['mode', mergeReadinessConfirm.mode, 'merge-readiness'],
+  ['merge_readiness.stage', mergeReadinessConfirm.merge_readiness?.stage, 'Stage 47'],
+  ['merge_readiness.readiness_status', mergeReadinessConfirm.merge_readiness?.readiness_status, 'merge-readiness-passed-approval-required'],
+  ['merge_readiness.allowed_followup.0', mergeReadinessConfirm.merge_readiness?.allowed_followup?.[0], 'merge-approval-only'],
+  ['merge_readiness.source_merge', mergeReadinessConfirm.merge_readiness?.source_merge, false],
+  ['merge_readiness.business_source_write', mergeReadinessConfirm.merge_readiness?.business_source_write, false],
+  ['merge_readiness.auto_apply', mergeReadinessConfirm.merge_readiness?.auto_apply, false],
+  ['merge_readiness.policy.governance_required', mergeReadinessConfirm.merge_readiness?.policy?.governance_required, true],
+  ['safety.merge_readiness_artifact', mergeReadinessConfirm.safety?.merge_readiness_artifact, true],
+  ['safety.auto_apply', mergeReadinessConfirm.safety?.auto_apply, false],
+  ['merge_readiness_file.type', typeof mergeReadinessFile, 'string'],
+], 'merge --readiness --confirm --json');
+if (!mergeReadinessFile || !fs.existsSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-readiness', mergeReadinessFile))) throw new Error('merge readiness did not write readiness artifact');
+const mergeReadinessVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'merge', '--verify', mergeReadinessFile, '--json', '--root', subagentsTarget], {}, options), 'merge --verify readiness --json');
+assertJsonMarkers([
+  ['mode', mergeReadinessVerify.mode, 'merge-readiness-verify'],
+  ['verification.ok', mergeReadinessVerify.verification?.ok, true],
+], 'merge --verify readiness --json');
+const mergeReadinessAliasPath = path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-readiness', 'bad-alias.merge-readiness.json');
+fs.copyFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-readiness', mergeReadinessFile), mergeReadinessAliasPath);
+run('node', ['tools/vibe-runtime/index.mjs', 'merge', '--verify', 'bad-alias.merge-readiness.json', '--root', subagentsTarget], {
+  allowFailure: true,
+  expectOutput: ['merge artifact verification failed:', 'Stage 47 merge readiness file identity mismatch'],
+}, options);
+fs.rmSync(mergeReadinessAliasPath, { force: true });
+const badMergeReadiness = JSON.parse(fs.readFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-readiness', mergeReadinessFile), 'utf8'));
+badMergeReadiness.merge_readiness.source_merge = true;
+badMergeReadiness.merge_readiness.git = true;
+badMergeReadiness.merge_readiness.worktree = true;
+badMergeReadiness.merge_readiness.auto_apply = true;
+badMergeReadiness.merge_readiness.allowed_followup = ['merge-approval-only', 'controlled-merge-apply-only'];
+delete badMergeReadiness.merge_readiness.readiness_digest;
+badMergeReadiness.merge_readiness.readiness_digest = digestObject(badMergeReadiness.merge_readiness);
+fs.writeFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-readiness', 'bad-resigned.merge-readiness.json'), `${JSON.stringify(badMergeReadiness, null, 2)}\n`, 'utf8');
+run('node', ['tools/vibe-runtime/index.mjs', 'merge', '--verify', 'bad-resigned.merge-readiness.json', '--root', subagentsTarget], {
+  allowFailure: true,
+  expectOutput: ['merge artifact verification failed:', 'merge_readiness.allowed_followup must equal merge-approval-only', 'merge_readiness.source_merge must be false', 'merge_readiness.git must be false', 'merge_readiness.worktree must be false', 'merge_readiness.auto_apply must be false'],
+}, options);
+fs.rmSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-readiness', 'bad-resigned.merge-readiness.json'), { force: true });
+const badMergeReadinessVerificationDigest = JSON.parse(fs.readFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-readiness', mergeReadinessFile), 'utf8'));
+badMergeReadinessVerificationDigest.merge_readiness.verification_digest = '0'.repeat(64);
+delete badMergeReadinessVerificationDigest.merge_readiness.readiness_digest;
+badMergeReadinessVerificationDigest.merge_readiness.readiness_digest = digestObject(badMergeReadinessVerificationDigest.merge_readiness);
+fs.writeFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-readiness', 'bad-verification-digest.merge-readiness.json'), `${JSON.stringify(badMergeReadinessVerificationDigest, null, 2)}\n`, 'utf8');
+run('node', ['tools/vibe-runtime/index.mjs', 'merge', '--verify', 'bad-verification-digest.merge-readiness.json', '--root', subagentsTarget], {
+  allowFailure: true,
+  expectOutput: ['merge artifact verification failed:', 'merge_readiness verification digest mismatch'],
+}, options);
+fs.rmSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-readiness', 'bad-verification-digest.merge-readiness.json'), { force: true });
+const badMergeReadinessGovernanceDigest = JSON.parse(fs.readFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-readiness', mergeReadinessFile), 'utf8'));
+badMergeReadinessGovernanceDigest.merge_readiness.governance_digest = '1'.repeat(64);
+delete badMergeReadinessGovernanceDigest.merge_readiness.readiness_digest;
+badMergeReadinessGovernanceDigest.merge_readiness.readiness_digest = digestObject(badMergeReadinessGovernanceDigest.merge_readiness);
+fs.writeFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-readiness', 'bad-governance-digest.merge-readiness.json'), `${JSON.stringify(badMergeReadinessGovernanceDigest, null, 2)}\n`, 'utf8');
+run('node', ['tools/vibe-runtime/index.mjs', 'merge', '--verify', 'bad-governance-digest.merge-readiness.json', '--root', subagentsTarget], {
+  allowFailure: true,
+  expectOutput: ['merge artifact verification failed:', 'merge_readiness governance digest mismatch'],
+}, options);
+fs.rmSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-readiness', 'bad-governance-digest.merge-readiness.json'), { force: true });
+
+return { mergeReadinessFile };
+}
+
+function runMergeApprovalSmoke(context, options, mergeReadinessFile) {
+  const {
+    subagentsTarget,
+    absoluteSubagentsTarget,
+  } = context;
+
+const mergeApprovalConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'merge', '--approve', mergeReadinessFile, '--confirm', '--json', '--root', subagentsTarget], {}, options), 'merge --approve --confirm --json');
+const mergeApprovalFile = mergeApprovalConfirm.merge_approval_file;
+assertJsonMarkers([
+  ['command', mergeApprovalConfirm.command, 'merge'],
+  ['mode', mergeApprovalConfirm.mode, 'merge-approval'],
+  ['merge_approval.stage', mergeApprovalConfirm.merge_approval?.stage, 'Stage 47'],
+  ['merge_approval.approval_status', mergeApprovalConfirm.merge_approval?.approval_status, 'merge-approved-apply-required'],
+  ['merge_approval.allowed_followup.0', mergeApprovalConfirm.merge_approval?.allowed_followup?.[0], 'controlled-merge-apply-only'],
+  ['merge_approval.source_merge', mergeApprovalConfirm.merge_approval?.source_merge, false],
+  ['merge_approval.business_source_write', mergeApprovalConfirm.merge_approval?.business_source_write, false],
+  ['merge_approval.auto_apply', mergeApprovalConfirm.merge_approval?.auto_apply, false],
+  ['safety.merge_approval_artifact', mergeApprovalConfirm.safety?.merge_approval_artifact, true],
+  ['safety.auto_apply', mergeApprovalConfirm.safety?.auto_apply, false],
+  ['merge_approval_file.type', typeof mergeApprovalFile, 'string'],
+], 'merge --approve --confirm --json');
+if (!mergeApprovalFile || !fs.existsSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-approvals', mergeApprovalFile))) throw new Error('merge approval did not write approval artifact');
+const mergeApprovalVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'merge', '--verify', mergeApprovalFile, '--json', '--root', subagentsTarget], {}, options), 'merge --verify approval --json');
+assertJsonMarkers([
+  ['mode', mergeApprovalVerify.mode, 'merge-approval-verify'],
+  ['verification.ok', mergeApprovalVerify.verification?.ok, true],
+], 'merge --verify approval --json');
+const mergeApprovalAliasPath = path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-approvals', 'bad-alias.merge-approval.json');
+fs.copyFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-approvals', mergeApprovalFile), mergeApprovalAliasPath);
+run('node', ['tools/vibe-runtime/index.mjs', 'merge', '--verify', 'bad-alias.merge-approval.json', '--root', subagentsTarget], {
+  allowFailure: true,
+  expectOutput: ['merge artifact verification failed:', 'Stage 47 merge approval file identity mismatch'],
+}, options);
+fs.rmSync(mergeApprovalAliasPath, { force: true });
+const badMergeApproval = JSON.parse(fs.readFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-approvals', mergeApprovalFile), 'utf8'));
+badMergeApproval.merge_approval.source_merge = true;
+badMergeApproval.merge_approval.git = true;
+badMergeApproval.merge_approval.worktree = true;
+badMergeApproval.merge_approval.auto_apply = true;
+badMergeApproval.merge_approval.allowed_followup = ['controlled-merge-apply-only', 'commit'];
+delete badMergeApproval.merge_approval.approval_digest;
+badMergeApproval.merge_approval.approval_digest = digestObject(badMergeApproval.merge_approval);
+fs.writeFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-approvals', 'bad-resigned.merge-approval.json'), `${JSON.stringify(badMergeApproval, null, 2)}\n`, 'utf8');
+run('node', ['tools/vibe-runtime/index.mjs', 'merge', '--verify', 'bad-resigned.merge-approval.json', '--root', subagentsTarget], {
+  allowFailure: true,
+  expectOutput: ['merge artifact verification failed:', 'merge_approval.allowed_followup must equal controlled-merge-apply-only', 'merge_approval.source_merge must be false', 'merge_approval.git must be false', 'merge_approval.worktree must be false', 'merge_approval.auto_apply must be false'],
+}, options);
+fs.rmSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-approvals', 'bad-resigned.merge-approval.json'), { force: true });
+const badMergeApprovalReadinessDigest = JSON.parse(fs.readFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-approvals', mergeApprovalFile), 'utf8'));
+badMergeApprovalReadinessDigest.merge_approval.readiness_digest = '2'.repeat(64);
+delete badMergeApprovalReadinessDigest.merge_approval.approval_digest;
+badMergeApprovalReadinessDigest.merge_approval.approval_digest = digestObject(badMergeApprovalReadinessDigest.merge_approval);
+fs.writeFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-approvals', 'bad-readiness-digest.merge-approval.json'), `${JSON.stringify(badMergeApprovalReadinessDigest, null, 2)}\n`, 'utf8');
+run('node', ['tools/vibe-runtime/index.mjs', 'merge', '--verify', 'bad-readiness-digest.merge-approval.json', '--root', subagentsTarget], {
+  allowFailure: true,
+  expectOutput: ['merge artifact verification failed:', 'merge_approval readiness digest mismatch'],
+}, options);
+fs.rmSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-approvals', 'bad-readiness-digest.merge-approval.json'), { force: true });
+
+return { mergeApprovalFile };
+}
+
+function runMergeApplySmoke(context, options, mergeApprovalFile) {
+  const {
+    subagentsTarget,
+    absoluteSubagentsTarget,
+  } = context;
+
+const mergeApplyConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'merge', '--apply', mergeApprovalFile, '--confirm', '--json', '--root', subagentsTarget], {}, options), 'merge --apply --confirm --json');
+const mergeApplyFile = mergeApplyConfirm.merge_apply_file;
+assertJsonMarkers([
+  ['command', mergeApplyConfirm.command, 'merge'],
+  ['mode', mergeApplyConfirm.mode, 'merge-apply'],
+  ['merge_apply.stage', mergeApplyConfirm.merge_apply?.stage, 'Stage 48'],
+  ['merge_apply.apply_status', mergeApplyConfirm.merge_apply?.apply_status, 'controlled-merge-apply-completed'],
+  ['merge_apply.apply_mode', mergeApplyConfirm.merge_apply?.apply_mode, 'controlled-local-marker-apply'],
+  ['merge_apply.applied_files.0', mergeApplyConfirm.merge_apply?.applied_files?.[0], 'docs/runtime-auto-merge-ledger.md'],
+  ['merge_apply.business_source_write', mergeApplyConfirm.merge_apply?.business_source_write, true],
+  ['merge_apply.source_merge', mergeApplyConfirm.merge_apply?.source_merge, true],
+  ['merge_apply.worktree', mergeApplyConfirm.merge_apply?.worktree, true],
+  ['merge_apply.git', mergeApplyConfirm.merge_apply?.git, false],
+  ['merge_apply.commit', mergeApplyConfirm.merge_apply?.commit, false],
+  ['merge_apply.push', mergeApplyConfirm.merge_apply?.push, false],
+  ['merge_apply.pr', mergeApplyConfirm.merge_apply?.pr, false],
+  ['safety.merge_apply_artifact', mergeApplyConfirm.safety?.merge_apply_artifact, true],
+  ['safety.controlled_apply', mergeApplyConfirm.safety?.controlled_apply, true],
+  ['safety.git', mergeApplyConfirm.safety?.git, false],
+  ['merge_apply_file.type', typeof mergeApplyFile, 'string'],
+], 'merge --apply --confirm --json');
+if (!mergeApplyFile || !fs.existsSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-applies', mergeApplyFile))) throw new Error('merge apply did not write apply artifact');
+if (!fs.existsSync(path.join(absoluteSubagentsTarget, 'docs', 'runtime-auto-merge-ledger.md'))) throw new Error('merge apply did not write allowlisted worktree marker');
+const mergeApplyVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'merge', '--verify', mergeApplyFile, '--json', '--root', subagentsTarget], {}, options), 'merge --verify apply --json');
+assertJsonMarkers([
+  ['mode', mergeApplyVerify.mode, 'merge-apply-verify'],
+  ['verification.ok', mergeApplyVerify.verification?.ok, true],
+], 'merge --verify apply --json');
+run('node', ['tools/vibe-runtime/index.mjs', 'source', '--apply-to-worktree', '--approval', mergeApprovalFile, '--json', '--root', subagentsTarget], {
+  allowFailure: true,
+  expectOutput: ['source --apply-to-worktree requires --confirm'],
+}, options);
+run('node', ['tools/vibe-runtime/index.mjs', 'source', '--apply-to-worktree', '--confirm', '--json', '--root', subagentsTarget], {
+  allowFailure: true,
+  expectOutput: ['source --apply-to-worktree requires --approval'],
+}, options);
+const sourceApplyConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'source', '--apply-to-worktree', '--approval', mergeApprovalFile, '--confirm', '--json', '--root', subagentsTarget], {}, options), 'source --apply-to-worktree --confirm --json');
+const sourceApplyFile = sourceApplyConfirm.source_apply_to_worktree?.merge_apply_file;
+assertJsonMarkers([
+  ['command', sourceApplyConfirm.command, 'source'],
+  ['mode', sourceApplyConfirm.mode, 'source-apply-to-worktree'],
+  ['source_apply_to_worktree.stage', sourceApplyConfirm.source_apply_to_worktree?.stage, 'P9'],
+  ['source_apply_to_worktree.human_confirmed', sourceApplyConfirm.source_apply_to_worktree?.human_confirmed, true],
+  ['source_apply_to_worktree.delegated_apply', sourceApplyConfirm.source_apply_to_worktree?.delegated_apply, 'merge --apply'],
+  ['source_apply_to_worktree.applied_files.0', sourceApplyConfirm.source_apply_to_worktree?.applied_files?.[0], 'docs/runtime-auto-merge-ledger.md'],
+  ['source_apply_to_worktree.git', sourceApplyConfirm.source_apply_to_worktree?.git, false],
+  ['source_apply_to_worktree.commit', sourceApplyConfirm.source_apply_to_worktree?.commit, false],
+  ['source_apply_to_worktree.push', sourceApplyConfirm.source_apply_to_worktree?.push, false],
+  ['source_apply_to_worktree.pr', sourceApplyConfirm.source_apply_to_worktree?.pr, false],
+  ['merge_apply.apply_status', sourceApplyConfirm.merge_apply?.apply_status, 'controlled-merge-apply-completed'],
+  ['safety.human_confirmed_apply', sourceApplyConfirm.safety?.human_confirmed_apply, true],
+  ['safety.git', sourceApplyConfirm.safety?.git, false],
+], 'source --apply-to-worktree --confirm --json');
+if (!sourceApplyFile || !fs.existsSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-applies', sourceApplyFile))) throw new Error('source apply-to-worktree did not write delegated merge apply artifact');
+const sourceApplyVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'merge', '--verify', sourceApplyFile, '--json', '--root', subagentsTarget], {}, options), 'merge --verify source delegated apply --json');
+assertJsonMarkers([
+  ['mode', sourceApplyVerify.mode, 'merge-apply-verify'],
+  ['verification.ok', sourceApplyVerify.verification?.ok, true],
+], 'merge --verify source delegated apply --json');
+const mergeApplyAliasPath = path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-applies', 'bad-alias.merge-apply.json');
+fs.copyFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-applies', mergeApplyFile), mergeApplyAliasPath);
+run('node', ['tools/vibe-runtime/index.mjs', 'merge', '--verify', 'bad-alias.merge-apply.json', '--root', subagentsTarget], {
+  allowFailure: true,
+  expectOutput: ['merge artifact verification failed:', 'Stage 48 merge apply file identity mismatch'],
+}, options);
+fs.rmSync(mergeApplyAliasPath, { force: true });
+const badMergeApply = JSON.parse(fs.readFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-applies', mergeApplyFile), 'utf8'));
+badMergeApply.merge_apply.git = true;
+badMergeApply.merge_apply.commit = true;
+badMergeApply.merge_apply.push = true;
+badMergeApply.merge_apply.pr = true;
+badMergeApply.merge_apply.force = true;
+badMergeApply.merge_apply.allowed_followup = ['trace-governance-attestation-only', 'push'];
+delete badMergeApply.merge_apply.apply_digest;
+badMergeApply.merge_apply.apply_digest = digestObject(badMergeApply.merge_apply);
+fs.writeFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-applies', 'bad-resigned.merge-apply.json'), `${JSON.stringify(badMergeApply, null, 2)}\n`, 'utf8');
+run('node', ['tools/vibe-runtime/index.mjs', 'merge', '--verify', 'bad-resigned.merge-apply.json', '--root', subagentsTarget], {
+  allowFailure: true,
+  expectOutput: ['merge artifact verification failed:', 'merge_apply.allowed_followup must equal trace-governance-attestation-only', 'merge_apply.git must be false', 'merge_apply.commit must be false', 'merge_apply.push must be false', 'merge_apply.pr must be false', 'merge_apply.force must be false'],
+}, options);
+fs.rmSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-applies', 'bad-resigned.merge-apply.json'), { force: true });
+const badMergeApplyApprovalDigest = JSON.parse(fs.readFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-applies', mergeApplyFile), 'utf8'));
+badMergeApplyApprovalDigest.merge_apply.approval_digest = '3'.repeat(64);
+delete badMergeApplyApprovalDigest.merge_apply.apply_digest;
+badMergeApplyApprovalDigest.merge_apply.apply_digest = digestObject(badMergeApplyApprovalDigest.merge_apply);
+fs.writeFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-applies', 'bad-approval-digest.merge-apply.json'), `${JSON.stringify(badMergeApplyApprovalDigest, null, 2)}\n`, 'utf8');
+run('node', ['tools/vibe-runtime/index.mjs', 'merge', '--verify', 'bad-approval-digest.merge-apply.json', '--root', subagentsTarget], {
+  allowFailure: true,
+  expectOutput: ['merge artifact verification failed:', 'merge_apply approval digest mismatch'],
+}, options);
+fs.rmSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-applies', 'bad-approval-digest.merge-apply.json'), { force: true });
+const badMergeApplyAfterDigest = JSON.parse(fs.readFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-applies', mergeApplyFile), 'utf8'));
+badMergeApplyAfterDigest.merge_apply.after_file_digests['docs/runtime-auto-merge-ledger.md'] = '4'.repeat(64);
+delete badMergeApplyAfterDigest.merge_apply.apply_digest;
+badMergeApplyAfterDigest.merge_apply.apply_digest = digestObject(badMergeApplyAfterDigest.merge_apply);
+fs.writeFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-applies', 'bad-after-digest.merge-apply.json'), `${JSON.stringify(badMergeApplyAfterDigest, null, 2)}\n`, 'utf8');
+run('node', ['tools/vibe-runtime/index.mjs', 'merge', '--verify', 'bad-after-digest.merge-apply.json', '--root', subagentsTarget], {
+  allowFailure: true,
+  expectOutput: ['merge artifact verification failed:', 'merge_apply after file digest mismatch: docs/runtime-auto-merge-ledger.md'],
+}, options);
+fs.rmSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-applies', 'bad-after-digest.merge-apply.json'), { force: true });
+const badMergeApplyShaDrift = JSON.parse(fs.readFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-applies', mergeApplyFile), 'utf8'));
+badMergeApplyShaDrift.merge_apply.before_sha = '5'.repeat(40);
+delete badMergeApplyShaDrift.merge_apply.apply_digest;
+badMergeApplyShaDrift.merge_apply.apply_digest = digestObject(badMergeApplyShaDrift.merge_apply);
+fs.writeFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-applies', 'bad-sha-drift.merge-apply.json'), `${JSON.stringify(badMergeApplyShaDrift, null, 2)}\n`, 'utf8');
+run('node', ['tools/vibe-runtime/index.mjs', 'merge', '--verify', 'bad-sha-drift.merge-apply.json', '--root', subagentsTarget], {
+  allowFailure: true,
+  expectOutput: ['merge artifact verification failed:', 'merge_apply before_sha and after_sha must match base_sha'],
+}, options);
+fs.rmSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'merge-applies', 'bad-sha-drift.merge-apply.json'), { force: true });
+const mergeList = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'merge', '--list', '--json', '--root', subagentsTarget], {}, options), 'merge --list --json');
+assertJsonMarkers([
+  ['command', mergeList.command, 'merge'],
+  ['mode', mergeList.mode, 'merge-artifact-list'],
+  ['summary.readiness_count', mergeList.summary?.readiness_count, 1],
+  ['summary.approval_count', mergeList.summary?.approval_count, 1],
+  ['summary.apply_count', mergeList.summary?.apply_count, 2],
+], 'merge --list --json');
+const mergeTrace = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'traces', '--build', '--confirm', '--json', '--root', subagentsTarget], {}, options), 'traces --build merge stage47-48 --confirm --json');
+const mergeTraceTypes = mergeTrace.runtime_trace?.source_types || {};
+if (!mergeTraceTypes.merge_readiness || !mergeTraceTypes.merge_approvals || !mergeTraceTypes.merge_applies) throw new Error('merge trace did not include Stage 47-48 source types');
+
+return { mergeApplyFile };
+}
+
+export function runSourceCandidateSmoke(context, platformContext, options) {
+  runSourcePatchPlanSmoke(context, options);
+  const { sourceCandidateFile, sourceSandboxFile } = runSourceCandidateSandboxSmoke(context, platformContext, options);
+  const { sourceVerificationFile } = runSourceVerificationSmoke(context, options, sourceSandboxFile);
+  const { mergeReadinessFile } = runMergeReadinessSmoke(context, options, sourceVerificationFile);
+  const { mergeApprovalFile } = runMergeApprovalSmoke(context, options, mergeReadinessFile);
+  const { mergeApplyFile } = runMergeApplySmoke(context, options, mergeApprovalFile);
+
+  return {
+    sourceCandidateFile,
+    sourceSandboxFile,
+    sourceVerificationFile,
+    mergeReadinessFile,
+    mergeApprovalFile,
+    mergeApplyFile,
+  };
+}

package/tools/vibe-release-check/release-check-runtime-automation-source-suite.mjs

@@ -0,0 +1,5 @@
+import { runSourceCandidateSmoke } from './release-check-runtime-automation-source-candidate-smoke-helpers.mjs';
+
+export function runRuntimeAutomationSourceSmoke(context, platformContext, options) {
+  return runSourceCandidateSmoke(context, platformContext, options);
+}