@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime-check/runtime-entry-size-contracts.mjs

@@ -0,0 +1,477 @@
+import { runtimeInteractionCommandDomainOwnerFiles, runtimeInteractionCommandDomains, runtimeInteractionCommandDomainNames, runtimeInteractionHighRiskSidecarBoundaries, runtimeOwnerManifestByFile, runtimeSurfaceFileGroups } from '../vibe-runtime/runtime-command-surface-registry.mjs';
+
+function fileLineCount(text) {
+  if (!text) return 0;
+  return text.split(/\r?\n/).length;
+}
+
+const runtimeArchitecturePerformanceBudgets = [
+  {
+    file: 'tools/vibe-release-check/index.mjs',
+    shortTermLines: 8000,
+    stableLines: 5000,
+    idealLines: 2500,
+    owner: 'release-check',
+    layer: 'entry',
+  },
+  {
+    file: 'tools/vibe-runtime/index.mjs',
+    shortTermLines: 20000,
+    stableLines: 10000,
+    idealLines: 5000,
+    owner: 'runtime',
+    layer: 'entry',
+  },
+  {
+    file: 'tools/vibe-runtime/runtime-cli-args.mjs',
+    shortTermLines: 2500,
+    stableLines: 1500,
+    idealLines: 900,
+    owner: 'runtime-cli-parser',
+    layer: 'validation',
+  },
+  {
+    file: 'tools/vibe-runtime/runtime-interaction-command.mjs',
+    shortTermLines: 5000,
+    stableLines: 3000,
+    idealLines: 1800,
+    owner: 'runtime-interaction',
+    layer: 'commandWrapper',
+  },
+  {
+    file: 'tools/vibe-release-check/release-check-stage121-136-smoke.mjs',
+    shortTermLines: 2200,
+    stableLines: 1400,
+    idealLines: 900,
+    owner: 'release-check-runtime-smoke',
+    layer: 'smoke',
+  },
+  {
+    file: 'tools/vibe-release-check/release-check-stage103-118-smoke.mjs',
+    shortTermLines: 2200,
+    stableLines: 1400,
+    idealLines: 900,
+    owner: 'release-check-runtime-smoke',
+    layer: 'smoke',
+  },
+];
+
+export function checkEntryFileSizeBudgets(root, api) {
+  for (const budget of runtimeArchitecturePerformanceBudgets) {
+    if (!api.exists(root, budget.file)) continue;
+    const text = api.readText(root, budget.file);
+    const lines = fileLineCount(text);
+    const bytes = Buffer.byteLength(text);
+    const detail = `${lines} lines / ${bytes} bytes; layer=${budget.layer}; short-term=${budget.shortTermLines}, stable=${budget.stableLines}, ideal=${budget.idealLines}`;
+    if (lines > budget.shortTermLines) {
+      api.warn(`${budget.file} exceeds ${budget.owner} short-term architecture performance budget`, detail, 'Continue low-risk command/helper/smoke extraction; keep execution/state semantics unchanged.');
+    } else if (lines > budget.stableLines) {
+      api.ok(`${budget.file} remains within short-term architecture performance budget`, `${detail}; stable target remains a refactor goal, not a warning gate.`);
+    } else {
+      api.ok(`${budget.file} stays within stable architecture performance budget`, detail);
+    }
+  }
+}
+
+function fileStats(root, api, file) {
+  if (!api.exists(root, file)) return { file, exists: false, lines: 0, bytes: 0 };
+  const text = api.readText(root, file);
+  return { file, exists: true, lines: fileLineCount(text), bytes: Buffer.byteLength(text), text };
+}
+
+function countText(text, needle) {
+  return String(text || '').split(needle).length - 1;
+}
+
+function readonlySmokeSpecKeys(text) {
+  const source = String(text || '');
+  const objectStart = source.indexOf('export const readonlySmokeMarkerSpecs = {');
+  if (objectStart === -1) return [];
+  const bodyStart = source.indexOf('{', objectStart);
+  const bodyEnd = source.lastIndexOf('};');
+  if (bodyStart === -1 || bodyEnd === -1 || bodyEnd <= bodyStart) return [];
+  const body = source.slice(bodyStart + 1, bodyEnd);
+  return [...body.matchAll(/^  ([A-Za-z][A-Za-z0-9]*): \{/gm)].map((match) => match[1]);
+}
+
+function readonlySmokeUsageByKey(text) {
+  const usage = {};
+  for (const match of String(text || '').matchAll(/readonlySmokeMarkers\([^,]+,\s*['"]([A-Za-z][A-Za-z0-9]*)['"]\)/g)) {
+    const key = match[1];
+    usage[key] = (usage[key] || 0) + 1;
+  }
+  return usage;
+}
+
+function mergeUsageMaps(...maps) {
+  return maps.reduce((merged, map) => {
+    for (const [key, count] of Object.entries(map)) merged[key] = (merged[key] || 0) + count;
+    return merged;
+  }, {});
+}
+
+function readonlySmokeMarkerDataStats(root, api) {
+  const markerDataFile = fileStats(root, api, 'tools/vibe-release-check/release-check-readonly-marker-data.mjs');
+  const markerSpecFile = fileStats(root, api, 'tools/vibe-release-check/release-check-readonly-marker-smoke-specs.mjs');
+  const stage121Smoke = fileStats(root, api, 'tools/vibe-release-check/release-check-stage121-136-smoke.mjs');
+  const stage103Smoke = fileStats(root, api, 'tools/vibe-release-check/release-check-stage103-118-smoke.mjs');
+  const specText = markerSpecFile.exists ? markerSpecFile.text : markerDataFile.text;
+  const specKeys = readonlySmokeSpecKeys(specText);
+  const stage103UsageByKey = readonlySmokeUsageByKey(stage103Smoke.text);
+  const stage121UsageByKey = readonlySmokeUsageByKey(stage121Smoke.text);
+  const usageByKey = mergeUsageMaps(stage103UsageByKey, stage121UsageByKey);
+  const unusedSpecKeys = specKeys.filter((key) => !usageByKey[key]);
+  const unknownUsageKeys = Object.keys(usageByKey).filter((key) => !specKeys.includes(key));
+  return {
+    markerDataFile,
+    markerSpecFile,
+    stage121Smoke,
+    stage103Smoke,
+    specText,
+    specKeys,
+    stage103UsageByKey,
+    stage121UsageByKey,
+    usageByKey,
+    unusedSpecKeys,
+    unknownUsageKeys,
+    specCount: specKeys.length,
+    payloadKeyCount: countText(specText, 'payloadKey:'),
+    payloadPrefixCount: countText(specText, 'payloadPrefix:'),
+    payloadSpecsCount: countText(specText, 'payloadSpecs:'),
+    boundaryFieldCount: countText(specText, 'boundaryFields:'),
+    safetyFieldCount: countText(specText, 'safetyFields:'),
+    stage103MarkerFactoryCalls: Object.values(stage103UsageByKey).reduce((total, count) => total + count, 0),
+    stage121MarkerFactoryCalls: Object.values(stage121UsageByKey).reduce((total, count) => total + count, 0),
+  };
+}
+
+const minimumRuntimePresentationFiles = 8;
+const interactionPresentationDelegates = [
+  'createWorkflowPresentation',
+  'createCompletionPresentation',
+  'createEntryPresentation',
+  'createLearningPresentation',
+  'printMethodologyPresentation',
+  'createMethodologyCoveragePresentation',
+];
+
+function runtimePresentationCoverageStats(root, api) {
+  const registryFiles = runtimeSurfaceFileGroups.presentation || [];
+  const ownerByFile = runtimeOwnerManifestByFile();
+  const missingFiles = registryFiles.filter((file) => !api.exists(root, file));
+  const invalidManifestEntries = registryFiles.filter((file) => {
+    const entry = ownerByFile[file] || {};
+    return entry.owner !== 'runtime-presentation' || entry.layer !== 'commandWrapper' || entry.risk !== 'low';
+  });
+  const interactionCommandText = fileStats(root, api, 'tools/vibe-runtime/runtime-interaction-command.mjs').text;
+  const methodologyCommandText = fileStats(root, api, 'tools/vibe-runtime/runtime-methodology-interaction-command.mjs').text;
+  const interactionDelegateText = `${interactionCommandText}\n${methodologyCommandText}`;
+  const missingPresentationDelegates = interactionPresentationDelegates.filter((delegateName) => !interactionDelegateText.includes(delegateName));
+  const factoryExportCount = registryFiles.reduce((total, file) => total + countText(fileStats(root, api, file).text, 'export function create'), 0);
+
+  return {
+    registryCount: registryFiles.length,
+    minimumRegistryFiles: minimumRuntimePresentationFiles,
+    existingCount: registryFiles.length - missingFiles.length,
+    factoryExportCount,
+    missingFiles,
+    invalidManifestEntries,
+    interactionPresentationDelegates,
+    interactionPresentationDelegateCount: interactionPresentationDelegates.length - missingPresentationDelegates.length,
+    missingPresentationDelegates,
+  };
+}
+
+export function checkRuntimePresentationCoverageContracts(root, api) {
+  const stats = runtimePresentationCoverageStats(root, api);
+
+  if (stats.missingFiles.length === 0 && stats.registryCount >= stats.minimumRegistryFiles) {
+    api.ok('runtime presentation modules exist for extracted command output owners', `files=${stats.existingCount}/${stats.registryCount}; minimum=${stats.minimumRegistryFiles}`);
+  } else {
+    api.fail('runtime presentation module coverage regressed', `files=${stats.existingCount}/${stats.registryCount}; minimum=${stats.minimumRegistryFiles}; missing=${stats.missingFiles.join(', ') || 'none'}`, 'Keep extracted text/output formatting in explicit runtime-*-presentation.mjs modules.');
+  }
+
+  if (stats.invalidManifestEntries.length === 0) {
+    api.ok('runtime presentation modules are declared as low-risk command wrapper surface', `registry=${stats.registryCount}; factoryExports=${stats.factoryExportCount}`);
+  } else {
+    api.fail('runtime presentation registry coverage drifted', `invalid=${stats.invalidManifestEntries.join(', ')}`, 'Keep presentation modules registered under runtime-presentation with low risk and commandWrapper layer.');
+  }
+
+  if (stats.missingPresentationDelegates.length === 0) {
+    api.ok('runtime interaction wrapper delegates extracted presentation output', `delegates=${stats.interactionPresentationDelegateCount}/${stats.interactionPresentationDelegates.length}`);
+  } else {
+    api.fail('runtime interaction presentation delegation regressed', `Missing delegate(s): ${stats.missingPresentationDelegates.join(', ')}`, 'Keep workflow, completion, entry, learning, methodology, and methodology coverage printing delegated to presentation modules; do not move IO/state/dispatch semantics.');
+  }
+}
+
+function runtimeInteractionDomainOwnerFiles(domain) {
+  const boundary = runtimeInteractionHighRiskSidecarBoundaries[domain];
+  return [...new Set([
+    'tools/vibe-runtime/runtime-interaction-command.mjs',
+    ...(runtimeInteractionCommandDomainOwnerFiles[domain] || []),
+    boundary?.currentOwnerFile,
+    ...(boundary?.commandOwnerFiles || []),
+    ...(boundary?.futureOwnerFiles || []),
+  ].filter(Boolean))];
+}
+
+function interactionCommandDomainStats(root, api) {
+  const interactionFile = fileStats(root, api, 'tools/vibe-runtime/runtime-interaction-command.mjs');
+  const textByFile = new Map();
+  const textForFile = (file) => {
+    if (!textByFile.has(file)) textByFile.set(file, fileStats(root, api, file).text || '');
+    return textByFile.get(file);
+  };
+  const functionNamesFromText = (text) => [...String(text || '').matchAll(/^\s*function\s+([A-Za-z][A-Za-z0-9_]*)\s*\(/gm)].map((match) => match[1]);
+  const surfaceText = textForFile('tools/vibe-runtime/runtime-interaction-command.mjs');
+  const domainEntries = Object.entries(runtimeInteractionCommandDomains).map(([domain, spec]) => {
+    const ownerFiles = runtimeInteractionDomainOwnerFiles(domain).filter((file) => api.exists(root, file));
+    const domainText = ownerFiles.map((file) => textForFile(file)).join('\n');
+    const declaredFunctionSet = new Set(functionNamesFromText(domainText));
+    const functions = spec.functions || [];
+    const surfaceExports = spec.surfaceExports || [];
+    const missingFunctions = functions.filter((name) => !declaredFunctionSet.has(name));
+    const missingSurfaceExports = surfaceExports.filter((name) => !new RegExp(`\\b${name}\\b\\s*[:,]`).test(surfaceText));
+    return {
+      domain,
+      ownerFiles,
+      functionCount: functions.length,
+      surfaceExportCount: surfaceExports.length,
+      missingFunctions,
+      missingSurfaceExports,
+      declaredFunctions: [...declaredFunctionSet],
+    };
+  });
+  const declaredFunctionNames = [...new Set(domainEntries.flatMap((entry) => entry.declaredFunctions))];
+  const assignedFunctions = domainEntries.flatMap((entry) => runtimeInteractionCommandDomains[entry.domain].functions || []);
+  const duplicateFunctions = assignedFunctions.filter((name, index) => assignedFunctions.indexOf(name) !== index);
+  const unassignedFunctions = declaredFunctionNames.filter((name) => !assignedFunctions.includes(name));
+  return {
+    interactionFile,
+    declaredFunctionCount: declaredFunctionNames.length,
+    domainCount: domainEntries.length,
+    domainNames: domainEntries.map((entry) => entry.domain),
+    domainEntries,
+    assignedFunctionCount: assignedFunctions.length,
+    duplicateFunctions: [...new Set(duplicateFunctions)].sort(),
+    unassignedFunctions,
+  };
+}
+
+export function checkRuntimeInteractionCommandDomainContracts(root, api) {
+  const stats = interactionCommandDomainStats(root, api);
+  const expectedDomains = ['entryWorkflow', 'methodology', 'completion', 'learning', 'tokens'];
+  const missingDomains = expectedDomains.filter((domain) => !runtimeInteractionCommandDomainNames.includes(domain));
+  const domainGaps = stats.domainEntries.flatMap((entry) => [
+    ...entry.missingFunctions.map((name) => `${entry.domain}:${name}`),
+    ...entry.missingSurfaceExports.map((name) => `${entry.domain}:${name}`),
+  ]);
+
+  if (missingDomains.length === 0 && stats.domainCount >= expectedDomains.length) {
+    api.ok('runtime interaction command domains are declared for staged owner extraction', `domains=${stats.domainNames.join(', ')}`);
+  } else {
+    api.fail('runtime interaction command domain map is incomplete', `missing=${missingDomains.join(', ') || 'none'}; domains=${stats.domainNames.join(', ')}`, 'Keep entryWorkflow, methodology, completion, learning, and tokens visible before splitting command owners.');
+  }
+
+  if (domainGaps.length === 0 && stats.duplicateFunctions.length === 0) {
+    api.ok('runtime interaction command domain map covers declared functions and surface exports', `functions=${stats.assignedFunctionCount}/${stats.declaredFunctionCount}; surfaces=${stats.domainEntries.reduce((total, entry) => total + entry.surfaceExportCount, 0)}`);
+  } else {
+    api.fail('runtime interaction command domain map drifted', `missing=${domainGaps.join(', ') || 'none'}; duplicates=${stats.duplicateFunctions.join(', ') || 'none'}`, 'Update the domain map whenever interaction wrapper functions or returned command surfaces move.');
+  }
+}
+
+function interactionHighRiskSidecarGaps(root, api) {
+  const entries = Object.entries(runtimeInteractionHighRiskSidecarBoundaries);
+  const gaps = { entries, missingDomains: ['learning', 'tokens'].filter((domain) => !runtimeInteractionHighRiskSidecarBoundaries[domain]), missingProtected: [], futureLeaks: [], protectedCount: 0 };
+  for (const [domain, spec] of entries) {
+    const approvedOwnerFiles = [
+      spec.currentOwnerFile,
+      ...(spec.commandOwnerFiles || []),
+      ...(spec.artifactOwnerFiles || []),
+    ].filter(Boolean);
+    const approvedTexts = approvedOwnerFiles.map((file) => fileStats(root, api, file).text || '');
+    gaps.protectedCount += spec.protectedFunctions.length;
+    for (const name of spec.protectedFunctions) {
+      const declaredInApprovedOwner = approvedTexts.some((text) => text.includes(`function ${name}(`));
+      if (!declaredInApprovedOwner) gaps.missingProtected.push(`${domain}:${name}`);
+    }
+    for (const file of spec.futureOwnerFiles) if (api.exists(root, file)) {
+      const text = fileStats(root, api, file).text || '';
+      for (const name of spec.protectedFunctions) if (text.includes(name)) gaps.futureLeaks.push(`${file}:${name}`);
+    }
+  } return gaps;
+}
+
+export function checkRuntimeInteractionHighRiskSidecarBoundaryContracts(root, api) {
+  const gaps = interactionHighRiskSidecarGaps(root, api), domainSummary = gaps.entries.map(([domain, spec]) => `${domain}:${spec.protectedFunctions.length}`).join(', ');
+  if (gaps.missingDomains.length === 0 && gaps.entries.length >= 2) api.ok('runtime interaction high-risk sidecar boundaries are declared', `domains=${domainSummary}`);
+  else api.fail('runtime interaction high-risk sidecar boundary map is incomplete', `missing=${gaps.missingDomains.join(', ') || 'none'}`, 'Keep learning and token sidecar migration boundaries explicit before extracting command owners.');
+  if (gaps.missingProtected.length === 0 && gaps.futureLeaks.length === 0) api.ok('runtime interaction high-risk sidecar write and validation chain remains protected', `protected=${gaps.protectedCount}; futureLeaks=0`);
+  else api.fail('runtime interaction high-risk sidecar migration guard regressed', `missing=${gaps.missingProtected.join(', ') || 'none'}; futureLeaks=${gaps.futureLeaks.join(', ') || 'none'}`, 'Do not migrate learning/token sidecar write, validation, path, or digest-sensitive chains without a dedicated staged owner and targeted verification.');
+}
+
+export function checkReadonlySmokeMarkerDataContracts(root, api) {
+  const stats = readonlySmokeMarkerDataStats(root, api);
+  if (!stats.markerDataFile.exists) {
+    api.fail('readonly smoke marker data file missing', '', 'Restore release-check-readonly-marker-data.mjs so smoke marker assertions stay data-driven.');
+    return;
+  }
+
+  const requiredKeys = ['automationReadiness', 'workflowLoopContract', 'planActionManifest', 'selfTestProfile', 'commitReadiness', 'confirmedOneShotPlan', 'tddTrace', 'superpowersGap', 'progressiveEntryUx', 'executablePlan', 'stageRunbook', 'adapterBootstrapMatrix', 'skillRuntimeTraceability', 'experienceLearningPattern', 'adapterEntryAcceptance', 'experienceDashboard', 'superpowersComparison', 'sessionStartShape', 'entryTriggerDiscipline', 'methodologyCoverage', 'superpowersRegressionGuard', 'experienceFriction', 'stageScriptlet'];
+  const missingKeys = requiredKeys.filter((key) => !stats.specText.includes(`${key}: {`));
+  if (missingKeys.length === 0) {
+    api.ok('readonly smoke marker data includes staged fixture specs', `specs=${stats.specCount}; required=${requiredKeys.length}`);
+  } else {
+    api.fail('readonly smoke marker data staged specs incomplete', `Missing spec key(s): ${missingKeys.join(', ')}`, 'Keep large readonly marker groups in release-check-readonly-marker-data.mjs instead of expanding smoke owner files.');
+  }
+
+  if (stats.specCount >= requiredKeys.length
+    && stats.payloadKeyCount === stats.specCount
+    && stats.payloadPrefixCount === stats.specCount
+    && stats.payloadSpecsCount === stats.specCount
+    && stats.boundaryFieldCount === stats.specCount
+    && stats.safetyFieldCount === stats.specCount) {
+    api.ok('readonly smoke marker specs keep payload, boundary, and safety fields aligned', `specs=${stats.specCount}; payloadKey=${stats.payloadKeyCount}; payloadPrefix=${stats.payloadPrefixCount}; payloadSpecs=${stats.payloadSpecsCount}; boundaryFields=${stats.boundaryFieldCount}; safetyFields=${stats.safetyFieldCount}`);
+  } else {
+    api.fail('readonly smoke marker spec shape drifted', `specs=${stats.specCount}; payloadKey=${stats.payloadKeyCount}; payloadPrefix=${stats.payloadPrefixCount}; payloadSpecs=${stats.payloadSpecsCount}; boundaryFields=${stats.boundaryFieldCount}; safetyFields=${stats.safetyFieldCount}`, 'Each readonly smoke marker spec must declare payloadKey, payloadPrefix, payloadSpecs, boundaryFields, and safetyFields.');
+  }
+
+  if (stats.unusedSpecKeys.length === 0 && stats.unknownUsageKeys.length === 0) {
+    api.ok('readonly smoke marker specs are covered by smoke factory calls', `specs=${stats.specCount}; used=${Object.keys(stats.usageByKey).length}; stage103=${stats.stage103MarkerFactoryCalls}; stage121=${stats.stage121MarkerFactoryCalls}`);
+  } else {
+    api.fail('readonly smoke marker spec coverage drifted', `unused=${stats.unusedSpecKeys.join(', ') || 'none'}; unknown=${stats.unknownUsageKeys.join(', ') || 'none'}`, 'Every readonly smoke marker spec must be referenced through readonlySmokeMarkers in a runtime smoke file, and smoke files must not reference unknown spec keys.');
+  }
+
+  if (stats.stage103MarkerFactoryCalls >= 6 && stats.stage121MarkerFactoryCalls >= 4) {
+    api.ok('release smoke files use readonly smoke marker factory calls', `stage103=${stats.stage103MarkerFactoryCalls}; stage121=${stats.stage121MarkerFactoryCalls}`);
+  } else {
+    api.fail('release smoke marker factory coverage regressed', `stage103=${stats.stage103MarkerFactoryCalls}; stage121=${stats.stage121MarkerFactoryCalls}`, 'Keep large readonly marker assertion blocks routed through readonlySmokeMarkers without changing smoke command execution order.');
+  }
+}
+
+function architecturePerformanceFileDiagnostics(budget, stats) {
+  const stableLineGap = Math.max(0, stats.lines - budget.stableLines);
+  const idealLineGap = Math.max(0, stats.lines - budget.idealLines);
+  return {
+    file: budget.file,
+    owner: budget.owner,
+    layer: budget.layer,
+    lines: stats.lines,
+    bytes: stats.bytes,
+    stableTargetLines: budget.stableLines,
+    idealTargetLines: budget.idealLines,
+    stablePassed: stats.lines <= budget.stableLines,
+    idealPassed: stats.lines <= budget.idealLines,
+    stableLineGap,
+    idealLineGap,
+    idealRemainingLines: Math.max(0, budget.idealLines - stats.lines),
+  };
+}
+
+const runtimeInteractionPureModelFiles = ['tools/vibe-runtime/runtime-methodology-route-model.mjs', 'tools/vibe-runtime/runtime-workflow-start-model.mjs', 'tools/vibe-runtime/runtime-methodology-gate-model.mjs', 'tools/vibe-runtime/runtime-workflow-readiness-model.mjs', 'tools/vibe-runtime/runtime-entry-advice-model.mjs', 'tools/vibe-runtime/runtime-human-completion-evidence-model.mjs', 'tools/vibe-runtime/runtime-advice-hub-model.mjs', 'tools/vibe-runtime/runtime-learning-advice-model.mjs', 'tools/vibe-runtime/runtime-learning-observation-model.mjs', 'tools/vibe-runtime/runtime-token-economy-model.mjs', 'tools/vibe-runtime/runtime-workflow-ux-model.mjs'];
+
+const runtimeCliSpecFiles = ['tools/vibe-runtime/runtime-cli-option-defaults.mjs', 'tools/vibe-runtime/runtime-cli-option-handlers.mjs', 'tools/vibe-runtime/runtime-cli-value-options.mjs', 'tools/vibe-runtime/runtime-cli-from-options.mjs', 'tools/vibe-runtime/runtime-cli-evidence-options.mjs'];
+
+export function collectArchitecturePerformanceDiagnostics(root, api) {
+  const trackedFiles = runtimeArchitecturePerformanceBudgets.map((budget) => {
+    const stats = fileStats(root, api, budget.file);
+    return architecturePerformanceFileDiagnostics(budget, stats);
+  });
+  const idealGapFiles = trackedFiles
+    .filter((file) => file.exists !== false)
+    .filter((file) => file.idealLineGap > 0)
+    .sort((left, right) => right.idealLineGap - left.idealLineGap);
+  const totalIdealLineGap = idealGapFiles.reduce((total, file) => total + file.idealLineGap, 0);
+  const topIdealGapFile = idealGapFiles[0] || null;
+
+  const builderFile = fileStats(root, api, 'tools/vibe-runtime/runtime-entry-deps-builder.mjs');
+  const indexFile = fileStats(root, api, 'tools/vibe-runtime/index.mjs');
+  const helperFile = fileStats(root, api, 'tools/vibe-release-check/release-check-json-assertion-helpers.mjs');
+  const stage121Smoke = fileStats(root, api, 'tools/vibe-release-check/release-check-stage121-136-smoke.mjs');
+  const stage103Smoke = fileStats(root, api, 'tools/vibe-release-check/release-check-stage103-118-smoke.mjs');
+  const markerDataStats = readonlySmokeMarkerDataStats(root, api);
+  const presentationCoverage = runtimePresentationCoverageStats(root, api);
+  const interactionDomainStats = interactionCommandDomainStats(root, api);
+
+  return {
+    trackedFiles,
+    idealGapFiles,
+    totalIdealLineGap,
+    topIdealGapFile,
+    interaction: {
+      extractedPureModels: runtimeInteractionPureModelFiles.filter((file) => api.exists(root, file)).length,
+      expectedPureModels: runtimeInteractionPureModelFiles.length,
+      tokenModel: api.exists(root, 'tools/vibe-runtime/runtime-token-economy-model.mjs'),
+      learningAdviceModel: api.exists(root, 'tools/vibe-runtime/runtime-learning-advice-model.mjs'),
+      learningObservationModel: api.exists(root, 'tools/vibe-runtime/runtime-learning-observation-model.mjs'),
+      adviceHubModel: api.exists(root, 'tools/vibe-runtime/runtime-advice-hub-model.mjs'),
+      workflowUxModel: api.exists(root, 'tools/vibe-runtime/runtime-workflow-ux-model.mjs'),
+      files: runtimeInteractionPureModelFiles,
+      domains: interactionDomainStats.domainEntries.map((entry) => ({
+        domain: entry.domain,
+        functions: entry.functionCount,
+        surfaces: entry.surfaceExportCount,
+        missingFunctions: entry.missingFunctions.length,
+        missingSurfaceExports: entry.missingSurfaceExports.length,
+      })),
+      declaredFunctionCount: interactionDomainStats.declaredFunctionCount,
+      assignedFunctionCount: interactionDomainStats.assignedFunctionCount,
+      unassignedFunctionCount: interactionDomainStats.unassignedFunctions.length,
+      duplicateFunctionCount: interactionDomainStats.duplicateFunctions.length,
+    },
+    cliParser: {
+      extractedSpecs: runtimeCliSpecFiles.filter((file) => api.exists(root, file)).length,
+      expectedSpecs: runtimeCliSpecFiles.length,
+      lowRiskFromOptionCalls: countText(indexFile.text, 'parseLowRiskRuntimeCliFromOption') + countText(fileStats(root, api, 'tools/vibe-runtime/runtime-cli-args.mjs').text, 'parseLowRiskRuntimeCliFromOption'),
+      files: runtimeCliSpecFiles,
+    },
+    smokeAssertions: {
+      helperForbiddenFlagChecks: countText(helperFile.text, 'runForbiddenFlagChecks'),
+      markerDataFactorySpecs: markerDataStats.specCount,
+      markerDataSpecKeys: markerDataStats.specKeys,
+      markerDataUsedSpecKeys: Object.keys(markerDataStats.usageByKey).sort(),
+      markerDataUnusedSpecKeys: markerDataStats.unusedSpecKeys,
+      markerDataUnknownUsageKeys: markerDataStats.unknownUsageKeys,
+      markerDataPayloadKeys: markerDataStats.payloadKeyCount,
+      markerDataPayloadPrefixes: markerDataStats.payloadPrefixCount,
+      markerDataPayloadSpecs: markerDataStats.payloadSpecsCount,
+      markerDataBoundaryFields: markerDataStats.boundaryFieldCount,
+      markerDataSafetyFields: markerDataStats.safetyFieldCount,
+      markerDataFactoryExports: countText(helperFile.text, 'readonlySmokeMarkers') + countText(helperFile.text, 'readonlySmokeMarkerSpecKeys'),
+      adapterEntryAcceptanceUsage: markerDataStats.usageByKey.adapterEntryAcceptance || 0,
+      adapterBootstrapMatrixUsage: markerDataStats.usageByKey.adapterBootstrapMatrix || 0,
+      skillRuntimeTraceabilityUsage: markerDataStats.usageByKey.skillRuntimeTraceability || 0,
+      experienceLearningPatternUsage: markerDataStats.usageByKey.experienceLearningPattern || 0,
+      entryTriggerDisciplineUsage: markerDataStats.usageByKey.entryTriggerDiscipline || 0,
+      tddTraceUsage: markerDataStats.usageByKey.tddTrace || 0,
+      superpowersGapUsage: markerDataStats.usageByKey.superpowersGap || 0,
+      progressiveEntryUxUsage: markerDataStats.usageByKey.progressiveEntryUx || 0,
+      executablePlanUsage: markerDataStats.usageByKey.executablePlan || 0,
+      stageRunbookUsage: markerDataStats.usageByKey.stageRunbook || 0,
+      stage121ForbiddenLoops: countText(stage121Smoke.text, 'for (const forbidden'),
+      stage121HelperCalls: countText(stage121Smoke.text, 'runForbiddenFlagChecks'),
+      stage121MarkerFactoryCalls: markerDataStats.stage121MarkerFactoryCalls,
+      stage103ForbiddenLoops: countText(stage103Smoke.text, 'for (const forbidden'),
+      stage103HelperCalls: countText(stage103Smoke.text, 'runForbiddenFlagChecks'),
+      stage103MarkerFactoryCalls: markerDataStats.stage103MarkerFactoryCalls,
+    },
+    presentation: {
+      registryFiles: presentationCoverage.registryCount,
+      minimumRegistryFiles: presentationCoverage.minimumRegistryFiles,
+      existingFiles: presentationCoverage.existingCount,
+      factoryExports: presentationCoverage.factoryExportCount,
+      interactionPresentationDelegates: presentationCoverage.interactionPresentationDelegateCount,
+      expectedInteractionPresentationDelegates: presentationCoverage.interactionPresentationDelegates.length,
+      missingFiles: presentationCoverage.missingFiles,
+      invalidManifestEntries: presentationCoverage.invalidManifestEntries,
+      missingPresentationDelegates: presentationCoverage.missingPresentationDelegates,
+    },
+    dependencyBuilder: {
+      exportedBuilders: countText(builderFile.text, 'export function createRuntime'),
+      indexBuilderCalls: ['createRuntimeInteractionCommandDeps', 'createRuntimeGovernanceCommandDeps', 'createRuntimeWorkflowCommandDeps', 'createRuntimeTokensCommandDeps']
+        .reduce((total, name) => total + countText(indexFile.text, `${name}({`), 0),
+      hasTokensBuilder: builderFile.text?.includes('createRuntimeTokensCommandDeps') === true,
+      hasWorkflowBuilder: builderFile.text?.includes('createRuntimeWorkflowCommandDeps') === true,
+    },
+  };
+}

package/tools/vibe-runtime-check/runtime-experience-cli-contract-specs.mjs

@@ -0,0 +1,98 @@
+export const EXPERIENCE_CLI_CONTRACTS = [
+  {
+    markers: ['governance --experience-dashboard', 'governanceExperienceDashboard', 'experienceRegressionDashboardEnvelope', 'printExperienceRegressionDashboard', 'runtimeExperienceRegressionDashboard', 'runtime-experience-regression-dashboard', 'experience_regression_dashboard', 'experience-regression-dashboard', 'dashboard_digest', 'Dashboard digest', 'experience_dashboard_artifact=false', 'regression_dashboard_artifact=false', 'experience_scorecard', 'superpowers_comparison_delta', 'token_savior_delta', 'learning_loop_delta', 'daily_user_friction_delta', 'regression_blockers', 'next_bet', 'command_execution=false', 'check_execution=false', 'smoke_execution=false', 'test_execution=false', 'git=false', 'git_write=false', 'subagent=false', 'Stage 132'],
+    okLabel: 'tools/vibe-runtime/index.mjs supports Stage 132 experience regression dashboard boundaries',
+    failLabel: 'tools/vibe-runtime/index.mjs Stage 132 experience dashboard markers incomplete',
+    fix: 'Keep governance --experience-dashboard, local contract aggregation, digest output, and no execution/write/git/subagent boundary synchronized.',
+  },
+  {
+    markers: ['governance --superpowers-comparison', 'governanceSuperpowersComparison', 'superpowersComparisonEnvelope', 'printSuperpowersComparisonMatrix', 'runtimeSuperpowersComparisonMatrix', 'runtime-superpowers-comparison-matrix', 'superpowers_comparison_matrix', 'superpowers-comparative-evidence-matrix', 'comparison_digest', 'Superpowers comparison digest', 'superpowers_comparison_artifact=false', 'comparison_matrix_artifact=false', 'parity_gaps', 'vibecoding_advantages', 'borrowable_patterns', 'do_not_copy', 'recommended_stage_sequence', 'next_comparison_bet', 'superpowers_comparison_invariants', 'command_execution=false', 'check_execution=false', 'smoke_execution=false', 'test_execution=false', 'hook_execution=false', 'git=false', 'git_write=false', 'subagent=false', 'Stage 133'],
+    okLabel: 'tools/vibe-runtime/index.mjs supports Stage 133 Superpowers comparison boundaries',
+    failLabel: 'tools/vibe-runtime/index.mjs Stage 133 Superpowers comparison markers incomplete',
+    fix: 'Keep governance --superpowers-comparison, local source matrix output, digest output, and no execution/write/git/subagent boundary synchronized.',
+  },
+  {
+    markers: ['platforms --session-start-shape', 'platformsSessionStartShape', 'sessionStartShapeAcceptanceEnvelope', 'runtimeSessionStartShapeAcceptance', 'runtime-session-start-shape-acceptance', 'runtime-platform-acceptance-command', 'runSessionStartShapeAcceptanceCommand', 'printSessionStartShapeAcceptance', 'session_start_shape_acceptance', 'session-start-shape-acceptance', 'shape_digest', 'Shape blockers', 'session_start_shape_artifact=false', 'captured_output_write=false', 'adapter_output_shape', 'context_present', 'using_vibecoding_marker', 'lightweight_routing_marker', 'boundary_declaration_marker', 'no_full_skill_injection', 'no_forbidden_trigger', 'adapter_execution=false', 'hook_execution=false', 'workflow_execution=false', 'skill_execution=false', 'command_execution=false', 'git=false', 'git_write=false', 'subagent=false', 'Stage 134'],
+    okLabel: 'tools/vibe-runtime/index.mjs supports Stage 134 session-start shape boundaries',
+    failLabel: 'tools/vibe-runtime/index.mjs Stage 134 session-start shape markers incomplete',
+    fix: 'Keep platforms --session-start-shape, captured output shape gate, digest output, and no execution/write/git/subagent boundary synchronized.',
+  },
+  {
+    markers: ['workflow --entry-discipline', 'workflowEntryDiscipline', 'entryTriggerDisciplineEnvelope', 'printEntryTriggerDiscipline', 'runtimeEntryTriggerDiscipline', 'runtime-entry-trigger-discipline', 'entry_trigger_discipline', 'entry-trigger-discipline-contract', 'discipline_digest', 'Entry discipline digest', 'entry_discipline_artifact=false', 'transcript_write=false', 'using_vibecoding_first', 'protocol_layers_declared', 'intent_route_match', 'no_direct_implementation_jump', 'no_blind_bug_fix', 'no_false_skill_claim', 'no_forbidden_trigger', 'workflow_execution=false', 'skill_execution=false', 'command_execution=false', 'git=false', 'git_write=false', 'subagent=false', 'Stage 135'],
+    okLabel: 'tools/vibe-runtime/index.mjs supports Stage 135 entry trigger discipline boundaries',
+    failLabel: 'tools/vibe-runtime/index.mjs Stage 135 entry trigger discipline markers incomplete',
+    fix: 'Keep workflow --entry-discipline, local transcript gate output, digest output, and no execution/write/git/subagent boundary synchronized.',
+  },
+  {
+    markers: ['methodology --coverage-map', 'methodologyCoverageMap', 'methodologyCoverageEnvelope', 'printMethodologyCoverageMap', 'runtimeMethodologyCoverageMap', 'runtime-methodology-coverage-map', 'methodology_coverage_map', 'methodology-coverage-map', 'coverage_digest', 'Coverage digest', 'methodology_coverage_artifact=false', 'coverage_map_artifact=false', 'covered_patterns', 'partial_patterns', 'missing_patterns', 'vibecoding_specific_patterns', 'coverage_summary', 'next_coverage_bet', 'methodology_coverage_invariants', 'command_execution=false', 'check_execution=false', 'smoke_execution=false', 'test_execution=false', 'hook_execution=false', 'adapter_execution=false', 'workflow_execution=false', 'skill_execution=false', 'skill_mutation=false', 'git=false', 'git_write=false', 'subagent=false', 'Stage 136'],
+    okLabel: 'tools/vibe-runtime/index.mjs supports Stage 136 methodology coverage boundaries',
+    failLabel: 'tools/vibe-runtime/index.mjs Stage 136 methodology coverage markers incomplete',
+    fix: 'Keep methodology --coverage-map, local source coverage map output, digest output, and no execution/write/git/subagent boundary synchronized.',
+  },
+  {
+    markers: ['platforms --install-experience', 'platformsInstallExperience', 'installExperienceEnvelope', 'printInstallExperience', 'runtimeInstallExperienceScore', 'runtime-install-experience-score', 'runtime-install-experience-command', 'runInstallExperienceCommand', 'install_experience_score', 'hook-adapter-install-experience-score', 'install_experience_digest', 'Install experience score', 'Manual steps remaining', 'Docs friction', 'install_experience_artifact=false', 'bootstrap_matrix_artifact: false', 'entry_acceptance_artifact: false', 'natural_entry_score', 'adapter_consistency_score', 'adapter_scores', 'manual_steps_remaining', 'docs_friction', 'adapter_install=false', 'adapter_execution=false', 'hook_execution=false', 'workflow_execution=false', 'skill_execution=false', 'command_execution=false', 'git=false', 'git_write=false', 'subagent=false', 'Stage 137'],
+    okLabel: 'tools/vibe-runtime/index.mjs supports Stage 137 install experience score boundaries',
+    failLabel: 'tools/vibe-runtime/index.mjs Stage 137 install experience markers incomplete',
+    fix: 'Keep platforms --install-experience, local evidence score output, digest output, and no install/execution/write/git/subagent boundary synchronized.',
+  },
+  {
+    markers: ['evals --superpowers-style-pack', 'evalsSuperpowersStylePack', 'superpowersStyleEvalPackEnvelope', 'printSuperpowersStyleEvalPack', 'runtimeSuperpowersStyleEvalPack', 'runtime-superpowers-style-eval-pack', 'superpowers_style_eval_pack', 'superpowers-style-behavioral-eval-scenario-pack', 'eval_pack_digest', 'Eval pack digest', 'scenario_pack', 'scenario_summary', 'scenario_ids', 'eval_pack_artifact=false', 'scenario_artifact=false', 'comparison_artifact=false', 'eval_execution=false', 'agent_session_execution=false', 'workflow_execution=false', 'skill_execution=false', 'model_invocation=false', 'git=false', 'git_write=false', 'subagent=false', 'Stage 138'],
+    okLabel: 'tools/vibe-runtime/index.mjs supports Stage 138 Superpowers-style eval pack boundaries',
+    failLabel: 'tools/vibe-runtime/index.mjs Stage 138 eval pack markers incomplete',
+    fix: 'Keep evals --superpowers-style-pack, local scenario pack output, digest output, and no eval/model/session/git/subagent boundary synchronized.',
+  },
+  {
+    markers: ['governance --experience-upgrades', 'governanceExperienceUpgrades', 'experienceUpgradePrioritizerEnvelope', 'printExperienceUpgradePrioritizer', 'runtimeExperienceUpgradePrioritizer', 'runtime-experience-upgrade-prioritizer', 'runtime-experience-upgrade-command', 'runExperienceUpgradePrioritizerCommand', 'experience_upgrade_prioritizer', 'experience-upgrade-prioritizer', 'upgrade_digest', 'Upgrade digest', 'upgrade_candidates', 'recommended_stage_order', 'defer', 'prioritization_policy', 'next_upgrade_bet', 'upgrade_artifact=false', 'prioritizer_artifact=false', 'comparison_artifact=false', 'dashboard_artifact=false', 'install_experience_artifact=false', 'eval_execution=false', 'workflow_execution=false', 'skill_execution=false', 'prompt_mutation=false', 'hook_registration=false', 'model_invocation=false', 'git=false', 'git_write=false', 'subagent=false', 'Stage 139'],
+    okLabel: 'tools/vibe-runtime/index.mjs supports Stage 139 experience upgrade prioritizer boundaries',
+    failLabel: 'tools/vibe-runtime/index.mjs Stage 139 experience upgrade markers incomplete',
+    fix: 'Keep governance --experience-upgrades, local upgrade prioritizer output, digest output, and no execution/write/git/subagent boundary synchronized.',
+  },
+  {
+    markers: ['governance --superpowers-parity-scorecard', 'governanceSuperpowersParityScorecard', 'superpowersParityScorecardEnvelope', 'printSuperpowersParityScorecard', 'runtime-superpowers-parity-command', '--from-entry-discipline', '--from-upgrades', 'Stage 140'],
+    okLabel: 'tools/vibe-runtime/index.mjs wires Stage 140 Superpowers parity scorecard command',
+    failLabel: 'tools/vibe-runtime/index.mjs Stage 140 parity scorecard command wiring incomplete',
+    fix: 'Keep governance --superpowers-parity-scorecard CLI parsing and dispatch wired to the Stage 140 command module.',
+  },
+  {
+    markers: ['workflow --entry-tightening', 'workflowEntryTightening', 'fromDiscipline', 'fromScorecard', 'runEntryTriggerTighteningCommand', 'entryTriggerTighteningEnvelope', 'runtimeEntryTriggerTightening', 'runtime-entry-trigger-tightening', 'runtime-entry-trigger-tightening-command', 'entry_trigger_tightening', 'entry-trigger-tightening-contract', 'tightening_score', 'missing_entry_moves', 'recommended_opening_sentence', 'must_not_skip', 'tightening_digest', 'Tightening digest', 'entry_tightening_artifact=false', 'entry_trigger_tightening_artifact=false', 'prompt_mutation=false', 'template_mutation=false', 'skill_mutation=false', 'hook_execution=false', 'adapter_execution=false', 'workflow_execution=false', 'skill_execution=false', 'command_execution=false', 'git=false', 'git_write=false', 'subagent=false', 'Stage 141'],
+    okLabel: 'tools/vibe-runtime/index.mjs wires Stage 141 entry trigger tightening command',
+    failLabel: 'tools/vibe-runtime/index.mjs Stage 141 entry trigger tightening command wiring incomplete',
+    fix: 'Keep workflow --entry-tightening CLI parsing and dispatch wired to the Stage 141 command/core modules without moving domain logic into index.mjs.',
+  },
+  {
+    markers: ['workflow --next-evidence-prompts', 'workflowNextEvidencePrompts', 'fromConsole', 'fromDashboard', 'fromUpgrades', 'runNextActionEvidencePromptsCommand', 'runtimeNextActionEvidencePrompts', 'runtime-next-action-evidence-prompts', 'runtime-next-action-evidence-prompts-command', 'next_action_evidence_prompts', 'next-action-evidence-prompts', 'evidence_prompt_cards', 'copy_ready_validation_notes', 'blocked_until', 'prompts_digest', 'Prompts digest', 'next_action_evidence_prompts_artifact=false', 'evidence_prompt_artifact=false', 'evidence_write=false', 'validation_note_write=false', 'prompt_mutation=false', 'template_mutation=false', 'skill_mutation=false', 'workflow_execution=false', 'skill_execution=false', 'command_execution=false', 'git=false', 'git_write=false', 'subagent=false', 'Stage 143'],
+    okLabel: 'tools/vibe-runtime/index.mjs wires Stage 143 next-action evidence prompts command',
+    failLabel: 'tools/vibe-runtime/index.mjs Stage 143 next-action evidence prompts command wiring incomplete',
+    fix: 'Keep workflow --next-evidence-prompts CLI parsing and dispatch wired to the Stage 143 command/core modules without moving domain logic into index.mjs.',
+  },
+  {
+    markers: ['tokens --entry-defaults', 'tokensEntryDefaults', 'fromBudget', 'fromScorecard', 'runContextBudgetEntryDefaultsCommand', 'runtimeContextBudgetEntryDefaults', 'runtime-context-budget-entry-defaults', 'runtime-context-budget-entry-defaults-command', 'context_budget_entry_defaults', 'context-budget-entry-defaults', 'recommended_profile', 'surface_now', 'defer_until_needed', 'token_saving_boundary', 'entry_defaults_digest', 'Entry defaults digest', 'context_budget_entry_defaults_artifact=false', 'entry_defaults_artifact=false', 'prompt_mutation=false', 'template_mutation=false', 'skill_mutation=false', 'full_skill_injection=false', 'workflow_execution=false', 'skill_execution=false', 'command_execution=false', 'embeddings=false', 'remote_config=false', 'git=false', 'git_write=false', 'subagent=false', 'Stage 144'],
+    okLabel: 'tools/vibe-runtime/index.mjs wires Stage 144 context budget entry defaults command',
+    failLabel: 'tools/vibe-runtime/index.mjs Stage 144 context budget entry defaults command wiring incomplete',
+    fix: 'Keep tokens --entry-defaults CLI parsing and dispatch wired to the Stage 144 command/core modules without moving domain logic into index.mjs.',
+  },
+  {
+    markers: ['evals --local-behavior-contracts', 'evalsLocalBehaviorContracts', 'fromStylePack', 'fromEntryTightening', 'runLocalBehaviorEvalContractsCommand', 'runtimeLocalBehaviorEvalContracts', 'runtime-local-behavior-eval-contracts', 'runtime-local-behavior-eval-contracts-command', 'local_behavior_eval_contracts', 'local-behavior-eval-contracts', 'contract_cases', 'deterministic_judges', 'live_eval_deferred', 'visible_entry_route_judge', 'evidence_before_completion_judge', 'forbidden_action_boundary_judge', 'deterministic_contract_only_judge', 'false_skill_claim_judge', 'over_workflow_discipline_judge', 'evidence_free_completion_judge', 'contracts_digest', 'Contracts digest', 'local_behavior_eval_contracts_artifact=false', 'behavior_contract_artifact=false', 'style_pack_artifact=false', 'entry_tightening_artifact=false', 'eval_execution=false', 'live_eval_execution=false', 'agent_session_execution=false', 'model_judge_execution=false', 'prompt_mutation=false', 'template_mutation=false', 'skill_mutation=false', 'workflow_execution=false', 'skill_execution=false', 'command_execution=false', 'git=false', 'git_write=false', 'subagent=false', 'Stage 145'],
+    okLabel: 'tools/vibe-runtime/index.mjs wires Stage 145 local behavior eval contracts command',
+    failLabel: 'tools/vibe-runtime/index.mjs Stage 145 local behavior eval contracts command wiring incomplete',
+    fix: 'Keep evals --local-behavior-contracts CLI parsing and dispatch wired to the Stage 145 command/core modules without moving domain logic into index.mjs.',
+  },
+  {
+    markers: ['governance --contributor-guardrails', 'governanceContributorGuardrails', 'fromEvidencePrompts', 'runContributorGuardrailCommand', 'runtimeContributorGuardrailEvidence', 'runtime-contributor-guardrail-evidence', 'runtime-contributor-guardrail-command', 'contributor_guardrail_evidence', 'contributor-guardrail-evidence', 'guardrail_findings', 'required_disclosures', 'unsafe_closeout_risks', 'closeout_contract', 'validation-evidence-required', 'no-remote-pr-review-search', 'no-auto-repair-from-evidence', 'guardrail_digest', 'Guardrail digest', 'contributor_guardrail_evidence_artifact=false', 'guardrail_artifact=false', 'parity_scorecard_artifact=false', 'evidence_prompts_artifact=false', 'remote_pr_search=false', 'remote_review_search=false', 'command_execution=false', 'check_execution=false', 'test_execution=false', 'workflow_execution=false', 'runtime_action=false', 'auto_execution=false', 'repair_execution=false', 'auto_fix=false', 'git=false', 'git_write=false', 'subagent=false', 'Stage 146'],
+    okLabel: 'tools/vibe-runtime/index.mjs wires Stage 146 contributor guardrail evidence command',
+    failLabel: 'tools/vibe-runtime/index.mjs Stage 146 contributor guardrail evidence command wiring incomplete',
+    fix: 'Keep governance --contributor-guardrails CLI parsing and dispatch wired to the Stage 146 command/core modules without moving domain logic into index.mjs.',
+  },
+  {
+    markers: ['governance --subagent-permission', 'governanceSubagentPermission', 'fromGuardrails', 'runSubagentPermissionCommand', 'runtimeSubagentPermissionVisibility', 'runtime-subagent-permission-visibility', 'runtime-subagent-permission-command', 'subagent_permission_visibility', 'subagent-permission-visibility', 'permission_gate', 'brief_requirements', 'must_ask_user_first', 'visibility_contract', 'explicit-user-permission', 'brief-completeness', 'no-hidden-dispatch', 'permission_digest', 'Permission digest', 'subagent_permission_visibility_artifact=false', 'permission_artifact=false', 'guardrail_artifact=false', 'parity_scorecard_artifact=false', 'brief_artifact=false', 'dispatch_artifact=false', 'session_artifact=false', 'subagent_dispatch=false', 'subagent_session=false', 'session_create=false', 'command_execution=false', 'check_execution=false', 'test_execution=false', 'workflow_execution=false', 'runtime_action=false', 'auto_execution=false', 'auto_dispatch=false', 'git=false', 'git_write=false', 'subagent=false', 'Stage 147'],
+    okLabel: 'tools/vibe-runtime/index.mjs wires Stage 147 subagent permission visibility command',
+    failLabel: 'tools/vibe-runtime/index.mjs Stage 147 subagent permission visibility command wiring incomplete',
+    fix: 'Keep governance --subagent-permission CLI parsing and dispatch wired to the Stage 147 command/core modules without moving domain logic into index.mjs.',
+  },
+  {
+    markers: ['platforms --adapter-packaging-consistency', 'platformsAdapterPackagingConsistency', 'fromSessionExamples', 'runAdapterPackagingConsistencyCommand', 'runtimeAdapterPackagingConsistency', 'runtime-adapter-packaging-consistency', 'runtime-adapter-packaging-consistency-command', 'adapter_packaging_consistency', 'adapter-packaging-consistency-checklist', 'adapter_rows', 'missing_install_markers', 'copy_ready_fix_notes', 'consistency_digest', 'Consistency digest', 'adapter_packaging_consistency_artifact=false', 'bootstrap_matrix_artifact=false', 'session_start_example_pack_artifact=false', 'adapter_row_artifact=false', 'fix_note_artifact=false', 'adapter_install=false', 'adapter_execution=false', 'hook_execution=false', 'manifest_write=false', 'plugin_manifest_write=false', 'install_doc_write=false', 'command_execution=false', 'check_execution=false', 'test_execution=false', 'workflow_execution=false', 'runtime_action=false', 'auto_execution=false', 'repair_execution=false', 'auto_fix=false', 'git=false', 'git_write=false', 'subagent=false', 'Stage 148'],
+    okLabel: 'tools/vibe-runtime/index.mjs wires Stage 148 adapter packaging consistency command',
+    failLabel: 'tools/vibe-runtime/index.mjs Stage 148 adapter packaging consistency command wiring incomplete',
+    fix: 'Keep platforms --adapter-packaging-consistency CLI parsing and dispatch wired to the Stage 148 command/core modules without moving domain logic into index.mjs.',
+  },
+];

package/tools/vibe-runtime-check/runtime-experience-cli-contracts.mjs

@@ -0,0 +1,12 @@
+import { EXPERIENCE_CLI_CONTRACTS } from './runtime-experience-cli-contract-specs.mjs';
+
+export function checkRuntimeExperienceCliContracts(api, cliSurfaceText) {
+  for (const contract of EXPERIENCE_CLI_CONTRACTS) {
+    const missingMarkers = contract.markers.filter((marker) => !cliSurfaceText.includes(marker));
+    if (missingMarkers.length === 0) {
+      api.ok(contract.okLabel);
+    } else {
+      api.fail(contract.failLabel, `Missing marker(s): ${missingMarkers.join(', ')}`, contract.fix);
+    }
+  }
+}