@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-release-check/release-check-runtime-automation-subagents-lifecycle-smoke-helpers.mjs

@@ -0,0 +1,305 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  assertJsonMarkers,
+  digestObject,
+  parseJsonOutput,
+  run,
+} from './release-check-runtime.mjs';
+import { checkSubagentAdapterBridgeSmoke } from './release-check-subagent-adapter-bridge-smoke.mjs';
+
+export function runSubagentEligibilityLifecycleSmoke(context, options) {
+  const {
+    subagentsTarget,
+    absoluteSubagentsTarget,
+    subagentsHandoffFile,
+  } = context;
+
+  fs.writeFileSync(subagentsHandoffFile, `${JSON.stringify({
+    current_skill: 'vibe-subagent-driven-development',
+    next_skill: 'vibe-executing-plans',
+    reason: 'release check subagent eligibility smoke',
+    handoff: {
+      goal: 'release check subagent eligibility gate',
+      scope: ['subagent eligibility smoke'],
+      key_decisions: ['subagent eligibility is evidence-driven and does not dispatch'],
+      files: ['tools/vibe-runtime/index.mjs'],
+      risks: ['none'],
+      acceptance: ['subagent eligibility can be previewed, written, verified, and rejects semantic drift'],
+      evidence: ['release-check subagent smoke'],
+      tasks: [
+        {
+          id: 'subagent-task',
+          title: 'release check subagent eligibility task',
+          status: 'pending',
+          review_status: 'requested',
+          files: ['tools/vibe-runtime/index.mjs'],
+          depends_on: [],
+          acceptance: ['subagent eligibility gate is auditable'],
+          evidence: ['subagent-consent', 'brief-complete', 'file-scope-isolated', 'shared-state-clear', 'task-review-gate', 'final-review-gate', 'fallback-path', 'platform-capability-subagent'],
+          risks: ['none'],
+          notes: ['subagent eligibility smoke'],
+        },
+      ],
+    },
+    stop_condition: 'none',
+  }, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'record-handoff', '--from-file', subagentsHandoffFile, '--root', subagentsTarget], {}, options);
+  const subagentsPreview = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--eligibility', '--task', 'subagent-task', '--json', '--root', subagentsTarget], {}, options), 'subagents --eligibility --json');
+  assertJsonMarkers([
+    ['command', subagentsPreview.command, 'subagents'],
+    ['mode', subagentsPreview.mode, 'subagent-eligibility'],
+    ['subagent_eligibility.stage', subagentsPreview.subagent_eligibility?.stage, 'Stage 35'],
+    ['subagent_eligibility.eligible', subagentsPreview.subagent_eligibility?.eligible, true],
+    ['subagent_eligibility.allowed_followup.0', subagentsPreview.subagent_eligibility?.allowed_followup?.[0], 'dispatch-artifact-only'],
+    ['safety.writes', subagentsPreview.safety?.writes, false],
+    ['safety.subagent_dispatch', subagentsPreview.safety?.subagent_dispatch, false],
+    ['safety.session_create', subagentsPreview.safety?.session_create, false],
+  ], 'subagents --eligibility --json');
+  if (fs.existsSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'subagent-eligibility'))) throw new Error('subagents eligibility preview created unexpected eligibility directory');
+  const subagentsConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--eligibility', '--task', 'subagent-task', '--confirm', '--json', '--root', subagentsTarget], {}, options), 'subagents --eligibility --confirm --json');
+  const subagentEligibilityFile = subagentsConfirm.subagent_eligibility_file;
+  assertJsonMarkers([
+    ['command', subagentsConfirm.command, 'subagents'],
+    ['mode', subagentsConfirm.mode, 'subagent-eligibility'],
+    ['safety.stage', subagentsConfirm.safety?.stage, 'Stage 35'],
+    ['safety.subagent_eligibility_artifact', subagentsConfirm.safety?.subagent_eligibility_artifact, true],
+    ['safety.subagent_dispatch', subagentsConfirm.safety?.subagent_dispatch, false],
+    ['subagent_eligibility_file.type', typeof subagentEligibilityFile, 'string'],
+  ], 'subagents --eligibility --confirm --json');
+  if (!subagentEligibilityFile || !fs.existsSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'subagent-eligibility', subagentEligibilityFile))) throw new Error('subagents eligibility confirm did not write eligibility artifact');
+  const subagentsVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', subagentEligibilityFile, '--json', '--root', subagentsTarget], {}, options), 'subagents --verify --json');
+  assertJsonMarkers([
+    ['command', subagentsVerify.command, 'subagents'],
+    ['mode', subagentsVerify.mode, 'subagent-eligibility-verify'],
+    ['verification.ok', subagentsVerify.verification?.ok, true],
+  ], 'subagents --verify --json');
+  const subagentEligibilityPath = path.join(absoluteSubagentsTarget, '.vibecoding-state', 'subagent-eligibility', subagentEligibilityFile);
+  const tamperedSubagentEligibility = JSON.parse(fs.readFileSync(subagentEligibilityPath, 'utf8'));
+  tamperedSubagentEligibility.safety.subagent_dispatch = true;
+  fs.writeFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'subagent-eligibility', 'bad-safety.subagent-eligibility.json'), `${JSON.stringify(tamperedSubagentEligibility, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', 'bad-safety.subagent-eligibility.json', '--root', subagentsTarget], {
+    allowFailure: true,
+    expectOutput: ['subagent eligibility verification failed:', 'safety.subagent_dispatch must be false'],
+  }, options);
+  fs.rmSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'subagent-eligibility', 'bad-safety.subagent-eligibility.json'), { force: true });
+  const resignedBadSubagentEligibility = JSON.parse(fs.readFileSync(subagentEligibilityPath, 'utf8'));
+  resignedBadSubagentEligibility.subagent_eligibility.allowed_followup = ['dispatch-artifact-only', 'session-create'];
+  resignedBadSubagentEligibility.subagent_eligibility.no_subagent_dispatch = false;
+  resignedBadSubagentEligibility.subagent_eligibility.gates[0].passed = true;
+  resignedBadSubagentEligibility.subagent_eligibility.gates[0].missing_evidence = ['subagent-consent'];
+  delete resignedBadSubagentEligibility.subagent_eligibility.eligibility_digest;
+  resignedBadSubagentEligibility.subagent_eligibility.eligibility_digest = digestObject(resignedBadSubagentEligibility.subagent_eligibility);
+  fs.writeFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'subagent-eligibility', 'bad-resigned.subagent-eligibility.json'), `${JSON.stringify(resignedBadSubagentEligibility, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', 'bad-resigned.subagent-eligibility.json', '--root', subagentsTarget], {
+    allowFailure: true,
+    expectOutput: ['subagent eligibility verification failed:', 'subagent_eligibility.allowed_followup must equal dispatch-artifact-only', 'subagent_eligibility.no_subagent_dispatch must be true'],
+  }, options);
+  fs.rmSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'subagent-eligibility', 'bad-resigned.subagent-eligibility.json'), { force: true });
+
+  return { subagentEligibilityFile };
+}
+
+export function runSubagentDispatchLifecycleSmoke(context, options, subagentEligibilityFile) {
+  const { subagentsTarget, absoluteSubagentsTarget } = context;
+
+  const subagentHookJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'hooks', '--preview', '--confirm', '--json', '--root', subagentsTarget], {}, options), 'subagents hooks --preview --confirm --json');
+  const subagentHookFile = subagentHookJson.hook_intent_file;
+  const subagentPlanJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'scheduler', '--from-hook', subagentHookFile, '--plan', '--confirm', '--json', '--root', subagentsTarget], {}, options), 'subagents scheduler --from-hook --plan --confirm --json');
+  const subagentSchedulerPlanFile = subagentPlanJson.scheduler_hook_plan_file;
+  const subagentDispatchConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--dispatch', '--from-plan', subagentSchedulerPlanFile, '--eligibility', subagentEligibilityFile, '--confirm', '--json', '--root', subagentsTarget], {}, options), 'subagents --dispatch --confirm --json');
+  const subagentDispatchFile = subagentDispatchConfirm.subagent_dispatch_file;
+  assertJsonMarkers([
+    ['command', subagentDispatchConfirm.command, 'subagents'],
+    ['mode', subagentDispatchConfirm.mode, 'subagent-dispatch'],
+    ['subagent_dispatch.stage', subagentDispatchConfirm.subagent_dispatch?.stage, 'Stage 36'],
+    ['subagent_dispatch.dispatch_status', subagentDispatchConfirm.subagent_dispatch?.dispatch_status, 'approved-dispatch-artifact-only'],
+    ['subagent_dispatch.no_session_create', subagentDispatchConfirm.subagent_dispatch?.no_session_create, true],
+    ['safety.subagent_dispatch', subagentDispatchConfirm.safety?.subagent_dispatch, false],
+    ['subagent_dispatch_file.type', typeof subagentDispatchFile, 'string'],
+  ], 'subagents --dispatch --confirm --json');
+  if (!subagentDispatchFile || !fs.existsSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'subagent-dispatches', subagentDispatchFile))) throw new Error('subagents dispatch confirm did not write dispatch artifact');
+  const subagentDispatchVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', subagentDispatchFile, '--json', '--root', subagentsTarget], {}, options), 'subagents --verify dispatch --json');
+  assertJsonMarkers([
+    ['command', subagentDispatchVerify.command, 'subagents'],
+    ['mode', subagentDispatchVerify.mode, 'subagent-dispatch-verify'],
+    ['verification.ok', subagentDispatchVerify.verification?.ok, true],
+  ], 'subagents --verify dispatch --json');
+  const { subagentAdapterDispatchFile } = checkSubagentAdapterBridgeSmoke(context, options, subagentDispatchFile);
+  const subagentDispatchPath = path.join(absoluteSubagentsTarget, '.vibecoding-state', 'subagent-dispatches', subagentDispatchFile);
+  const tamperedSubagentDispatch = JSON.parse(fs.readFileSync(subagentDispatchPath, 'utf8'));
+  tamperedSubagentDispatch.safety.subagent_dispatch = true;
+  fs.writeFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'subagent-dispatches', 'bad-safety.subagent-dispatch.json'), `${JSON.stringify(tamperedSubagentDispatch, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', 'bad-safety.subagent-dispatch.json', '--root', subagentsTarget], {
+    allowFailure: true,
+    expectOutput: ['subagent dispatch verification failed:', 'safety.subagent_dispatch must be false'],
+  }, options);
+  fs.rmSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'subagent-dispatches', 'bad-safety.subagent-dispatch.json'), { force: true });
+  const resignedBadSubagentDispatch = JSON.parse(fs.readFileSync(subagentDispatchPath, 'utf8'));
+  resignedBadSubagentDispatch.subagent_dispatch.allowed_followup = ['claim-artifact-only', 'session-create'];
+  resignedBadSubagentDispatch.subagent_dispatch.no_session_create = false;
+  resignedBadSubagentDispatch.subagent_dispatch.no_subagent_run = false;
+  delete resignedBadSubagentDispatch.subagent_dispatch.dispatch_digest;
+  resignedBadSubagentDispatch.subagent_dispatch.dispatch_digest = digestObject(resignedBadSubagentDispatch.subagent_dispatch);
+  fs.writeFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'subagent-dispatches', 'bad-resigned.subagent-dispatch.json'), `${JSON.stringify(resignedBadSubagentDispatch, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', 'bad-resigned.subagent-dispatch.json', '--root', subagentsTarget], {
+    allowFailure: true,
+    expectOutput: ['subagent dispatch verification failed:', 'subagent_dispatch.allowed_followup must equal claim-artifact-only', 'subagent_dispatch.no_session_create must be true', 'subagent_dispatch.no_subagent_run must be true'],
+  }, options);
+  fs.rmSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'subagent-dispatches', 'bad-resigned.subagent-dispatch.json'), { force: true });
+
+  return { subagentDispatchFile, subagentAdapterDispatchFile };
+}
+
+export function runSubagentSingleShotLifecycleSmoke(context, options, subagentDispatchFile) {
+  const { subagentsTarget, absoluteSubagentsTarget } = context;
+
+  const subagentRunConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--run', '--from-dispatch', subagentDispatchFile, '--confirm', '--json', '--root', subagentsTarget], {}, options), 'subagents --run --from-dispatch --confirm --json');
+  const subagentSchedulerRunFile = subagentRunConfirm.subagent_scheduler_run_file;
+  const subagentLeaseFile = subagentRunConfirm.subagent_lease_file;
+  const subagentRunResultFile = subagentRunConfirm.subagent_run_result_file;
+  assertJsonMarkers([
+    ['command', subagentRunConfirm.command, 'subagents'],
+    ['mode', subagentRunConfirm.mode, 'subagent-single-shot-run'],
+    ['subagent_scheduler_run.stage', subagentRunConfirm.subagent_scheduler_run?.stage, 'Stage 37'],
+    ['subagent_scheduler_run.foreground_only', subagentRunConfirm.subagent_scheduler_run?.foreground_only, true],
+    ['subagent_scheduler_run.session_created', subagentRunConfirm.subagent_scheduler_run?.session_created, false],
+    ['subagent_run_result.review_required', subagentRunConfirm.subagent_run_result?.review_required, true],
+    ['safety.scheduler_selected', subagentRunConfirm.safety?.scheduler_selected, true],
+    ['safety.session_create', subagentRunConfirm.safety?.session_create, false],
+    ['subagent_scheduler_run_file.type', typeof subagentSchedulerRunFile, 'string'],
+    ['subagent_lease_file.type', typeof subagentLeaseFile, 'string'],
+    ['subagent_run_result_file.type', typeof subagentRunResultFile, 'string'],
+  ], 'subagents --run --from-dispatch --confirm --json');
+  if (!subagentSchedulerRunFile || !fs.existsSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'scheduler-runs', subagentSchedulerRunFile))) throw new Error('subagents run did not write scheduler run artifact');
+  if (!subagentLeaseFile || !fs.existsSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'subagent-run-leases', subagentLeaseFile))) throw new Error('subagents run did not write lease artifact');
+  if (!subagentRunResultFile || !fs.existsSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'subagent-run-results', subagentRunResultFile))) throw new Error('subagents run did not write result artifact');
+  const subagentRunVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', subagentSchedulerRunFile, '--json', '--root', subagentsTarget], {}, options), 'subagents --verify scheduler run --json');
+  assertJsonMarkers([
+    ['command', subagentRunVerify.command, 'subagents'],
+    ['mode', subagentRunVerify.mode, 'subagent-single-shot-run-verify'],
+    ['verification.ok', subagentRunVerify.verification?.ok, true],
+  ], 'subagents --verify scheduler run --json');
+  const subagentResultVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', subagentRunResultFile, '--json', '--root', subagentsTarget], {}, options), 'subagents --verify run result --json');
+  assertJsonMarkers([
+    ['command', subagentResultVerify.command, 'subagents'],
+    ['mode', subagentResultVerify.mode, 'subagent-single-shot-run-verify'],
+    ['verification.ok', subagentResultVerify.verification?.ok, true],
+  ], 'subagents --verify run result --json');
+  const subagentRunPath = path.join(absoluteSubagentsTarget, '.vibecoding-state', 'scheduler-runs', subagentSchedulerRunFile);
+  const resignedBadSubagentRun = JSON.parse(fs.readFileSync(subagentRunPath, 'utf8'));
+  resignedBadSubagentRun.subagent_scheduler_run.session_created = true;
+  resignedBadSubagentRun.subagent_scheduler_run.allowed_followup = ['result-review-gate-only', 'auto-merge'];
+  delete resignedBadSubagentRun.subagent_scheduler_run.run_digest;
+  resignedBadSubagentRun.subagent_scheduler_run.run_digest = digestObject(resignedBadSubagentRun.subagent_scheduler_run);
+  fs.writeFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'scheduler-runs', 'bad-resigned.subagent-scheduler-run.json'), `${JSON.stringify(resignedBadSubagentRun, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', 'bad-resigned.subagent-scheduler-run.json', '--root', subagentsTarget], {
+    allowFailure: true,
+    expectOutput: ['subagent single-shot run verification failed:', 'subagent_scheduler_run.allowed_followup must equal result-review-gate-only', 'subagent_scheduler_run.session_created must be false'],
+  }, options);
+  fs.rmSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'scheduler-runs', 'bad-resigned.subagent-scheduler-run.json'), { force: true });
+
+  return { subagentRunResultFile };
+}
+
+export function runSubagentResultReviewLifecycleSmoke(context, options, subagentRunResultFile) {
+  const { subagentsTarget, absoluteSubagentsTarget } = context;
+
+  const subagentIngestConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--ingest-result', subagentRunResultFile, '--confirm', '--json', '--root', subagentsTarget], {}, options), 'subagents --ingest-result --confirm --json');
+  const subagentResultFile = subagentIngestConfirm.subagent_result_file;
+  assertJsonMarkers([
+    ['command', subagentIngestConfirm.command, 'subagents'],
+    ['mode', subagentIngestConfirm.mode, 'subagent-result-ingestion'],
+    ['subagent_result.stage', subagentIngestConfirm.subagent_result?.stage, 'Stage 38'],
+    ['subagent_result.review_required', subagentIngestConfirm.subagent_result?.review_required, true],
+    ['subagent_result.source_merge', subagentIngestConfirm.subagent_result?.source_merge, false],
+    ['safety.subagent_result_artifact', subagentIngestConfirm.safety?.subagent_result_artifact, true],
+  ], 'subagents --ingest-result --confirm --json');
+  if (!subagentResultFile || !fs.existsSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'subagent-results', subagentResultFile))) throw new Error('subagents ingest-result did not write result artifact');
+  const subagentResultAliasPath = path.join(absoluteSubagentsTarget, '.vibecoding-state', 'subagent-results', 'bad-alias.subagent-result.json');
+  fs.copyFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'subagent-results', subagentResultFile), subagentResultAliasPath);
+  run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', 'bad-alias.subagent-result.json', '--root', subagentsTarget], {
+    allowFailure: true,
+    expectOutput: ['subagent result verification failed:', 'Stage 38 subagent result file identity mismatch'],
+  }, options);
+  fs.rmSync(subagentResultAliasPath, { force: true });
+  const subagentReviewConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--review-gate', subagentResultFile, '--confirm', '--json', '--root', subagentsTarget], {}, options), 'subagents --review-gate --confirm --json');
+  const subagentReviewFile = subagentReviewConfirm.subagent_review_file;
+  assertJsonMarkers([
+    ['command', subagentReviewConfirm.command, 'subagents'],
+    ['mode', subagentReviewConfirm.mode, 'subagent-review-gate'],
+    ['subagent_review.stage', subagentReviewConfirm.subagent_review?.stage, 'Stage 38'],
+    ['subagent_review.review_required', subagentReviewConfirm.subagent_review?.review_required, true],
+    ['subagent_review.review_completed', subagentReviewConfirm.subagent_review?.review_completed, false],
+    ['safety.subagent_review_artifact', subagentReviewConfirm.safety?.subagent_review_artifact, true],
+  ], 'subagents --review-gate --confirm --json');
+  if (!subagentReviewFile || !fs.existsSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'subagent-reviews', subagentReviewFile))) throw new Error('subagents review-gate did not write review artifact');
+  const subagentReviewAliasPath = path.join(absoluteSubagentsTarget, '.vibecoding-state', 'subagent-reviews', 'bad-alias.subagent-review.json');
+  fs.copyFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'subagent-reviews', subagentReviewFile), subagentReviewAliasPath);
+  run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', 'bad-alias.subagent-review.json', '--root', subagentsTarget], {
+    allowFailure: true,
+    expectOutput: ['subagent review verification failed:', 'Stage 38 subagent review file identity mismatch'],
+  }, options);
+  fs.rmSync(subagentReviewAliasPath, { force: true });
+  const resignedBadSubagentReview = JSON.parse(fs.readFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'subagent-reviews', subagentReviewFile), 'utf8'));
+  resignedBadSubagentReview.subagent_review.review_completed = true;
+  resignedBadSubagentReview.subagent_review.allowed_followup = ['manual-review-or-fallback-only', 'auto-merge'];
+  delete resignedBadSubagentReview.subagent_review.review_digest;
+  resignedBadSubagentReview.subagent_review.review_digest = digestObject(resignedBadSubagentReview.subagent_review);
+  fs.writeFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'subagent-reviews', 'bad-resigned.subagent-review.json'), `${JSON.stringify(resignedBadSubagentReview, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', 'bad-resigned.subagent-review.json', '--root', subagentsTarget], {
+    allowFailure: true,
+    expectOutput: ['subagent review verification failed:', 'subagent_review.allowed_followup must equal manual-review-or-fallback-only', 'subagent_review must not merge source or mark review completed'],
+  }, options);
+  fs.rmSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'subagent-reviews', 'bad-resigned.subagent-review.json'), { force: true });
+
+  return { subagentResultFile, subagentReviewFile };
+}
+
+export function runHookBoundedLifecycleSmoke(context, options) {
+  const { subagentsTarget, absoluteSubagentsTarget } = context;
+
+  const hookRunConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'hooks', '--hook-run', '--max-iterations', '2', '--confirm', '--json', '--root', subagentsTarget], {}, options), 'hooks --hook-run --confirm --json');
+  const hookRunFile = hookRunConfirm.hook_run_file;
+  assertJsonMarkers([
+    ['command', hookRunConfirm.command, 'hooks'],
+    ['mode', hookRunConfirm.mode, 'hook-bounded-run'],
+    ['hook_run.stage', hookRunConfirm.hook_run?.stage, 'Stage 39'],
+    ['hook_run.long_running', hookRunConfirm.hook_run?.long_running, false],
+    ['hook_run.daemon', hookRunConfirm.hook_run?.daemon, false],
+    ['safety.hook_run_artifact', hookRunConfirm.safety?.hook_run_artifact, true],
+  ], 'hooks --hook-run --confirm --json');
+  if (!hookRunFile || !fs.existsSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'hook-runs', hookRunFile))) throw new Error('hooks hook-run did not write hook run artifact');
+  const hookRunAliasPath = path.join(absoluteSubagentsTarget, '.vibecoding-state', 'hook-runs', 'bad-alias.hook-run.json');
+  fs.copyFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'hook-runs', hookRunFile), hookRunAliasPath);
+  run('node', ['tools/vibe-runtime/index.mjs', 'hooks', '--verify', 'bad-alias.hook-run.json', '--root', subagentsTarget], {
+    allowFailure: true,
+    expectOutput: ['hook run verification failed:', 'Stage 39 hook run file identity mismatch'],
+  }, options);
+  fs.rmSync(hookRunAliasPath, { force: true });
+  const resignedBadHookRun = JSON.parse(fs.readFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'hook-runs', hookRunFile), 'utf8'));
+  resignedBadHookRun.hook_run.long_running = true;
+  resignedBadHookRun.hook_run.allowed_followup = ['trace-governance-attestation-only', 'subagent-dispatch'];
+  delete resignedBadHookRun.hook_run.run_digest;
+  resignedBadHookRun.hook_run.run_digest = digestObject(resignedBadHookRun.hook_run);
+  fs.writeFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'hook-runs', 'bad-resigned.hook-run.json'), `${JSON.stringify(resignedBadHookRun, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'hooks', '--verify', 'bad-resigned.hook-run.json', '--root', subagentsTarget], {
+    allowFailure: true,
+    expectOutput: ['hook run verification failed:', 'hook_run.allowed_followup must equal trace-governance-attestation-only', 'hook_run.long_running must be false'],
+  }, options);
+  fs.rmSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'hook-runs', 'bad-resigned.hook-run.json'), { force: true });
+  const automationTrace = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'traces', '--build', '--confirm', '--json', '--root', subagentsTarget], {}, options), 'traces --build automation --confirm --json');
+  const automationTraceFile = automationTrace.runtime_trace_file;
+  const automationSourceTypes = automationTrace.runtime_trace?.source_types || {};
+  if (!automationSourceTypes.subagent_results || !automationSourceTypes.subagent_reviews || !automationSourceTypes.hook_runs) throw new Error('automation trace did not include Stage 38-39 source types');
+  const automationMethodology = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'methodology', '--gate', '--kind', 'automation', '--confirm', '--json', '--root', subagentsTarget], {}, options), 'methodology --gate --kind automation --confirm --json');
+  assertJsonMarkers([
+    ['command', automationMethodology.command, 'methodology'],
+    ['mode', automationMethodology.mode, 'methodology-gate'],
+    ['methodology_gate.kind', automationMethodology.methodology_gate?.kind, 'automation'],
+    ['methodology_gate.outcome', automationMethodology.methodology_gate?.outcome, 'passed'],
+  ], 'methodology --gate --kind automation --confirm --json');
+  if (!automationTraceFile) throw new Error('automation trace file was not written');
+
+  return { hookRunFile };
+}

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

@@ -0,0 +1,25 @@
+import {
+  runHookBoundedLifecycleSmoke,
+  runSubagentDispatchLifecycleSmoke,
+  runSubagentEligibilityLifecycleSmoke,
+  runSubagentResultReviewLifecycleSmoke,
+  runSubagentSingleShotLifecycleSmoke,
+} from './release-check-runtime-automation-subagents-lifecycle-smoke-helpers.mjs';
+
+export function runRuntimeAutomationSubagentsSmoke(context, options) {
+  const { subagentEligibilityFile } = runSubagentEligibilityLifecycleSmoke(context, options);
+  const { subagentDispatchFile, subagentAdapterDispatchFile } = runSubagentDispatchLifecycleSmoke(context, options, subagentEligibilityFile);
+  const { subagentRunResultFile } = runSubagentSingleShotLifecycleSmoke(context, options, subagentDispatchFile);
+  const { subagentResultFile, subagentReviewFile } = runSubagentResultReviewLifecycleSmoke(context, options, subagentRunResultFile);
+  const { hookRunFile } = runHookBoundedLifecycleSmoke(context, options);
+
+  return {
+    subagentEligibilityFile,
+    subagentDispatchFile,
+    subagentAdapterDispatchFile,
+    subagentRunResultFile,
+    subagentResultFile,
+    subagentReviewFile,
+    hookRunFile,
+  };
+}

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

@@ -0,0 +1,25 @@
+import { buildRuntimeAutomationFixtureContext } from './release-check-runtime-automation-fixtures.mjs';
+import { runRuntimeAutomationGovernanceSmoke } from './release-check-runtime-automation-governance-suite.mjs';
+import { runRuntimeAutomationMethodologySmoke } from './release-check-runtime-automation-methodology-suite.mjs';
+import { runRuntimeAutomationPlatformSmoke } from './release-check-runtime-automation-platform-suite.mjs';
+import { runRuntimeAutomationSourceSmoke } from './release-check-runtime-automation-source-suite.mjs';
+import { runRuntimeAutomationSubagentsSmoke } from './release-check-runtime-automation-subagents-suite.mjs';
+import { runRuntimeCloseoutSmoke, runRuntimeSddConsumptionSmoke, runRuntimeSddPlanPreflightSmoke, runRuntimeSddReviewPackageSmoke, runRuntimeSddTaskBriefSmoke } from './release-check-runtime-sdd-suite.mjs';
+
+export function runRuntimeAutomationSmoke(options) {
+  const context = buildRuntimeAutomationFixtureContext(options);
+  try {
+    runRuntimeAutomationMethodologySmoke(context, options);
+    const subagentsContext = runRuntimeAutomationSubagentsSmoke(context, options);
+    const platformContext = runRuntimeAutomationPlatformSmoke(context, subagentsContext, options);
+    runRuntimeSddPlanPreflightSmoke(options);
+    runRuntimeSddTaskBriefSmoke(options);
+    runRuntimeSddReviewPackageSmoke(options);
+    runRuntimeSddConsumptionSmoke(options);
+    runRuntimeCloseoutSmoke(options);
+    runRuntimeAutomationSourceSmoke(context, platformContext, options);
+    runRuntimeAutomationGovernanceSmoke(context, options);
+  } finally {
+    context.cleanup();
+  }
+}

package/tools/vibe-release-check/release-check-runtime-daemon-bounded-run-smoke-helpers.mjs

@@ -0,0 +1,243 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  assertJsonMarkers,
+  parseJsonOutput,
+  repoRoot,
+  run,
+} from './release-check-runtime.mjs';
+
+function runDaemonUnsupportedInvocationSmoke(cleanDispatchTarget, daemonRunsDirectory, options) {
+  run('node', ['tools/vibe-runtime/index.mjs', 'daemon', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['daemon requires --dry-run, --scan --dry-run, or --once --confirm'],
+  }, options);
+  if (fs.existsSync(daemonRunsDirectory)) throw new Error('daemon default invocation wrote unexpected daemon-runs directory');
+
+  run('node', ['tools/vibe-runtime/index.mjs', 'daemon', '--scan', '--dry-run', '--pickup-verify', 'missing.json', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['daemon supports only --dry-run, --scan --dry-run, or --once --confirm'],
+  }, options);
+  if (fs.existsSync(daemonRunsDirectory)) throw new Error('daemon rejected unsupported pickup-verify but wrote unexpected daemon-runs directory');
+
+  run('node', ['tools/vibe-runtime/index.mjs', 'daemon', '--scan', '--dry-run', '--verify', 'missing.execution.json', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['daemon supports only --dry-run, --scan --dry-run, or --once --confirm'],
+  }, options);
+  if (fs.existsSync(daemonRunsDirectory)) throw new Error('daemon rejected unsupported executions verify but wrote unexpected daemon-runs directory');
+}
+
+function runDaemonDryRunPreviewSmoke(cleanDispatchTarget, daemonRunsDirectory, dispatchSnapshot, options) {
+  const { dispatchesDirectory, dispatchFilesAfterText, originalDispatchEventText, dispatchClaimFile, dispatchClaimTextAfterAck } = dispatchSnapshot;
+  const daemonDryRunJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'daemon', '--dry-run', '--json', '--root', cleanDispatchTarget], {}, options), 'daemon --dry-run --json clean');
+  assertJsonMarkers([
+    ['schema_version', daemonDryRunJson.schema_version, 1],
+    ['command', daemonDryRunJson.command, 'daemon'],
+    ['mode', daemonDryRunJson.mode, 'daemon-dry-run'],
+    ['ok', daemonDryRunJson.ok, true],
+    ['daemon_run.default_enabled', daemonDryRunJson.daemon_run?.default_enabled, false],
+    ['daemon_run.queue', daemonDryRunJson.daemon_run?.queue, 'manual-only'],
+    ['daemon_run.candidates.length', daemonDryRunJson.daemon_run?.candidates?.length, 0],
+    ['daemon_run.gates.0', daemonDryRunJson.daemon_run?.gates?.[0], 'manual-confirmation-required'],
+    ['daemon_run.worker', daemonDryRunJson.daemon_run?.worker, false],
+    ['daemon_run.long_running', daemonDryRunJson.daemon_run?.long_running, false],
+    ['daemon_run.watcher', daemonDryRunJson.daemon_run?.watcher, false],
+    ['daemon_run.dispatch_scan_execution', daemonDryRunJson.daemon_run?.dispatch_scan_execution, false],
+    ['daemon_run.scan_noop', daemonDryRunJson.daemon_run?.scan_noop, true],
+    ['daemon_run.scheduler_policy_dry_run', daemonDryRunJson.daemon_run?.scheduler_policy_dry_run, true],
+    ['daemon_run.retry_policy.retry_allowed', daemonDryRunJson.daemon_run?.retry_policy?.retry_allowed, false],
+    ['daemon_run.lock.lock_required', daemonDryRunJson.daemon_run?.lock?.lock_required, true],
+    ['daemon_run.lock.lock_acquired', daemonDryRunJson.daemon_run?.lock?.lock_acquired, false],
+    ['daemon_run.lease.heartbeat_started', daemonDryRunJson.daemon_run?.lease?.heartbeat_started, false],
+    ['daemon_run.watcher_contract.enabled', daemonDryRunJson.daemon_run?.watcher_contract?.enabled, false],
+    ['safety.dry_run', daemonDryRunJson.safety?.dry_run, true],
+    ['safety.writes', daemonDryRunJson.safety?.writes, false],
+    ['safety.dispatch_scan_execution', daemonDryRunJson.safety?.dispatch_scan_execution, false],
+    ['safety.auto_execution', daemonDryRunJson.safety?.auto_execution, false],
+    ['safety.skill_execution', daemonDryRunJson.safety?.skill_execution, false],
+    ['safety.platform_api', daemonDryRunJson.safety?.platform_api, false],
+  ], 'daemon --dry-run --json clean');
+  if (fs.existsSync(daemonRunsDirectory)) throw new Error('daemon --dry-run wrote unexpected daemon-runs directory');
+
+  const daemonScanJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'daemon', '--scan', '--dry-run', '--json', '--root', cleanDispatchTarget], {}, options), 'daemon --scan --dry-run --json clean');
+  assertJsonMarkers([
+    ['schema_version', daemonScanJson.schema_version, 1],
+    ['command', daemonScanJson.command, 'daemon'],
+    ['mode', daemonScanJson.mode, 'daemon-scan-dry-run'],
+    ['ok', daemonScanJson.ok, true],
+    ['scheduler.queue', daemonScanJson.scheduler?.queue, 'manual-only'],
+    ['scheduler.scan', daemonScanJson.scheduler?.scan, true],
+    ['scheduler.lock.lock_required', daemonScanJson.scheduler?.lock?.lock_required, true],
+    ['scheduler.lock.lock_acquired', daemonScanJson.scheduler?.lock?.lock_acquired, false],
+    ['scheduler.lock.lease_required', daemonScanJson.scheduler?.lock?.lease_required, true],
+    ['scheduler.watcher.enabled', daemonScanJson.scheduler?.watcher?.enabled, false],
+    ['scheduler.worker', daemonScanJson.scheduler?.worker, false],
+    ['safety.writes', daemonScanJson.safety?.writes, false],
+    ['safety.auto_execution', daemonScanJson.safety?.auto_execution, false],
+  ], 'daemon --scan --dry-run --json clean');
+  if (fs.existsSync(daemonRunsDirectory)) throw new Error('daemon --scan --dry-run wrote unexpected daemon-runs directory');
+
+  run('node', ['tools/vibe-runtime/index.mjs', 'daemon', '--scan', '--dry-run', '--root', cleanDispatchTarget], {
+    expectOutput: ['Vibecoding Runtime Scheduler Audit', 'Mode: scan-dry-run', 'Queue: manual-only', 'Candidates:', 'Blocked:', 'Retry preview:', 'retry_allowed=false', 'Lock: required=true; acquired=false; lease_required=true; heartbeat_required=true', 'Watcher: enabled=false; long_running=false', 'Safety: scan=true; dry_run=true; writes=false; auto_execution=false; platform_api=false; skill_execution=false; worker=false; watcher=false; git=false; worktree=false.', 'Action: scheduler scan dry-run audited dispatch, claim, and execution state. No daemon run envelope, background worker, pickup, execute, retry, skill execution, platform API, subagent, MCP, git, worktree, or business source write occurred.'],
+  }, options);
+  if (fs.readFileSync(path.join(dispatchesDirectory, dispatchFilesAfterText[0]), 'utf8') !== originalDispatchEventText) throw new Error('daemon scan modified original dispatch event');
+  if (fs.readFileSync(dispatchClaimFile, 'utf8') !== dispatchClaimTextAfterAck) throw new Error('daemon scan unexpectedly modified claim state');
+
+  run('node', ['tools/vibe-runtime/index.mjs', 'daemon', '--dry-run', '--root', cleanDispatchTarget], {
+    expectOutput: ['Vibecoding Runtime Daemon Gate', 'Mode: dry-run', 'Default enabled: false', 'Queue: manual-only', 'Candidates: 0', 'Worker: false', 'Long running: false', 'Watcher: false', 'Safety: once=true; long_running=false; watcher=false; auto_execution=false; platform_api=false; skill_execution=false; subagent=false; mcp=false; daemon=false; git=false; worktree=false.', 'Action: daemon once-run gate was previewed. No daemon run envelope, background worker, dispatch scan execution, skill execution, platform API, subagent, MCP, git, worktree, or business source write occurred.'],
+  }, options);
+}
+
+function runDaemonOnceEnvelopeSmoke(cleanDispatchTarget, daemonRunsDirectory, dispatchSnapshot, options) {
+  const { dispatchesDirectory, dispatchFilesAfterText, originalDispatchEventText, dispatchClaimFile, dispatchClaimTextAfterAck } = dispatchSnapshot;
+  const daemonOnceJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'daemon', '--once', '--confirm', '--json', '--root', cleanDispatchTarget], {}, options), 'daemon --once --confirm --json clean');
+  assertJsonMarkers([
+    ['schema_version', daemonOnceJson.schema_version, 1],
+    ['command', daemonOnceJson.command, 'daemon'],
+    ['mode', daemonOnceJson.mode, 'daemon-once-confirm'],
+    ['ok', daemonOnceJson.ok, true],
+    ['safety.confirmed', daemonOnceJson.safety?.confirmed, true],
+    ['safety.writes', daemonOnceJson.safety?.writes, true],
+    ['safety.daemon_run_envelope', daemonOnceJson.safety?.daemon_run_envelope, true],
+    ['safety.dispatch_scan_execution', daemonOnceJson.safety?.dispatch_scan_execution, false],
+    ['daemon_run.scan_noop', daemonOnceJson.daemon_run?.scan_noop, true],
+    ['daemon_run.scheduler_policy_dry_run', daemonOnceJson.daemon_run?.scheduler_policy_dry_run, true],
+    ['daemon_run.retry_policy.retry_allowed', daemonOnceJson.daemon_run?.retry_policy?.retry_allowed, false],
+    ['daemon_run.lock.lock_required', daemonOnceJson.daemon_run?.lock?.lock_required, true],
+    ['daemon_run.lock.lock_acquired', daemonOnceJson.daemon_run?.lock?.lock_acquired, false],
+    ['daemon_run.lease.lease_required', daemonOnceJson.daemon_run?.lease?.lease_required, true],
+    ['daemon_run.lease.heartbeat_started', daemonOnceJson.daemon_run?.lease?.heartbeat_started, false],
+    ['daemon_run.watcher_contract.enabled', daemonOnceJson.daemon_run?.watcher_contract?.enabled, false],
+    ['safety.auto_execution', daemonOnceJson.safety?.auto_execution, false],
+    ['safety.git', daemonOnceJson.safety?.git, false],
+    ['safety.worktree', daemonOnceJson.safety?.worktree, false],
+  ], 'daemon --once --confirm --json clean');
+
+  const daemonRunFilesAfterJson = fs.readdirSync(daemonRunsDirectory);
+  if (daemonRunFilesAfterJson.length !== 1) throw new Error(`daemon --once --confirm expected one daemon run envelope, found ${daemonRunFilesAfterJson.length}`);
+  const daemonRunJson = JSON.parse(fs.readFileSync(path.join(daemonRunsDirectory, daemonRunFilesAfterJson[0]), 'utf8'));
+  assertJsonMarkers([
+    ['event.command', daemonRunJson.command, 'daemon'],
+    ['event.mode', daemonRunJson.mode, 'daemon-once-confirm'],
+    ['event.daemon_run.default_enabled', daemonRunJson.daemon_run?.default_enabled, false],
+    ['event.daemon_run.queue', daemonRunJson.daemon_run?.queue, 'manual-only'],
+    ['event.daemon_run.candidates.length', daemonRunJson.daemon_run?.candidates?.length, 0],
+    ['event.daemon_run.gates.0', daemonRunJson.daemon_run?.gates?.[0], 'manual-confirmation-required'],
+    ['event.daemon_run.worker', daemonRunJson.daemon_run?.worker, false],
+    ['event.daemon_run.long_running', daemonRunJson.daemon_run?.long_running, false],
+    ['event.daemon_run.watcher', daemonRunJson.daemon_run?.watcher, false],
+    ['event.daemon_run.dispatch_scan_execution', daemonRunJson.daemon_run?.dispatch_scan_execution, false],
+    ['event.daemon_run.scan_noop', daemonRunJson.daemon_run?.scan_noop, true],
+    ['event.daemon_run.scheduler_policy_dry_run', daemonRunJson.daemon_run?.scheduler_policy_dry_run, true],
+    ['event.daemon_run.retry_policy.retry_allowed', daemonRunJson.daemon_run?.retry_policy?.retry_allowed, false],
+    ['event.daemon_run.lock.lock_acquired', daemonRunJson.daemon_run?.lock?.lock_acquired, false],
+    ['event.daemon_run.lease.heartbeat_started', daemonRunJson.daemon_run?.lease?.heartbeat_started, false],
+    ['event.daemon_run.watcher_contract.enabled', daemonRunJson.daemon_run?.watcher_contract?.enabled, false],
+    ['event.safety.auto_execution', daemonRunJson.safety?.auto_execution, false],
+    ['event.safety.dispatch_scan_execution', daemonRunJson.safety?.dispatch_scan_execution, false],
+    ['event.safety.daemon', daemonRunJson.safety?.daemon, false],
+    ['event.safety.git', daemonRunJson.safety?.git, false],
+    ['event.safety.worktree', daemonRunJson.safety?.worktree, false],
+  ], 'daemon persisted envelope');
+
+  run('node', ['tools/vibe-runtime/index.mjs', 'daemon', '--once', '--confirm', '--root', cleanDispatchTarget], {
+    expectOutput: ['Vibecoding Runtime Daemon Gate', 'Mode: once-confirm', 'Default enabled: false', 'Queue: manual-only', 'Candidates: 0', 'Worker: false', 'Long running: false', 'Watcher: false', 'Daemon run envelope:', 'Action: daemon once-run envelope was written. No background worker, dispatch scan execution, skill execution, platform API, subagent, MCP, git, worktree, or business source write occurred.'],
+  }, options);
+  const daemonRunFilesAfterText = fs.readdirSync(daemonRunsDirectory);
+  if (daemonRunFilesAfterText.length !== 2) throw new Error(`daemon text expected two distinct daemon run envelopes, found ${daemonRunFilesAfterText.length}`);
+  if (new Set(daemonRunFilesAfterText).size !== 2) throw new Error('daemon wrote duplicate daemon run envelope filenames');
+  if (fs.readFileSync(path.join(dispatchesDirectory, dispatchFilesAfterText[0]), 'utf8') !== originalDispatchEventText) throw new Error('daemon modified original dispatch event');
+  if (fs.readFileSync(dispatchClaimFile, 'utf8') !== dispatchClaimTextAfterAck) throw new Error('daemon unexpectedly modified claim state');
+}
+
+function runDispatchVerificationGuardSmoke(cleanDispatchTarget, dispatchSnapshot, options) {
+  const { dispatchesDirectory, dispatchFilesAfterText, dispatchEventJson } = dispatchSnapshot;
+  run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--verify', '..\\escape.json', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['Dispatch event file must not include path separators'],
+  }, options);
+
+  const invalidJsonDispatchFile = path.join(dispatchesDirectory, 'invalid-json.json');
+  fs.writeFileSync(invalidJsonDispatchFile, '{ invalid json', 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--verify', 'invalid-json.json', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['Dispatch event JSON is invalid: invalid-json.json'],
+  }, options);
+
+  const invalidModeDispatchFile = path.join(dispatchesDirectory, 'invalid-mode.json');
+  fs.writeFileSync(invalidModeDispatchFile, `${JSON.stringify({ ...dispatchEventJson, mode: 'dispatch-intent' }, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--verify', 'invalid-mode.json', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['confirm-dispatch event verification failed: mode must be confirm-dispatch'],
+  }, options);
+
+  const missingForbiddenActionDispatchFile = path.join(dispatchesDirectory, 'missing-forbidden-action.json');
+  const missingForbiddenActionDispatch = JSON.parse(fs.readFileSync(path.join(dispatchesDirectory, dispatchFilesAfterText[0]), 'utf8'));
+  missingForbiddenActionDispatch.safety.forbidden_actions = missingForbiddenActionDispatch.safety.forbidden_actions.filter((action) => action !== 'git_write');
+  fs.writeFileSync(missingForbiddenActionDispatchFile, `${JSON.stringify(missingForbiddenActionDispatch, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'dispatches', '--verify', 'missing-forbidden-action.json', '--root', cleanDispatchTarget], {
+    allowFailure: true,
+    expectOutput: ['confirm-dispatch event verification failed: safety.forbidden_actions missing git_write'],
+  }, options);
+}
+
+function runBlockedDispatchTargetSmoke(targetSpec, options) {
+  const { handoffFile, target, absoluteTarget, expectedOutput, unexpectedStateError } = targetSpec;
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  fs.mkdirSync(absoluteTarget, { recursive: true });
+  run('node', ['tools/vibe-runtime/index.mjs', 'record-handoff', '--from-file', handoffFile, '--root', target], {}, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'next', '--confirm', '--dispatch', '--root', target], {
+    allowFailure: true,
+    expectOutput: [expectedOutput],
+  }, options);
+  if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'dispatches'))) throw new Error(unexpectedStateError);
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+}
+
+function runBlockedDispatchGuardSmoke(context, options) {
+  const {
+    target,
+    absoluteTarget,
+    invalidTransitionDispatchHandoffFile,
+    reviewNeedsFixDispatchHandoffFile,
+    waitingDependencyDispatchHandoffFile,
+  } = context;
+  runBlockedDispatchTargetSmoke({
+    handoffFile: invalidTransitionDispatchHandoffFile,
+    target: '.tmp/vibe-runtime-invalid-transition-dispatch-ledger',
+    absoluteTarget: path.join(repoRoot, '.tmp/vibe-runtime-invalid-transition-dispatch-ledger'),
+    expectedOutput: 'confirm-dispatch gate failed: transition is not listed in runtime-contract',
+    unexpectedStateError: 'invalid transition dispatch wrote unexpected dispatches directory',
+  }, options);
+  runBlockedDispatchTargetSmoke({
+    handoffFile: reviewNeedsFixDispatchHandoffFile,
+    target: '.tmp/vibe-runtime-review-needs-fix-dispatch-ledger',
+    absoluteTarget: path.join(repoRoot, '.tmp/vibe-runtime-review-needs-fix-dispatch-ledger'),
+    expectedOutput: 'confirm-dispatch gate failed: review_status needs_fix is present',
+    unexpectedStateError: 'review needs_fix dispatch wrote unexpected dispatches directory',
+  }, options);
+  runBlockedDispatchTargetSmoke({
+    handoffFile: waitingDependencyDispatchHandoffFile,
+    target: '.tmp/vibe-runtime-waiting-dependency-dispatch-ledger',
+    absoluteTarget: path.join(repoRoot, '.tmp/vibe-runtime-waiting-dependency-dispatch-ledger'),
+    expectedOutput: 'confirm-dispatch gate failed: task readiness has waiting or blocked items',
+    unexpectedStateError: 'waiting dependency dispatch wrote unexpected dispatches directory',
+  }, options);
+
+  run('node', ['tools/vibe-runtime/index.mjs', 'next', '--confirm', '--dispatch', '--root', target], {
+    allowFailure: true,
+    expectOutput: ['confirm-dispatch gate failed: review_status needs_fix is present; task readiness has waiting or blocked items'],
+  }, options);
+  if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'dispatches'))) throw new Error('blocked confirm-dispatch wrote unexpected dispatches directory');
+}
+
+export function runDaemonBoundedRunSmoke(context, dispatchContext, options) {
+  const { cleanDispatchTarget, absoluteCleanDispatchTarget } = dispatchContext;
+  const daemonRunsDirectory = path.join(absoluteCleanDispatchTarget, '.vibecoding-state', 'daemon-runs');
+  runDaemonUnsupportedInvocationSmoke(cleanDispatchTarget, daemonRunsDirectory, options);
+  runDaemonDryRunPreviewSmoke(cleanDispatchTarget, daemonRunsDirectory, dispatchContext, options);
+  runDaemonOnceEnvelopeSmoke(cleanDispatchTarget, daemonRunsDirectory, dispatchContext, options);
+  runDispatchVerificationGuardSmoke(cleanDispatchTarget, dispatchContext, options);
+  runBlockedDispatchGuardSmoke(context, options);
+  fs.rmSync(absoluteCleanDispatchTarget, { recursive: true, force: true });
+}

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

@@ -0,0 +1,5 @@
+import { runDaemonBoundedRunSmoke } from './release-check-runtime-daemon-bounded-run-smoke-helpers.mjs';
+
+export function runRuntimeDaemonSmoke(context, dispatchContext, options) {
+  return runDaemonBoundedRunSmoke(context, dispatchContext, options);
+}