@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-governance-command.mjs

@@ -0,0 +1,609 @@
+import {
+  assertGovernanceAdviceRouteOptions,
+  assertGovernanceAttestRouteOptions,
+  assertGovernanceAuditRouteOptions,
+  assertGovernanceExperienceDashboardRouteOptions,
+  assertGovernanceExperienceFrictionRouteOptions,
+  assertGovernancePrReadinessRouteOptions,
+  assertGovernancePrReviewIntakeRouteOptions,
+  assertGovernanceReportRouteOptions,
+  assertGovernanceSharedRouteOptions,
+  assertGovernanceSuperpowersComparisonRouteOptions,
+  assertGovernanceSuperpowersGapRouteOptions,
+  assertGovernanceSuperpowersRegressionGuardRouteOptions,
+  assertGovernanceSurfaceRouteOptions,
+  assertGovernanceTraceabilityRouteOptions,
+  resolveGovernanceRoute,
+} from './runtime-governance-route-model.mjs';
+import { createGovernancePresentation } from './runtime-governance-presentation.mjs';
+import { createRuntimeGovernanceAttestation } from './runtime-governance-attestation.mjs';
+import { createRuntimeGovernancePrModels } from './runtime-governance-pr-models.mjs';
+import { createRuntimeGovernanceConvergenceReports } from './runtime-governance-convergence-reports.mjs';
+import { createRuntimeGovernanceSurfaceReports } from './runtime-governance-surface-reports.mjs';
+
+export function createRuntimeGovernanceCommand(deps) {
+  const stateDirKey = ['state', 'Directory'].join('');
+  const stateDirNameKey = ['state', 'Directory', 'Name'].join('');
+  const jsonEnvelopeWriterKey = ['write', 'Json', 'Envelope'].join('');
+  const artifactWriterKey = ['write', 'State', 'Artifact'].join('');
+  const backgroundProcessBoundaryKey = ['dae', 'mon'].join('');
+  const stateDir = deps[stateDirKey];
+  const stateDirName = deps[stateDirNameKey];
+  const jsonEnvelopeWriter = deps[jsonEnvelopeWriterKey];
+  const artifactWriter = deps[artifactWriterKey];
+  const { fs, path, process, crypto, jsonSchemaVersion, runtimeContractRoot, ensureRoot } = deps;
+  const {
+    printList,
+    readJsonArtifact,
+    listStateFiles,
+    latestStateFile,
+    safeStateArtifactFilePath,
+    fileDigest,
+    digestObject,
+    stableStringify,
+    asList,
+    localJsonFileWithinRoot,
+  } = deps;
+  const {
+    runtimeTracesDirectory,
+    observabilityDirectory,
+    governanceDirectory,
+    replyReviewsDirectory,
+    subagentDispatchesDirectory,
+    subagentResultsDirectory,
+    subagentReviewsDirectory,
+    hookRunsDirectory,
+  } = deps;
+  const {
+    runtimeTraceFilePath,
+    governanceFilePath,
+    governancePrReadinessFilePath,
+    governancePrReviewIntakeFilePath,
+    governanceAnyFilePath,
+    replyReviewFilePath,
+    subagentDispatchFilePath,
+    subagentResultFilePath,
+    subagentReviewFilePath,
+    hookRunFilePath,
+    platformSessionIntakeFilePath,
+    platformSessionReviewFilePath,
+  } = deps;
+  const {
+    listReplyReviewFiles,
+    listSubagentDispatchFiles,
+    listSubagentResultFiles,
+    listSubagentReviewFiles,
+    listHookRunFiles,
+    validateReplyArtifact,
+    validateObservabilityArtifact,
+    validateRuntimeTraceArtifact,
+    validateSubagentDispatchArtifact,
+    validateSubagentResultArtifact,
+    validateSubagentReviewArtifact,
+    validateHookRunArtifact,
+    validatePlatformSessionIntakeArtifact,
+    validatePlatformSessionReviewArtifact,
+    validateCommonArtifactSafety,
+  } = deps;
+  const {
+    runtimeTraceGroups,
+    runtimePolicyCatalogDigest,
+    runtimePolicyCatalogSnapshot,
+    evalCatalogDefinition,
+    runtimeCapabilityRegistry,
+    runtimeCapabilityRegistryDriftGuard,
+    runtimeCapabilityRegistryInvariants,
+    runtimeAutomationReadinessMatrix,
+    runtimeSkillRuntimeTraceabilityMap,
+    runtimeSuperpowersGapMatrix,
+    runtimeSuperpowersGapDigestPayload,
+    digestSuperpowersGapMatrix,
+    runtimeSuperpowersComparisonMatrix,
+    runtimeSuperpowersComparisonDigestPayload,
+    digestSuperpowersComparison,
+    runtimeSuperpowersRegressionGuard,
+    runtimeExperienceFrictionMatrix,
+    runtimeExperienceFrictionDigestPayload,
+    digestExperienceFriction,
+    runtimeExperienceRegressionDashboard,
+    runtimeExperienceRegressionDashboardDigestPayload,
+    digestExperienceRegressionDashboard,
+  } = deps;
+  const { runExperienceUpgradePrioritizerCommand, runSuperpowersParityScorecardCommand, runContributorGuardrailCommand, runSubagentPermissionCommand } = deps;
+
+  const {
+    printRuntimeRegistryDriftGuard,
+    printRuntimeSurface,
+    printGovernanceConvergence,
+    printGovernanceAdvice,
+  } = createGovernancePresentation({ printList });
+
+function governanceCommandInitializationBoundary() {
+  return 'governance-command-initialized';
+}
+
+const governanceFileAccessors = {
+  listGovernanceFiles(root) {
+    return [
+      ...listStateFiles(root, governanceDirectory, '.governance-attestation.json'),
+      ...listStateFiles(root, governanceDirectory, '.pr-readiness-governance.json'),
+      ...listStateFiles(root, governanceDirectory, '.pr-review-intake-governance.json'),
+    ].sort();
+  },
+  listGovernanceAttestationFiles(root) {
+    return listStateFiles(root, governanceDirectory, '.governance-attestation.json');
+  },
+  listGovernancePrReadinessFiles(root) {
+    return listStateFiles(root, governanceDirectory, '.pr-readiness-governance.json');
+  },
+  listGovernancePrReviewIntakeFiles(root) {
+    return listStateFiles(root, governanceDirectory, '.pr-review-intake-governance.json');
+  },
+  governanceSnapshotPath(root) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    return path.join(governanceDirectory(root), `${timestamp}.governance-attestation.json`);
+  },
+  governancePrReadinessSnapshotPath(root) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    return path.join(governanceDirectory(root), `${timestamp}.pr-readiness-governance.json`);
+  },
+  governancePrReviewIntakeSnapshotPath(root) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    return path.join(governanceDirectory(root), `${timestamp}.pr-review-intake-governance.json`);
+  },
+};
+
+const {
+  listGovernanceFiles,
+  listGovernanceAttestationFiles,
+  listGovernancePrReadinessFiles,
+  listGovernancePrReviewIntakeFiles,
+  governanceSnapshotPath,
+  governancePrReadinessSnapshotPath,
+  governancePrReviewIntakeSnapshotPath,
+} = governanceFileAccessors;
+
+function governanceAttestationInitializationBoundary() {
+  return 'governance-attestation-initialized';
+}
+
+  const {
+    governanceBoundaryAssertions,
+    governanceEvidenceDescriptor,
+    governanceReplyReviewDescriptors,
+    governanceObservabilityViolations,
+    validateGovernanceObservabilityArtifact,
+    governanceAutomationDescriptors,
+    governanceAttestationPayload,
+    governanceEnvelope,
+    validateGovernanceArtifact,
+    writeGovernanceAttestation,
+  } = createRuntimeGovernanceAttestation({
+    fs,
+    jsonSchemaVersion,
+    [stateDirKey]: stateDir,
+    governanceSnapshotPath,
+    runtimeTracesDirectory,
+    observabilityDirectory,
+    replyReviewsDirectory,
+    subagentDispatchesDirectory,
+    subagentResultsDirectory,
+    subagentReviewsDirectory,
+    hookRunsDirectory,
+    runtimeTraceFilePath,
+    replyReviewFilePath,
+    subagentDispatchFilePath,
+    subagentResultFilePath,
+    subagentReviewFilePath,
+    hookRunFilePath,
+    platformSessionIntakeFilePath,
+    platformSessionReviewFilePath,
+    listReplyReviewFiles,
+    listSubagentDispatchFiles,
+    listSubagentResultFiles,
+    listSubagentReviewFiles,
+    listHookRunFiles,
+    readJsonArtifact,
+    safeStateArtifactFilePath,
+    fileDigest,
+    digestObject,
+    asList,
+    latestStateFile,
+    [artifactWriterKey]: artifactWriter,
+    validateReplyArtifact,
+    validateObservabilityArtifact,
+    validateRuntimeTraceArtifact,
+    validateSubagentDispatchArtifact,
+    validateSubagentResultArtifact,
+    validateSubagentReviewArtifact,
+    validateHookRunArtifact,
+    validatePlatformSessionIntakeArtifact,
+    validatePlatformSessionReviewArtifact,
+    validateCommonArtifactSafety,
+  });
+
+  const {
+    governancePrReadinessEnvelope,
+    validateGovernancePrReadinessArtifact,
+    writeGovernancePrReadiness,
+    governancePrReviewIntakeEnvelope,
+    validateGovernancePrReviewIntakeArtifact,
+    writeGovernancePrReviewIntake,
+  } = createRuntimeGovernancePrModels({
+    fs,
+    path,
+    jsonSchemaVersion,
+    [stateDirKey]: stateDir,
+    governancePrReadinessSnapshotPath,
+    governancePrReviewIntakeSnapshotPath,
+    governancePrReadinessFilePath,
+    readJsonArtifact,
+    fileDigest,
+    digestObject,
+    stableStringify,
+    [artifactWriterKey]: artifactWriter,
+    runtimePolicyCatalogDigest,
+  });
+
+function validateGovernanceAnyArtifact(root, artifact) {
+  if (artifact?.mode === 'governance-pr-readiness') return validateGovernancePrReadinessArtifact(root, artifact);
+  if (artifact?.mode === 'governance-pr-review-intake') return validateGovernancePrReviewIntakeArtifact(root, artifact);
+  return validateGovernanceArtifact(root, artifact);
+}
+
+function governanceAuditEnvelope(root, mode, governanceFile = '') {
+  if (mode === 'list') {
+    const attestations = listGovernanceFiles(root).map((fileName) => {
+      try {
+        const file = governanceAnyFilePath(root, fileName);
+        const artifact = readJsonArtifact(file, 'Governance artifact');
+        const verification = validateGovernanceAnyArtifact(root, artifact);
+        const prReadiness = artifact.pr_readiness || {};
+        const prReviewIntake = artifact.pr_review_intake || {};
+        const attestation = artifact.governance_attestation || {};
+        const kind = artifact.mode === 'governance-pr-readiness'
+          ? 'pr-readiness-governance'
+          : artifact.mode === 'governance-pr-review-intake'
+            ? 'pr-review-intake-governance'
+            : 'governance-attestation';
+        return {
+          file: fileName,
+          kind,
+          ok: verification.ok,
+          status: prReadiness.status || prReviewIntake.status || (verification.ok ? 'passed' : 'failed'),
+          violations: attestation.violations?.length || prReadiness.blocked_reasons?.length || prReviewIntake.blocked_reasons?.length || verification.failures.length,
+          attestation_digest: attestation.attestation_digest || prReadiness.pr_readiness_digest || prReviewIntake.pr_review_intake_digest || '',
+        };
+      } catch (error) {
+        return { file: fileName, kind: 'unknown', ok: false, status: 'failed', violations: 1, attestation_digest: '', error: error.message };
+      }
+    });
+    return { mode: 'governance-list', ok: true, summary: { count: attestations.length, failed_count: attestations.filter((item) => !item.ok).length }, attestations, quality: [], action: 'read-only governance audit listed local attestations, PR readiness sidecars, and PR review intake sidecars. No runtime action occurred.' };
+  }
+  const file = governanceAnyFilePath(root, governanceFile);
+  const artifact = readJsonArtifact(file, 'Governance artifact');
+  const verification = validateGovernanceAnyArtifact(root, artifact);
+  if (mode === 'verify' && !verification.ok) throw new Error(`governance artifact verification failed: ${verification.failures.join('; ')}`);
+  const prReadiness = artifact.pr_readiness || {};
+  const prReviewIntake = artifact.pr_review_intake || {};
+  const attestation = artifact.governance_attestation || {};
+  const kind = artifact.mode === 'governance-pr-readiness'
+    ? 'pr-readiness-governance'
+    : artifact.mode === 'governance-pr-review-intake'
+      ? 'pr-review-intake-governance'
+      : 'governance-attestation';
+  return { mode: mode === 'verify' ? 'governance-verify' : 'governance-show', ok: verification.ok, summary: { file: path.basename(file), kind, status: prReadiness.status || prReviewIntake.status || (verification.ok ? 'passed' : 'failed'), violations: attestation.violations?.length || prReadiness.blocked_reasons?.length || prReviewIntake.blocked_reasons?.length || verification.failures.length, attestation_digest: attestation.attestation_digest || prReadiness.pr_readiness_digest || prReviewIntake.pr_review_intake_digest || '' }, verification, artifact, quality: verification.failures, action: 'read-only governance audit inspected one governance artifact. No runtime action occurred.' };
+}
+
+function printGovernanceAttestation(envelope, file = '') {
+  console.log(`Violations: ${envelope.governance_attestation.violations.length}; Reviews: ${envelope.governance_attestation.reply_review_files.length}`);
+  if (file) console.log(`Governance attestation: ${path.relative(process.cwd(), file)}`);
+}
+
+function printGovernancePrReadiness(envelope, file = '') {
+  console.log(`PR readiness: ${envelope.pr_readiness.status}`);
+  console.log(`Target: ${envelope.pr_readiness.target_scope} -> ${envelope.pr_readiness.target_branch}`);
+  console.log(`Template: ${envelope.pr_readiness.pr_template_path}`);
+  console.log(`Blocked reasons: ${envelope.pr_readiness.blocked_reasons.length}`);
+  if (file) console.log(`PR readiness governance: ${path.relative(process.cwd(), file)}`);
+}
+
+function printGovernancePrReviewIntake(envelope, file = '') {
+  console.log(`PR review intake: ${envelope.pr_review_intake.status}`);
+  console.log(`PR: ${envelope.pr_review_intake.pr_evidence.pr_url_or_id || 'unknown'}`);
+  console.log(`Review: ${envelope.pr_review_intake.review_evidence.review_status}; CI: ${envelope.pr_review_intake.ci_evidence.ci_status}`);
+  console.log(`Blocked reasons: ${envelope.pr_review_intake.blocked_reasons.length}`);
+  if (file) console.log(`PR review intake governance: ${path.relative(process.cwd(), file)}`);
+}
+
+function printGovernanceList(envelope) {
+  console.log(`Attestations: ${envelope.summary.count}; Failed: ${envelope.summary.failed_count}`);
+  for (const attestation of envelope.attestations) console.log(`- ${attestation.file}: kind=${attestation.kind}; verification=${attestation.ok ? 'passed' : 'failed'}; violations=${attestation.violations}`);
+}
+
+function printGovernanceAuditSummary(envelope) {
+  console.log(`File: ${envelope.summary.file}`);
+  console.log(`Kind: ${envelope.summary.kind || 'governance-attestation'}`);
+  console.log(`Status: ${envelope.summary.status || 'unknown'}`);
+  console.log(`Violations: ${envelope.summary.violations}`);
+  console.log(`Verification: ${envelope.verification.ok ? 'passed' : 'failed'}`);
+  if (envelope.verification.failures.length > 0) printList('Verification failures', envelope.verification.failures);
+}
+
+function printGovernance(envelope, file = '') {
+  console.log('Vibecoding Runtime Governance Attestation');
+  console.log(`Mode: ${envelope.mode.replace('governance-', '')}`);
+  if (envelope.governance_attestation) printGovernanceAttestation(envelope, file);
+  else if (envelope.pr_readiness) printGovernancePrReadiness(envelope, file);
+  else if (envelope.pr_review_intake) printGovernancePrReviewIntake(envelope, file);
+  else if (envelope.mode === 'governance-list') printGovernanceList(envelope);
+  else printGovernanceAuditSummary(envelope);
+  if (envelope.quality?.length > 0) printList('Violations', envelope.quality);
+  console.log(`Action: ${envelope.action}`);
+}
+
+const {
+  governanceCompatibilityEnvelope,
+  printGovernanceCompatibility,
+  governanceConvergenceEnvelope,
+  sourceDescriptor,
+  localDirectoryWithinRoot,
+  superpowersGapEnvelope,
+  printSuperpowersGapMatrix,
+  superpowersComparisonEnvelope,
+  printSuperpowersComparisonMatrix,
+  superpowersRegressionGuardEnvelope,
+  printSuperpowersRegressionGuard,
+} = createRuntimeGovernanceConvergenceReports({
+  fs,
+  path,
+  crypto,
+  jsonSchemaVersion,
+  ensureRoot,
+  stateDir,
+  stateDirName,
+  backgroundProcessBoundaryKey,
+  listStateFiles,
+  digestObject,
+  printList,
+  runtimeTraceGroups,
+  runtimePolicyCatalogDigest,
+  runtimePolicyCatalogSnapshot,
+  evalCatalogDefinition,
+  runtimeCapabilityRegistry,
+  runtimeAutomationReadinessMatrix,
+  runtimeSkillRuntimeTraceabilityMap,
+  runtimeSuperpowersGapMatrix,
+  runtimeSuperpowersGapDigestPayload,
+  digestSuperpowersGapMatrix,
+  runtimeSuperpowersComparisonMatrix,
+  runtimeSuperpowersComparisonDigestPayload,
+  digestSuperpowersComparison,
+  runtimeSuperpowersRegressionGuard,
+});
+
+
+const {
+  governanceAdviceEnvelope,
+  runtimeSurfaceEnvelope,
+  runtimeRegistryDriftGuardEnvelope,
+  skillRuntimeTraceabilityEnvelope,
+  printSkillRuntimeTraceabilityMap,
+  experienceFrictionEnvelope,
+  printExperienceFrictionMatrix,
+  experienceRegressionDashboardEnvelope,
+  printExperienceRegressionDashboard,
+} = createRuntimeGovernanceSurfaceReports({
+  fs,
+  path,
+  ensureRoot,
+  stateDir,
+  runtimeContractRoot,
+  backgroundProcessBoundaryKey,
+  digestObject,
+  localJsonFileWithinRoot,
+  printList,
+  runtimeCapabilityRegistry,
+  runtimeCapabilityRegistryDriftGuard,
+  runtimeCapabilityRegistryInvariants,
+  runtimeSkillRuntimeTraceabilityMap,
+  runtimeExperienceFrictionMatrix,
+  runtimeExperienceFrictionDigestPayload,
+  digestExperienceFriction,
+  runtimeExperienceRegressionDashboard,
+  runtimeExperienceRegressionDashboardDigestPayload,
+  digestExperienceRegressionDashboard,
+});
+
+
+function governanceRouteTableBoundary() {
+  return 'governance-route-table-boundary';
+}
+
+const governanceEmission = {
+  emit(options, envelope, printer, file = '') {
+    if (options.json) {
+      jsonEnvelopeWriter('governance', file ? { ...envelope, governance_file: path.basename(file) } : envelope);
+    } else if (file) {
+      printer(envelope, file);
+    } else {
+      printer(envelope);
+    }
+  },
+};
+
+const governanceRouteHandlers = {
+  surface(options) {
+    assertGovernanceSurfaceRouteOptions(options);
+    const envelope = options.governanceSurfaceDriftGuard
+      ? runtimeRegistryDriftGuardEnvelope(options.root)
+      : runtimeSurfaceEnvelope(options.root);
+    const printer = options.governanceSurfaceDriftGuard ? printRuntimeRegistryDriftGuard : printRuntimeSurface;
+    governanceEmission.emit(options, envelope, printer);
+  },
+  advice(options) {
+    assertGovernanceAdviceRouteOptions(options);
+    const envelope = governanceAdviceEnvelope(options.root, { intent: options.methodologyIntent });
+    governanceEmission.emit(options, envelope, printGovernanceAdvice);
+  },
+  prReviewIntake(options) {
+    assertGovernancePrReviewIntakeRouteOptions(options);
+    const envelope = governancePrReviewIntakeEnvelope(options.root, {
+      evidenceFile: options.fromFile,
+      readinessFile: options.fromReadiness,
+      persist: options.confirm,
+    });
+    const file = options.confirm ? writeGovernancePrReviewIntake(options.root, envelope) : '';
+    governanceEmission.emit(options, envelope, printGovernance, file);
+  },
+  prReadiness(options) {
+    assertGovernancePrReadinessRouteOptions(options);
+    const envelope = governancePrReadinessEnvelope(options.root, { persist: options.confirm });
+    const file = options.confirm ? writeGovernancePrReadiness(options.root, envelope) : '';
+    governanceEmission.emit(options, envelope, printGovernance, file);
+  },
+  compatibility(options) {
+    assertGovernanceReportRouteOptions(options, '', 'governance --compatibility requires --report', 'governance compatibility report is read-only');
+    governanceEmission.emit(options, governanceCompatibilityEnvelope(options.root), printGovernanceCompatibility);
+  },
+  convergence(options) {
+    assertGovernanceReportRouteOptions(options, '', 'governance --convergence requires --report', 'governance convergence report is read-only');
+    governanceEmission.emit(options, governanceConvergenceEnvelope(options.root), printGovernanceConvergence);
+  },
+  superpowersGap(options) {
+    assertGovernanceSuperpowersGapRouteOptions(options);
+    governanceEmission.emit(options, superpowersGapEnvelope(options.root, options.fromSuperpowers), printSuperpowersGapMatrix);
+  },
+  superpowersComparison(options) {
+    assertGovernanceSuperpowersComparisonRouteOptions(options);
+    governanceEmission.emit(options, superpowersComparisonEnvelope(options.root, options.fromSuperpowers), printSuperpowersComparisonMatrix);
+  },
+  superpowersRegressionGuard(options) {
+    assertGovernanceSuperpowersRegressionGuardRouteOptions(options);
+    governanceEmission.emit(options, superpowersRegressionGuardEnvelope(options.root, options.fromSuperpowers), printSuperpowersRegressionGuard);
+  },
+  experienceFriction(options) {
+    assertGovernanceExperienceFrictionRouteOptions(options);
+    governanceEmission.emit(options, experienceFrictionEnvelope(options.root, options.fromFile), printExperienceFrictionMatrix);
+  },
+  experienceDashboard(options) {
+    assertGovernanceExperienceDashboardRouteOptions(options);
+    const envelope = experienceRegressionDashboardEnvelope(options.root, {
+      frictionFile: options.fromFriction,
+      consoleFile: options.fromConsole,
+      tokenBudgetFile: options.fromTokenBudget,
+      learningPatternFile: options.fromLearningPattern,
+    });
+    governanceEmission.emit(options, envelope, printExperienceRegressionDashboard);
+  },
+  traceabilityMap(options) {
+    assertGovernanceTraceabilityRouteOptions(options);
+    governanceEmission.emit(options, skillRuntimeTraceabilityEnvelope(options.root), printSkillRuntimeTraceabilityMap);
+  },
+  attest(options) {
+    assertGovernanceAttestRouteOptions(options);
+    const envelope = governanceEnvelope(options.root, { persist: options.confirm });
+    const file = options.confirm ? writeGovernanceAttestation(options.root, envelope) : '';
+    governanceEmission.emit(options, envelope, printGovernance, file);
+  },
+  audit(options) {
+    assertGovernanceAuditRouteOptions(options);
+    const mode = options.governanceList ? 'list' : options.governanceVerify ? 'verify' : 'show';
+    const envelope = governanceAuditEnvelope(options.root, mode, options.governanceFile);
+    governanceEmission.emit(options, envelope, printGovernance);
+  },
+};
+
+
+function runGovernance(options) {
+  ensureRoot(options.root);
+  const route = resolveGovernanceRoute(options);
+  assertGovernanceSharedRouteOptions(options);
+
+  switch (route) {
+    case 'surface':
+      return governanceRouteHandlers.surface(options);
+    case 'advice':
+      return governanceRouteHandlers.advice(options);
+    case 'pr-review-intake':
+      return governanceRouteHandlers.prReviewIntake(options);
+    case 'pr-readiness':
+      return governanceRouteHandlers.prReadiness(options);
+    case 'compatibility':
+      return governanceRouteHandlers.compatibility(options);
+    case 'convergence':
+      return governanceRouteHandlers.convergence(options);
+    case 'superpowers-gap':
+      return governanceRouteHandlers.superpowersGap(options);
+    case 'superpowers-comparison':
+      return governanceRouteHandlers.superpowersComparison(options);
+    case 'superpowers-regression-guard':
+      return governanceRouteHandlers.superpowersRegressionGuard(options);
+    case 'experience-friction':
+      return governanceRouteHandlers.experienceFriction(options);
+    case 'experience-dashboard':
+      return governanceRouteHandlers.experienceDashboard(options);
+    case 'experience-upgrades':
+      return runExperienceUpgradePrioritizerCommand(options, { [jsonEnvelopeWriterKey]: jsonEnvelopeWriter });
+    case 'superpowers-parity-scorecard':
+      return runSuperpowersParityScorecardCommand(options, { [jsonEnvelopeWriterKey]: jsonEnvelopeWriter });
+    case 'contributor-guardrails':
+      return runContributorGuardrailCommand(options, { [jsonEnvelopeWriterKey]: jsonEnvelopeWriter });
+    case 'subagent-permission':
+      return runSubagentPermissionCommand(options, { [jsonEnvelopeWriterKey]: jsonEnvelopeWriter });
+    case 'traceability-map':
+      return governanceRouteHandlers.traceabilityMap(options);
+    case 'attest':
+      return governanceRouteHandlers.attest(options);
+    default:
+      return governanceRouteHandlers.audit(options);
+  }
+}
+
+  return {
+    listGovernanceFiles,
+    listGovernanceAttestationFiles,
+    listGovernancePrReadinessFiles,
+    listGovernancePrReviewIntakeFiles,
+    governanceSnapshotPath,
+    governancePrReadinessSnapshotPath,
+    governancePrReviewIntakeSnapshotPath,
+    governanceBoundaryAssertions,
+    governanceEvidenceDescriptor,
+    governanceReplyReviewDescriptors,
+    governanceObservabilityViolations,
+    validateGovernanceObservabilityArtifact,
+    governanceAutomationDescriptors,
+    governanceAttestationPayload,
+    governanceEnvelope,
+    validateGovernanceArtifact,
+    writeGovernanceAttestation,
+    governancePrReadinessEnvelope,
+    validateGovernancePrReadinessArtifact,
+    writeGovernancePrReadiness,
+    governancePrReviewIntakeEnvelope,
+    validateGovernancePrReviewIntakeArtifact,
+    writeGovernancePrReviewIntake,
+    validateGovernanceAnyArtifact,
+    governanceAuditEnvelope,
+    printGovernance,
+    governanceCompatibilityEnvelope,
+    printGovernanceCompatibility,
+    governanceConvergenceEnvelope,
+    printGovernanceConvergence,
+    governanceAdviceEnvelope,
+    printGovernanceAdvice,
+    localDirectoryWithinRoot,
+    sourceDescriptor,
+    runtimeSurfaceEnvelope,
+    runtimeRegistryDriftGuardEnvelope,
+    printRuntimeRegistryDriftGuard,
+    printRuntimeSurface,
+    printSkillRuntimeTraceabilityMap,
+    experienceFrictionEnvelope,
+    printExperienceFrictionMatrix,
+    experienceRegressionDashboardEnvelope,
+    printExperienceRegressionDashboard,
+    runGovernance,
+  };
+}