@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-release-check/release-check-runtime-automation-governance-reply-trace-smoke-helpers.mjs

@@ -0,0 +1,224 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  assertJsonMarkers,
+  digestObject,
+  parseJsonOutput,
+  run,
+} from './release-check-runtime.mjs';
+import { runtimeAutomationGovernanceSmokeSpecs } from './release-check-runtime-automation-governance-smoke-specs.mjs';
+
+function specMarkerValue(source, markerPath) {
+  if (markerPath.endsWith('.type')) return typeof specMarkerValue(source, markerPath.slice(0, -5));
+  return markerPath.split('.').reduce((value, key) => value?.[key], source);
+}
+
+function assertSpecJsonMarkers(source, spec) {
+  assertJsonMarkers(
+    spec.markers.map(([markerPath, expected]) => [markerPath, specMarkerValue(source, markerPath), expected]),
+    spec.label,
+  );
+}
+
+function runAutomationGovernanceDaemonLoopSmoke(context, options) {
+  const {
+    target,
+    absoluteTarget,
+  } = context;
+
+  const retryList = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'retry', '--list-packages', '--json', '--root', target], {}, options), runtimeAutomationGovernanceSmokeSpecs.retryListJson.label);
+  assertSpecJsonMarkers(retryList, runtimeAutomationGovernanceSmokeSpecs.retryListJson);
+  if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('retry list created unexpected state directory');
+
+  const loopDryRun = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'daemon', '--loop', '--dry-run', '--json', '--root', target], {}, options), runtimeAutomationGovernanceSmokeSpecs.loopDryRunJson.label);
+  assertSpecJsonMarkers(loopDryRun, runtimeAutomationGovernanceSmokeSpecs.loopDryRunJson);
+  if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('daemon loop dry-run created unexpected state directory');
+
+  const loopConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'daemon', '--loop', '--confirm', '--max-iterations', '1', '--json', '--root', target], {}, options), runtimeAutomationGovernanceSmokeSpecs.loopConfirmJson.label);
+  const loopFile = loopConfirm.daemon_loop_file;
+  assertSpecJsonMarkers(loopConfirm, runtimeAutomationGovernanceSmokeSpecs.loopConfirmJson);
+  if (!fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'daemon-loops', loopFile))) throw new Error('daemon loop confirm did not write loop artifact');
+
+  const stopJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'daemon', '--stop', '--confirm', '--reason', 'release-check', '--json', '--root', target], {}, options), runtimeAutomationGovernanceSmokeSpecs.stopJson.label);
+  assertSpecJsonMarkers(stopJson, runtimeAutomationGovernanceSmokeSpecs.stopJson);
+}
+
+function runAutomationGovernanceReplyOutboxSmoke(context, options) {
+  const {
+    target,
+    absoluteTarget,
+  } = context;
+
+  const draftPreview = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'reply', '--draft', '--json', '--root', target], {}, options), runtimeAutomationGovernanceSmokeSpecs.draftPreviewJson.label);
+  assertSpecJsonMarkers(draftPreview, runtimeAutomationGovernanceSmokeSpecs.draftPreviewJson);
+  const draftConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'reply', '--draft', '--confirm', '--json', '--root', target], {}, options), 'reply --draft --confirm --json');
+  const draftFile = draftConfirm.reply_draft_file;
+  if (!draftFile || !fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'reply-drafts', draftFile))) throw new Error('reply draft confirm did not write draft artifact');
+  const approvalConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'reply', '--approve', draftFile, '--confirm', '--json', '--root', target], {}, options), 'reply --approve --confirm --json');
+  const approvalFile = approvalConfirm.reply_approval_file;
+  const outboxConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'reply', '--outbox', approvalFile, '--confirm', '--json', '--root', target], {}, options), 'reply --outbox --confirm --json');
+  const outboxFile = outboxConfirm.reply_outbox_file;
+  const outboxVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'reply', '--verify', outboxFile, '--json', '--root', target], {}, options), runtimeAutomationGovernanceSmokeSpecs.outboxVerifyJson.label);
+  assertSpecJsonMarkers(outboxVerify, runtimeAutomationGovernanceSmokeSpecs.outboxVerifyJson);
+  const outboxPath = path.join(absoluteTarget, '.vibecoding-state', 'reply-outbox', outboxFile);
+  const tamperedOutbox = JSON.parse(fs.readFileSync(outboxPath, 'utf8'));
+  tamperedOutbox.reply_outbox.approval_digest = 'bad-approval-digest';
+  fs.writeFileSync(path.join(absoluteTarget, '.vibecoding-state', 'reply-outbox', 'bad-digest.reply-outbox.json'), `${JSON.stringify(tamperedOutbox, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'reply', '--verify', 'bad-digest.reply-outbox.json', '--root', target], {
+    allowFailure: true,
+    expectOutput: runtimeAutomationGovernanceSmokeSpecs.badOutboxDigestOutput,
+  }, options);
+
+  return { outboxFile };
+}
+
+function runAutomationGovernanceTraceReadinessSmoke(context, options) {
+  const {
+    target,
+    absoluteTarget,
+  } = context;
+
+  const traceDryRun = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'traces', '--build', '--dry-run', '--json', '--root', target], {}, options), runtimeAutomationGovernanceSmokeSpecs.traceDryRunJson.label);
+  assertSpecJsonMarkers(traceDryRun, runtimeAutomationGovernanceSmokeSpecs.traceDryRunJson);
+  if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'runtime-traces'))) throw new Error('trace dry-run wrote unexpected runtime trace directory');
+
+  const traceConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'traces', '--build', '--confirm', '--json', '--root', target], {}, options), runtimeAutomationGovernanceSmokeSpecs.traceConfirmJson.label);
+  const traceFile = traceConfirm.runtime_trace_file;
+  assertSpecJsonMarkers(traceConfirm, runtimeAutomationGovernanceSmokeSpecs.traceConfirmJson);
+  if (!traceFile || !fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'runtime-traces', traceFile))) throw new Error('trace confirm did not write runtime trace artifact');
+  const traceVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'traces', '--verify', traceFile, '--json', '--root', target], {}, options), runtimeAutomationGovernanceSmokeSpecs.traceVerifyJson.label);
+  assertSpecJsonMarkers(traceVerify, runtimeAutomationGovernanceSmokeSpecs.traceVerifyJson);
+  let tracePath = path.join(absoluteTarget, '.vibecoding-state', 'runtime-traces', traceFile);
+  const tamperedTrace = JSON.parse(fs.readFileSync(tracePath, 'utf8'));
+  tamperedTrace.runtime_trace.sources.push({ type: 'reply_drafts', file: 'missing.reply-draft.json', state_path: '.vibecoding-state/reply-drafts/missing.reply-draft.json', digest: 'missing', command: 'reply', mode: 'reply-draft', source_descriptor_digest: 'bad' });
+  fs.writeFileSync(path.join(absoluteTarget, '.vibecoding-state', 'runtime-traces', 'bad.runtime-trace.json'), `${JSON.stringify(tamperedTrace, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'traces', '--verify', 'bad.runtime-trace.json', '--root', target], {
+    allowFailure: true,
+    expectOutput: runtimeAutomationGovernanceSmokeSpecs.badTraceVerifyOutput,
+  }, options);
+  fs.rmSync(path.join(absoluteTarget, '.vibecoding-state', 'runtime-traces', 'bad.runtime-trace.json'), { force: true });
+
+  const expandedReadiness = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'readiness', '--score', '--json', '--root', target], {}, options), runtimeAutomationGovernanceSmokeSpecs.expandedReadinessJson.label);
+  assertSpecJsonMarkers(expandedReadiness, runtimeAutomationGovernanceSmokeSpecs.expandedReadinessJson);
+  fs.rmSync(path.join(absoluteTarget, '.vibecoding-state', 'reply-outbox', 'bad-digest.reply-outbox.json'), { force: true });
+  fs.rmSync(path.join(absoluteTarget, '.vibecoding-state', 'daemon-stop', 'stop.json'), { force: true });
+  fs.rmSync(path.join(absoluteTarget, '.vibecoding-state', 'runtime-traces'), { recursive: true, force: true });
+  const cleanTraceConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'traces', '--build', '--confirm', '--json', '--root', target], {}, options), 'traces --build clean governance baseline --confirm --json');
+  const cleanTraceFile = cleanTraceConfirm.runtime_trace_file;
+  tracePath = path.join(absoluteTarget, '.vibecoding-state', 'runtime-traces', cleanTraceFile);
+  if (!cleanTraceFile || !fs.existsSync(tracePath)) throw new Error('clean governance baseline trace was not written');
+  const sourceBoundReadiness = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'readiness', '--score', '--confirm', '--json', '--root', target], {}, options), runtimeAutomationGovernanceSmokeSpecs.sourceBoundReadinessJson.label);
+  assertSpecJsonMarkers(sourceBoundReadiness, runtimeAutomationGovernanceSmokeSpecs.sourceBoundReadinessJson);
+
+  return { sourceBoundReadiness, tracePath };
+}
+
+function runAutomationGovernanceSourceBoundReviewSmoke(context, options, tracePath) {
+  const {
+    target,
+    absoluteTarget,
+  } = context;
+
+  const sourceBoundPreview = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'reply', '--draft', '--source-bound', '--json', '--root', target], {}, options), runtimeAutomationGovernanceSmokeSpecs.sourceBoundPreviewJson.label);
+  assertSpecJsonMarkers(sourceBoundPreview, runtimeAutomationGovernanceSmokeSpecs.sourceBoundPreviewJson);
+  const sourceBoundConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'reply', '--draft', '--source-bound', '--confirm', '--json', '--root', target], {}, options), 'reply --draft --source-bound --confirm --json');
+  const sourceBoundDraftFile = sourceBoundConfirm.reply_draft_file;
+  if (!sourceBoundDraftFile || !fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'reply-drafts', sourceBoundDraftFile))) throw new Error('source-bound reply draft confirm did not write draft artifact');
+  const sourceBoundVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'reply', '--verify', sourceBoundDraftFile, '--json', '--root', target], {}, options), runtimeAutomationGovernanceSmokeSpecs.sourceBoundVerifyJson.label);
+  assertSpecJsonMarkers(sourceBoundVerify, runtimeAutomationGovernanceSmokeSpecs.sourceBoundVerifyJson);
+  fs.writeFileSync(path.join(absoluteTarget, '.vibecoding-state', 'runtime-traces', 'zz-source-drift.runtime-trace.json'), fs.readFileSync(tracePath, 'utf8'), 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'reply', '--approve', sourceBoundDraftFile, '--confirm', '--json', '--root', target], {
+    allowFailure: true,
+    expectOutput: runtimeAutomationGovernanceSmokeSpecs.sourceDriftApprovalOutput,
+  }, options);
+  const sourceBoundDraft = JSON.parse(fs.readFileSync(path.join(absoluteTarget, '.vibecoding-state', 'reply-drafts', sourceBoundDraftFile), 'utf8'));
+  sourceBoundDraft.reply_draft.source_manifest.sources = sourceBoundDraft.reply_draft.source_manifest.sources.filter((source) => source.type !== 'latest_runtime_trace');
+  sourceBoundDraft.reply_draft.source_manifest.present_count = sourceBoundDraft.reply_draft.source_manifest.sources.filter((source) => source.present).length;
+  sourceBoundDraft.reply_draft.source_manifest.source_digest = digestObject(sourceBoundDraft.reply_draft.source_manifest.sources);
+  const draftDigestPayload = { ...sourceBoundDraft.reply_draft };
+  delete draftDigestPayload.writes;
+  delete draftDigestPayload.policy_digest;
+  delete draftDigestPayload.draft_digest;
+  sourceBoundDraft.reply_draft.draft_digest = digestObject(draftDigestPayload);
+  fs.writeFileSync(path.join(absoluteTarget, '.vibecoding-state', 'reply-drafts', 'bad-source-manifest.reply-draft.json'), `${JSON.stringify(sourceBoundDraft, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'reply', '--verify', 'bad-source-manifest.reply-draft.json', '--root', target], {
+    allowFailure: true,
+    expectOutput: runtimeAutomationGovernanceSmokeSpecs.badSourceManifestVerifyOutput,
+  }, options);
+  fs.rmSync(path.join(absoluteTarget, '.vibecoding-state', 'runtime-traces', 'zz-source-drift.runtime-trace.json'), { force: true });
+  run('node', ['tools/vibe-runtime/index.mjs', 'reply', '--approve', sourceBoundDraftFile, '--confirm', '--json', '--root', target], {
+    allowFailure: true,
+    expectOutput: runtimeAutomationGovernanceSmokeSpecs.missingReviewApprovalOutput,
+  }, options);
+  const reviewPreview = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'reply', '--review', sourceBoundDraftFile, '--json', '--root', target], {}, options), runtimeAutomationGovernanceSmokeSpecs.reviewPreviewJson.label);
+  assertSpecJsonMarkers(reviewPreview, runtimeAutomationGovernanceSmokeSpecs.reviewPreviewJson);
+  const reviewConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'reply', '--review', sourceBoundDraftFile, '--confirm', '--json', '--root', target], {}, options), runtimeAutomationGovernanceSmokeSpecs.reviewConfirmJson.label);
+  const reviewFile = reviewConfirm.reply_review_file;
+  assertSpecJsonMarkers(reviewConfirm, runtimeAutomationGovernanceSmokeSpecs.reviewConfirmJson);
+  if (!reviewFile || !fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'reply-reviews', reviewFile))) throw new Error('reply review confirm did not write review artifact');
+  const reviewVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'reply', '--verify', reviewFile, '--json', '--root', target], {}, options), runtimeAutomationGovernanceSmokeSpecs.reviewVerifyJson.label);
+  assertSpecJsonMarkers(reviewVerify, runtimeAutomationGovernanceSmokeSpecs.reviewVerifyJson);
+  const sourceBoundApproval = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'reply', '--approve', sourceBoundDraftFile, '--confirm', '--json', '--root', target], {}, options), 'reply --approve source-bound --confirm --json');
+  const sourceBoundApprovalFile = sourceBoundApproval.reply_approval_file;
+
+  return { sourceBoundApprovalFile, reviewFile };
+}
+
+function runAutomationGovernanceAttestationSmoke(context, options, sourceBoundReadiness, reviewFile, tracePath, outboxFile, sourceBoundApprovalFile) {
+  const {
+    target,
+    absoluteTarget,
+  } = context;
+
+  const governanceDryRun = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--attest', '--dry-run', '--json', '--root', target], {}, options), runtimeAutomationGovernanceSmokeSpecs.governanceDryRunJson.label);
+  assertSpecJsonMarkers(governanceDryRun, runtimeAutomationGovernanceSmokeSpecs.governanceDryRunJson);
+  if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'governance'))) throw new Error('governance dry-run wrote unexpected governance directory');
+  const governanceConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--attest', '--confirm', '--json', '--root', target], {}, options), runtimeAutomationGovernanceSmokeSpecs.governanceConfirmJson.label);
+  const governanceFile = governanceConfirm.governance_file;
+  assertSpecJsonMarkers(governanceConfirm, runtimeAutomationGovernanceSmokeSpecs.governanceConfirmJson);
+  if (!governanceFile || !fs.existsSync(path.join(absoluteTarget, '.vibecoding-state', 'governance', governanceFile))) throw new Error('governance confirm did not write attestation artifact');
+  const governanceVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--verify', governanceFile, '--json', '--root', target], {}, options), runtimeAutomationGovernanceSmokeSpecs.governanceVerifyJson.label);
+  assertSpecJsonMarkers(governanceVerify, runtimeAutomationGovernanceSmokeSpecs.governanceVerifyJson);
+  const observabilityPath = path.join(absoluteTarget, '.vibecoding-state', 'observability', sourceBoundReadiness.observability_file);
+  const unhealthyObservability = JSON.parse(fs.readFileSync(observabilityPath, 'utf8'));
+  unhealthyObservability.observability.reply_health.blocked_reasons.push('release-check injected governance reply health violation');
+  unhealthyObservability.quality.push('release-check injected governance quality violation');
+  fs.writeFileSync(path.join(absoluteTarget, '.vibecoding-state', 'observability', 'zz-unhealthy.observability.json'), `${JSON.stringify(unhealthyObservability, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--attest', '--confirm', '--json', '--root', target], {
+    allowFailure: true,
+    expectOutput: runtimeAutomationGovernanceSmokeSpecs.unhealthyGovernanceOutput,
+  }, options);
+  fs.rmSync(path.join(absoluteTarget, '.vibecoding-state', 'observability', 'zz-unhealthy.observability.json'), { force: true });
+  const tamperedObservability = JSON.parse(fs.readFileSync(observabilityPath, 'utf8'));
+  tamperedObservability.safety.platform_api = true;
+  fs.writeFileSync(path.join(absoluteTarget, '.vibecoding-state', 'observability', 'zz-tampered.observability.json'), `${JSON.stringify(tamperedObservability, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--attest', '--confirm', '--json', '--root', target], {
+    allowFailure: true,
+    expectOutput: runtimeAutomationGovernanceSmokeSpecs.tamperedObservabilityGovernanceOutput,
+  }, options);
+  fs.rmSync(path.join(absoluteTarget, '.vibecoding-state', 'observability', 'zz-tampered.observability.json'), { force: true });
+  const reviewPath = path.join(absoluteTarget, '.vibecoding-state', 'reply-reviews', reviewFile);
+  const tamperedReview = JSON.parse(fs.readFileSync(reviewPath, 'utf8'));
+  tamperedReview.reply_review.boundary_assertions.external_delivery = true;
+  fs.writeFileSync(path.join(absoluteTarget, '.vibecoding-state', 'reply-reviews', 'bad-boundary.reply-review.json'), `${JSON.stringify(tamperedReview, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'reply', '--verify', 'bad-boundary.reply-review.json', '--root', target], {
+    allowFailure: true,
+    expectOutput: runtimeAutomationGovernanceSmokeSpecs.badReviewVerifyOutput,
+  }, options);
+  fs.writeFileSync(path.join(absoluteTarget, '.vibecoding-state', 'runtime-traces', 'zz-source-drift.runtime-trace.json'), fs.readFileSync(tracePath, 'utf8'), 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'reply', '--outbox', sourceBoundApprovalFile, '--confirm', '--json', '--root', target], {
+    allowFailure: true,
+    expectOutput: runtimeAutomationGovernanceSmokeSpecs.sourceDriftOutboxOutput,
+  }, options);
+
+  const sendConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'reply', '--send', outboxFile, '--confirm', '--json', '--root', target], {}, options), runtimeAutomationGovernanceSmokeSpecs.sendConfirmJson.label);
+  assertSpecJsonMarkers(sendConfirm, runtimeAutomationGovernanceSmokeSpecs.sendConfirmJson);
+}
+
+export function runAutomationGovernanceReplyTraceSmoke(context, options) {
+  runAutomationGovernanceDaemonLoopSmoke(context, options);
+  const { outboxFile } = runAutomationGovernanceReplyOutboxSmoke(context, options);
+  const { sourceBoundReadiness, tracePath } = runAutomationGovernanceTraceReadinessSmoke(context, options);
+  const { sourceBoundApprovalFile, reviewFile } = runAutomationGovernanceSourceBoundReviewSmoke(context, options, tracePath);
+  runAutomationGovernanceAttestationSmoke(context, options, sourceBoundReadiness, reviewFile, tracePath, outboxFile, sourceBoundApprovalFile);
+}

package/tools/vibe-release-check/release-check-runtime-automation-governance-smoke-specs.mjs

@@ -0,0 +1,215 @@
+export const runtimeAutomationGovernanceSmokeSpecs = {
+  retryListJson: {
+    label: 'retry --list-packages --json',
+    markers: [
+      ['command', 'retry'],
+      ['mode', 'retry-package-list'],
+      ['summary.count', 0],
+    ],
+  },
+  loopDryRunJson: {
+    label: 'daemon --loop --dry-run --json',
+    markers: [
+      ['command', 'daemon'],
+      ['mode', 'daemon-loop-dry-run'],
+      ['daemon_loop.foreground_only', true],
+      ['safety.writes', false],
+    ],
+  },
+  loopConfirmJson: {
+    label: 'daemon --loop --confirm --json',
+    markers: [
+      ['command', 'daemon'],
+      ['mode', 'daemon-loop-run'],
+      ['safety.daemon_loop_artifact', true],
+      ['safety.long_running', false],
+    ],
+  },
+  stopJson: {
+    label: 'daemon --stop --confirm --json',
+    markers: [
+      ['command', 'daemon'],
+      ['mode', 'daemon-stop-file'],
+      ['safety.stop_file', true],
+    ],
+  },
+  draftPreviewJson: {
+    label: 'reply --draft --json',
+    markers: [
+      ['command', 'reply'],
+      ['mode', 'reply-draft'],
+      ['reply_draft.external_delivery', false],
+      ['safety.writes', false],
+    ],
+  },
+  outboxVerifyJson: {
+    label: 'reply --verify outbox --json',
+    markers: [
+      ['command', 'reply'],
+      ['mode', 'reply-verify'],
+      ['verification.ok', true],
+    ],
+  },
+  badOutboxDigestOutput: [
+    'reply artifact verification failed:',
+    'reply outbox approval digest mismatch',
+  ],
+  traceDryRunJson: {
+    label: 'traces --build --dry-run --json',
+    markers: [
+      ['command', 'traces'],
+      ['mode', 'runtime-trace-build'],
+      ['runtime_trace.stage', 'Stage 29'],
+      ['safety.writes', false],
+    ],
+  },
+  traceConfirmJson: {
+    label: 'traces --build --confirm --json',
+    markers: [
+      ['command', 'traces'],
+      ['mode', 'runtime-trace-build'],
+      ['safety.trace_artifact', true],
+    ],
+  },
+  traceVerifyJson: {
+    label: 'traces --verify --json',
+    markers: [
+      ['command', 'traces'],
+      ['mode', 'runtime-trace-verify'],
+      ['verification.ok', true],
+    ],
+  },
+  badTraceVerifyOutput: [
+    'runtime trace verification failed:',
+    'source_descriptor_digest mismatch',
+  ],
+  expandedReadinessJson: {
+    label: 'readiness --score expanded --json',
+    markers: [
+      ['command', 'observability'],
+      ['safety.stage', 'Stage 30'],
+      ['observability.trace_health.traces.count', 1],
+      ['observability.reply_health.send_disabled', false],
+    ],
+  },
+  sourceBoundReadinessJson: {
+    label: 'readiness --score source-bound baseline --confirm --json',
+    markers: [
+      ['command', 'observability'],
+      ['mode', 'observability-readiness-score'],
+      ['safety.observability_snapshot', true],
+      ['observability_file.type', 'string'],
+    ],
+  },
+  sourceBoundPreviewJson: {
+    label: 'reply --draft --source-bound --json',
+    markers: [
+      ['command', 'reply'],
+      ['mode', 'reply-draft'],
+      ['reply_draft.source_manifest.stage', 'Reply E'],
+      ['safety.source_bound', true],
+      ['safety.writes', false],
+    ],
+  },
+  sourceBoundVerifyJson: {
+    label: 'reply --verify source-bound draft --json',
+    markers: [
+      ['command', 'reply'],
+      ['mode', 'reply-verify'],
+      ['verification.ok', true],
+    ],
+  },
+  sourceDriftApprovalOutput: [
+    'reply approval gate failed:',
+    'reply source manifest latest_runtime_trace file mismatch',
+  ],
+  badSourceManifestVerifyOutput: [
+    'reply artifact verification failed:',
+    'reply source manifest source count mismatch',
+  ],
+  missingReviewApprovalOutput: [
+    'reply approval gate failed:',
+    'source-bound reply draft requires an approved reply review sidecar',
+  ],
+  reviewPreviewJson: {
+    label: 'reply --review source-bound --json',
+    markers: [
+      ['command', 'reply'],
+      ['mode', 'reply-review'],
+      ['ok', true],
+      ['safety.stage', 'Reply F'],
+      ['safety.writes', false],
+    ],
+  },
+  reviewConfirmJson: {
+    label: 'reply --review source-bound --confirm --json',
+    markers: [
+      ['command', 'reply'],
+      ['mode', 'reply-review'],
+      ['reply_review.review_outcome', 'approved'],
+      ['safety.review_artifact', true],
+      ['reply_review_file.type', 'string'],
+    ],
+  },
+  reviewVerifyJson: {
+    label: 'reply --verify review --json',
+    markers: [
+      ['command', 'reply'],
+      ['mode', 'reply-verify'],
+      ['verification.ok', true],
+    ],
+  },
+  governanceDryRunJson: {
+    label: 'governance --attest --dry-run --json',
+    markers: [
+      ['command', 'governance'],
+      ['mode', 'governance-attest'],
+      ['governance_attestation.stage', 'Stage 31'],
+      ['safety.writes', false],
+    ],
+  },
+  governanceConfirmJson: {
+    label: 'governance --attest --confirm --json',
+    markers: [
+      ['command', 'governance'],
+      ['mode', 'governance-attest'],
+      ['safety.stage', 'Stage 31'],
+      ['safety.governance_artifact', true],
+      ['governance_file.type', 'string'],
+    ],
+  },
+  governanceVerifyJson: {
+    label: 'governance --verify --json',
+    markers: [
+      ['command', 'governance'],
+      ['mode', 'governance-verify'],
+      ['verification.ok', true],
+    ],
+  },
+  unhealthyGovernanceOutput: [
+    'governance attestation gate failed:',
+    'observability: quality: release-check injected governance quality violation',
+  ],
+  tamperedObservabilityGovernanceOutput: [
+    'governance attestation gate failed:',
+    'observability: artifact: safety.platform_api must be false',
+  ],
+  badReviewVerifyOutput: [
+    'reply artifact verification failed:',
+    'reply review digest mismatch',
+  ],
+  sourceDriftOutboxOutput: [
+    'reply outbox gate failed:',
+    'reply approval verification failed: reply approval draft verification failed: reply source manifest latest_runtime_trace file mismatch',
+  ],
+  sendConfirmJson: {
+    label: 'reply --send --confirm --json',
+    markers: [
+      ['command', 'reply'],
+      ['mode', 'reply-send-gate'],
+      ['reply_send_run.sent', false],
+      ['reply_send_run.external_delivery', false],
+      ['safety.platform_api', false],
+    ],
+  },
+};

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

@@ -0,0 +1,5 @@
+import { runAutomationGovernanceReplyTraceSmoke } from './release-check-runtime-automation-governance-reply-trace-smoke-helpers.mjs';
+
+export function runRuntimeAutomationGovernanceSmoke(context, options) {
+  runAutomationGovernanceReplyTraceSmoke(context, options);
+}

package/tools/vibe-release-check/release-check-runtime-automation-methodology-smoke-specs.mjs

@@ -0,0 +1,157 @@
+export const runtimeAutomationMethodologySpecs = {
+  methodologyHandoff: {
+    current_skill: 'vibe-verification-before-completion',
+    next_skill: 'vibe-finishing-a-development-branch',
+    reason: 'release check methodology gate smoke',
+    handoff: {
+      goal: 'release check methodology gate',
+      scope: ['methodology gate smoke'],
+      key_decisions: ['fresh evidence is required before completion claims'],
+      files: ['tools/vibe-runtime/index.mjs'],
+      risks: ['none'],
+      acceptance: ['methodology gate can be previewed, written, verified, and rejects tamper'],
+      evidence: ['release-check methodology smoke'],
+    },
+    stop_condition: 'none',
+  },
+  methodologyCatalogJson: {
+    label: 'methodology --catalog --json',
+    markers: [
+      ['command', 'methodology'],
+      ['mode', 'methodology-catalog'],
+      ['catalog.stage', 'Stage 32'],
+      ['catalog.gates.length', 7],
+    ],
+  },
+  methodologyPreviewJson: {
+    label: 'methodology --gate completion --json',
+    markers: [
+      ['command', 'methodology'],
+      ['mode', 'methodology-gate'],
+      ['methodology_gate.stage', 'Stage 32'],
+      ['methodology_gate.kind', 'completion'],
+      ['methodology_gate.outcome', 'passed'],
+      ['safety.writes', false],
+    ],
+  },
+  methodologyConfirmJson: {
+    label: 'methodology --gate completion --confirm --json',
+    markers: [
+      ['command', 'methodology'],
+      ['mode', 'methodology-gate'],
+      ['safety.stage', 'Stage 32'],
+      ['safety.methodology_gate_artifact', true],
+      ['methodology_gate_file.type', 'string'],
+    ],
+  },
+  methodologyVerifyJson: {
+    label: 'methodology --verify --json',
+    markers: [
+      ['command', 'methodology'],
+      ['mode', 'methodology-verify'],
+      ['verification.ok', true],
+    ],
+  },
+  tamperedMethodologyVerifyOutput: [
+    'methodology gate verification failed:',
+    'methodology gate digest mismatch',
+    'methodology boundary git must be false',
+  ],
+  hooksCatalogJson: {
+    label: 'hooks --catalog --json',
+    markers: [
+      ['command', 'hooks'],
+      ['mode', 'hooks-catalog'],
+      ['catalog.stage', 'Stage 33'],
+      ['catalog.default_enabled', false],
+      ['catalog.sources.length', 4],
+    ],
+  },
+  hooksPreviewJson: {
+    label: 'hooks --preview --json',
+    markers: [
+      ['command', 'hooks'],
+      ['mode', 'hook-intent'],
+      ['hook_intent.stage', 'Stage 33'],
+      ['hook_intent.default_enabled', false],
+      ['hook_intent.subagent_dispatch', false],
+      ['safety.writes', false],
+      ['safety.scheduler_plan', false],
+      ['safety.subagent_dispatch', false],
+    ],
+  },
+  hooksConfirmJson: {
+    label: 'hooks --preview --confirm --json',
+    markers: [
+      ['command', 'hooks'],
+      ['mode', 'hook-intent'],
+      ['safety.stage', 'Stage 33'],
+      ['safety.hook_intent_artifact', true],
+      ['safety.platform_api', false],
+      ['hook_intent_file.type', 'string'],
+    ],
+  },
+  hooksVerifyJson: {
+    label: 'hooks --verify --json',
+    markers: [
+      ['command', 'hooks'],
+      ['mode', 'hooks-verify'],
+      ['verification.ok', true],
+    ],
+  },
+  tamperedHookIntentVerifyOutput: [
+    'hook intent verification failed:',
+    'hook intent digest mismatch',
+    'hook intent subagent_dispatch must be false',
+  ],
+  resignedHookIntentVerifyOutput: [
+    'hook intent verification failed:',
+    'hook intent hook_source must be session_start',
+    'hook intent allowed_followup must equal scheduler-plan-only',
+  ],
+  schedulerHookPreviewJson: {
+    label: 'scheduler --from-hook --plan --json',
+    markers: [
+      ['command', 'scheduler'],
+      ['mode', 'scheduler-hook-plan'],
+      ['scheduler_hook_plan.stage', 'Stage 34'],
+      ['scheduler_hook_plan.scheduler_profile', 'scheduler-dry-run'],
+      ['scheduler_hook_plan.budget.runtime_action_allowed', false],
+      ['scheduler_hook_plan.budget.subagent_dispatch_allowed', false],
+      ['safety.writes', false],
+      ['safety.scheduler_run', false],
+      ['safety.subagent_dispatch', false],
+    ],
+  },
+  schedulerHookConfirmJson: {
+    label: 'scheduler --from-hook --plan --confirm --json',
+    markers: [
+      ['command', 'scheduler'],
+      ['mode', 'scheduler-hook-plan'],
+      ['safety.stage', 'Stage 34'],
+      ['safety.scheduler_hook_plan_artifact', true],
+      ['safety.scheduler_run', false],
+      ['scheduler_hook_plan_file.type', 'string'],
+    ],
+  },
+  schedulerHookVerifyJson: {
+    label: 'scheduler --verify scheduler hook plan --json',
+    markers: [
+      ['command', 'scheduler'],
+      ['mode', 'scheduler-hook-plan-verify'],
+      ['verification.ok', true],
+    ],
+  },
+  tamperedSchedulerHookPlanVerifyOutput: [
+    'scheduler hook plan verification failed:',
+    'scheduler_hook_plan budget must disable runtime action and subagent dispatch',
+    'scheduler_hook_plan digest mismatch',
+  ],
+  resignedSchedulerHookPlanVerifyOutput: [
+    'scheduler hook plan verification failed:',
+    'scheduler_hook_plan.allowed_followup must equal scheduler-plan-only',
+    'scheduler_hook_plan.no_subagent_dispatch must be true',
+    'scheduler_hook_plan.required_approvals must equal scheduler-hook-plan-review',
+    'scheduler_hook_plan budget.max_runs_per_invocation must be 0',
+  ],
+};