@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime-check/runtime-capability-registry-contracts.mjs

@@ -0,0 +1,299 @@
+import { checkMarkers } from './marker-contract-core.mjs';
+
+const CAPABILITY_REGISTRY_FILE = 'tools/vibe-runtime/runtime-capability-registry.mjs';
+
+const CAPABILITY_REGISTRY_CONTRACTS = [
+  {
+    markers: ['runtimeCapabilityRegistry', 'runtimeCapabilityRegistryInvariants', "registry_stage: 'Stage 101'", "registry_kind: 'runtime-capability-registry'", 'registry_version', 'capability_groups', 'stage_inventory', 'closeout_chain', 'boundary_assertions', 'capability_registry_artifact: false', 'command_execution: false', 'runtime_action: false', 'workflow_execution: false', 'verification_execution: false', 'git: false', 'push: false', 'pr: false', 'merge: false', 'Stage 101'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs defines Stage 101 runtime capability registry boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 101 markers incomplete',
+    fix: 'Keep Stage 101 capability registry data, invariant checks, digest inputs, and no execution/git/platform boundary synchronized.',
+  },
+  {
+    markers: ['runtimeCapabilityRegistryDriftGuard', 'runtimeCapabilityRegistryDriftGuardMarkerExpectations', 'runtime-capability-registry-drift-guard', 'doc_marker_expectations', 'surface registry mismatch', 'Stage 102', 'runtime_registry_drift_guard', 'drift_guard_digest'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs defines Stage 102 registry drift guard expectations',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 102 drift guard markers incomplete',
+    fix: 'Keep Stage 102 registry drift guard checks and marker expectations synchronized with governance --surface --drift-guard.',
+  },
+  {
+    markers: ['Stage 103', 'automation', 'automation --readiness', 'runtime automation readiness matrix', 'runtime capability registry drift guard'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 103 automation readiness inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 103 automation readiness markers incomplete',
+    fix: 'Keep Stage 103 automation readiness listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['Stage 104', 'workflow --loop-contract', 'workflow loop contract', 'read-only workflow UX, choreography, and loop contract'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 104 workflow loop contract inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 104 workflow loop contract markers incomplete',
+    fix: 'Keep Stage 104 workflow loop contract listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 105', 'planner --action-manifest', 'plan-to-action manifest', 'workflow method orientation, plan lint, and read-only plan-to-action manifest'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 105 plan-to-action manifest inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 105 plan-to-action manifest markers incomplete',
+    fix: 'Keep Stage 105 planner action manifest listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 106', 'verification --self-test-profile', 'self-test gate profile', 'read-only self-test gate profile; recommends checks but never runs them'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 106 self-test gate profile inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 106 self-test gate profile markers incomplete',
+    fix: 'Keep Stage 106 verification self-test profile listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 107', 'release --commit-readiness', 'commit readiness envelope', 'explicit release evidence and read-only commit readiness only'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 107 commit readiness inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 107 commit readiness markers incomplete',
+    fix: 'Keep Stage 107 release commit readiness listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 108', 'automation --one-shot-plan', 'confirmed one-shot execution plan', 'confirmed one-shot plan contract'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 108 confirmed one-shot plan inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 108 confirmed one-shot plan markers incomplete',
+    fix: 'Keep Stage 108 automation one-shot plan listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 109', 'workflow --close-loop-dashboard', 'close-loop dashboard', 'read-only workflow UX, choreography, loop contract, and close-loop dashboard only; no execution'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 109 close-loop dashboard inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 109 close-loop dashboard markers incomplete',
+    fix: 'Keep Stage 109 workflow close-loop dashboard listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 110', 'verification --evidence-intake', 'evidence intake envelope', 'read-only self-test gate profile and evidence intake'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 110 evidence intake inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 110 evidence intake markers incomplete',
+    fix: 'Keep Stage 110 verification evidence intake listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 111', 'release --diff-coverage', 'diff coverage envelope', 'read-only diff coverage'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 111 diff coverage inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 111 diff coverage markers incomplete',
+    fix: 'Keep Stage 111 release diff coverage listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 112', 'review --intake', 'review --resolution', 'review intake and resolution envelope', 'read-only review intake and review resolution'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 112 review inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 112 review markers incomplete',
+    fix: 'Keep Stage 112 review intake and resolution listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 113', 'verification --tdd-trace', 'TDD trace contract', 'read-only self-test gate profile, evidence intake, TDD trace contract, and execution evidence binding'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 113 TDD trace inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 113 TDD trace markers incomplete',
+    fix: 'Keep Stage 113 verification TDD trace listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 114', 'workflow --close-loop', 'workflow --next-evidence', 'human-friendly close-loop alias', 'human-friendly next evidence alias', 'read-only workflow UX, choreography, loop contract, human-friendly aliases, progressive entry UX, and one-screen next action console only; no execution'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 114 human-friendly alias inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 114 alias markers incomplete',
+    fix: 'Keep Stage 114 workflow aliases listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 115', 'governance --superpowers-gap', 'Superpowers gap matrix', 'Stage 115 superpowers gap matrix reads local comparison sources only and never writes state'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 115 Superpowers gap matrix inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 115 Superpowers gap markers incomplete',
+    fix: 'Keep Stage 115 governance Superpowers gap matrix listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 116', 'workflow --entry-ux', 'progressive entry UX contract', 'one-screen next action console only; no execution'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 116 progressive entry UX inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 116 progressive entry UX markers incomplete',
+    fix: 'Keep Stage 116 workflow entry UX listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 117', 'planner --executable-plan', 'executable plan quality contract', 'read-only executable plan quality contract'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 117 executable plan quality inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 117 executable plan markers incomplete',
+    fix: 'Keep Stage 117 planner executable plan contract listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 118', 'automation --stage-runbook', 'sequential stage runbook', 'read-only sequential stage runbook only; no automation execution'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 118 sequential stage runbook inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 118 runbook markers incomplete',
+    fix: 'Keep Stage 118 automation stage runbook listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 119', 'verification --execution-evidence', 'execution evidence binding', 'execution evidence binds local Stage 118 runbook evidence without running commands or writing state'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 119 execution evidence binding inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 119 execution evidence markers incomplete',
+    fix: 'Keep Stage 119 verification execution evidence binding listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 120', 'release --staged-commit-readiness', 'staged commit readiness contract', 'staged commit readiness binds local runbook and execution evidence without committing'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 120 staged commit readiness inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 120 staged commit readiness markers incomplete',
+    fix: 'Keep Stage 120 release staged commit readiness listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 121', 'evals --behavior-contract', 'behavioral evaluation contract', 'Stage 121 behavioral evaluation contract reads a local transcript artifact and writes nothing'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 121 behavioral evaluation contract inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 121 behavioral evaluation markers incomplete',
+    fix: 'Keep Stage 121 evals behavior contract listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 123', 'governance --traceability-map', 'skill-to-runtime traceability map', 'Stage 123 skill-to-runtime traceability map reads local skill files and the runtime registry only'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 123 skill-to-runtime traceability inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 123 traceability markers incomplete',
+    fix: 'Keep Stage 123 governance traceability map listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 124', 'completion --evidence-bundle', 'human completion evidence bundle', 'Stage 124 human one-screen completion evidence bundle'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 124 human completion evidence bundle inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 124 human completion evidence markers incomplete',
+    fix: 'Keep Stage 124 completion evidence bundle listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 125', 'governance --superpowers-regression-guard', 'Superpowers regression guard', 'Stage 125 Superpowers regression guard aggregates local Stage 115-124 governance signals'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 125 Superpowers regression guard inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 125 Superpowers regression guard markers incomplete',
+    fix: 'Keep Stage 125 governance regression guard listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 126', 'governance --experience-friction', 'experience friction matrix', 'Stage 126 experience friction matrix reads one local session evidence JSON'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 126 experience friction matrix inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 126 experience friction markers incomplete',
+    fix: 'Keep Stage 126 governance experience friction matrix listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 127', 'workflow --next-action-console', 'one-screen next action console', 'read-only workflow UX, choreography, loop contract, human-friendly aliases, progressive entry UX, and one-screen next action console only'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 127 one-screen next action console inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 127 next action console markers incomplete',
+    fix: 'Keep Stage 127 workflow next action console listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 128', 'tokens --savior-budget', 'Token Savior entry budget contract', 'deterministic local token economy; Stage 128 Token Savior entry budget recommends prompt/friction-bound context budgets'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 128 Token Savior budget inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 128 Token Savior budget markers incomplete',
+    fix: 'Keep Stage 128 tokens savior budget listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 129', 'learning --experience-pattern', 'ECC learning experience pattern gate', 'candidate-only pattern extraction from local friction and observations'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 129 ECC learning experience pattern inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 129 experience learning pattern markers incomplete',
+    fix: 'Keep Stage 129 learning experience pattern gate listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 130', 'automation --stage-scriptlet', 'copy-ready stage execution scriptlet', 'Stage 130 copy-ready scriptlet preview only'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 130 copy-ready scriptlet inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 130 stage scriptlet markers incomplete',
+    fix: 'Keep Stage 130 automation stage scriptlet listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 131', 'platforms --entry-acceptance', 'adapter entry acceptance contract', 'Stage 131 adapter entry acceptance reads one local transcript contract only'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 131 adapter entry acceptance inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 131 adapter entry acceptance markers incomplete',
+    fix: 'Keep Stage 131 platforms entry acceptance listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 132', 'governance --experience-dashboard', 'experience regression dashboard', 'Stage 132 experience regression dashboard aggregates local Stage 126-129 experience contracts'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 132 experience dashboard inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 132 experience dashboard markers incomplete',
+    fix: 'Keep Stage 132 governance experience dashboard listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 133', 'governance --superpowers-comparison', 'Superpowers comparative evidence matrix', 'Stage 133 Superpowers comparative evidence matrix reads local fork/superpowers and Vibecoding source files'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 133 Superpowers comparison inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 133 Superpowers comparison markers incomplete',
+    fix: 'Keep Stage 133 governance Superpowers comparison listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 134', 'platforms --session-start-shape', 'session-start output shape acceptance', 'Stage 134 session-start shape acceptance reads one local captured session-start output only'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 134 session-start shape acceptance inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 134 session-start shape markers incomplete',
+    fix: 'Keep Stage 134 platforms session-start shape acceptance listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 135', 'workflow --entry-discipline', 'entry trigger discipline contract', 'Stage 135 entry trigger discipline reads one local transcript JSON only'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 135 entry trigger discipline inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 135 entry trigger discipline markers incomplete',
+    fix: 'Keep Stage 135 workflow entry trigger discipline listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 136', 'methodology --coverage-map', 'methodology coverage map', 'Stage 136 methodology coverage map only'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 136 methodology coverage inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 136 methodology coverage markers incomplete',
+    fix: 'Keep Stage 136 methodology coverage map listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 137', 'platforms --install-experience', 'hook and adapter install experience score', 'Stage 137 install experience score reads local Stage 122 bootstrap matrix JSON and Stage 131 entry acceptance JSON only'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 137 install experience inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 137 install experience markers incomplete',
+    fix: 'Keep Stage 137 platforms install experience listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 138', 'evals --superpowers-style-pack', 'Superpowers-style behavioral eval scenario pack', 'Stage 138 Superpowers-style behavior scenario pack reads one local Stage 133 comparison JSON only'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 138 eval scenario pack inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 138 eval pack markers incomplete',
+    fix: 'Keep Stage 138 eval scenario pack listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 139', 'governance --experience-upgrades', 'experience upgrade prioritizer', 'Stage 139 experience upgrade prioritizer reads local Stage 133 comparison'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 139 experience upgrade prioritizer inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 139 experience upgrade markers incomplete',
+    fix: 'Keep Stage 139 governance experience upgrades listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 140', 'governance --superpowers-parity-scorecard', 'Superpowers parity scorecard v2', 'Stage 140 Superpowers parity scorecard reads local Stage 133 comparison'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 140 Superpowers parity scorecard inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 140 parity scorecard markers incomplete',
+    fix: 'Keep Stage 140 governance Superpowers parity scorecard listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 141', 'workflow --entry-tightening', 'entry trigger tightening contract', 'Stage 141 entry trigger tightening reads local Stage 135 entry discipline JSON'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 141 entry trigger tightening inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 141 entry trigger tightening markers incomplete',
+    fix: 'Keep Stage 141 workflow entry trigger tightening listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 142', 'platforms --session-start-examples', 'session-start example pack', 'Stage 142 session-start example pack reads local Stage 134 shape acceptance JSON'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 142 session-start example pack inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 142 session-start example pack markers incomplete',
+    fix: 'Keep Stage 142 platforms session-start examples listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 143', 'workflow --next-evidence-prompts', 'next-action evidence prompts', 'Stage 143 next-action evidence prompts read local Stage 127 console'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 143 next-action evidence prompts inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 143 next-action evidence prompt markers incomplete',
+    fix: 'Keep Stage 143 workflow next-evidence-prompts listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 144', 'tokens --entry-defaults', 'context budget entry defaults', 'Stage 144 context budget entry defaults read local Stage 128 token budget JSON'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 144 context budget entry defaults inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 144 context budget entry defaults markers incomplete',
+    fix: 'Keep Stage 144 tokens entry-defaults listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 145', 'evals --local-behavior-contracts', 'local behavior eval contracts', 'Stage 145 local behavior eval contracts read local Stage 138 scenario pack JSON'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 145 local behavior eval contracts inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 145 local behavior eval contracts markers incomplete',
+    fix: 'Keep Stage 145 evals local-behavior-contracts listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 146', 'governance --contributor-guardrails', 'contributor guardrail evidence', 'Stage 146 contributor guardrail evidence reads local Stage 140 parity scorecard JSON'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 146 contributor guardrail evidence inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 146 contributor guardrail evidence markers incomplete',
+    fix: 'Keep Stage 146 governance contributor-guardrails listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 147', 'governance --subagent-permission', 'subagent permission visibility', 'Stage 147 subagent permission visibility reads local Stage 140 parity scorecard JSON'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 147 subagent permission visibility inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 147 subagent permission visibility markers incomplete',
+    fix: 'Keep Stage 147 governance subagent-permission listed in the registry capability groups and stage inventory.',
+  },
+  {
+    markers: ['registry_version: 47', 'Stage 148', 'platforms --adapter-packaging-consistency', 'adapter packaging consistency checklist', 'Stage 148 adapter packaging consistency reads local Stage 122 bootstrap matrix JSON'],
+    okLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs exposes Stage 148 adapter packaging consistency inventory',
+    failLabel: 'tools/vibe-runtime/runtime-capability-registry.mjs Stage 148 adapter packaging consistency markers incomplete',
+    fix: 'Keep Stage 148 platforms adapter-packaging-consistency listed in the registry capability groups and stage inventory.',
+  },
+];
+
+export function checkRuntimeCapabilityRegistryContracts(root, api) {
+  if (!api.exists(root, CAPABILITY_REGISTRY_FILE)) {
+    api.fail('tools/vibe-runtime/runtime-capability-registry.mjs missing', '', 'Restore the Stage 101 runtime capability registry source-of-truth module.');
+    return;
+  }
+
+  for (const contract of CAPABILITY_REGISTRY_CONTRACTS) {
+    checkMarkers(root, api, CAPABILITY_REGISTRY_FILE, contract.markers, contract.okLabel, contract.failLabel, contract.fix);
+  }
+}

package/tools/vibe-runtime-check/runtime-check-diagnostics-presentation.mjs

@@ -0,0 +1,71 @@
+import { formatReleaseCheckInstallPlacementDiagnostics } from './release-check-install-placement-contracts.mjs';
+
+function printSourceReaderDiagnostics(sourceReader) {
+  const stats = sourceReader.stats();
+  console.log('');
+  console.log('Source reader diagnostics');
+  console.log(`exists: hits=${stats.exists.hits}, misses=${stats.exists.misses}, cached=${stats.exists.cached}`);
+  console.log(`readText: hits=${stats.readText.hits}, misses=${stats.readText.misses}, skippedMissing=${stats.readText.skippedMissing}, cached=${stats.readText.cached}`);
+}
+
+function formatTrackedFileDiagnostic(file) {
+  return `file: ${file.file}; lines=${file.lines}; bytes=${file.bytes}; layer=${file.layer}; stable=${file.stableTargetLines}; stablePassed=${file.stablePassed}; stableGap=${file.stableLineGap}; ideal=${file.idealTargetLines}; idealPassed=${file.idealPassed}; idealGap=${file.idealLineGap}; idealRemaining=${file.idealRemainingLines}`;
+}
+
+function printIdealGapDiagnostics(diagnostics) {
+  if (diagnostics.idealGapFiles?.length <= 0) return;
+  const topIdealGaps = diagnostics.idealGapFiles
+    .map((file) => `${file.file}:${file.idealLineGap}`)
+    .join(', ');
+  console.log(`idealGaps: ${topIdealGaps}`);
+  console.log(`idealGapSummary: files=${diagnostics.idealGapFiles.length}; total=${diagnostics.totalIdealLineGap}; top=${diagnostics.topIdealGapFile?.file || 'none'}:${diagnostics.topIdealGapFile?.idealLineGap || 0}`);
+}
+
+function formatInteractionDiagnostics(interaction) {
+  const domainSummary = (interaction.domains || [])
+    .map((entry) => `${entry.domain}:${entry.functions}/${entry.surfaces}`)
+    .join(', ');
+  return `interaction: pureModels=${interaction.extractedPureModels}/${interaction.expectedPureModels}; tokenModel=${interaction.tokenModel}; learningAdviceModel=${interaction.learningAdviceModel}; learningObservationModel=${interaction.learningObservationModel}; adviceHubModel=${interaction.adviceHubModel}; workflowUxModel=${interaction.workflowUxModel}; domainFunctions=${interaction.assignedFunctionCount}/${interaction.declaredFunctionCount}; unassigned=${interaction.unassignedFunctionCount}; duplicate=${interaction.duplicateFunctionCount}; domains=${domainSummary}`;
+}
+
+function formatCliParserDiagnostics(cliParser) {
+  return `cliParser: specs=${cliParser.extractedSpecs}/${cliParser.expectedSpecs}; lowRiskFromOptionCalls=${cliParser.lowRiskFromOptionCalls}`;
+}
+
+function formatSmokeAssertionDiagnostics(smokeAssertions) {
+  return `smokeAssertions: markerDataFactorySpecs=${smokeAssertions.markerDataFactorySpecs}; markerDataUsedSpecKeys=${smokeAssertions.markerDataUsedSpecKeys.length}; markerDataUnusedSpecKeys=${smokeAssertions.markerDataUnusedSpecKeys.length}; markerDataUnknownUsageKeys=${smokeAssertions.markerDataUnknownUsageKeys.length}; markerDataPayloadKeys=${smokeAssertions.markerDataPayloadKeys}; markerDataPayloadPrefixes=${smokeAssertions.markerDataPayloadPrefixes}; markerDataPayloadSpecs=${smokeAssertions.markerDataPayloadSpecs}; markerDataBoundaryFields=${smokeAssertions.markerDataBoundaryFields}; markerDataSafetyFields=${smokeAssertions.markerDataSafetyFields}; adapterEntryAcceptanceUsage=${smokeAssertions.adapterEntryAcceptanceUsage}; adapterBootstrapMatrixUsage=${smokeAssertions.adapterBootstrapMatrixUsage}; skillRuntimeTraceabilityUsage=${smokeAssertions.skillRuntimeTraceabilityUsage}; experienceLearningPatternUsage=${smokeAssertions.experienceLearningPatternUsage}; entryTriggerDisciplineUsage=${smokeAssertions.entryTriggerDisciplineUsage}; tddTraceUsage=${smokeAssertions.tddTraceUsage}; superpowersGapUsage=${smokeAssertions.superpowersGapUsage}; progressiveEntryUxUsage=${smokeAssertions.progressiveEntryUxUsage}; executablePlanUsage=${smokeAssertions.executablePlanUsage}; stageRunbookUsage=${smokeAssertions.stageRunbookUsage}; stage121MarkerFactoryCalls=${smokeAssertions.stage121MarkerFactoryCalls}; stage103MarkerFactoryCalls=${smokeAssertions.stage103MarkerFactoryCalls}; stage121HelperCalls=${smokeAssertions.stage121HelperCalls}; stage121ForbiddenLoops=${smokeAssertions.stage121ForbiddenLoops}; stage103HelperCalls=${smokeAssertions.stage103HelperCalls}; stage103ForbiddenLoops=${smokeAssertions.stage103ForbiddenLoops}`;
+}
+
+function formatPresentationDiagnostics(presentation) {
+  return `presentation: files=${presentation.existingFiles}/${presentation.registryFiles}; minimum=${presentation.minimumRegistryFiles}; factoryExports=${presentation.factoryExports}; interactionDelegates=${presentation.interactionPresentationDelegates}/${presentation.expectedInteractionPresentationDelegates}; missingFiles=${presentation.missingFiles.length}; invalidManifestEntries=${presentation.invalidManifestEntries.length}; missingDelegates=${presentation.missingPresentationDelegates.length}`;
+}
+
+function formatDependencyBuilderDiagnostics(dependencyBuilder) {
+  return `dependencyBuilder: exportedBuilders=${dependencyBuilder.exportedBuilders}; indexBuilderCalls=${dependencyBuilder.indexBuilderCalls}; tokens=${dependencyBuilder.hasTokensBuilder}; workflow=${dependencyBuilder.hasWorkflowBuilder}`;
+}
+
+function printArchitecturePerformanceDiagnostics(diagnostics) {
+  if (!diagnostics) return;
+  console.log('');
+  console.log('Architecture performance diagnostics');
+  for (const file of diagnostics.trackedFiles) {
+    console.log(formatTrackedFileDiagnostic(file));
+  }
+  printIdealGapDiagnostics(diagnostics);
+  console.log(formatInteractionDiagnostics(diagnostics.interaction));
+  console.log(formatCliParserDiagnostics(diagnostics.cliParser));
+  console.log(formatSmokeAssertionDiagnostics(diagnostics.smokeAssertions));
+  console.log(formatPresentationDiagnostics(diagnostics.presentation));
+  console.log(formatDependencyBuilderDiagnostics(diagnostics.dependencyBuilder));
+}
+
+function printInstallPlacementDiagnostics(diagnostics) {
+  const line = formatReleaseCheckInstallPlacementDiagnostics(diagnostics);
+  if (line) console.log(line);
+}
+
+export function printRuntimeCheckDiagnostics(options) {
+  printSourceReaderDiagnostics(options.sourceReader);
+  printArchitecturePerformanceDiagnostics(options.architecturePerformanceDiagnostics);
+  printInstallPlacementDiagnostics(options.installPlacementDiagnostics);
+}

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

@@ -0,0 +1,156 @@
+const ledgerPathMarker = ['.vibecoding', '-state'].join('');
+const highRiskFromOptionCommandParts = [['sou', 'rce'], ['mer', 'ge'], ['exec', 'ute'], ['exec', 'ution'], ['exec', 'utions'], ['sche', 'duler'], ['dae', 'mon'], ['qu', 'eue'], ['re', 'try'], ['lea', 'se'], ['lea', 'ses']];
+const highRiskFromOptionTermParts = [['app', 'ly'], ['dis', 'patch'], ['con', 'firm'], ['r', 'un'], ['auto', 'Run'], ['auto', '-run'], ...highRiskFromOptionCommandParts];
+const highRiskFromOptionCommands = new Set(highRiskFromOptionCommandParts.map((parts) => parts.join('')));
+const highRiskFromOptionTerms = highRiskFromOptionTermParts.map((parts) => parts.join(''));
+
+function extractOptionSpecBlocks(text, exportName) {
+  const match = text.match(new RegExp(`${exportName}\\s*=\\s*\\[([\\s\\S]*?)\\];`));
+  return match ? match[1].split(/\n\s*},\s*\n\s*{/).map((block) => block.replace(/^\s*{/, '').replace(/}\s*$/, '')).filter((block) => block.includes('arg:')) : [];
+}
+
+function extractFromOptionSpecBlocks(text) {
+  return extractOptionSpecBlocks(text, 'runtimeCliFromOptionSpecs');
+}
+
+function extractEvidenceOptionSpecBlocks(text) {
+  return extractOptionSpecBlocks(text, 'runtimeCliEvidenceOptionSpecs');
+}
+
+function extractStringField(block, field) {
+  const match = block.match(new RegExp(`${field}:\\s*'([^']*)'`));
+  return match ? match[1] : '';
+}
+
+function extractCommandFields(block) {
+  const match = block.match(/commands:\s*\[([^\]]*)\]/);
+  return match ? [...match[1].matchAll(/'([^']+)'/g)].map((entry) => entry[1]) : [];
+}
+
+function hasHighRiskFromOptionSemantic(block) {
+  const arg = extractStringField(block, 'arg');
+  const option = extractStringField(block, 'option');
+  const commands = extractCommandFields(block);
+  const fieldText = [arg, option, ...commands]
+    .join(' ')
+    .toLowerCase()
+    .replaceAll('release', '');
+  return commands.some((command) => highRiskFromOptionCommands.has(command))
+    || highRiskFromOptionTerms.some((term) => fieldText.includes(term.toLowerCase()));
+}
+
+export function checkRuntimeCliSurfaceContracts(root, api, { cliDispatchText, cliSurfaceText }) {
+  const ledgerCommandText = api.exists(root, 'tools/vibe-runtime/runtime-workflow-ledger-command.mjs')
+    ? api.readText(root, 'tools/vibe-runtime/runtime-workflow-ledger-command.mjs')
+    : '';
+  const ledgerSurfaceText = `${cliSurfaceText}\n${ledgerCommandText}`;
+  const dispatchMarkers = ['runtimeCommandNames', 'runtimeCommandHandlers', 'dispatchRuntimeCommand', 'Unknown command:', 'governance', 'release', 'tasks', 'reset'];
+  const missingDispatchMarkers = dispatchMarkers.filter((marker) => !cliDispatchText.includes(marker));
+  if (missingDispatchMarkers.length === 0) {
+    api.ok('tools/vibe-runtime/runtime-cli-dispatch.mjs defines CLI dispatch surface');
+  } else {
+    api.fail('tools/vibe-runtime/runtime-cli-dispatch.mjs dispatch markers incomplete', `Missing marker(s): ${missingDispatchMarkers.join(', ')}`, 'Keep CLI command names and dispatch validation centralized after splitting index.mjs.');
+  }
+
+  const stage2Markers = ['record-handoff', ledgerPathMarker, 'next only supports --dry-run', 'reset requires --confirm'];
+  const missingStage2 = stage2Markers.filter((marker) => !ledgerSurfaceText.includes(marker));
+  if (missingStage2.length === 0) {
+    api.ok('tools/vibe-runtime/runtime-workflow-ledger-command.mjs preserves Stage 2 command boundaries');
+  } else {
+    api.fail('tools/vibe-runtime/runtime-workflow-ledger-command.mjs Stage 2 boundaries incomplete', `Missing marker(s): ${missingStage2.join(', ')}`, 'Keep vibe-runtime limited to explicit ledger writes, dry-run next, and confirmed reset.');
+  }
+
+  const stage3Markers = ['parseJsonHandoff', 'parseLegacyHandoff', 'JSON handoff', 'Vibecoding Runtime Next Step', "status: 'ready'", 'Action: no skill was executed.', 'Action: status is read-only. No workflow state was changed.', 'Handoff quality:', 'Action: handoff was recorded. No next skill was executed.'];
+  const missingStage3 = stage3Markers.filter((marker) => !ledgerSurfaceText.includes(marker));
+  if (missingStage3.length === 0) {
+    api.ok('tools/vibe-runtime/runtime-workflow-ledger-command.mjs supports Stage 3 JSON-first handoff parsing');
+  } else {
+    api.fail('tools/vibe-runtime/runtime-workflow-ledger-command.mjs Stage 3 JSON handoff parsing incomplete', `Missing marker(s): ${missingStage3.join(', ')}`, 'Keep record-handoff JSON-first while preserving legacy fallback parsing.');
+  }
+
+  if (api.exists(root, 'tools/vibe-runtime/runtime-cli-usage.mjs')) {
+    const text = api.readText(root, 'tools/vibe-runtime/runtime-cli-usage.mjs');
+    const cliUsageMarkers = ['export function usage', 'Vibecoding Runtime', 'Usage:', 'governance --superpowers-parity-scorecard', 'governance --contributor-guardrails', 'governance --subagent-permission', 'platforms --adapter-packaging-consistency', 'tokens --savior-budget', 'tokens --entry-defaults', 'evals --local-behavior-contracts', 'Options:', '--help'];
+    const missingCliUsage = cliUsageMarkers.filter((marker) => !text.includes(marker));
+    if (missingCliUsage.length === 0) {
+      api.ok('tools/vibe-runtime/runtime-cli-usage.mjs defines CLI usage surface');
+    } else {
+      api.fail('tools/vibe-runtime/runtime-cli-usage.mjs CLI usage markers incomplete', `Missing marker(s): ${missingCliUsage.join(', ')}`, 'Keep CLI usage text centralized in runtime-cli-usage.mjs while preserving command discovery markers.');
+    }
+  } else {
+    api.fail('tools/vibe-runtime/runtime-cli-usage.mjs missing', '', 'Restore the runtime CLI usage module.');
+  }
+
+  if (api.exists(root, 'tools/vibe-runtime/runtime-cli-args.mjs')) {
+    const text = api.readText(root, 'tools/vibe-runtime/runtime-cli-args.mjs');
+    const defaultsText = api.exists(root, 'tools/vibe-runtime/runtime-cli-option-defaults.mjs')
+      ? api.readText(root, 'tools/vibe-runtime/runtime-cli-option-defaults.mjs')
+      : '';
+    const handlersText = api.exists(root, 'tools/vibe-runtime/runtime-cli-option-handlers.mjs')
+      ? api.readText(root, 'tools/vibe-runtime/runtime-cli-option-handlers.mjs')
+      : '';
+    const valueOptionsText = api.exists(root, 'tools/vibe-runtime/runtime-cli-value-options.mjs')
+      ? api.readText(root, 'tools/vibe-runtime/runtime-cli-value-options.mjs')
+      : '';
+    const fromOptionsText = api.exists(root, 'tools/vibe-runtime/runtime-cli-from-options.mjs')
+      ? api.readText(root, 'tools/vibe-runtime/runtime-cli-from-options.mjs')
+      : '';
+    const evidenceOptionsText = api.exists(root, 'tools/vibe-runtime/runtime-cli-evidence-options.mjs')
+      ? api.readText(root, 'tools/vibe-runtime/runtime-cli-evidence-options.mjs')
+      : '';
+    const evidenceOptionSpecsText = api.exists(root, 'tools/vibe-runtime/runtime-cli-evidence-option-specs.mjs')
+      ? api.readText(root, 'tools/vibe-runtime/runtime-cli-evidence-option-specs.mjs')
+      : '';
+    const lowRiskOptionSpecsText = api.exists(root, 'tools/vibe-runtime/runtime-cli-low-risk-option-specs.mjs')
+      ? api.readText(root, 'tools/vibe-runtime/runtime-cli-low-risk-option-specs.mjs')
+      : '';
+    const cliArgsSurfaceText = `${text}\n${defaultsText}\n${handlersText}\n${valueOptionsText}\n${fromOptionsText}\n${evidenceOptionsText}\n${evidenceOptionSpecsText}\n${lowRiskOptionSpecsText}`;
+    const cliArgsMarkers = ['export function parseArgs', 'createRuntimeCliDefaultOptions', 'parseLowRiskRuntimeCliOption', 'parseLowRiskRuntimeCliValueOption', 'parseLowRiskRuntimeCliFromOption', 'parseLowRiskRuntimeCliEvidenceOption', 'runtimeCliFromOptionSpecs', 'runtimeCliEvidenceOptionSpecs', "risk: 'low'", 'process.cwd()', 'path.resolve', 'validateTaskId', 'governanceSuperpowersParityScorecard', 'governanceContributorGuardrails', 'governanceSubagentPermission', 'platformsAdapterPackagingConsistency', 'fromComparison', 'fromEntryDiscipline', 'fromInstallExperience', 'fromUpgrades', 'workflowEntryTightening', 'workflowNextEvidencePrompts', 'tokensEntryDefaults', 'fromBudget', 'evalsLocalBehaviorContracts', 'fromStylePack', 'fromEntryTightening', 'fromDiscipline', 'fromScorecard', 'fromEvidencePrompts', 'fromGuardrails', 'fromSessionExamples', 'fromConsole', 'fromDashboard'];
+    const missingCliArgs = cliArgsMarkers.filter((marker) => !cliArgsSurfaceText.includes(marker));
+    if (missingCliArgs.length === 0) {
+      api.ok('tools/vibe-runtime/runtime-cli-args.mjs defines CLI args parsing surface');
+    } else {
+      api.fail('tools/vibe-runtime/runtime-cli-args.mjs CLI args markers incomplete', `Missing marker(s): ${missingCliArgs.join(', ')}`, 'Keep CLI parsing in runtime-cli-args.mjs, default option fields in runtime-cli-option-defaults.mjs, and low-risk flag handlers in runtime-cli-option-handlers.mjs.');
+    }
+
+    const fromOptionSpecBlocks = extractFromOptionSpecBlocks(fromOptionsText);
+    const evidenceOptionSpecBlocks = extractEvidenceOptionSpecBlocks(evidenceOptionSpecsText || evidenceOptionsText);
+    const allLowRiskSpecBlocks = [...fromOptionSpecBlocks, ...evidenceOptionSpecBlocks];
+    const fromOptionRouteIndex = text.indexOf('parseLowRiskRuntimeCliFromOption(options, argv, index)');
+    const evidenceOptionRouteIndex = text.indexOf('parseLowRiskRuntimeCliEvidenceOption(options, argv, index)');
+    const valueOptionRouteIndex = text.indexOf('parseLowRiskRuntimeCliValueOption(options, argv, index)');
+    const unknownArgumentIndex = text.indexOf('Unknown argument:');
+    if (
+      fromOptionSpecBlocks.length > 0
+      && evidenceOptionSpecBlocks.length > 0
+      && fromOptionRouteIndex >= 0
+      && evidenceOptionRouteIndex > fromOptionRouteIndex
+      && valueOptionRouteIndex > evidenceOptionRouteIndex
+      && unknownArgumentIndex > fromOptionRouteIndex
+    ) {
+      api.ok('runtime CLI parser routes low-risk from/evidence specs before value fallback and unknown argument handling');
+    } else {
+      api.fail('runtime CLI parser low-risk from/evidence route incomplete', '', 'Keep parseLowRiskRuntimeCliFromOption and parseLowRiskRuntimeCliEvidenceOption in the main parser before value-option fallback while preserving final unknown argument handling.');
+    }
+
+    const missingLowRiskMarkers = allLowRiskSpecBlocks
+      .map((block) => extractStringField(block, 'arg') || '(unknown)')
+      .filter((arg, blockIndex) => !allLowRiskSpecBlocks[blockIndex].includes("risk: 'low'"));
+    if (allLowRiskSpecBlocks.length > 0 && missingLowRiskMarkers.length === 0) {
+      api.ok('runtime CLI low-risk option specs declare every migrated option as low risk');
+    } else {
+      api.fail('runtime CLI low-risk option spec markers incomplete', `Missing risk marker(s): ${missingLowRiskMarkers.join(', ')}`, 'Every option in runtime CLI low-risk option specs must explicitly declare risk: low.');
+    }
+
+    const highRiskSpecArgs = allLowRiskSpecBlocks
+      .filter((block) => hasHighRiskFromOptionSemantic(block))
+      .map((block) => extractStringField(block, 'arg') || '(unknown)');
+    if (highRiskSpecArgs.length === 0) {
+      api.ok('runtime CLI low-risk option specs exclude high-risk execution/write semantics');
+    } else {
+      api.fail('runtime CLI low-risk option specs include high-risk semantics', `High-risk option(s): ${highRiskSpecArgs.join(', ')}`, 'Do not migrate protected execution/write owner semantics into low-risk parser specs.');
+    }
+  } else {
+    api.fail('tools/vibe-runtime/runtime-cli-args.mjs missing', '', 'Restore the runtime CLI args module.');
+  }
+}