@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-release-check/release-check-subagent-adapter-bridge-smoke.mjs

@@ -0,0 +1,162 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  assertJsonMarkers,
+  digestObject,
+  parseJsonOutput,
+  run,
+} from './release-check-runtime.mjs';
+
+const adapterDispatchPreviewMarkerSpecs = [
+  ['command', 'command', 'subagents'],
+  ['mode', 'mode', 'subagent-adapter-dispatch'],
+  ['subagent_adapter_dispatch.stage', 'subagent_adapter_dispatch.stage', 'P8'],
+  ['subagent_adapter_dispatch.writes', 'subagent_adapter_dispatch.writes', false],
+  ['subagent_adapter_dispatch.permission_snapshot.user_permission_present', 'subagent_adapter_dispatch.permission_snapshot.user_permission_present', false],
+  ['subagent_adapter_dispatch.subagent_permission_gate.stage', 'subagent_adapter_dispatch.subagent_permission_gate.stage', 'P30'],
+  ['subagent_adapter_dispatch.subagent_permission_gate.gate_kind', 'subagent_adapter_dispatch.subagent_permission_gate.gate_kind', 'subagent-explicit-permission-gate'],
+  ['subagent_adapter_dispatch.subagent_permission_gate.pass', 'subagent_adapter_dispatch.subagent_permission_gate.pass', false],
+  ['subagent_adapter_dispatch.subagent_permission_gate.boundary_assertions.session_create', 'subagent_adapter_dispatch.subagent_permission_gate.boundary_assertions.session_create', false],
+  ['subagent_adapter_dispatch.adapter_consumable', 'subagent_adapter_dispatch.adapter_consumable', false],
+  ['safety.writes', 'safety.writes', false],
+  ['safety.session_create', 'safety.session_create', false],
+  ['safety.platform_api', 'safety.platform_api', false],
+  ['safety.model_invocation', 'safety.model_invocation', false],
+  ['safety.subagent', 'safety.subagent', false],
+];
+
+const adapterDispatchConfirmMarkerSpecs = [
+  ['command', 'command', 'subagents'],
+  ['mode', 'mode', 'subagent-adapter-dispatch'],
+  ['subagent_adapter_dispatch.dispatch_status', 'subagent_adapter_dispatch.dispatch_status', 'adapter-dispatch-artifact-ready'],
+  ['subagent_adapter_dispatch.permission_snapshot.user_permission_present', 'subagent_adapter_dispatch.permission_snapshot.user_permission_present', true],
+  ['subagent_adapter_dispatch.subagent_permission_gate.stage', 'subagent_adapter_dispatch.subagent_permission_gate.stage', 'P30'],
+  ['subagent_adapter_dispatch.subagent_permission_gate.gate_kind', 'subagent_adapter_dispatch.subagent_permission_gate.gate_kind', 'subagent-explicit-permission-gate'],
+  ['subagent_adapter_dispatch.subagent_permission_gate.permission_source', 'subagent_adapter_dispatch.subagent_permission_gate.permission_source', 'confirm-plus-eligibility-evidence'],
+  ['subagent_adapter_dispatch.subagent_permission_gate.pass', 'subagent_adapter_dispatch.subagent_permission_gate.pass', true],
+  ['subagent_adapter_dispatch.subagent_permission_gate.boundary_assertions.session_create', 'subagent_adapter_dispatch.subagent_permission_gate.boundary_assertions.session_create', false],
+  ['subagent_adapter_dispatch.adapter_consumable', 'subagent_adapter_dispatch.adapter_consumable', true],
+  ['subagent_adapter_dispatch.no_session_create', 'subagent_adapter_dispatch.no_session_create', true],
+  ['subagent_adapter_dispatch.no_platform_api', 'subagent_adapter_dispatch.no_platform_api', true],
+  ['subagent_adapter_dispatch.no_model_invocation', 'subagent_adapter_dispatch.no_model_invocation', true],
+  ['subagent_adapter_dispatch.no_business_source_write', 'subagent_adapter_dispatch.no_business_source_write', true],
+  ['safety.subagent_adapter_dispatch_artifact', 'safety.subagent_adapter_dispatch_artifact', true],
+  ['safety.adapter_consumable', 'safety.adapter_consumable', true],
+  ['safety.session_create', 'safety.session_create', false],
+  ['safety.platform_api', 'safety.platform_api', false],
+  ['safety.hidden_handoff', 'safety.hidden_handoff', false],
+  ['subagent_adapter_dispatch_file.type', 'subagent_adapter_dispatch_file_type', 'string'],
+];
+
+export function checkSubagentAdapterBridgeSmoke(context, options, subagentDispatchFile) {
+  const {
+    subagentsTarget,
+    absoluteSubagentsTarget,
+  } = context;
+
+  const platformCapabilityConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--probe', 'cursor', '--confirm', '--json', '--root', subagentsTarget], {}, options), 'platforms --probe cursor --confirm --json');
+  const platformCapabilityFile = platformCapabilityConfirm.platform_capability_file;
+  assertJsonMarkers([
+    ['command', platformCapabilityConfirm.command, 'platforms'],
+    ['mode', platformCapabilityConfirm.mode, 'platform-capability-probe'],
+    ['platform_capability.platform', platformCapabilityConfirm.platform_capability?.platform, 'cursor'],
+    ['platform_capability.platform_api', platformCapabilityConfirm.platform_capability?.platform_api, false],
+    ['platform_capability.model_invocation', platformCapabilityConfirm.platform_capability?.model_invocation, false],
+    ['safety.platform_capability_artifact', platformCapabilityConfirm.safety?.platform_capability_artifact, true],
+    ['platform_capability_file.type', typeof platformCapabilityFile, 'string'],
+  ], 'platforms --probe cursor --confirm --json');
+  if (!platformCapabilityFile || !fs.existsSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-capabilities', platformCapabilityFile))) throw new Error('platform capability probe did not write capability artifact');
+
+  const adapterPreview = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--adapter-dispatch', '--from-dispatch', subagentDispatchFile, '--capability', platformCapabilityFile, '--json', '--root', subagentsTarget], {}, options), 'subagents --adapter-dispatch --json');
+  assertAdapterDispatchPreviewMarkers(adapterPreview);
+  if (fs.existsSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'subagent-adapter-dispatches'))) throw new Error('subagents adapter dispatch preview created unexpected adapter dispatch directory');
+
+  run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--adapter-dispatch', '--from-dispatch', subagentDispatchFile, '--json', '--root', subagentsTarget], {
+    allowFailure: true,
+    expectOutput: ['subagents --adapter-dispatch requires --capability'],
+  }, options);
+
+  const adapterConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--adapter-dispatch', '--from-dispatch', subagentDispatchFile, '--capability', platformCapabilityFile, '--confirm', '--json', '--root', subagentsTarget], {}, options), 'subagents --adapter-dispatch --confirm --json');
+  const subagentAdapterDispatchFile = adapterConfirm.subagent_adapter_dispatch_file;
+  assertAdapterDispatchConfirmMarkers(adapterConfirm, subagentAdapterDispatchFile);
+  const adapterDispatchPath = path.join(absoluteSubagentsTarget, '.vibecoding-state', 'subagent-adapter-dispatches', subagentAdapterDispatchFile);
+  if (!subagentAdapterDispatchFile || !fs.existsSync(adapterDispatchPath)) throw new Error('subagents adapter dispatch confirm did not write adapter dispatch artifact');
+
+  const adapterVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', subagentAdapterDispatchFile, '--json', '--root', subagentsTarget], {}, options), 'subagents --verify adapter dispatch --json');
+  assertJsonMarkers([
+    ['command', adapterVerify.command, 'subagents'],
+    ['mode', adapterVerify.mode, 'subagent-adapter-dispatch-verify'],
+    ['verification.ok', adapterVerify.verification?.ok, true],
+  ], 'subagents --verify adapter dispatch --json');
+
+  checkAdapterDispatchTamperGuard({
+    absoluteSubagentsTarget,
+    subagentsTarget,
+    adapterDispatchPath,
+    options,
+    fileName: 'bad-safety.subagent-adapter-dispatch.json',
+    expectOutput: ['subagent adapter dispatch verification failed:', 'safety.platform_api must be false'],
+    mutate: (artifact) => { artifact.safety.platform_api = true; },
+  });
+  checkAdapterDispatchTamperGuard({
+    absoluteSubagentsTarget,
+    subagentsTarget,
+    adapterDispatchPath,
+    options,
+    fileName: 'bad-resigned.subagent-adapter-dispatch.json',
+    expectOutput: ['subagent adapter dispatch verification failed:', 'subagent_adapter_dispatch.allowed_followup mismatch', 'subagent_adapter_dispatch.no_session_create must be true'],
+    mutate: (artifact) => {
+      artifact.subagent_adapter_dispatch.allowed_followup = ['external-adapter-consume-only', 'session-create'];
+      artifact.subagent_adapter_dispatch.no_session_create = false;
+      resignSubagentAdapterDispatch(artifact);
+    },
+  });
+  checkAdapterDispatchTamperGuard({
+    absoluteSubagentsTarget,
+    subagentsTarget,
+    adapterDispatchPath,
+    options,
+    fileName: 'bad-permission-gate.subagent-adapter-dispatch.json',
+    expectOutput: ['subagent adapter dispatch verification failed:', 'subagent_adapter_dispatch permission gate must pass'],
+    mutate: (artifact) => {
+      artifact.subagent_adapter_dispatch.subagent_permission_gate.pass = false;
+      artifact.subagent_adapter_dispatch.subagent_permission_gate.status = 'blocked';
+      resignSubagentAdapterDispatch(artifact);
+    },
+  });
+
+  return { platformCapabilityFile, subagentAdapterDispatchFile };
+}
+
+function assertAdapterDispatchPreviewMarkers(adapterPreview) {
+  assertMarkerSpecs(adapterPreview, adapterDispatchPreviewMarkerSpecs, 'subagents --adapter-dispatch --json');
+}
+
+function assertAdapterDispatchConfirmMarkers(adapterConfirm, subagentAdapterDispatchFile) {
+  assertMarkerSpecs({ ...adapterConfirm, subagent_adapter_dispatch_file_type: typeof subagentAdapterDispatchFile }, adapterDispatchConfirmMarkerSpecs, 'subagents --adapter-dispatch --confirm --json');
+}
+
+function assertMarkerSpecs(source, specs, label) {
+  assertJsonMarkers(specs.map(([marker, objectPath, expected]) => [marker, markerValue(source, objectPath), expected]), label);
+}
+
+function markerValue(source, objectPath) {
+  return objectPath.split('.').reduce((value, key) => (value && typeof value === 'object' ? value[key] : undefined), source);
+}
+
+function checkAdapterDispatchTamperGuard({ absoluteSubagentsTarget, subagentsTarget, adapterDispatchPath, options, fileName, expectOutput, mutate }) {
+  const dispatchesDirectory = path.join(absoluteSubagentsTarget, '.vibecoding-state', 'subagent-adapter-dispatches');
+  const tamperedArtifact = JSON.parse(fs.readFileSync(adapterDispatchPath, 'utf8'));
+  mutate(tamperedArtifact);
+  fs.writeFileSync(path.join(dispatchesDirectory, fileName), `${JSON.stringify(tamperedArtifact, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', fileName, '--root', subagentsTarget], {
+    allowFailure: true,
+    expectOutput,
+  }, options);
+  fs.rmSync(path.join(dispatchesDirectory, fileName), { force: true });
+}
+
+function resignSubagentAdapterDispatch(artifact) {
+  delete artifact.subagent_adapter_dispatch.adapter_dispatch_digest;
+  artifact.subagent_adapter_dispatch.adapter_dispatch_digest = digestObject(artifact.subagent_adapter_dispatch);
+}

package/tools/vibe-release-check/release-check-suite-plan-smoke.mjs

@@ -0,0 +1,86 @@
+import path from 'node:path';
+
+import {
+  READ_ONLY_RUNTIME_CONTROL_FLAGS_WITH_PREVIEW,
+  assertNoSmokeState,
+  cleanupSmokeTmpRoot,
+  prepareSmokeTmpRoot,
+  runForbiddenFlagChecks,
+  writeSmokeJsonFixture,
+} from './release-check-json-assertion-helpers.mjs';
+
+function timingFixture() {
+  return {
+    suite: 'runtime',
+    result: 'passed',
+    command_count: 3,
+    timing: [
+      { label: 'runtime-surface-smoke', durationMs: 120, runtimeSuiteLayer: 'surface' },
+      { label: 'test-run-smoke', durationMs: 430, runtimeSuiteLayer: 'execution-boundary' },
+      { label: 'commit-readiness-smoke', durationMs: 90, runtimeSuiteLayer: 'release-closeout' },
+    ],
+  };
+}
+
+export function runSuitePlanSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const target = '.tmp/vibe-suite-plan';
+  const absoluteTarget = prepareSmokeTmpRoot(repoRoot, target);
+  const timingFile = path.join(target, 'timing-summary.json');
+
+  try {
+    writeSmokeJsonFixture(repoRoot, timingFile, timingFixture());
+
+    const plan = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'release', '--suite-plan', '--from-file', timingFile, '--change-kind', 'execution', '--json', '--root', target], {}, options), 'release --suite-plan --json');
+    assertJsonMarkers([
+      ['command', plan.command, 'release'],
+      ['mode', plan.mode, 'timing-suite-selection-plan'],
+      ['ok', plan.ok, true],
+      ['suite_selection_plan.stage', plan.suite_selection_plan?.stage, 'P5'],
+      ['suite_selection_plan.plan_kind', plan.suite_selection_plan?.plan_kind, 'timing-suite-selection-plan'],
+      ['suite_selection_plan.change_kind', plan.suite_selection_plan?.change_kind, 'execution'],
+      ['suite_selection_plan.recommended_targeted_suite', plan.suite_selection_plan?.recommended_targeted_suite, 'runtime:execution-boundary'],
+      ['suite_selection_plan.required_gate_unchanged', plan.suite_selection_plan?.required_gate_unchanged, true],
+      ['suite_selection_plan.advisory_only', plan.suite_selection_plan?.advisory_only, true],
+      ['suite_selection_plan.package_scripts_changed', plan.suite_selection_plan?.package_scripts_changed, false],
+      ['suite_selection_plan.release_check_order_changed', plan.suite_selection_plan?.release_check_order_changed, false],
+      ['suite_selection_plan.failure_strictness_changed', plan.suite_selection_plan?.failure_strictness_changed, false],
+      ['suite_selection_plan.command_execution', plan.suite_selection_plan?.command_execution, false],
+      ['suite_selection_plan.suite_execution', plan.suite_selection_plan?.suite_execution, false],
+      ['suite_selection_plan.git_write', plan.suite_selection_plan?.git_write, false],
+      ['suite_selection_plan.worktree_write', plan.suite_selection_plan?.worktree_write, false],
+      ['suite_selection_plan.suite_plan_invariants.pass', plan.suite_selection_plan?.suite_plan_invariants?.pass, true],
+      ['safety.stage', plan.safety?.stage, 'P5'],
+      ['safety.writes', plan.safety?.writes, false],
+      ['safety.command_execution', plan.safety?.command_execution, false],
+      ['safety.suite_execution', plan.safety?.suite_execution, false],
+      ['safety.git_write', plan.safety?.git_write, false],
+      ['safety.worktree_write', plan.safety?.worktree_write, false],
+    ], 'release --suite-plan --json');
+    if (!plan.suite_selection_plan?.suite_plan_digest) throw new Error('suite plan missing digest');
+    if (!plan.suite_selection_plan?.slow_command_diagnostics?.length) throw new Error('suite plan missing slow command diagnostics');
+    if (!plan.suite_selection_plan?.hot_layer_diagnostics?.length) throw new Error('suite plan missing hot layer diagnostics');
+    assertNoSmokeState(repoRoot, target, 'release --suite-plan JSON output');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'release', '--suite-plan', '--from-file', timingFile, '--change-kind', 'runtime', '--root', target], {
+      expectOutput: ['Vibecoding Runtime Timing Suite Plan', 'Stage: P5; Kind: timing-suite-selection-plan; pass=true', 'Change kind: runtime; recommended=runtime', 'Required gate unchanged: true; advisory_only=true', 'Boundary: writes=false; command_execution=false; suite_execution=false; package_scripts_changed=false; release_check_order_changed=false; failure_strictness_changed=false; git_write=false; worktree_write=false', 'Suite plan digest:'],
+    }, options);
+    assertNoSmokeState(repoRoot, target, 'release --suite-plan text output');
+
+    runForbiddenFlagChecks(run, ['tools/vibe-runtime/index.mjs', 'release', '--suite-plan', '--from-file', timingFile], ['--root', target], READ_ONLY_RUNTIME_CONTROL_FLAGS_WITH_PREVIEW, 'release --suite-plan is read-only', options);
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'release', '--suite-plan', '--json', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['release --suite-plan requires --from-file'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'release', '--suite-plan', '--from-file', timingFile, '--change-kind', 'unsafe', '--json', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['release --suite-plan --change-kind must be one of'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'release', '--suite-plan', '--from-file', '../outside.json', '--json', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['release --suite-plan --from-file must stay within --root'],
+    }, options);
+  } finally {
+    cleanupSmokeTmpRoot(absoluteTarget, options);
+  }
+}

package/tools/vibe-release-check/release-check-suites.mjs

@@ -0,0 +1,164 @@
+import {
+  commandEntryRuntimeSuiteLayer,
+  commandEntrySuites,
+} from './command-manifest/release-check-command-metadata.mjs';
+import { runtimeSuiteLayers } from './command-manifest/release-check-runtime-smoke-commands.mjs';
+
+function labelFor(entry) {
+  const [command, args = []] = entry;
+  return [command, ...args].join(' ');
+}
+
+function entryHasSuite(entry, suite) {
+  return commandEntrySuites(entry).includes(suite);
+}
+
+function isExactNodeCommand(entry, expectedArgs) {
+  const [command, args = []] = entry;
+  if (command !== 'node') return false;
+  if (args.length !== expectedArgs.length) return false;
+  return args.every((arg, index) => arg === expectedArgs[index]);
+}
+
+function isLegacyProductArtifactFastSmoke(entry) {
+  const [command, args = []] = entry;
+  if (command !== 'node') return false;
+  const joined = args.join(' ');
+  return joined.startsWith('tools/vibe-runtime/index.mjs methodology --gate --kind product-spec ')
+    || joined.startsWith('tools/vibe-runtime/index.mjs methodology --gate --kind ui-design ')
+    || joined.startsWith('tools/vibe-runtime/index.mjs methodology --gate --kind scenario-acceptance ')
+    || joined.startsWith('tools/vibe-runtime/index.mjs methodology --gate --kind architecture-design ')
+    || joined.startsWith('tools/vibe-runtime/index.mjs methodology --gate --kind delivery-traceability ')
+    || joined.startsWith('tools/vibe-runtime/index.mjs completion --evidence-bundle --from-product-discovery ')
+    || joined.includes('examples/runtime-fixtures/negative/');
+}
+
+function isFastCommand(entry) {
+  if (entryHasSuite(entry, 'fast')) return true;
+  const [command] = entry;
+  return command === 'git'
+    || command === 'check-not-ignored'
+    || isLegacyProductArtifactFastSmoke(entry)
+    || isExactNodeCommand(entry, ['tools/vibe-doctor/index.mjs', '--help'])
+    || isExactNodeCommand(entry, ['tools/vibe-doctor/index.mjs'])
+    || isExactNodeCommand(entry, ['tools/vibe-runtime-check/index.mjs'])
+    || isExactNodeCommand(entry, ['tools/vibe-architecture-check/index.mjs', '--root', '.', '--json']);
+}
+
+function isInstallCommand(entry) {
+  if (entryHasSuite(entry, 'install')) return true;
+  const [command, args = []] = entry;
+  if (command === 'single-platform-smoke') return true;
+  if (command !== 'node') return false;
+  const joined = args.join(' ');
+  return joined.startsWith('bin/vibe.mjs plugin pack ')
+    || joined.startsWith('tools/vibe-init/index.mjs ')
+    || joined === 'tools/vibe-doctor/index.mjs .tmp/vibe-init-target';
+}
+
+function isLearningCommand(entry) {
+  if (entryHasSuite(entry, 'learning')) return true;
+  return isLegacyLearningCommand(entry);
+}
+
+function isLegacyLearningCommand(entry) {
+  const [command] = entry;
+  return command.startsWith('learning-');
+}
+
+function isTokenCommand(entry) {
+  if (entryHasSuite(entry, 'tokens')) return true;
+  return isLegacyTokenCommand(entry);
+}
+
+function isLegacyTokenCommand(entry) {
+  const [command] = entry;
+  return command.startsWith('token-');
+}
+
+function isFullChainCommand(entry) {
+  if (entryHasSuite(entry, 'full-chain')) return true;
+  const [command] = entry;
+  return command === 'full-chain-demo-smoke';
+}
+
+function isGoldenPathCommand(entry) {
+  if (entryHasSuite(entry, 'golden-path')) return true;
+  const [command] = entry;
+  return command === 'golden-path-demo-smoke';
+}
+
+function isRuntimeCommand(entry) {
+  if (entryHasSuite(entry, 'runtime')) return true;
+  const [command] = entry;
+  if (!command.endsWith('-smoke')) return false;
+  return !isInstallCommand(entry) && !isLearningCommand(entry) && !isTokenCommand(entry) && !isFullChainCommand(entry) && !isGoldenPathCommand(entry);
+}
+
+function isRuntimeLayerCommand(entry, layer) {
+  return isRuntimeCommand(entry) && commandEntryRuntimeSuiteLayer(entry) === layer;
+}
+
+function isBehaviorCommand(entry) {
+  return entryHasSuite(entry, 'behavior');
+}
+
+const suitePredicates = {
+  all: () => true,
+  fast: isFastCommand,
+  install: isInstallCommand,
+  runtime: isRuntimeCommand,
+  'full-chain': isFullChainCommand,
+  'golden-path': isGoldenPathCommand,
+  learning: isLearningCommand,
+  tokens: isTokenCommand,
+  behavior: isBehaviorCommand,
+};
+
+for (const layer of runtimeSuiteLayers) {
+  suitePredicates[`runtime:${layer}`] = (entry) => isRuntimeLayerCommand(entry, layer);
+}
+
+export const releaseCheckSuites = Object.freeze(Object.keys(suitePredicates));
+
+export function normalizeReleaseCheckSuite(value = 'all') {
+  const suite = String(value || 'all').trim();
+  if (!suitePredicates[suite]) {
+    throw new Error(`Unknown release check suite: ${suite}. Available suites: ${releaseCheckSuites.join(', ')}`);
+  }
+  return suite;
+}
+
+export function filterReleaseCheckCommands(commands, suite) {
+  const normalizedSuite = normalizeReleaseCheckSuite(suite);
+  if (normalizedSuite === 'all') return commands;
+  const predicate = suitePredicates[normalizedSuite];
+  const selected = commands.filter((entry) => predicate(entry));
+  if (selected.length === 0) {
+    throw new Error(`Release check suite has no commands: ${normalizedSuite}`);
+  }
+  return selected;
+}
+
+export function releaseCheckSuiteDescription(suite) {
+  const normalizedSuite = normalizeReleaseCheckSuite(suite);
+  if (normalizedSuite.startsWith('runtime:')) {
+    const layer = normalizedSuite.slice('runtime:'.length);
+    return `runtime ${layer} smoke checks`;
+  }
+  return {
+    all: 'full release gate',
+    fast: 'layout, runtime-check, architecture-check, git/submodule hygiene',
+    install: 'plugin pack, vibe-init, installed doctor, platform install smoke',
+    runtime: 'runtime command, governance, workflow, completion, and stage smoke checks',
+    'full-chain': 'full compliance readiness demo smoke',
+    'golden-path': 'golden path team-mode demo smoke',
+    learning: 'learning observation, instinct, and advice smoke checks',
+    tokens: 'token compaction, metrics, and advice smoke checks',
+    behavior: 'transcript/replay behavior gate with negative fixtures for side effects, evidence skips, subagent misuse, and ok=false explanation',
+  }[normalizedSuite];
+}
+
+export function releaseCheckCommandLabel(entry) {
+  return labelFor(entry);
+}

package/tools/vibe-release-check/release-check-test-run-smoke.mjs

@@ -0,0 +1,59 @@
+import {
+  assertNoSmokeState,
+} from './release-check-json-assertion-helpers.mjs';
+
+export function runTestRunSmoke({ repoRoot, run, parseJsonOutput, assertJsonMarkers }, options) {
+  const root = '.';
+  const profile = 'runtime-test-evidence-syntax';
+
+  const evidence = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'tests', '--run', '--profile', profile, '--confirm', '--json', '--root', root], {}, options), 'tests --run --json');
+  assertJsonMarkers([
+    ['command', evidence.command, 'tests'],
+    ['ok', evidence.ok, true],
+    ['artifact_kind', evidence.artifact_kind, 'test-evidence'],
+    ['stage', evidence.stage, 'P4'],
+    ['evidence_kind', evidence.evidence_kind, 'allowlisted-test-run-evidence'],
+    ['test_evidence_ref', evidence.test_evidence_ref, profile],
+    ['runtime_executed_command', evidence.runtime_executed_command, true],
+    ['runtime_run_test', evidence.runtime_run_test, true],
+    ['allowlisted_profile', evidence.allowlisted_profile, true],
+    ['confirmation_required', evidence.confirmation_required, true],
+    ['confirmation_received', evidence.confirmation_received, true],
+    ['command_execution', evidence.command_execution, true],
+    ['test_execution', evidence.test_execution, true],
+    ['git_write', evidence.git_write, false],
+    ['worktree_write', evidence.worktree_write, false],
+    ['runtime_test_run.profile_id', evidence.runtime_test_run?.profile_id, profile],
+    ['runtime_test_run.allowlist.fixed_profile', evidence.runtime_test_run?.allowlist?.fixed_profile, true],
+    ['runtime_test_run.allowlist.arbitrary_shell', evidence.runtime_test_run?.allowlist?.arbitrary_shell, false],
+    ['runtime_test_run.allowlist.user_command_string', evidence.runtime_test_run?.allowlist?.user_command_string, false],
+    ['runtime_test_run.allowlist.foreground', evidence.runtime_test_run?.allowlist?.foreground, true],
+    ['test_evidence_invariants.pass', evidence.test_evidence_invariants?.pass, true],
+    ['runs.0.id', evidence.runs?.[0]?.id, profile],
+    ['runs.0.exit_code', evidence.runs?.[0]?.exit_code, 0],
+    ['runs.0.status', evidence.runs?.[0]?.status, 'pass'],
+  ], 'tests --run --json');
+  if (!evidence.test_evidence_digest) throw new Error('test run evidence missing test_evidence_digest');
+  if (!evidence.runtime_test_run?.output_digest) throw new Error('test run evidence missing output digest');
+  if (!evidence.runs?.[0]?.task_refs?.includes('auto-test-run')) throw new Error('test run evidence missing task ref');
+  if (!evidence.runs?.[0]?.scenario_refs?.includes('p4:runtime-test-evidence-syntax')) throw new Error('test run evidence missing scenario ref');
+  assertNoSmokeState(repoRoot, root, 'tests --run JSON output');
+
+  run('node', ['tools/vibe-runtime/index.mjs', 'tests', '--run', '--profile', profile, '--confirm', '--root', root], {
+    expectOutput: ['Vibecoding Runtime Test Evidence', 'Profile: runtime-test-evidence-syntax', 'Status: pass; exit_code=0', 'Command: node --check tools/vibe-runtime/runtime-test-evidence-model.mjs', 'Boundary: allowlisted_profile=true; confirmation_received=true; git_write=false; worktree_write=false', 'Evidence digest:'],
+  }, options);
+  assertNoSmokeState(repoRoot, root, 'tests --run text output');
+
+  run('node', ['tools/vibe-runtime/index.mjs', 'tests', '--run', '--profile', profile, '--json', '--root', root], {
+    allowFailure: true,
+    expectOutput: ['tests --run requires --confirm'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'tests', '--run', '--profile', 'unknown-profile', '--confirm', '--json', '--root', root], {
+    allowFailure: true,
+    expectOutput: ['tests --run profile is not allowlisted: unknown-profile'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'tests', '--run', '--profile', profile, '--confirm', '--command', 'npm run check', '--json', '--root', root], {
+    allowFailure: true,
+    expectOutput: ['--command is only supported by'],
+  }, options);
+}

package/tools/vibe-release-check/release-check-timing.mjs

@@ -0,0 +1,98 @@
+import { commandEntryRuntimeSuiteLayer } from './command-manifest/release-check-command-metadata.mjs';
+import { releaseCheckCommandLabel } from './release-check-suites.mjs';
+
+function formatRuntimeSuiteLayer(value) {
+  return value ? ` layer=${value}` : '';
+}
+
+function formatSeconds(durationMs) {
+  return `${(durationMs / 1000).toFixed(2)}s`;
+}
+
+function formatPercent(value, total) {
+  if (total <= 0) return '0.0%';
+  return `${((value / total) * 100).toFixed(1)}%`;
+}
+
+function shortenLabel(label, maxLength = 120) {
+  if (label.length <= maxLength) return label;
+  return `${label.slice(0, maxLength - 1)}…`;
+}
+
+function groupRecordsByRuntimeLayer(records) {
+  const groups = new Map();
+  for (const record of records) {
+    const layer = record.runtimeSuiteLayer || 'unlayered';
+    const current = groups.get(layer) || { layer, commandCount: 0, durationMs: 0 };
+    current.commandCount += 1;
+    current.durationMs += record.durationMs;
+    groups.set(layer, current);
+  }
+  return [...groups.values()].sort((left, right) => right.durationMs - left.durationMs);
+}
+
+function printTimingDecisionAid({ records, slowest, layerTotals, totalMs, writeLine }) {
+  if (records.length === 0) return;
+  const topCommand = slowest[0];
+  const topLayer = layerTotals[0];
+  const topThreeMs = slowest.slice(0, 3).reduce((sum, record) => sum + record.durationMs, 0);
+
+  writeLine('Maintainer decision aid:');
+  if (topCommand) {
+    writeLine(`- Slowest command: ${formatSeconds(topCommand.durationMs)} (${formatPercent(topCommand.durationMs, totalMs)}) ${shortenLabel(topCommand.label)}`);
+  }
+  if (topLayer) {
+    writeLine(`- Hottest layer: ${topLayer.layer} ${formatSeconds(topLayer.durationMs)} (${formatPercent(topLayer.durationMs, totalMs)}, ${topLayer.commandCount} command${topLayer.commandCount === 1 ? '' : 's'})`);
+  }
+  writeLine(`- Top 3 share: ${formatSeconds(topThreeMs)} (${formatPercent(topThreeMs, totalMs)})`);
+  writeLine('- Use this as an advisory signal only; suite scope, command order, and failure strictness are unchanged.');
+}
+
+export function createReleaseCheckTiming(enabled, writeLine = () => {}) {
+  const records = [];
+
+  return {
+    run(entry, callback) {
+      const label = releaseCheckCommandLabel(entry);
+      const runtimeSuiteLayer = commandEntryRuntimeSuiteLayer(entry);
+      const startedAt = Date.now();
+      if (enabled) writeLine(`[timing] start${formatRuntimeSuiteLayer(runtimeSuiteLayer)} ${label}`);
+      try {
+        return callback();
+      } finally {
+        const durationMs = Date.now() - startedAt;
+        records.push({
+          label,
+          runtimeSuiteLayer,
+          durationMs,
+        });
+        if (enabled) writeLine(`[timing] done ${(durationMs / 1000).toFixed(2)}s${formatRuntimeSuiteLayer(runtimeSuiteLayer)} ${label}`);
+      }
+    },
+    print({ limit = 10 } = {}) {
+      if (!enabled) return;
+      const totalMs = records.reduce((sum, record) => sum + record.durationMs, 0);
+      const slowest = [...records]
+        .sort((left, right) => right.durationMs - left.durationMs)
+        .slice(0, limit);
+      const layerTotals = groupRecordsByRuntimeLayer(records);
+
+      writeLine('');
+      writeLine('Release check timing');
+      writeLine(`Commands: ${records.length}`);
+      writeLine(`Total observed time: ${formatSeconds(totalMs)}`);
+      printTimingDecisionAid({ records, slowest, layerTotals, totalMs, writeLine });
+      if (layerTotals.length > 0) {
+        writeLine('Runtime layer totals:');
+        for (const group of layerTotals) {
+          writeLine(`- ${group.layer}: ${formatSeconds(group.durationMs)} (${group.commandCount} command${group.commandCount === 1 ? '' : 's'})`);
+        }
+      }
+      writeLine(`Slowest ${slowest.length}:`);
+      for (const [index, record] of slowest.entries()) {
+        writeLine(`${index + 1}. ${formatSeconds(record.durationMs)}${formatRuntimeSuiteLayer(record.runtimeSuiteLayer)} ${record.label}`);
+      }
+    },
+    records,
+  };
+}