@jtf19/vibecoding-kit 0.1.0

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

@@ -0,0 +1,250 @@
+export function runtimeCapabilityRegistry() {
+  return {
+    registry_stage: 'Stage 101',
+    registry_kind: 'runtime-capability-registry',
+    registry_version: 47,
+    boundary_assertions: runtimeCapabilityRegistryBoundaryAssertions(),
+    capability_groups: runtimeCapabilityRegistryCapabilityGroups(),
+    stage_inventory: runtimeCapabilityRegistryStageInventory(),
+    closeout_chain: runtimeCapabilityRegistryCloseoutChain(),
+  };
+}
+
+export function runtimeCapabilityRegistryInvariants(registry) {
+  const groupNames = new Set(registry.capability_groups.map((group) => group.group));
+  const inventoryGroups = registry.stage_inventory
+    .filter((item) => !groupNames.has(item.group))
+    .map((item) => `${item.stage}:${item.group}`);
+  const duplicateStages = registry.stage_inventory
+    .map((item) => `${item.stage}:${item.command}`)
+    .filter((item, index, items) => items.indexOf(item) !== index);
+  const missingCloseoutOrder = registry.closeout_chain.some((item, index) => item.order !== index + 1);
+  const writableBoundaryEntries = Object.entries(registry.boundary_assertions)
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const findings = [
+    ...inventoryGroups.map((item) => `inventory item references unknown group: ${item}`),
+    ...duplicateStages.map((item) => `duplicate stage command inventory item: ${item}`),
+    ...(missingCloseoutOrder ? ['closeout chain order must be contiguous from 1'] : []),
+    ...writableBoundaryEntries.map((item) => `boundary assertion must remain false: ${item}`),
+  ];
+
+  return {
+    pass: findings.length === 0,
+    checked: ['capability_groups', 'stage_inventory', 'closeout_chain', 'boundary_assertions'],
+    findings,
+  };
+}
+
+export function runtimeCapabilityRegistryDriftGuard(registry, surface) {
+  const registryInvariants = runtimeCapabilityRegistryInvariants(registry);
+  const comparisons = [
+    ['registry_stage', surface.registry_stage, registry.registry_stage],
+    ['registry_kind', surface.registry_kind, registry.registry_kind],
+    ['registry_version', surface.registry_version, registry.registry_version],
+    ['surface_stage', surface.stage, 'Stage 100'],
+    ['surface_kind', surface.surface_kind, 'runtime-capability-surface'],
+    ['capability_groups', surface.capability_groups, registry.capability_groups],
+    ['stage_inventory', surface.stage_inventory, registry.stage_inventory],
+    ['closeout_chain', surface.closeout_chain, registry.closeout_chain],
+    ['boundary_assertions', surface.boundary_assertions, registry.boundary_assertions],
+  ];
+  const mismatches = comparisons
+    .filter(([, actual, expected]) => JSON.stringify(actual) !== JSON.stringify(expected))
+    .map(([field]) => `surface registry mismatch: ${field}`);
+  const findings = [
+    ...registryInvariants.findings,
+    ...mismatches,
+  ];
+
+  return {
+    pass: findings.length === 0,
+    checked: [
+      'registry_invariants',
+      'surface_registry_stage',
+      'surface_registry_kind',
+      'surface_registry_version',
+      'surface_stage',
+      'surface_kind',
+      'capability_groups',
+      'stage_inventory',
+      'closeout_chain',
+      'boundary_assertions',
+      'doc_marker_expectations',
+      'runtime_check_marker_expectations',
+      'release_check_smoke_expectations',
+    ],
+    findings,
+    doc_marker_expectations: runtimeCapabilityRegistryDriftGuardMarkerExpectations(),
+  };
+}
+
+function runtimeCapabilityRegistryDriftGuardMarkerExpectations() {
+  return [
+    { file: 'tools/vibe-runtime/README.md', markers: ['Stage 102', 'runtime capability registry drift guard', 'governance --surface --drift-guard', 'runtime_registry_drift_guard', 'runtime-capability-registry-drift-guard'] },
+    { file: 'docs/runtime-roadmap.md', markers: ['Stage 102', 'Runtime Capability Registry Drift Guard', 'governance --surface --drift-guard', 'runtime_registry_drift_guard', 'runtime-capability-registry-drift-guard'] },
+    { file: 'tools/vibe-runtime-check/runtime-capability-registry-contracts.mjs', markers: ['Stage 102', '--drift-guard', 'runtime_registry_drift_guard', 'drift_guard_digest'] },
+    { file: 'tools/vibe-release-check/index.mjs', markers: ['Stage 102', 'governance --surface --drift-guard', 'runtime_registry_drift_guard', 'drift_guard_digest'] },
+  ];
+}
+
+function runtimeCapabilityRegistryBoundaryAssertions() {
+  return {
+    runtime_surface_artifact: false,
+    capability_registry_artifact: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    command_execution: false,
+    runtime_action: false,
+    workflow_execution: false,
+    verification_execution: false,
+    git: false,
+    git_write: false,
+    pr: false,
+    push: false,
+    merge: false,
+    tag: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    daemon: false,
+    worktree: false,
+    business_source_write: false,
+  };
+}
+
+function runtimeCapabilityRegistryCapabilityGroups() {
+  return [
+    { group: 'entry', stages: ['Stage 78', 'Stage 91'], commands: ['entry --advice', 'entry --contract'], boundary: 'read-only workflow entry decision' },
+    { group: 'workflow', stages: ['Stage 83', 'Stage 85', 'Stage 87', 'Stage 92', 'Stage 93', 'Stage 94', 'Stage 95', 'Stage 104', 'Stage 109', 'Stage 114', 'Stage 116', 'Stage 127', 'Stage 135', 'Stage 141', 'Stage 143', 'P7'], commands: ['advice --hub', 'methodology --readiness', 'workflow --cockpit', 'workflow --receipt', 'workflow --start', 'workflow --run-plan', 'workflow --entry-ux', 'workflow --entry-discipline', 'workflow --entry-tightening', 'workflow --next-action-console', 'workflow --next-evidence-prompts', 'workflow --sequence', 'workflow --loop-contract', 'workflow --close-loop-dashboard', 'workflow --close-loop', 'workflow --next-evidence', 'onboarding --brief'], boundary: 'read-only workflow UX, choreography, and loop contract; read-only workflow UX, choreography, loop contract, and close-loop dashboard only; no execution; read-only workflow UX, choreography, loop contract, human-friendly aliases, progressive entry UX, and one-screen next action console only; no execution; P7 workflow run plan selects a skill, required inputs, handoff, stop conditions, evidence requirements, and one controlled single-step plan chain without executing skills, writing evidence/state/source, running commands/checks/tests, git, platform API, model, MCP, or subagent action; Stage 135 entry trigger discipline reads one local transcript JSON only and validates using-vibecoding-first trigger discipline, L0/L1/L2 layering, workflow route fit, and no direct implementation, blind bug fix, false skill claim, auto execution, git, platform API, model, MCP, or subagent action; Stage 141 entry trigger tightening reads local Stage 135 entry discipline JSON and Stage 140 parity scorecard JSON only to recommend missing entry moves, a copy-ready opening sentence, and must-not-skip boundaries without executing workflow skills, mutating prompts/templates/skills/hooks, writing artifacts/state/source, git, platform API, model, MCP, or subagent action; Stage 143 next-action evidence prompts read local Stage 127 console, Stage 132 dashboard, and Stage 139 upgrades JSON only to emit prompt cards, validation notes, and blocked-until conditions without writing evidence, running checks/tests/workflows, mutating prompts/templates/skills, git, platform API, model, MCP, or subagent action' },
+    { group: 'completion', stages: ['Stage 88', 'Stage 99', 'Stage 124', 'P6'], commands: ['completion --readiness', 'completion --evidence-bundle', 'completion --repair-plan'], boundary: 'read-only completion readiness, legacy completion evidence bundle, Stage 124 human one-screen completion evidence bundle, and P6 evidence repair plan sidecar only; no verification execution, source evidence mutation, git, PR, platform API, model, or subagent' },
+    { group: 'verification', stages: ['Stage 106', 'Stage 110', 'Stage 113', 'Stage 119'], commands: ['verification --self-test-profile', 'verification --evidence-intake', 'verification --tdd-trace', 'verification --execution-evidence'], boundary: 'read-only self-test gate profile; recommends checks but never runs them; read-only self-test gate profile and evidence intake; read-only self-test gate profile, evidence intake, TDD trace contract, and execution evidence binding; evidence intake validates local evidence structure without executing checks; TDD trace proves local RED-GREEN-REFACTOR evidence without running tests; execution evidence binds local Stage 118 runbook evidence without running commands or writing state' },
+    { group: 'release', stages: ['Stage 52', 'Stage 65', 'Stage 68', 'Stage 98', 'Stage 107', 'Stage 111', 'Stage 120', 'Stage 151', 'P3', 'P5', 'P13'], commands: ['release --gate', 'release --verify-gate', 'release --notes', 'release --verify-notes', 'release --commit-guard', 'release --commit-readiness', 'release --diff-coverage', 'release --diff-read', 'release --suite-plan', 'release --staged-commit-readiness', 'release --closeout-readiness', 'release --task-commit-readiness', 'release --task-commit'], boundary: 'explicit release evidence and read-only commit readiness only; explicit release evidence, read-only commit readiness, read-only diff coverage, read-only git diff evidence, read-only timing suite plan, read-only staged commit readiness, read-only closeout readiness, and optional task commit gate sidecars only; no git write by advice layers; diff coverage reads a local diff file and plan manifest without calling git; git diff evidence runs only fixed read-only git diff commands and forbids git write or worktree write; timing suite plan reads one local timing JSON and never changes package scripts, suite order, required gate, or failure strictness; staged commit readiness binds local runbook and execution evidence without committing; closeout readiness reads local SDD ledger, test evidence, diff evidence, and task commit readiness to recommend manual next action without git, PR, platform API, model, MCP, or subagent action; task commit gates require superpowers-parity-task-commits and isolated workspace, clean review, passing tests, and non-main branch evidence before writing a local manual-decision sidecar' },
+    { group: 'tests', stages: ['P4'], commands: ['tests --run'], boundary: 'confirmed foreground allowlisted test profile only; no arbitrary shell string, git write, worktree write, hidden run, failure repair, platform API, model, MCP, subagent, or business source write' },
+    { group: 'subagents', stages: ['P8', 'P30'], commands: ['subagents --adapter-dispatch'], boundary: 'confirmed local adapter dispatch artifact only; requires existing subagent dispatch and platform capability artifacts plus a passing P30 explicit permission gate with user consent evidence, complete task brief digest, file boundary evidence, fallback, and review gate; no session creation, platform API, model invocation, hidden handoff, git, worktree, MCP, or business source write' },
+    { group: 'sdd', stages: ['Stage 149', 'P12', 'P16', 'P17', 'P18'], commands: ['sdd --plan', 'sdd --task-brief', 'sdd --review-package', 'sdd --run-loop', 'sdd --evidence-chain', 'sdd --consume-adapter-result'], boundary: 'Superpowers-parity SDD loop owner; plan reads one local implementation plan only; task brief previews read-only and confirmed task brief writes only local markdown plus JSON sidecars; review package uses fixed git read commands for explicit base..head and confirmed writes only local diff markdown plus JSON sidecars; confirmed run-loop writes local progress, task brief if missing, and adapter dispatch sidecars for one pending task only; confirmed evidence-chain runs one fixed allowlisted test profile, reads fixed git diff summaries, and writes local evidence/progress sidecars only; confirmed adapter result consumption reads one local adapter result plus existing SDD dispatch/progress/report artifacts, validates DONE/QUESTIONS/BLOCKED report status, and writes only local progress/consumption sidecars; no runtime subagent invocation, adapter execution, platform API, model invocation, source write, git write, worktree, PR, push, or merge' },
+    { group: 'workspace', stages: ['Stage 150'], commands: ['workspace --isolate-plan', 'workspace --create', 'workspace --status', 'workspace --cleanup-plan'], boundary: 'Superpowers-parity workspace isolation contract; isolate-plan/status/cleanup-plan are read-only; confirmed create writes only local workspace isolation contract sidecars under .vibecoding-state/workspaces and does not create git worktrees, mutate source, run commands/tests, write git, commit, push, PR, merge, invoke models/platform APIs/MCP, or call subagents' },
+    { group: 'source', stages: ['P9'], commands: ['source --patch-plan', 'source --sandbox-apply', 'source --apply-to-worktree'], boundary: 'P9 source patch planning is read-only from a local task artifact; sandbox apply remains explicit-confirm local sidecar only; apply-to-worktree requires explicit confirmation plus a verified approval and delegates to the existing Stage 48 controlled allowlisted apply; no default worktree write, hidden execution, git commit, push, PR, platform API, model, MCP, or subagent action' },
+    { group: 'review', stages: ['Stage 112'], commands: ['review --intake', 'review --resolution'], boundary: 'read-only review intake and review resolution only; consumes local review and evidence files; no reviewer invocation, repair, platform API, git, PR, push, merge, model, MCP, or subagent' },
+    { group: 'governance', stages: ['Stage 56', 'Stage 57', 'Stage 58', 'Stage 59', 'Stage 81', 'Stage 100', 'Stage 101', 'Stage 102', 'Stage 115', 'Stage 123', 'Stage 125', 'Stage 126', 'Stage 132', 'Stage 133', 'Stage 139', 'Stage 140', 'Stage 146', 'Stage 147'], commands: ['governance --compatibility --report', 'governance --pr-readiness', 'governance --pr-review-intake', 'governance --convergence --report', 'governance --superpowers-gap', 'governance --superpowers-regression-guard', 'governance --experience-friction', 'governance --experience-dashboard', 'governance --experience-upgrades', 'governance --superpowers-parity-scorecard', 'governance --contributor-guardrails', 'governance --subagent-permission', 'governance --superpowers-comparison', 'governance --traceability-map', 'governance --advice', 'governance --surface', 'governance --surface --drift-guard'], boundary: 'local governance reports and sidecars only when explicitly confirmed by existing commands; Stage 115 superpowers gap matrix reads local comparison sources only and never writes state; Stage 123 skill-to-runtime traceability map reads local skill files and the runtime registry only, without skill execution or state writes; Stage 125 Superpowers regression guard aggregates local Stage 115-124 governance signals without command execution, state writes, git, platform API, or subagent dispatch; Stage 126 experience friction matrix reads one local session evidence JSON and scores daily-use friction without command execution, state writes, git, platform API, model invocation, or subagent dispatch; Stage 132 experience regression dashboard aggregates local Stage 126-129 experience contracts into a deterministic report-only scorecard without command execution, state writes, git, platform API, model invocation, MCP, or subagent dispatch; Stage 133 Superpowers comparative evidence matrix reads local fork/superpowers and Vibecoding source files to report parity gaps, Vibecoding advantages, borrowable patterns, do-not-copy boundaries, and next comparison bet without command execution, hook execution, state writes, git, platform API, model invocation, MCP, or subagent dispatch; Stage 139 experience upgrade prioritizer reads local Stage 133 comparison, local Stage 132 dashboard, and optional local Stage 137 install experience evidence to rank upgrade candidates and deferrals without executing upgrades, writing artifacts, mutating prompts/hooks/source, git, platform API, model invocation, MCP, or subagent dispatch; Stage 140 Superpowers parity scorecard reads local Stage 133 comparison, Stage 135 entry discipline, Stage 137 install experience, and Stage 139 upgrades JSON to explain absorbed advantages, remaining gaps, do-not-cross boundaries, and the next-cycle bet without writing artifacts, injecting full skills, executing commands/checks/evals/workflows, git, platform API, model invocation, MCP, or subagent dispatch; Stage 146 contributor guardrail evidence reads local Stage 140 parity scorecard JSON and Stage 143 evidence prompts JSON only to emit guardrail findings, required disclosures, unsafe closeout risks, and a non-authorizing closeout contract without PR creation, remote PR/review search, push, merge, command execution, auto-fix, state/source/artifact writes, git, platform API, model, MCP, or subagent action; Stage 147 subagent permission visibility reads local Stage 140 parity scorecard JSON and Stage 146 contributor guardrails JSON only to emit permission gates, brief requirements, must-ask-user-first prompts, and a non-authorizing visibility contract without subagent dispatch/session creation, hidden handoff, command execution, state/source/artifact writes, git, PR, platform API, model, MCP, or worktree action' },
+    { group: 'automation', stages: ['Stage 103', 'Stage 108', 'Stage 118', 'Stage 130', 'Stage 9'], commands: ['automation --readiness', 'automation --one-shot-plan', 'automation --stage-runbook', 'automation --stage-scriptlet'], boundary: 'deterministic automation readiness classification, confirmed one-shot plan contract, read-only sequential stage runbook only; no automation execution; Stage 9 runbook executor preview dry-run only; Stage 130 copy-ready scriptlet preview only; no automation execution, command execution, evidence write, git write, platform API, model, MCP, or subagent' },
+    { group: 'tokens', stages: ['Stage 63', 'Stage 64', 'Stage 79', 'Stage 128', 'Stage 144'], commands: ['tokens --catalog', 'tokens --compact-output', 'tokens --profile', 'tokens --metrics', 'tokens --rewrite-preview', 'tokens --advice', 'tokens --savior-budget', 'tokens --entry-defaults'], boundary: 'deterministic local token economy; Stage 128 Token Savior entry budget recommends prompt/friction-bound context budgets, skill surfacing, deferrals, and command previews without embeddings, model invocation, remote config, dynamic tool execution, command execution, or state writes; Stage 144 context budget entry defaults read local Stage 128 token budget JSON and Stage 140 parity scorecard JSON only to recommend lightweight entry context, deferrals, and token-saving boundaries without embeddings, model invocation, remote config, full skill injection, prompt/template/skill/hook mutation, command/check/test/workflow execution, state/source/artifact writes, git, platform API, MCP, or subagent action' },
+    { group: 'learning', stages: ['Stage 61', 'Stage 62', 'Stage 80', 'Stage 129'], commands: ['learning --observe', 'learning --observe-from-run', 'learning --instincts', 'learning --promote', 'learning --advice', 'learning --experience-pattern'], boundary: 'local evidence learning, read-only run-to-learning preview, and Stage 129 ECC learning experience pattern gate; candidate-only pattern extraction from local friction and observations; no automatic skill mutation, prompt mutation, hook registration, agent-first delegation, platform API, model, git, MCP, or subagent' },
+    { group: 'methodology', stages: ['Stage 32', 'Stage 60', 'Stage 85', 'Stage 86', 'Stage 105', 'Stage 136'], commands: ['methodology --catalog', 'methodology --route', 'methodology --readiness', 'methodology --coverage-map', 'planner --lint', 'planner --action-manifest'], boundary: 'workflow method orientation, plan lint, and read-only plan-to-action manifest, plus Stage 136 methodology coverage map only; Stage 136 reads local fork/superpowers and Vibecoding source files to report covered, partial, missing, and Vibecoding-specific methodology patterns without command execution, hook execution, adapter execution, workflow execution, skill execution, state writes, git, platform API, model, MCP, or subagent dispatch' },
+    { group: 'evals', stages: ['Stage 51', 'Stage 121', 'Stage 138', 'Stage 145', 'P21'], commands: ['evals --catalog', 'evals --run-contract', 'evals --run-scenario', 'evals --run-behavior', 'evals --run-adversarial', 'evals --behavior-contract', 'evals --transcript-intake', 'evals --superpowers-style-pack', 'evals --local-behavior-contracts', 'evals --verify'], boundary: 'Stage 51 local deterministic eval suite sidecars only when explicitly confirmed; Stage 121 behavioral evaluation contract reads a local transcript artifact and writes nothing; Stage 138 Superpowers-style behavior scenario pack reads one local Stage 133 comparison JSON only and emits scenario contracts without eval execution, agent sessions, model judges, command execution, state writes, git, platform API, MCP, or subagents; Stage 145 local behavior eval contracts read local Stage 138 scenario pack JSON and Stage 141 entry tightening JSON only to emit deterministic contract cases, local judge definitions, and live-eval deferrals without running evals, creating agent sessions, invoking model judges, writing artifacts/state/source, mutating prompts/templates/skills/hooks, git, platform API, MCP, or subagent action; P21 platform transcript intake reads one local platform-exported JSON inside --root, normalizes transcript fields, validates boundary markers, and writes nothing without executing transcript commands, connecting platform APIs, invoking models, creating subagents, touching git, or writing source' },
+    { group: 'platforms', stages: ['Stage 41', 'Stage 122', 'Stage 131', 'Stage 134', 'Stage 137', 'Stage 142', 'Stage 148'], commands: ['platforms --catalog', 'platforms --bootstrap-matrix', 'platforms --entry-acceptance', 'platforms --session-start-shape', 'platforms --session-start-examples', 'platforms --adapter-packaging-consistency', 'platforms --install-experience', 'platforms --probe', 'platforms --list', 'platforms --show', 'platforms --verify'], boundary: 'Stage 41 platform capability probes are local contract data; Stage 122 adapter bootstrap conformance matrix reads local adapter manifests and install docs only; Stage 131 adapter entry acceptance reads one local transcript contract only and validates installed-entry transcript expectations; Stage 134 session-start shape acceptance reads one local captured session-start output only and validates adapter-specific context field shape plus lightweight using-vibecoding boundaries; Stage 137 install experience score reads local Stage 122 bootstrap matrix JSON and Stage 131 entry acceptance JSON only to score natural entry, adapter consistency, manual steps remaining, and docs friction; Stage 142 session-start example pack reads local Stage 134 shape acceptance JSON and local Stage 137 install experience JSON only to emit copy-ready adapter output examples, context shapes, and format warnings without writing examples, executing hooks/adapters/workflows/skills/commands/checks/tests, mutating prompts/templates/skills/manifests/docs/source, installing adapters, state writes, git, platform API, model invocation, MCP, subagent, or worktree action; Stage 148 adapter packaging consistency reads local Stage 122 bootstrap matrix JSON and local Stage 142 session-start examples JSON only to emit adapter rows, missing install markers, and copy-ready fix notes without installing adapters, executing hooks/adapters/commands/checks/tests/workflows, mutating plugin manifests/install docs/source/prompts/templates/skills, writing state/artifacts, git, platform API, model invocation, MCP, subagent, or worktree action' },
+    { group: 'planner', stages: ['Stage 117'], commands: ['planner --executable-plan'], boundary: 'read-only executable plan quality contract; scores local plan structure without execution, repair, state writes, git, platform API, model, MCP, or subagent' },
+  ];
+}
+
+function runtimeCapabilityRegistryStageInventory() {
+  return [
+    { stage: 'Stage 78', capability: 'entry advice', command: 'entry --advice', group: 'entry' },
+    { stage: 'Stage 79', capability: 'token advice', command: 'tokens --advice', group: 'tokens' },
+    { stage: 'Stage 128', capability: 'Token Savior entry budget contract', command: 'tokens --savior-budget', group: 'tokens' },
+    { stage: 'Stage 144', capability: 'context budget entry defaults', command: 'tokens --entry-defaults', group: 'tokens' },
+    { stage: 'Stage 129', capability: 'ECC learning experience pattern gate', command: 'learning --experience-pattern', group: 'learning' },
+    { stage: 'Stage 80', capability: 'learning advice', command: 'learning --advice', group: 'learning' },
+    { stage: 'Stage 81', capability: 'governance advice', command: 'governance --advice', group: 'governance' },
+    { stage: 'Stage 83', capability: 'unified advice hub', command: 'advice --hub', group: 'workflow' },
+    { stage: 'Stage 85', capability: 'workflow readiness gate', command: 'methodology --readiness', group: 'workflow' },
+    { stage: 'Stage 86', capability: 'plan lint', command: 'planner --lint', group: 'methodology' },
+    { stage: 'Stage 87', capability: 'workflow cockpit', command: 'workflow --cockpit', group: 'workflow' },
+    { stage: 'Stage 88', capability: 'completion readiness', command: 'completion --readiness', group: 'completion' },
+    { stage: 'Stage 90', capability: 'completion readiness closeout', command: 'completion --readiness', group: 'completion' },
+    { stage: 'Stage 91', capability: 'entry contract', command: 'entry --contract', group: 'entry' },
+    { stage: 'Stage 92', capability: 'visible workflow receipt', command: 'workflow --receipt', group: 'workflow' },
+    { stage: 'Stage 93', capability: 'unified workflow start', command: 'workflow --start', group: 'workflow' },
+    { stage: 'P7', capability: 'workflow skill run plan', command: 'workflow --run-plan', group: 'workflow' },
+    { stage: 'Stage 94', capability: 'workflow sequence', command: 'workflow --sequence', group: 'workflow' },
+    { stage: 'Stage 95', capability: 'onboarding brief', command: 'onboarding --brief', group: 'workflow' },
+    { stage: 'Stage 104', capability: 'workflow loop contract', command: 'workflow --loop-contract', group: 'workflow' },
+    { stage: 'Stage 109', capability: 'close-loop dashboard', command: 'workflow --close-loop-dashboard', group: 'workflow' },
+    { stage: 'Stage 114', capability: 'human-friendly close-loop alias', command: 'workflow --close-loop', group: 'workflow' },
+    { stage: 'Stage 114', capability: 'human-friendly next evidence alias', command: 'workflow --next-evidence', group: 'workflow' },
+    { stage: 'Stage 116', capability: 'progressive entry UX contract', command: 'workflow --entry-ux', group: 'workflow' },
+    { stage: 'Stage 127', capability: 'one-screen next action console', command: 'workflow --next-action-console', group: 'workflow' },
+    { stage: 'Stage 135', capability: 'entry trigger discipline contract', command: 'workflow --entry-discipline', group: 'workflow' },
+    { stage: 'Stage 141', capability: 'entry trigger tightening contract', command: 'workflow --entry-tightening', group: 'workflow' },
+    { stage: 'Stage 143', capability: 'next-action evidence prompts', command: 'workflow --next-evidence-prompts', group: 'workflow' },
+    { stage: 'Stage 98', capability: 'commit title guard', command: 'release --commit-guard', group: 'release' },
+    { stage: 'Stage 99', capability: 'completion evidence bundle', command: 'completion --evidence-bundle', group: 'completion' },
+    { stage: 'Stage 124', capability: 'human completion evidence bundle', command: 'completion --evidence-bundle', group: 'completion' },
+    { stage: 'P6', capability: 'evidence repair plan', command: 'completion --repair-plan', group: 'completion' },
+    { stage: 'Stage 100', capability: 'runtime capability surface', command: 'governance --surface', group: 'governance' },
+    { stage: 'Stage 101', capability: 'runtime capability registry', command: 'governance --surface', group: 'governance' },
+    { stage: 'Stage 102', capability: 'runtime capability registry drift guard', command: 'governance --surface --drift-guard', group: 'governance' },
+    { stage: 'Stage 115', capability: 'Superpowers gap matrix', command: 'governance --superpowers-gap', group: 'governance' },
+    { stage: 'Stage 123', capability: 'skill-to-runtime traceability map', command: 'governance --traceability-map', group: 'governance' },
+    { stage: 'Stage 125', capability: 'Superpowers regression guard', command: 'governance --superpowers-regression-guard', group: 'governance' },
+    { stage: 'Stage 126', capability: 'experience friction matrix', command: 'governance --experience-friction', group: 'governance' },
+    { stage: 'Stage 132', capability: 'experience regression dashboard', command: 'governance --experience-dashboard', group: 'governance' },
+    { stage: 'Stage 133', capability: 'Superpowers comparative evidence matrix', command: 'governance --superpowers-comparison', group: 'governance' },
+    { stage: 'Stage 139', capability: 'experience upgrade prioritizer', command: 'governance --experience-upgrades', group: 'governance' },
+    { stage: 'Stage 140', capability: 'Superpowers parity scorecard v2', command: 'governance --superpowers-parity-scorecard', group: 'governance' },
+    { stage: 'Stage 146', capability: 'contributor guardrail evidence', command: 'governance --contributor-guardrails', group: 'governance' },
+    { stage: 'Stage 147', capability: 'subagent permission visibility', command: 'governance --subagent-permission', group: 'governance' },
+    { stage: 'Stage 134', capability: 'session-start output shape acceptance', command: 'platforms --session-start-shape', group: 'platforms' },
+    { stage: 'Stage 103', capability: 'runtime automation readiness matrix', command: 'automation --readiness', group: 'automation' },
+    { stage: 'Stage 108', capability: 'confirmed one-shot execution plan', command: 'automation --one-shot-plan', group: 'automation' },
+    { stage: 'Stage 118', capability: 'sequential stage runbook with Stage 9 executor preview', command: 'automation --stage-runbook', group: 'automation' },
+    { stage: 'Stage 130', capability: 'copy-ready stage execution scriptlet', command: 'automation --stage-scriptlet', group: 'automation' },
+    { stage: 'Stage 105', capability: 'plan-to-action manifest', command: 'planner --action-manifest', group: 'methodology' },
+    { stage: 'Stage 136', capability: 'methodology coverage map', command: 'methodology --coverage-map', group: 'methodology' },
+    { stage: 'Stage 117', capability: 'executable plan quality contract', command: 'planner --executable-plan', group: 'planner' },
+    { stage: 'Stage 106', capability: 'self-test gate profile', command: 'verification --self-test-profile', group: 'verification' },
+    { stage: 'Stage 110', capability: 'evidence intake envelope', command: 'verification --evidence-intake', group: 'verification' },
+    { stage: 'Stage 119', capability: 'execution evidence binding', command: 'verification --execution-evidence', group: 'verification' },
+    { stage: 'Stage 107', capability: 'commit readiness envelope', command: 'release --commit-readiness', group: 'release' },
+    { stage: 'Stage 111', capability: 'diff coverage envelope', command: 'release --diff-coverage', group: 'release' },
+    { stage: 'P3', capability: 'read-only git diff evidence', command: 'release --diff-read', group: 'release' },
+    { stage: 'P5', capability: 'timing suite selection plan', command: 'release --suite-plan', group: 'release' },
+    { stage: 'P4', capability: 'allowlisted foreground test evidence', command: 'tests --run', group: 'tests' },
+    { stage: 'P8/P30', capability: 'adapter dispatch contract with explicit subagent permission gate', command: 'subagents --adapter-dispatch', group: 'subagents' },
+    { stage: 'Stage 149', capability: 'Superpowers-parity SDD loop plan', command: 'sdd --plan', group: 'sdd' },
+    { stage: 'P16', capability: 'Superpowers-parity SDD task brief artifact', command: 'sdd --task-brief', group: 'sdd' },
+    { stage: 'P17', capability: 'Superpowers-parity SDD review package artifact', command: 'sdd --review-package', group: 'sdd' },
+    { stage: 'Stage 149', capability: 'Superpowers-parity confirmed SDD loop sidecars', command: 'sdd --run-loop', group: 'sdd' },
+    { stage: 'Stage 149', capability: 'Superpowers-parity confirmed SDD evidence chain', command: 'sdd --evidence-chain', group: 'sdd' },
+    { stage: 'P18', capability: 'Superpowers-parity confirmed SDD implementer report consumption', command: 'sdd --consume-adapter-result', group: 'sdd' },
+    { stage: 'Stage 150', capability: 'Superpowers-parity workspace isolation plan', command: 'workspace --isolate-plan', group: 'workspace' },
+    { stage: 'Stage 150', capability: 'Superpowers-parity confirmed workspace isolation contract', command: 'workspace --create', group: 'workspace' },
+    { stage: 'Stage 150', capability: 'Superpowers-parity workspace status', command: 'workspace --status', group: 'workspace' },
+    { stage: 'Stage 150', capability: 'Superpowers-parity workspace cleanup plan', command: 'workspace --cleanup-plan', group: 'workspace' },
+    { stage: 'P9', capability: 'source sandbox patch plan', command: 'source --patch-plan', group: 'source' },
+    { stage: 'P9', capability: 'source sandbox apply alias', command: 'source --sandbox-apply', group: 'source' },
+    { stage: 'P9', capability: 'source human confirmed worktree apply', command: 'source --apply-to-worktree', group: 'source' },
+    { stage: 'Stage 120', capability: 'staged commit readiness contract', command: 'release --staged-commit-readiness', group: 'release' },
+    { stage: 'P13', capability: 'Superpowers-style closeout parity contract', command: 'release --closeout-readiness', group: 'release' },
+    { stage: 'Stage 151', capability: 'Superpowers-parity task commit readiness gate', command: 'release --task-commit-readiness', group: 'release' },
+    { stage: 'Stage 151', capability: 'Superpowers-parity confirmed task commit sidecar gate', command: 'release --task-commit', group: 'release' },
+    { stage: 'Stage 121', capability: 'behavioral evaluation contract', command: 'evals --behavior-contract', group: 'evals' },
+    { stage: 'P21', capability: 'platform transcript intake contract', command: 'evals --transcript-intake', group: 'evals' },
+    { stage: 'Stage 138', capability: 'Superpowers-style behavioral eval scenario pack', command: 'evals --superpowers-style-pack', group: 'evals' },
+    { stage: 'Stage 145', capability: 'local behavior eval contracts', command: 'evals --local-behavior-contracts', group: 'evals' },
+    { stage: 'Stage 122', capability: 'adapter bootstrap conformance matrix', command: 'platforms --bootstrap-matrix', group: 'platforms' },
+    { stage: 'Stage 131', capability: 'adapter entry acceptance contract', command: 'platforms --entry-acceptance', group: 'platforms' },
+    { stage: 'Stage 137', capability: 'hook and adapter install experience score', command: 'platforms --install-experience', group: 'platforms' },
+    { stage: 'Stage 142', capability: 'session-start example pack', command: 'platforms --session-start-examples', group: 'platforms' },
+    { stage: 'Stage 148', capability: 'adapter packaging consistency checklist', command: 'platforms --adapter-packaging-consistency', group: 'platforms' },
+    { stage: 'Stage 41', capability: 'platform capability catalog', command: 'platforms --catalog', group: 'platforms' },
+    { stage: 'Stage 41', capability: 'platform capability probe', command: 'platforms --probe', group: 'platforms' },
+    { stage: 'Stage 41', capability: 'platform capability artifact list', command: 'platforms --list', group: 'platforms' },
+    { stage: 'Stage 41', capability: 'platform capability artifact show', command: 'platforms --show', group: 'platforms' },
+    { stage: 'Stage 41', capability: 'platform capability artifact verify', command: 'platforms --verify', group: 'platforms' },
+    { stage: 'Stage 112', capability: 'review intake and resolution envelope', command: 'review --intake|review --resolution', group: 'review' },
+    { stage: 'Stage 113', capability: 'TDD trace contract', command: 'verification --tdd-trace', group: 'verification' },
+  ];
+}
+
+function runtimeCapabilityRegistryCloseoutChain() {
+  return [
+    { order: 1, command: 'workflow --start --json', purpose: 'select visible workflow entry and next manual action' },
+    { order: 2, command: 'completion --evidence-bundle --from-file <local-evidence-file> --json', purpose: 'bind local completion evidence to Stage 88 readiness and Stage 124 one-screen human closeout evidence' },
+    { order: 3, command: 'release --commit-guard --subject <commit-subject> --json', purpose: 'guard manual commit title before git commit' },
+    { order: 4, command: 'release --notes --from-file <local-release-evidence-file> --preview --json', purpose: 'preview release notes evidence when explicitly needed' },
+    { order: 5, command: 'release --gate --from-evals <eval-report-file...> --with-convergence --json', purpose: 'create explicit release gate evidence only through existing release command' },
+  ];
+}