@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-governance-convergence-reports.mjs

@@ -0,0 +1,601 @@
+export function createRuntimeGovernanceConvergenceReports(deps) {
+  const {
+    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,
+  } = deps;
+function runtimeCompatibilityKnownSourceTypes() {
+  return runtimeTraceGroups().map(([type, , extension, label]) => ({ type, extension, label }));
+}
+
+function runtimeCompatibilityStateFamilies(root) {
+  return runtimeTraceGroups().map(([type, directory, extension, label]) => {
+    const files = listStateFiles(root, directory, extension);
+    return {
+      type,
+      directory: `${stateDirName}/${path.basename(directory(root))}`.replace(/\\/g, '/'),
+      extension,
+      label,
+      file_count: files.length,
+      latest_file: files.length > 0 ? files[files.length - 1] : '',
+    };
+  });
+}
+
+function runtimeCompatibilityClassifyArtifact(root, family, fileName) {
+  const file = path.join(root, family.directory, fileName);
+  const result = {
+    type: family.type,
+    file: fileName,
+    stage: '',
+    version: '',
+    command: '',
+    mode: '',
+    compatibility_status: 'compatible',
+    reasons: [],
+  };
+  try {
+    const artifact = JSON.parse(fs.readFileSync(file, 'utf8'));
+    result.command = artifact.command || '';
+    result.mode = artifact.mode || '';
+    const payload = artifact[family.type.slice(0, -1)] || artifact[artifact.mode?.replace(/-/g, '_')] || {};
+    result.stage = payload.stage || artifact.safety?.stage || '';
+    result.version = payload.version ?? '';
+
+    if (artifact.schema_version !== jsonSchemaVersion) {
+      result.compatibility_status = 'manual-migration-required';
+      result.reasons.push(`schema_version=${artifact.schema_version ?? 'missing'} expected=${jsonSchemaVersion}`);
+    }
+
+    if (family.type === 'eval_suites' || family.type === 'eval_runs' || family.type === 'eval_reports') {
+      const policyDigest = payload.policy_catalog_digest || '';
+      const catalogDigest = family.type === 'eval_suites' ? payload.catalog_digest || '' : '';
+      if (policyDigest && policyDigest !== runtimePolicyCatalogDigest()) {
+        result.compatibility_status = 'manual-migration-required';
+        result.reasons.push('policy_catalog_digest drift');
+      }
+      if (catalogDigest && catalogDigest !== evalCatalogDefinition().catalog_digest) {
+        result.compatibility_status = 'manual-migration-required';
+        result.reasons.push('eval catalog digest drift');
+      }
+    }
+
+    if (['planner_routes', 'planner_plans', 'planner_briefs', 'router_plans', 'router_approvals', 'orchestrator_plans', 'orchestrator_dispatch_plans', 'release_gates', 'feedback_ledgers'].includes(family.type)) {
+      const policyDigest = payload.policy_catalog_digest || '';
+      if (policyDigest && policyDigest !== runtimePolicyCatalogDigest()) {
+        result.compatibility_status = 'manual-migration-required';
+        result.reasons.push('policy_catalog_digest drift');
+      }
+    }
+
+    if (family.type === 'runtime_traces') {
+      const sources = Array.isArray(artifact.runtime_trace?.sources) ? artifact.runtime_trace.sources : [];
+      const knownTypes = new Set(runtimeCompatibilityKnownSourceTypes().map((entry) => entry.type));
+      const unknownSourceTypes = [...new Set(sources.map((source) => source.type).filter((type) => !knownTypes.has(type)))];
+      if (unknownSourceTypes.length > 0) {
+        result.compatibility_status = 'untrusted';
+        result.reasons.push(`unknown trace source types: ${unknownSourceTypes.join(', ')}`);
+      }
+    }
+
+    if (!result.stage) {
+      result.compatibility_status = result.compatibility_status === 'untrusted' ? 'untrusted' : 'manual-migration-required';
+      result.reasons.push('stage missing');
+    }
+  } catch (error) {
+    result.compatibility_status = 'untrusted';
+    result.reasons.push(error.message);
+  }
+  return result;
+}
+
+function governanceCompatibilityEnvelope(root) {
+  ensureRoot(root);
+  const statePresent = fs.existsSync(stateDir(root));
+  const policyCatalog = runtimePolicyCatalogSnapshot();
+  const evalCatalog = evalCatalogDefinition();
+  const knownSourceTypes = runtimeCompatibilityKnownSourceTypes();
+  const families = runtimeCompatibilityStateFamilies(root);
+  const artifactResults = statePresent
+    ? families.flatMap((family) => {
+        const directoryPath = path.join(root, family.directory);
+        if (!fs.existsSync(directoryPath)) return [];
+        return fs.readdirSync(directoryPath, { withFileTypes: true })
+          .filter((entry) => entry.isFile() && entry.name.endsWith(family.extension))
+          .map((entry) => runtimeCompatibilityClassifyArtifact(root, family, entry.name));
+      })
+    : [];
+  const grouped = {
+    compatible: artifactResults.filter((item) => item.compatibility_status === 'compatible').length,
+    manual_migration_required: artifactResults.filter((item) => item.compatibility_status === 'manual-migration-required').length,
+    untrusted: artifactResults.filter((item) => item.compatibility_status === 'untrusted').length,
+  };
+  return {
+    mode: 'governance-compatibility-report',
+    ok: grouped.untrusted === 0,
+    state_present: statePresent,
+    compatibility: {
+      stage: 'Stage 56',
+      report_kind: 'runtime-compatibility-migration-check',
+      writes: false,
+      migration_applied: false,
+      state_directory_created: false,
+      policy_catalog_digest: policyCatalog.catalog_digest,
+      eval_catalog_digest: evalCatalog.catalog_digest,
+      known_trace_source_types: knownSourceTypes,
+      state_families: families,
+      artifact_results: artifactResults,
+      summary: {
+        total_artifacts: artifactResults.length,
+        compatible: grouped.compatible,
+        manual_migration_required: grouped.manual_migration_required,
+        untrusted: grouped.untrusted,
+      },
+    },
+    safety: {
+      stage: 'Stage 56',
+      writes: false,
+      compatibility_report: false,
+      migration_applied: false,
+      state_directory_created: false,
+      runtime_action: false,
+      auto_execution: false,
+      platform_api: false,
+      skill_execution: false,
+      business_source_write: false,
+      source_merge: false,
+      subagent: false,
+      mcp: false,
+      [backgroundProcessBoundaryKey]: false,
+      git: false,
+      worktree: false,
+      dispatch_event_modified: false,
+      claim_modified: false,
+    },
+    quality: artifactResults.filter((item) => item.compatibility_status !== 'compatible').flatMap((item) => item.reasons.map((reason) => `${item.file}: ${reason}`)),
+    action: statePresent
+      ? 'runtime compatibility report was computed read-only. No artifact was migrated, re-signed, or rewritten, and no state directory was created.'
+      : 'runtime compatibility report found no local state directory and remained read-only. No files were created.',
+  };
+}
+
+function printGovernanceCompatibility(envelope) {
+  console.log('Vibecoding Runtime Compatibility Report');
+  console.log('Mode: report');
+  console.log(`State present: ${envelope.state_present ? 'yes' : 'no'}`);
+  console.log(`Policy catalog digest: ${envelope.compatibility.policy_catalog_digest}`);
+  console.log(`Eval catalog digest: ${envelope.compatibility.eval_catalog_digest}`);
+  console.log(`Artifacts: ${envelope.compatibility.summary.total_artifacts}; Compatible: ${envelope.compatibility.summary.compatible}; Manual migration: ${envelope.compatibility.summary.manual_migration_required}; Untrusted: ${envelope.compatibility.summary.untrusted}`);
+  if (envelope.quality.length > 0) printList('Compatibility findings', envelope.quality);
+  console.log(`Action: ${envelope.action}`);
+}
+
+function governanceConvergenceDimensions() {
+  return [
+    {
+      id: 'workflow-experience',
+      source: 'Superpowers',
+      target_capability: 'agent-facing workflow bootstrap, strong trigger discipline, skill selection, and handoff consistency',
+      current_vibecoding_strength: 'explicit using-vibecoding entry, workflow handoff contract, methodology gate ledger, and governance sidecars',
+      current_gap: 'closed by Stage 60 methodology route and trigger discipline documentation; runtime keeps route suggestions read-only',
+      target_stage: 'Stage 60',
+      status: 'implemented',
+      acceptance: ['methodology route suggestion exists', 'using-vibecoding trigger discipline is documented', 'no automatic workflow execution is implied'],
+    },
+    {
+      id: 'learning-model',
+      source: 'ECC continuous-learning-v2',
+      target_capability: 'project-scoped observation ledger, candidate instincts, confidence scoring, evidence-backed promotion gate',
+      current_vibecoding_strength: 'digest-bound local sidecars and strict verify boundaries are already established',
+      current_gap: 'closed by Stage 61-62 learning observation, candidate instinct, and promotion sidecars; formal skill mutation remains explicitly gated',
+      target_stage: 'Stage 61-62',
+      status: 'implemented',
+      acceptance: ['learning observations come from local evidence files', 'candidate instincts are project-scoped by default', 'promotion never mutates skills automatically'],
+    },
+    {
+      id: 'deterministic-token-economy',
+      source: 'Token Savior',
+      target_capability: 'pure command output compactors, token-saving profiles, metrics, and full-output digest binding',
+      current_vibecoding_strength: 'vibe-compact exists and release/runtime checks already produce structured local output',
+      current_gap: 'closed by Stage 63-64 token compaction, profile, metrics, and rewrite-preview sidecars; LLM distillation remains optional and deferred',
+      target_stage: 'Stage 63-64',
+      status: 'implemented',
+      acceptance: ['compactors are pure functions', 'original output is digest-bound', 'rewrite behavior is preview-only'],
+    },
+    {
+      id: 'stream-distillation',
+      source: 'Distill',
+      target_capability: 'large stdout/stderr noise reduction while preserving task-relevant signal',
+      current_vibecoding_strength: 'local deterministic boundary can host a rule-based distillation layer safely',
+      current_gap: 'LLM-based streaming distillation is intentionally out of default scope because it is not deterministic or verify-first',
+      target_stage: 'post-Stage 64 optional adapter',
+      status: 'deferred',
+      acceptance: ['default path remains deterministic', 'LLM distill can only be optional and explicitly enabled', 'raw-output digest remains available'],
+    },
+    {
+      id: 'runtime-governance',
+      source: 'Vibecoding',
+      target_capability: 'sidecar-only governance, compatibility reports, release gates, feedback ledgers, policy catalog, PR readiness and PR review intake',
+      current_vibecoding_strength: 'Stage 31 and Stage 52-58 already provide the strongest local audit spine among compared projects',
+      current_gap: 'closed by Stage 65 optional release gate convergence binding plus runtime-check and release-check smoke coverage',
+      target_stage: 'Stage 65',
+      status: 'implemented',
+      acceptance: ['runtime-check covers Stage 59-64 markers', 'release-check smoke proves read-only/write boundaries', 'release gate can bind convergence evidence optionally'],
+    },
+  ];
+}
+
+function sourceDescriptor(root, baseDirectory, relativeFile, markers) {
+  const file = path.join(baseDirectory, ...relativeFile.split('/'));
+  const display = path.relative(root, file).replace(/\\/g, '/');
+  if (!fs.existsSync(file) || !fs.statSync(file).isFile()) {
+    return { file: display, present: false, digest: '', marker_hits: [] };
+  }
+  const text = fs.readFileSync(file, 'utf8');
+  return {
+    file: display,
+    present: true,
+    digest: crypto.createHash('sha256').update(text).digest('hex'),
+    marker_hits: markers.filter((marker) => text.includes(marker)),
+  };
+}
+
+function localDirectoryWithinRoot(root, input, label) {
+  const raw = String(input || '').trim();
+  if (!raw) throw new Error(`${label} requires a local directory path`);
+  if (raw.includes('\\')) throw new Error(`${label} must use forward-slash local paths`);
+  const resolved = path.isAbsolute(raw) ? path.resolve(raw) : path.resolve(root, raw);
+  const relative = path.relative(root, resolved);
+  if (relative.startsWith('..') || path.isAbsolute(relative)) throw new Error(`${label} must stay within --root`);
+  if (!fs.existsSync(resolved) || !fs.statSync(resolved).isDirectory()) throw new Error(`${label} directory not found: ${raw}`);
+  return resolved;
+}
+
+function superpowersGapSourceBundle(root, superpowersDirectoryInput) {
+  const superpowersDirectory = localDirectoryWithinRoot(root, superpowersDirectoryInput, 'governance --superpowers-gap --from-superpowers');
+  const allMarkers = [
+    'session-start', 'You have superpowers', 'using-superpowers', '1% chance', 'ABSOLUTELY MUST', 'Invoke relevant or requested skills BEFORE', 'Red Flags',
+    'Exact file paths', 'No Placeholders', 'Task Structure', 'Expected:', 'NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST', 'RED', 'GREEN', 'REFACTOR',
+    'fresh subagent per task', 'Continuous execution', 'progress ledger', 'review package', 'task reviewer', 'spec compliance', 'code quality', 'final whole-branch review',
+    'Evidence before claims', 'NO COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE', 'RUN', 'READ', 'finishing-a-development-branch', 'Verify Tests', 'Present Options', 'git commit',
+    'Quickstart', 'plugin marketplace', 'session-start hook', 'additionalContext', 'workflow', 'skill', 'review', 'verification',
+    'workflow --start', 'using-vibecoding', 'entry contract', '受控 agent 沙盒', '轻量入口', 'hooks/', 'session-start bootstrap', '轻量分流', '不要声称已使用某个 skill', 'workflow --receipt',
+    'planner --action-manifest', 'planner --lint', 'docs_expectations', 'code_expectations', 'verification --tdd-trace', 'TDD trace', 'RED-GREEN-REFACTOR', 'test_execution=false',
+    'automation --one-shot-plan', 'workflow --close-loop', 'execution_authorized=false', 'automation readiness', 'review --intake', 'review --resolution', 'review_intake_digest', 'review_resolution_digest',
+    'verification --evidence-intake', 'completion --readiness', 'freshness_findings', 'gate_coverage', 'release --commit-readiness', 'release --commit-guard', 'commit_execution_authorized=false',
+    'node bin/vibe.mjs', 'managed block', 'injectsFullSkill=false', 'runtime-capability-registry', 'boundary_assertions', 'registry_version', 'digest',
+  ];
+  const superpowersFiles = [
+    'README.md',
+    'skills/using-superpowers/SKILL.md',
+    'skills/writing-plans/SKILL.md',
+    'skills/executing-plans/SKILL.md',
+    'skills/subagent-driven-development/SKILL.md',
+    'skills/test-driven-development/SKILL.md',
+    'skills/verification-before-completion/SKILL.md',
+    'skills/finishing-a-development-branch/SKILL.md',
+    'hooks/session-start',
+    '.cursor-plugin/plugin.json',
+  ];
+  const vibecodingFiles = [
+    'README.md',
+    'tools/vibe-runtime/README.md',
+    'skills/using-vibecoding/SKILL.md',
+    'tools/vibe-runtime/runtime-capability-registry.mjs',
+    'tools/vibe-runtime/runtime-automation-readiness.mjs',
+    'adapters/cursor/plugin.json',
+  ];
+  return {
+    superpowers_sources: superpowersFiles.map((file) => sourceDescriptor(root, superpowersDirectory, file, allMarkers)),
+    vibecoding_sources: vibecodingFiles.map((file) => sourceDescriptor(root, root, file, allMarkers)),
+  };
+}
+
+function superpowersComparisonSourceBundle(root, superpowersDirectoryInput) {
+  const superpowersDirectory = localDirectoryWithinRoot(root, superpowersDirectoryInput, 'governance --superpowers-comparison --from-superpowers-root');
+  const allMarkers = [
+    'session-start', 'You have superpowers', 'using-superpowers', 'additionalContext', 'hookSpecificOutput', 'additional_context', 'SessionStart',
+    '1% chance', 'ABSOLUTELY MUST', 'Invoke relevant or requested skills BEFORE', 'Red Flags', 'brainstorming', 'writing-plans', 'test-driven-development', 'verification-before-completion',
+    'plugin.json', 'skills', 'hooks', 'plugin marketplace', 'tests', 'eval', 'run-skill-tests', 'test-session-start', 'subagent', 'fresh subagent', 'dispatch', 'review',
+    'PULL_REQUEST_TEMPLATE', 'Existing PRs', 'Identify yourself', 'human partner', 'full content', 'Skill tool', 'context', 'you don\'t need to do anything special', 'automatically', 'Quickstart', 'go',
+    'session-start.mjs', 'using-vibecoding', 'lightweight routing', 'injectsFullSkill=false', '轻量分流', '不要声称已使用某个 skill', 'L0',
+    'vibe-brainstorming', 'vibe-writing-plans', 'vibe-test-driven-development', 'vibe-verification-before-completion', '--format', 'installedSkills', 'sessionStartBootstrap', 'runtimeBridge',
+    'vibe-runtime-check', 'vibe-release-check', 'evals --behavior-contract', 'release-check', '用户明确允许', 'canCallSubagent', 'subagent=false', 'release --commit-readiness', 'review --intake', 'completion --evidence-bundle', 'PR',
+    'Token Savior', 'tokens --savior-budget', 'compact', 'skills_to_defer', 'workflow --start', 'workflow --next-action-console', 'automation --stage-scriptlet', 'experience dashboard',
+  ];
+  const superpowersFiles = [
+    'README.md',
+    'AGENTS.md',
+    'CLAUDE.md',
+    '.github/PULL_REQUEST_TEMPLATE.md',
+    'skills/using-superpowers/SKILL.md',
+    'skills/brainstorming/SKILL.md',
+    'skills/writing-plans/SKILL.md',
+    'skills/executing-plans/SKILL.md',
+    'skills/subagent-driven-development/SKILL.md',
+    'skills/test-driven-development/SKILL.md',
+    'skills/verification-before-completion/SKILL.md',
+    'skills/finishing-a-development-branch/SKILL.md',
+    'hooks/session-start',
+    'hooks/session-start-codex',
+    'tests/hooks/test-session-start.sh',
+    'tests/claude-code/run-skill-tests.sh',
+    '.cursor-plugin/plugin.json',
+    '.claude-plugin/plugin.json',
+    '.codex-plugin/plugin.json',
+  ];
+  const vibecodingFiles = [
+    'README.md',
+    'CLAUDE.md',
+    'AGENTS.md',
+    'templates/CLAUDE.md',
+    'templates/AGENTS.md',
+    'skills/using-vibecoding/SKILL.md',
+    'hooks/session-start/session-start.mjs',
+    'hooks/session-start/session-start.md',
+    'adapters/claude/plugin.json',
+    'adapters/cursor/plugin.json',
+    'adapters/codex/plugin.json',
+    'adapters/cursor/hooks.example.json',
+    'adapters/codex/hooks.example.json',
+    'tools/vibe-runtime/README.md',
+    'tools/vibe-runtime/runtime-capability-registry.mjs',
+    'tools/vibe-runtime/runtime-automation-readiness.mjs',
+    'tools/vibe-runtime/runtime-adapter-bootstrap-matrix.mjs',
+    'tools/vibe-runtime/runtime-adapter-entry-acceptance.mjs',
+    'tools/vibe-runtime/runtime-experience-regression-dashboard.mjs',
+    'tools/vibe-runtime-check/index.mjs',
+    'tools/vibe-release-check/index.mjs',
+  ];
+  const superpowersRootRelative = path.relative(root, superpowersDirectory).replace(/\\/g, '/');
+  return {
+    superpowers_root: superpowersRootRelative,
+    superpowers_root_digest: crypto.createHash('sha256').update(superpowersRootRelative).digest('hex'),
+    superpowers_sources: superpowersFiles.map((file) => sourceDescriptor(root, superpowersDirectory, file, allMarkers)),
+    vibecoding_sources: vibecodingFiles.map((file) => sourceDescriptor(root, root, file, allMarkers)),
+  };
+}
+
+function superpowersComparisonEnvelope(root, superpowersDirectoryInput) {
+  ensureRoot(root);
+  const sources = superpowersComparisonSourceBundle(root, superpowersDirectoryInput);
+  const registry = runtimeCapabilityRegistry();
+  const comparisonBase = runtimeSuperpowersComparisonMatrix({
+    superpowersSources: sources.superpowers_sources,
+    vibecodingSources: sources.vibecoding_sources,
+    registry,
+    source: {
+      superpowers_root: sources.superpowers_root,
+      superpowers_root_digest: sources.superpowers_root_digest,
+    },
+  });
+  const comparison = {
+    ...comparisonBase,
+    comparison_digest: digestSuperpowersComparison(runtimeSuperpowersComparisonDigestPayload(comparisonBase)),
+  };
+  return {
+    mode: 'superpowers-comparative-evidence-matrix',
+    ok: comparison.ok,
+    state_present: fs.existsSync(stateDir(root)),
+    superpowers_comparison_matrix: comparison,
+    safety: { stage: 'Stage 133', ...comparison.boundary_assertions },
+    quality: comparison.superpowers_comparison_invariants.findings,
+    action: 'superpowers comparative evidence matrix was computed read-only from local fork/superpowers and Vibecoding source files. It only reports parity gaps, Vibecoding advantages, borrowable patterns, do-not-copy boundaries, and next comparison bet; no comparison artifact, state directory, sidecar, command, check, smoke, test, hook execution, workflow skill execution, runtime action, repair, git, commit, push, PR, merge, platform API, external network, model, MCP, subagent, worktree, or business source write occurred.',
+  };
+}
+
+function printSuperpowersComparisonMatrix(envelope) {
+  const matrix = envelope.superpowers_comparison_matrix;
+  console.log('Vibecoding Runtime Superpowers Comparative Evidence Matrix');
+  console.log(`Stage: ${matrix.stage}; Kind: ${matrix.comparison_kind}; pass=${matrix.ok}`);
+  console.log(`Target: ${matrix.comparison_target}; root=${matrix.source_bindings.superpowers_root}`);
+  console.log(`Sources: superpowers=${matrix.source_bindings.superpowers.present_files}/${matrix.source_bindings.superpowers.files}; vibecoding=${matrix.source_bindings.vibecoding.present_files}/${matrix.source_bindings.vibecoding.files}`);
+  for (const dimension of matrix.dimensions) {
+    console.log(`- ${dimension.id}: status=${dimension.status}; delta=${dimension.delta}; superpowers=${dimension.superpowers_score}; vibecoding=${dimension.vibecoding_score}; stage=${dimension.recommended_stage}`);
+  }
+  const parityGapLines = matrix.parity_gaps.length > 0
+    ? matrix.parity_gaps.map((gap) => `${gap.id}: ${gap.status}; ${gap.recommended_stage}; ${gap.borrowable_pattern}`)
+    : ['none'];
+  printList('Parity gaps', parityGapLines);
+  printList('Vibecoding advantages', matrix.vibecoding_advantages);
+  printList('Borrowable patterns', matrix.borrowable_patterns.map((item) => `${item.dimension}: ${item.target_stage}; ${item.pattern}`));
+  printList('Do not copy', matrix.do_not_copy);
+  printList('Recommended stage sequence', matrix.recommended_stage_sequence);
+  console.log(`Next comparison bet: ${matrix.next_comparison_bet.id}; target=${matrix.next_comparison_bet.target_stage}; ${matrix.next_comparison_bet.action}`);
+  console.log('Boundary: writes=false; superpowers_comparison_artifact=false; comparison_matrix_artifact=false; source_write=false; sidecar_write=false; state_directory_created=false; command_execution=false; check_execution=false; smoke_execution=false; test_execution=false; verification_execution=false; hook_execution=false; workflow_execution=false; skill_execution=false; runtime_action=false; auto_execution=false; repair_execution=false; prompt_mutation=false; hook_registration=false; dynamic_tool_execution=false; embeddings=false; remote_config=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; git=false; git_write=false; git_add=false; commit=false; pr=false; push=false; merge=false; business_source_write=false');
+  console.log(`Superpowers comparison digest: ${matrix.comparison_digest}`);
+  if (envelope.quality.length > 0) printList('Findings', envelope.quality);
+  console.log(`Action: ${envelope.action}`);
+}
+
+function superpowersGapEnvelope(root, superpowersDirectoryInput) {
+  ensureRoot(root);
+  const sources = superpowersGapSourceBundle(root, superpowersDirectoryInput);
+  const registry = runtimeCapabilityRegistry();
+  const gapBase = runtimeSuperpowersGapMatrix({
+    superpowersSources: sources.superpowers_sources,
+    vibecodingSources: sources.vibecoding_sources,
+    registry,
+  });
+  const gapMatrix = {
+    ...gapBase,
+    gap_matrix_digest: digestSuperpowersGapMatrix(runtimeSuperpowersGapDigestPayload(gapBase)),
+  };
+  return {
+    mode: 'superpowers-gap-matrix',
+    ok: gapMatrix.gap_matrix_invariants.pass,
+    state_present: fs.existsSync(stateDir(root)),
+    superpowers_gap_matrix: gapMatrix,
+    safety: { stage: 'Stage 115', ...gapMatrix.boundary_assertions },
+    quality: gapMatrix.gap_matrix_invariants.findings,
+    action: 'superpowers gap matrix was computed read-only from local fork/superpowers and Vibecoding source files. No state directory, sidecar, command, check, test, skill execution, runtime action, git, commit, push, PR, merge, platform API, external network, model, MCP, subagent, worktree, or business source write occurred.',
+  };
+}
+
+function printSuperpowersGapMatrix(envelope) {
+  const matrix = envelope.superpowers_gap_matrix;
+  console.log('Vibecoding Runtime Superpowers Gap Matrix');
+  console.log(`Stage: ${matrix.stage}; Kind: ${matrix.gap_kind}; pass=${matrix.gap_matrix_invariants.pass}`);
+  console.log(`Sources: superpowers=${matrix.source_summary.superpowers.present_files}/${matrix.source_summary.superpowers.files}; vibecoding=${matrix.source_summary.vibecoding.present_files}/${matrix.source_summary.vibecoding.files}`);
+  for (const dimension of matrix.dimensions) {
+    console.log(`- ${dimension.id}: priority=${dimension.priority}; superpowers=${dimension.superpowers_score}; vibecoding=${dimension.vibecoding_score}; stage=${dimension.recommended_stage}`);
+  }
+  printList('Priority gaps', matrix.priority_gaps.map((gap) => `${gap.id}: ${gap.recommended_stage}; ${gap.gap}`));
+  printList('Recommended stage sequence', matrix.recommended_stage_sequence);
+  console.log('Boundary: writes=false; superpowers_gap_artifact=false; command_execution=false; skill_execution=false; git=false; git_write=false; commit=false; pr=false; push=false; merge=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; business_source_write=false');
+  console.log(`Superpowers gap digest: ${matrix.gap_matrix_digest}`);
+  console.log(`Manual action: ${matrix.manual_action}`);
+  console.log(`Action: ${envelope.action}`);
+}
+
+function superpowersRegressionGuardEnvelope(root, superpowersDirectoryInput) {
+  ensureRoot(root);
+  const gapMatrix = superpowersGapEnvelope(root, superpowersDirectoryInput).superpowers_gap_matrix;
+  const registry = runtimeCapabilityRegistry();
+  const registryDigest = digestObject(registry);
+  const automationReadiness = runtimeAutomationReadinessMatrix(registry, registryDigest);
+  const traceabilityMap = runtimeSkillRuntimeTraceabilityMap(root, registry);
+  const guard = runtimeSuperpowersRegressionGuard({ gapMatrix, registry, automationReadiness, traceabilityMap });
+  return {
+    mode: 'superpowers-regression-guard',
+    ok: guard.ok,
+    state_present: fs.existsSync(stateDir(root)),
+    superpowers_regression_guard: guard,
+    safety: { stage: 'Stage 125', ...guard.boundary_assertions },
+    quality: guard.blockers,
+    action: 'superpowers regression guard was computed read-only from local Superpowers comparison sources, Stage 115 gap matrix, runtime registry, automation readiness, and Stage 123 traceability. No state directory, sidecar, command, check, test, workflow skill execution, runtime action, git, commit, push, PR, merge, platform API, external network, model, MCP, subagent, worktree, or business source write occurred.',
+  };
+}
+
+function printSuperpowersRegressionGuard(envelope) {
+  const guard = envelope.superpowers_regression_guard;
+  console.log('Vibecoding Runtime Superpowers Regression Guard');
+  console.log(`Stage: ${guard.stage}; Guard: ${guard.guard_kind}; pass=${guard.ok}`);
+  console.log(`Claim: ${guard.superiority_claim}; Target: ${guard.comparison_target}`);
+  console.log(`Registry: ${guard.source_bindings.registry_stage}; version=${guard.source_bindings.registry_version}`);
+  console.log(`Protected stage sequence: ${guard.protected_stage_sequence.join(' -> ')}`);
+  console.log(`Invariants: regression_guard_invariants.pass=${guard.regression_guard_invariants.pass}`);
+  for (const gate of guard.regression_gates) console.log(`- ${gate.gate}: pass=${gate.pass}`);
+  printList('Protected capabilities', guard.protected_capabilities.map((item) => `${item.stage}: ${item.command}; category=${item.automation_category}; pass=${item.pass}`));
+  printList('Dimension scorecard', guard.dimension_scorecard.map((item) => `${item.dimension}: ${item.status}; stages=${item.protected_stages.join('|')}`));
+  if (guard.blockers.length > 0) printList('Blocked reasons', guard.blockers);
+  console.log('Boundary: writes=false; superpowers_regression_guard_artifact=false; superpowers_gap_artifact=false; traceability_map_artifact=false; automation_readiness_artifact=false; command_execution=false; check_execution=false; test_execution=false; git=false; git_write=false; pr=false; push=false; merge=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; business_source_write=false');
+  console.log(`Regression guard digest: ${guard.regression_guard_digest}`);
+  console.log(`Manual next action: ${guard.manual_next_action}`);
+  console.log(`Action: ${envelope.action}`);
+}
+
+function governanceConvergenceBoundaryAssertions() {
+  return {
+    writes: false,
+    state_directory_created: false,
+    migration_applied: false,
+    skill_mutation: false,
+    hook_registration: false,
+    shell_interception: false,
+    external_network: false,
+    model_invocation: false,
+    platform_api: false,
+    runtime_action: false,
+    auto_execution: false,
+    business_source_write: false,
+    source_merge: false,
+    subagent: false,
+    mcp: false,
+    [backgroundProcessBoundaryKey]: false,
+    git: false,
+    worktree: false,
+  };
+}
+
+function governanceConvergenceSafety() {
+  return {
+    stage: 'Stage 59',
+    convergence_report: true,
+    skill_execution: false,
+    dispatch_event_modified: false,
+    claim_modified: false,
+    ...governanceConvergenceBoundaryAssertions(),
+  };
+}
+
+function governanceConvergenceEnvelope(root) {
+  ensureRoot(root);
+  const dimensions = governanceConvergenceDimensions();
+  const statusCounts = dimensions.reduce((acc, item) => {
+    acc[item.status] = (acc[item.status] || 0) + 1;
+    return acc;
+  }, {});
+  const contract = {
+    stage: 'Stage 59',
+    report_kind: 'capability-convergence-gap-report',
+    writes: false,
+    state_directory_created: false,
+    convergence_target: 'Superpowers workflow experience + ECC learning model + Token Savior deterministic token economy + Vibecoding runtime governance',
+    default_adapters: {
+      superpowers_workflow_ux: 'absorb trigger discipline and workflow ergonomics without copying incompatible voice or bypassing user rules',
+      ecc_learning_model: 'absorb local project-scoped observation and candidate instinct model without auto-mutating skills',
+      token_savior: 'absorb deterministic compactors, profiles, and metrics without MCP requirement in the default runtime path',
+      distill: 'treat LLM distillation as deferred optional adapter; default remains deterministic and verify-first',
+      vibecoding_governance: 'all new capabilities must remain sidecar-only, digest-bound, locally verifiable, and no external action by default',
+    },
+    stage_sequence: ['Stage 60 workflow UX parity', 'Stage 61 learning ledger', 'Stage 62 candidate instinct promotion gate', 'Stage 63 deterministic token compactors', 'Stage 64 token metrics and rewrite preview', 'Stage 65 governance convergence gate'],
+    policy_catalog_digest: runtimePolicyCatalogDigest(),
+    eval_catalog_digest: evalCatalogDefinition().catalog_digest,
+    dimensions,
+    summary: {
+      total_dimensions: dimensions.length,
+      implemented: statusCounts.implemented || 0,
+      partially_implemented: statusCounts['partially-implemented'] || 0,
+      planned: statusCounts.planned || 0,
+      deferred: statusCounts.deferred || 0,
+    },
+    boundary_assertions: governanceConvergenceBoundaryAssertions(),
+  };
+  return {
+    mode: 'governance-convergence-report',
+    ok: true,
+    state_present: fs.existsSync(stateDir(root)),
+    convergence: { ...contract, convergence_digest: digestObject(contract) },
+    safety: governanceConvergenceSafety(),
+    quality: dimensions.filter((item) => item.status !== 'implemented').map((item) => `${item.id}: ${item.current_gap}`),
+    action: 'capability convergence gap report was computed read-only. No state directory, skill, hook, shell interception, external network, model, platform API, git, worktree, or business source write occurred.',
+  };
+}
+
+  return {
+    governanceCompatibilityEnvelope,
+    printGovernanceCompatibility,
+    governanceConvergenceEnvelope,
+    sourceDescriptor,
+    localDirectoryWithinRoot,
+    superpowersGapEnvelope,
+    printSuperpowersGapMatrix,
+    superpowersComparisonEnvelope,
+    printSuperpowersComparisonMatrix,
+    superpowersRegressionGuardEnvelope,
+    printSuperpowersRegressionGuard,
+  };
+}