@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-suite-plan-model.mjs

@@ -0,0 +1,194 @@
+import crypto from 'node:crypto';
+
+const suitePlanStage = 'P5';
+const suitePlanKind = 'timing-suite-selection-plan';
+
+const changeKindProfiles = Object.freeze({
+  runtime: {
+    recommended_suite: 'runtime',
+    fallback_suites: ['runtime:surface', 'runtime:execution-boundary', 'fast'],
+    full_gate_required_when: ['release boundary changed', 'runtime registry changed', 'completion gate changed'],
+  },
+  release: {
+    recommended_suite: 'fast',
+    fallback_suites: ['runtime:release-closeout', 'runtime:state-ledger'],
+    full_gate_required_when: ['release gate behavior changed', 'commit readiness changed', 'diff evidence changed'],
+  },
+  execution: {
+    recommended_suite: 'runtime:execution-boundary',
+    fallback_suites: ['runtime', 'fast'],
+    full_gate_required_when: ['execution boundary changed', 'allowlist changed', 'state write changed'],
+  },
+  docs: {
+    recommended_suite: 'fast',
+    fallback_suites: ['runtime:experience', 'install'],
+    full_gate_required_when: ['runtime docs markers changed', 'install docs changed', 'template entry changed'],
+  },
+  unknown: {
+    recommended_suite: 'fast',
+    fallback_suites: ['runtime', 'install'],
+    full_gate_required_when: ['change kind is unclear', 'cross-module change detected'],
+  },
+});
+
+export function runtimeSuitePlanEnvelope({ timingSummary = {}, timingFile = '', changeKind = 'unknown', digestObject = digestValue } = {}) {
+  const profile = changeKindProfiles[changeKind] || changeKindProfiles.unknown;
+  const timing = normalizeTiming(timingSummary);
+  const slowCommands = slowCommandDiagnostics(timing);
+  const hotLayers = hotLayerDiagnostics(timing);
+  const planCore = {
+    version: 1,
+    stage: suitePlanStage,
+    plan_kind: suitePlanKind,
+    change_kind: changeKindProfiles[changeKind] ? changeKind : 'unknown',
+    timing_file: timingFile ? fileNameOnly(timingFile) : '',
+    timing_digest: digestObject(timingSummary),
+    source_suite: timingSummary.suite || 'unknown',
+    source_result: timingSummary.result || 'unknown',
+    command_count: Number.isInteger(timingSummary.command_count) ? timingSummary.command_count : timing.length,
+    timing_record_count: timing.length,
+    recommended_targeted_suite: profile.recommended_suite,
+    fallback_suites: profile.fallback_suites,
+    required_gate_unchanged: true,
+    required_gate_policy: 'advisory-only; never lowers required release gate, command order, or failure strictness',
+    slow_command_diagnostics: slowCommands,
+    hot_layer_diagnostics: hotLayers,
+    still_run_full_or_fast_when: profile.full_gate_required_when,
+    advisory_only: true,
+    package_scripts_changed: false,
+    release_check_order_changed: false,
+    failure_strictness_changed: false,
+    command_execution: false,
+    suite_execution: false,
+    writes: false,
+    state_directory_created: false,
+    git: false,
+    git_write: false,
+    worktree_write: false,
+    boundary_assertions: suitePlanBoundaryAssertions(),
+  };
+  const invariants = suitePlanInvariants(planCore);
+  return {
+    mode: 'timing-suite-selection-plan',
+    ok: invariants.pass,
+    suite_selection_plan: {
+      ...planCore,
+      suite_plan_invariants: invariants,
+      suite_plan_digest: digestObject({ ...planCore, suite_plan_invariants: invariants }),
+    },
+    safety: {
+      stage: suitePlanStage,
+      writes: false,
+      suite_plan_artifact: false,
+      command_execution: false,
+      suite_execution: false,
+      package_scripts_changed: false,
+      release_check_order_changed: false,
+      failure_strictness_changed: false,
+      git: false,
+      git_write: false,
+      worktree_write: false,
+    },
+    action: 'Suite selection plan was computed from local timing summary only. It is advisory and does not change package scripts, release-check order, required gate, or failure strictness.',
+  };
+}
+
+export function printRuntimeSuitePlan(envelope) {
+  const plan = envelope.suite_selection_plan || {};
+  console.log('Vibecoding Runtime Timing Suite Plan');
+  console.log(`Stage: ${plan.stage}; Kind: ${plan.plan_kind}; pass=${plan.suite_plan_invariants?.pass}`);
+  console.log(`Change kind: ${plan.change_kind}; recommended=${plan.recommended_targeted_suite}`);
+  console.log(`Required gate unchanged: ${plan.required_gate_unchanged}; advisory_only=${plan.advisory_only}`);
+  console.log(`Timing: suite=${plan.source_suite}; result=${plan.source_result}; records=${plan.timing_record_count}`);
+  console.log(`Hot layers: ${plan.hot_layer_diagnostics?.map((item) => `${item.layer}:${item.duration_ms}ms`).join(', ') || 'none'}`);
+  console.log(`Slow commands: ${plan.slow_command_diagnostics?.map((item) => `${item.duration_ms}ms ${item.label}`).join(' | ') || 'none'}`);
+  console.log(`Boundary: writes=${plan.writes}; command_execution=${plan.command_execution}; suite_execution=${plan.suite_execution}; package_scripts_changed=${plan.package_scripts_changed}; release_check_order_changed=${plan.release_check_order_changed}; failure_strictness_changed=${plan.failure_strictness_changed}; git_write=${plan.git_write}; worktree_write=${plan.worktree_write}`);
+  console.log(`Suite plan digest: ${plan.suite_plan_digest}`);
+}
+
+function fileNameOnly(file) {
+  const normalized = String(file || '').replace(/\\/g, '/');
+  const parts = normalized.split('/').filter(Boolean);
+  return parts.at(-1) || '';
+}
+
+function normalizeTiming(summary) {
+  if (Array.isArray(summary.timing)) return summary.timing;
+  if (Array.isArray(summary.records)) return summary.records;
+  if (Array.isArray(summary.diagnostics?.slowest_timing)) return summary.diagnostics.slowest_timing.map((item) => ({ label: item.label, durationMs: item.duration_ms }));
+  return [];
+}
+
+function slowCommandDiagnostics(timing) {
+  return [...timing]
+    .map((item) => ({
+      label: String(item.label || item.display || 'unknown'),
+      duration_ms: Number(item.durationMs ?? item.duration_ms ?? 0),
+      runtime_suite_layer: item.runtimeSuiteLayer || item.runtime_suite_layer || 'unlayered',
+    }))
+    .sort((left, right) => right.duration_ms - left.duration_ms)
+    .slice(0, 5);
+}
+
+function hotLayerDiagnostics(timing) {
+  const layers = new Map();
+  for (const item of timing) {
+    const layer = item.runtimeSuiteLayer || item.runtime_suite_layer || 'unlayered';
+    const current = layers.get(layer) || { layer, command_count: 0, duration_ms: 0 };
+    current.command_count += 1;
+    current.duration_ms += Number(item.durationMs ?? item.duration_ms ?? 0);
+    layers.set(layer, current);
+  }
+  return [...layers.values()].sort((left, right) => right.duration_ms - left.duration_ms).slice(0, 5);
+}
+
+function suitePlanInvariants(plan) {
+  const findings = [
+    ...(plan.advisory_only === true ? [] : ['suite plan must remain advisory_only']),
+    ...(plan.required_gate_unchanged === true ? [] : ['required gate must remain unchanged']),
+    ...(plan.package_scripts_changed === false ? [] : ['package scripts must not change']),
+    ...(plan.release_check_order_changed === false ? [] : ['release-check order must not change']),
+    ...(plan.failure_strictness_changed === false ? [] : ['failure strictness must not change']),
+    ...(plan.command_execution === false && plan.suite_execution === false ? [] : ['suite plan must not execute commands or suites']),
+    ...(plan.writes === false && plan.state_directory_created === false ? [] : ['suite plan must not write state']),
+    ...(plan.git === false && plan.git_write === false && plan.worktree_write === false ? [] : ['git and worktree boundaries must remain false']),
+  ];
+  return {
+    pass: findings.length === 0,
+    checked: ['advisory_only', 'required_gate_unchanged', 'no_suite_execution', 'no_script_or_order_change', 'git_boundaries'],
+    findings,
+  };
+}
+
+function suitePlanBoundaryAssertions() {
+  return {
+    suite_plan_artifact: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    command_execution: false,
+    suite_execution: false,
+    package_scripts_changed: false,
+    release_check_order_changed: false,
+    failure_strictness_changed: false,
+    required_gate_lowered: false,
+    git: false,
+    git_write: false,
+    worktree_write: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    mcp: false,
+    subagent: false,
+    business_source_write: false,
+  };
+}
+
+function digestValue(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(',')}]`;
+  if (value && typeof value === 'object') return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+  return JSON.stringify(value);
+}

package/tools/vibe-runtime/runtime-superpowers-comparison-matrix.mjs

@@ -0,0 +1,399 @@
+import crypto from 'node:crypto';
+
+const comparisonStage = 'Stage 133';
+const comparisonKind = 'superpowers-comparative-evidence-matrix';
+const comparisonTarget = 'fork/superpowers';
+
+const comparisonDimensions = [
+  {
+    id: 'session_start_bootstrap',
+    label: 'Session-start bootstrap',
+    superpowers_markers: ['session-start', 'You have superpowers', 'using-superpowers', 'additionalContext'],
+    vibecoding_markers: ['session-start.mjs', 'using-vibecoding', 'lightweight routing', 'injectsFullSkill=false'],
+    why_it_matters: 'The first session turn determines whether the agent naturally enters the workflow instead of jumping to code.',
+    borrowable_pattern: 'Adopt explicit hook output-shape acceptance across adapters.',
+    do_not_copy: 'Do not inject the full using-vibecoding skill by default.',
+    recommended_stage: 'Stage 134',
+  },
+  {
+    id: 'skill_trigger_discipline',
+    label: 'Skill trigger discipline',
+    superpowers_markers: ['1% chance', 'ABSOLUTELY MUST', 'Invoke relevant or requested skills BEFORE', 'Red Flags'],
+    vibecoding_markers: ['轻量分流', 'using-vibecoding', '不要声称已使用某个 skill', 'L0'],
+    why_it_matters: 'Trigger discipline prevents silent process skips, especially on ambiguous or risky work.',
+    borrowable_pattern: 'Convert trigger expectations into transcript-level entry discipline checks.',
+    do_not_copy: 'Do not make every task a full workflow ceremony.',
+    recommended_stage: 'Stage 135',
+  },
+  {
+    id: 'methodology_coverage',
+    label: 'Methodology coverage',
+    superpowers_markers: ['brainstorming', 'writing-plans', 'test-driven-development', 'verification-before-completion'],
+    vibecoding_markers: ['vibe-brainstorming', 'vibe-writing-plans', 'vibe-test-driven-development', 'vibe-verification-before-completion'],
+    why_it_matters: 'A横向比较只有覆盖到核心方法论，后续 stage 才不会只补入口体验。',
+    borrowable_pattern: 'Map Superpowers method assets to Vibecoding skills and runtime gates.',
+    do_not_copy: 'Do not add duplicate skills when an existing Vibecoding skill already covers the method.',
+    recommended_stage: 'Stage 136',
+  },
+  {
+    id: 'hook_shape_coverage',
+    label: 'Hook output shape coverage',
+    superpowers_markers: ['hookSpecificOutput', 'additional_context', 'additionalContext', 'SessionStart'],
+    vibecoding_markers: ['hookSpecificOutput', 'additional_context', 'additionalContext', '--format'],
+    why_it_matters: 'Different harnesses accept different context field names; shape drift breaks natural entry.',
+    borrowable_pattern: 'Validate captured session-start output instead of trusting manifest prose.',
+    do_not_copy: 'Do not execute platform hooks from governance comparison.',
+    recommended_stage: 'Stage 134',
+  },
+  {
+    id: 'adapter_packaging',
+    label: 'Adapter packaging',
+    superpowers_markers: ['plugin.json', 'skills', 'hooks', 'plugin marketplace'],
+    vibecoding_markers: ['plugin.json', 'installedSkills', 'sessionStartBootstrap', 'runtimeBridge'],
+    why_it_matters: 'Packaging defines whether users install once and immediately get the intended entry behavior.',
+    borrowable_pattern: 'Score install experience from manifest, bootstrap matrix, and entry transcript evidence.',
+    do_not_copy: 'Do not require a marketplace-only install path for local deterministic usage.',
+    recommended_stage: 'Stage 137',
+  },
+  {
+    id: 'eval_and_test_harness',
+    label: 'Eval and test harness',
+    superpowers_markers: ['tests', 'eval', 'run-skill-tests', 'test-session-start'],
+    vibecoding_markers: ['vibe-runtime-check', 'vibe-release-check', 'evals --behavior-contract', 'release-check'],
+    why_it_matters: 'Experience claims need behavior-shaped checks, not only static docs markers.',
+    borrowable_pattern: 'Create Superpowers-style behavior scenario packs as local contracts.',
+    do_not_copy: 'Do not run live agent evals or model judges from default runtime checks.',
+    recommended_stage: 'Stage 138',
+  },
+  {
+    id: 'subagent_boundary',
+    label: 'Subagent boundary',
+    superpowers_markers: ['subagent', 'fresh subagent', 'dispatch', 'review'],
+    vibecoding_markers: ['subagent', '用户明确允许', 'canCallSubagent', 'subagent=false'],
+    why_it_matters: 'Superpowers leans on autonomous subagents; Vibecoding must preserve explicit permission and local eligibility gates.',
+    borrowable_pattern: 'Keep subagent value visible as a candidate workflow while requiring explicit permission.',
+    do_not_copy: 'Do not default to agent-first delegation or hidden session creation.',
+    recommended_stage: 'Stage 139',
+  },
+  {
+    id: 'contributor_guardrails',
+    label: 'Contributor guardrails',
+    superpowers_markers: ['PULL_REQUEST_TEMPLATE', 'Existing PRs', 'Identify yourself', 'human partner'],
+    vibecoding_markers: ['release --commit-readiness', 'review --intake', 'completion --evidence-bundle', 'PR'],
+    why_it_matters: 'External contribution workflows need evidence, disclosure, and duplicate avoidance before PR creation.',
+    borrowable_pattern: 'Translate contributor guardrails into local completion/release evidence requirements.',
+    do_not_copy: 'Do not automate PR creation or remote PR searches from the local runtime.',
+    recommended_stage: 'Stage 139',
+  },
+  {
+    id: 'token_and_context_economy',
+    label: 'Token and context economy',
+    superpowers_markers: ['full content', 'Skill tool', 'session-start', 'context'],
+    vibecoding_markers: ['Token Savior', 'tokens --savior-budget', 'compact', 'skills_to_defer'],
+    why_it_matters: 'Natural entry must not inflate context until the user needs deeper workflow guidance.',
+    borrowable_pattern: 'Use comparison findings to prioritize which context should surface first.',
+    do_not_copy: 'Do not inject all skill text at session start.',
+    recommended_stage: 'Stage 139',
+  },
+  {
+    id: 'daily_user_friction',
+    label: 'Daily user friction',
+    superpowers_markers: ['you don\'t need to do anything special', 'automatically', 'Quickstart', 'go'],
+    vibecoding_markers: ['workflow --start', 'workflow --next-action-console', 'automation --stage-scriptlet', 'experience dashboard'],
+    why_it_matters: 'The final measure is whether the user has fewer decisions, fewer commands to remember, and clearer evidence needs.',
+    borrowable_pattern: 'Feed comparison results into a deterministic upgrade prioritizer.',
+    do_not_copy: 'Do not trade explicit user control for invisible automation.',
+    recommended_stage: 'Stage 140',
+  },
+];
+
+export function runtimeSuperpowersComparisonMatrix({ superpowersSources = [], vibecodingSources = [], registry = {}, source = {} } = {}) {
+  const dimensions = comparisonDimensions.map((definition) => dimensionComparison(definition, superpowersSources, vibecodingSources));
+  const parityGaps = parityGapsFromDimensions(dimensions);
+  const matrixCore = {
+    version: 1,
+    stage: comparisonStage,
+    comparison_kind: comparisonKind,
+    comparison_target: comparisonTarget,
+    source_bindings: sourceBindingSummary(source, superpowersSources, vibecodingSources),
+    registry_binding: {
+      registry_stage: registry.registry_stage || '',
+      registry_kind: registry.registry_kind || '',
+      registry_version: registry.registry_version || 0,
+    },
+    dimensions,
+    parity_gaps: parityGaps,
+    vibecoding_advantages: vibecodingAdvantages(dimensions),
+    borrowable_patterns: borrowablePatterns(dimensions),
+    do_not_copy: doNotCopyPatterns(dimensions),
+    recommended_stage_sequence: recommendedStageSequence(dimensions),
+    next_comparison_bet: nextComparisonBet(parityGaps),
+    boundary_assertions: runtimeSuperpowersComparisonBoundaryAssertions(),
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = runtimeSuperpowersComparisonInvariants(matrixCore);
+  const matrix = {
+    ...matrixCore,
+    ok: invariants.pass,
+    superpowers_comparison_invariants: invariants,
+  };
+  return {
+    ...matrix,
+    comparison_digest: digestSuperpowersComparison(runtimeSuperpowersComparisonDigestPayload(matrix)),
+  };
+}
+
+export function runtimeSuperpowersComparisonDigestPayload(matrix) {
+  return {
+    stage: matrix.stage,
+    comparison_kind: matrix.comparison_kind,
+    comparison_target: matrix.comparison_target,
+    source_bindings: matrix.source_bindings,
+    registry_binding: matrix.registry_binding,
+    dimensions: matrix.dimensions,
+    parity_gaps: matrix.parity_gaps,
+    vibecoding_advantages: matrix.vibecoding_advantages,
+    borrowable_patterns: matrix.borrowable_patterns,
+    do_not_copy: matrix.do_not_copy,
+    recommended_stage_sequence: matrix.recommended_stage_sequence,
+    next_comparison_bet: matrix.next_comparison_bet,
+    boundary_assertions: matrix.boundary_assertions,
+    superpowers_comparison_invariants: matrix.superpowers_comparison_invariants,
+  };
+}
+
+export function runtimeSuperpowersComparisonBoundaryAssertions() {
+  return {
+    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,
+    daemon: false,
+    git: false,
+    git_write: false,
+    git_add: false,
+    commit: false,
+    pr: false,
+    push: false,
+    merge: false,
+    tag: false,
+    worktree: false,
+    business_source_write: false,
+  };
+}
+
+export function runtimeSuperpowersComparisonInvariants(matrix) {
+  const dimensionIds = (matrix.dimensions || []).map((dimension) => dimension.id);
+  const expectedIds = comparisonDimensions.map((dimension) => dimension.id);
+  const missingDimensions = expectedIds.filter((id) => !dimensionIds.includes(id));
+  const duplicateDimensions = dimensionIds.filter((id, index, ids) => ids.indexOf(id) !== index);
+  const unsafeBoundaries = Object.entries(matrix.boundary_assertions || {})
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const missingForbidden = ['superpowers_comparison_artifact', 'comparison_matrix_artifact', 'source_write', 'sidecar_write', 'state_directory_created', 'command_execution', 'check_execution', 'smoke_execution', 'test_execution', 'verification_execution', 'hook_execution', 'workflow_execution', 'skill_execution', 'runtime_action', 'auto_execution', 'platform_api', 'external_network', 'model_invocation', 'subagent', 'mcp', 'git', 'git_write', 'git_add', 'commit', 'pr', 'push', 'merge', 'business_source_write']
+    .filter((key) => matrix.boundary_assertions?.[key] !== false);
+  const findings = [
+    ...(matrix.stage === comparisonStage ? [] : [`stage must be ${comparisonStage}`]),
+    ...(matrix.comparison_kind === comparisonKind ? [] : [`comparison_kind must be ${comparisonKind}`]),
+    ...(matrix.comparison_target === comparisonTarget ? [] : [`comparison_target must be ${comparisonTarget}`]),
+    ...(matrix.source_bindings?.superpowers?.present_files > 0 ? [] : ['superpowers source files must be present']),
+    ...(matrix.source_bindings?.vibecoding?.present_files > 0 ? [] : ['vibecoding source files must be present']),
+    ...(matrix.registry_binding?.registry_version >= 32 ? [] : ['registry version must be at least 32 before Stage 133']),
+    ...(Array.isArray(matrix.parity_gaps) ? [] : ['parity_gaps must be a list']),
+    ...(Array.isArray(matrix.vibecoding_advantages) ? [] : ['vibecoding_advantages must be a list']),
+    ...(Array.isArray(matrix.borrowable_patterns) ? [] : ['borrowable_patterns must be a list']),
+    ...(Array.isArray(matrix.do_not_copy) ? [] : ['do_not_copy must be a list']),
+    ...(matrix.next_comparison_bet?.target_stage ? [] : ['next_comparison_bet.target_stage is required']),
+    ...missingDimensions.map((id) => `missing comparison dimension: ${id}`),
+    ...duplicateDimensions.map((id) => `duplicate comparison dimension: ${id}`),
+    ...unsafeBoundaries.map((key) => `boundary assertion must remain false: ${key}`),
+    ...missingForbidden.map((key) => `forbidden boundary missing or not false: ${key}`),
+  ];
+  return {
+    pass: findings.length === 0,
+    checked: ['source_bindings', 'registry_binding', 'dimension_coverage', 'parity_gaps', 'borrowable_patterns', 'do_not_copy', 'next_comparison_bet', 'read_only_boundary_assertions'],
+    findings,
+  };
+}
+
+export function digestSuperpowersComparison(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function dimensionComparison(definition, superpowersSources, vibecodingSources) {
+  const superpowersEvidence = evidenceForMarkers(superpowersSources, definition.superpowers_markers);
+  const vibecodingEvidence = evidenceForMarkers(vibecodingSources, definition.vibecoding_markers);
+  const superpowersScore = scoreEvidence(superpowersEvidence);
+  const vibecodingScore = scoreEvidence(vibecodingEvidence);
+  const delta = superpowersScore - vibecodingScore;
+  return {
+    id: definition.id,
+    label: definition.label,
+    why_it_matters: definition.why_it_matters,
+    superpowers_score: superpowersScore,
+    vibecoding_score: vibecodingScore,
+    delta,
+    status: dimensionStatus(delta),
+    recommended_stage: definition.recommended_stage,
+    borrowable_pattern: definition.borrowable_pattern,
+    do_not_copy: definition.do_not_copy,
+    superpowers_evidence: superpowersEvidence,
+    vibecoding_evidence: vibecodingEvidence,
+  };
+}
+
+function evidenceForMarkers(sources, markers) {
+  return markers.map((marker) => {
+    const hits = sources.filter((source) => source.present && source.marker_hits?.includes(marker));
+    return {
+      marker,
+      present: hits.length > 0,
+      files: hits.map((source) => source.file).slice(0, 8),
+    };
+  });
+}
+
+function scoreEvidence(evidence) {
+  if (!Array.isArray(evidence) || evidence.length === 0) return 0;
+  return Math.round((evidence.filter((item) => item.present).length / evidence.length) * 100);
+}
+
+function dimensionStatus(delta) {
+  if (delta >= 30) return 'superpowers-leads';
+  if (delta >= 10) return 'watch-gap';
+  if (delta <= -20) return 'vibecoding-leads';
+  return 'near-parity';
+}
+
+function parityGapsFromDimensions(dimensions) {
+  return dimensions
+    .filter((dimension) => ['superpowers-leads', 'watch-gap'].includes(dimension.status))
+    .map((dimension) => ({
+      id: dimension.id,
+      status: dimension.status,
+      delta: dimension.delta,
+      recommended_stage: dimension.recommended_stage,
+      reason: dimension.why_it_matters,
+      borrowable_pattern: dimension.borrowable_pattern,
+    }));
+}
+
+function vibecodingAdvantages(dimensions) {
+  const evidenceBased = dimensions
+    .filter((dimension) => dimension.status === 'vibecoding-leads')
+    .map((dimension) => `${dimension.id}: Vibecoding has stronger local evidence coverage by ${Math.abs(dimension.delta)} points.`);
+  return [
+    'local deterministic runtime contracts with digest-bound envelopes',
+    'explicit no-execution/no-git/no-platform/no-model/no-subagent boundaries',
+    'installed-project layout keeps workflow assets under .vibecoding while preserving root entry files',
+    'runtime-check and release-check enforce marker and smoke coverage across stages',
+    ...evidenceBased,
+  ];
+}
+
+function borrowablePatterns(dimensions) {
+  return dimensions.map((dimension) => ({
+    dimension: dimension.id,
+    pattern: dimension.borrowable_pattern,
+    target_stage: dimension.recommended_stage,
+  }));
+}
+
+function doNotCopyPatterns(dimensions) {
+  return [...new Set([
+    ...dimensions.map((dimension) => dimension.do_not_copy),
+    'Do not call external platform APIs, models, MCP, or subagents from comparison contracts.',
+    'Do not turn local comparison into automatic repair, PR creation, push, merge, or hook execution.',
+  ])];
+}
+
+function recommendedStageSequence(dimensions) {
+  return [...new Set(dimensions.map((dimension) => dimension.recommended_stage))]
+    .filter(Boolean)
+    .sort((left, right) => Number(left.replace(/\D/g, '')) - Number(right.replace(/\D/g, '')));
+}
+
+function nextComparisonBet(parityGaps) {
+  const first = parityGaps[0] || null;
+  if (!first) {
+    return {
+      id: 'maintain-parity',
+      target_stage: 'Stage 140',
+      action: 'Use the parity scorecard to preserve current advantages and avoid boundary regressions.',
+    };
+  }
+  return {
+    id: first.id,
+    target_stage: first.recommended_stage,
+    action: first.borrowable_pattern,
+  };
+}
+
+function sourceBindingSummary(source, superpowersSources, vibecodingSources) {
+  return {
+    superpowers_root: stringValue(source.superpowers_root),
+    superpowers_root_digest: stringValue(source.superpowers_root_digest),
+    superpowers: sourceFamilySummary(superpowersSources),
+    vibecoding: sourceFamilySummary(vibecodingSources),
+    source_digest: digestSuperpowersComparison({
+      superpowers_root: stringValue(source.superpowers_root),
+      superpowers: compactSources(superpowersSources),
+      vibecoding: compactSources(vibecodingSources),
+    }),
+  };
+}
+
+function sourceFamilySummary(sources) {
+  return {
+    files: sources.length,
+    present_files: sources.filter((source) => source.present).length,
+    missing_files: sources.filter((source) => !source.present).map((source) => source.file),
+    digest: digestSuperpowersComparison(compactSources(sources)),
+  };
+}
+
+function compactSources(sources) {
+  return sources.map((source) => ({
+    file: source.file,
+    present: source.present,
+    digest: source.digest,
+    marker_hits: source.marker_hits || [],
+  }));
+}
+
+function stringValue(value) {
+  return typeof value === 'string' ? value : '';
+}
+
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+  }
+  return JSON.stringify(value);
+}