@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-superpowers-parity-scorecard.mjs

@@ -0,0 +1,460 @@
+import crypto from 'node:crypto';
+
+const scorecardStage = 'Stage 140';
+const scorecardKind = 'superpowers-parity-scorecard-v2';
+const comparisonStage = 'Stage 133';
+const entryDisciplineStage = 'Stage 135';
+const installExperienceStage = 'Stage 137';
+const upgradesStage = 'Stage 139';
+
+const parityAxisDefinitions = [
+  {
+    id: 'session_start_bootstrap',
+    superpowers_advantage: 'Session-start naturally reminds the agent to use the entry skill.',
+    vibecoding_absorption: 'Kept lightweight session-start routing and scored install natural-entry evidence instead of injecting full skill text.',
+    weight: 12,
+    source: 'install_experience',
+  },
+  {
+    id: 'skill_trigger_discipline',
+    superpowers_advantage: 'Strong trigger language prevents silent workflow skips.',
+    vibecoding_absorption: 'Converted trigger expectations into a transcript-level entry discipline contract with L0/L1/L2 layering.',
+    weight: 14,
+    source: 'entry_discipline',
+  },
+  {
+    id: 'adapter_packaging',
+    superpowers_advantage: 'Plugin packaging makes the first installed session feel automatic.',
+    vibecoding_absorption: 'Scored adapter consistency and manual steps from local bootstrap and entry acceptance evidence.',
+    weight: 10,
+    source: 'install_experience',
+  },
+  {
+    id: 'hook_shape_coverage',
+    superpowers_advantage: 'Hook output shape is tested across multiple harness expectations.',
+    vibecoding_absorption: 'Captured the shape requirement as a local acceptance contract and reflected its install impact.',
+    weight: 10,
+    source: 'comparison',
+  },
+  {
+    id: 'eval_and_test_harness',
+    superpowers_advantage: 'Behavior-focused tests evaluate whether the agent actually follows the method.',
+    vibecoding_absorption: 'Kept behavior scenarios deterministic and deferred live model or agent-session eval runners.',
+    weight: 11,
+    source: 'upgrades',
+  },
+  {
+    id: 'daily_user_friction',
+    superpowers_advantage: 'The user remembers fewer commands and fewer process details.',
+    vibecoding_absorption: 'Fed comparison, dashboard, install, and upgrade ordering into one next-cycle bet.',
+    weight: 13,
+    source: 'upgrades',
+  },
+  {
+    id: 'subagent_boundary',
+    superpowers_advantage: 'Subagent delegation is highly visible as a powerful execution pattern.',
+    vibecoding_absorption: 'Preserved explicit permission gates and marked automatic subagent execution as deferred.',
+    weight: 12,
+    source: 'upgrades',
+  },
+  {
+    id: 'token_and_context_economy',
+    superpowers_advantage: 'Skill guidance appears at the right moment in context.',
+    vibecoding_absorption: 'Kept Token Savior-style budget pressure visible while avoiding full skill injection.',
+    weight: 9,
+    source: 'upgrades',
+  },
+  {
+    id: 'contributor_guardrails',
+    superpowers_advantage: 'Contribution rules push agents toward evidence, disclosure, and PR discipline.',
+    vibecoding_absorption: 'Translated contributor risk into local completion/release guardrail candidates without PR automation.',
+    weight: 9,
+    source: 'comparison',
+  },
+];
+
+export function runtimeSuperpowersParityScorecard({ comparison = {}, entryDiscipline = {}, installExperience = {}, upgrades = {}, source = {} } = {}) {
+  const matrix = unwrapComparison(comparison);
+  const discipline = unwrapEntryDiscipline(entryDiscipline);
+  const install = unwrapInstallExperience(installExperience);
+  const prioritizer = unwrapUpgrades(upgrades);
+  const context = parityContext(matrix, discipline, install, prioritizer);
+  const parityAxes = parityAxisDefinitions.map((definition) => axisScore(definition, context));
+  const score = weightedScore(parityAxes);
+  const core = {
+    version: 1,
+    stage: scorecardStage,
+    scorecard_kind: scorecardKind,
+    source_bindings: sourceBindingSummary(source, matrix, discipline, install, prioritizer),
+    input_summary: inputSummary(matrix, discipline, install, prioritizer),
+    parity_axes: parityAxes,
+    parity_score: score,
+    vibecoding_leads: vibecodingLeads(matrix, prioritizer, parityAxes),
+    remaining_gaps: remainingGaps(parityAxes, prioritizer),
+    do_not_cross_boundaries: doNotCrossBoundaries(matrix, prioritizer),
+    next_cycle_bet: nextCycleBet(parityAxes, prioritizer),
+    boundary_assertions: runtimeSuperpowersParityScorecardBoundaryAssertions(),
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = runtimeSuperpowersParityScorecardInvariants(core);
+  const scorecard = {
+    ...core,
+    ok: invariants.pass,
+    parity_invariants: invariants,
+  };
+  return {
+    ...scorecard,
+    parity_digest: digestSuperpowersParityScorecard(runtimeSuperpowersParityScorecardDigestPayload(scorecard)),
+  };
+}
+
+export function runtimeSuperpowersParityScorecardDigestPayload(scorecard) {
+  return {
+    stage: scorecard.stage,
+    scorecard_kind: scorecard.scorecard_kind,
+    source_bindings: scorecard.source_bindings,
+    input_summary: scorecard.input_summary,
+    parity_axes: scorecard.parity_axes,
+    parity_score: scorecard.parity_score,
+    vibecoding_leads: scorecard.vibecoding_leads,
+    remaining_gaps: scorecard.remaining_gaps,
+    do_not_cross_boundaries: scorecard.do_not_cross_boundaries,
+    next_cycle_bet: scorecard.next_cycle_bet,
+    boundary_assertions: scorecard.boundary_assertions,
+    parity_invariants: scorecard.parity_invariants,
+  };
+}
+
+export function runtimeSuperpowersParityScorecardBoundaryAssertions() {
+  return {
+    parity_scorecard_artifact: false,
+    scorecard_artifact: false,
+    comparison_artifact: false,
+    entry_discipline_artifact: false,
+    install_experience_artifact: false,
+    upgrades_artifact: false,
+    source_write: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    command_execution: false,
+    check_execution: false,
+    smoke_execution: false,
+    test_execution: false,
+    eval_execution: false,
+    agent_session_execution: false,
+    verification_execution: false,
+    workflow_execution: false,
+    skill_execution: false,
+    runtime_action: false,
+    auto_execution: false,
+    repair_execution: false,
+    prompt_mutation: false,
+    hook_registration: false,
+    full_skill_injection: 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 runtimeSuperpowersParityScorecardInvariants(scorecard) {
+  const axes = listValue(scorecard.parity_axes);
+  const axisIds = axes.map((axis) => axis.id);
+  const expectedAxisIds = parityAxisDefinitions.map((axis) => axis.id);
+  const duplicateAxes = axisIds.filter((id, index, ids) => ids.indexOf(id) !== index);
+  const missingAxes = expectedAxisIds.filter((id) => !axisIds.includes(id));
+  const unsafeBoundaries = Object.entries(scorecard.boundary_assertions || {})
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const missingForbidden = Object.keys(runtimeSuperpowersParityScorecardBoundaryAssertions())
+    .filter((key) => scorecard.boundary_assertions?.[key] !== false);
+  const scoreFindings = axes.flatMap((axis) => integerInRange(axis.axis_score, 0, 100) ? [] : [`${axis.id}.axis_score must be integer 0..100`]);
+  const findings = [
+    ...(scorecard.stage === scorecardStage ? [] : [`stage must be ${scorecardStage}`]),
+    ...(scorecard.scorecard_kind === scorecardKind ? [] : [`scorecard_kind must be ${scorecardKind}`]),
+    ...(scorecard.source_bindings?.comparison_file ? [] : ['comparison file binding is required']),
+    ...(scorecard.source_bindings?.entry_discipline_file ? [] : ['entry discipline file binding is required']),
+    ...(scorecard.source_bindings?.install_experience_file ? [] : ['install experience file binding is required']),
+    ...(scorecard.source_bindings?.upgrades_file ? [] : ['upgrades file binding is required']),
+    ...(scorecard.input_summary?.comparison_stage === comparisonStage ? [] : [`comparison stage must be ${comparisonStage}`]),
+    ...(scorecard.input_summary?.entry_discipline_stage === entryDisciplineStage ? [] : [`entry discipline stage must be ${entryDisciplineStage}`]),
+    ...(scorecard.input_summary?.install_experience_stage === installExperienceStage ? [] : [`install experience stage must be ${installExperienceStage}`]),
+    ...(scorecard.input_summary?.upgrades_stage === upgradesStage ? [] : [`upgrades stage must be ${upgradesStage}`]),
+    ...(integerInRange(scorecard.parity_score, 0, 100) ? [] : ['parity_score must be integer 0..100']),
+    ...(Array.isArray(scorecard.vibecoding_leads) && scorecard.vibecoding_leads.length > 0 ? [] : ['vibecoding_leads must be non-empty']),
+    ...(Array.isArray(scorecard.remaining_gaps) ? [] : ['remaining_gaps must be an array']),
+    ...(Array.isArray(scorecard.do_not_cross_boundaries) && scorecard.do_not_cross_boundaries.length >= 5 ? [] : ['do_not_cross_boundaries must include fixed boundary decisions']),
+    ...(scorecard.next_cycle_bet?.candidate_id ? [] : ['next_cycle_bet candidate_id is required']),
+    ...missingAxes.map((id) => `missing parity axis: ${id}`),
+    ...duplicateAxes.map((id) => `duplicate parity axis: ${id}`),
+    ...scoreFindings,
+    ...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: ['stage_133_comparison_binding', 'stage_135_entry_discipline_binding', 'stage_137_install_experience_binding', 'stage_139_upgrades_binding', 'weighted_parity_axes', 'remaining_gaps', 'do_not_cross_boundaries', 'read_only_boundary_assertions'],
+    findings,
+  };
+}
+
+export function digestSuperpowersParityScorecard(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function unwrapComparison(input) {
+  return input.superpowers_comparison_matrix || input.comparison || input;
+}
+
+function unwrapEntryDiscipline(input) {
+  return input.entry_trigger_discipline || input.discipline || input;
+}
+
+function unwrapInstallExperience(input) {
+  return input.install_experience_scorecard || input.install_experience || input;
+}
+
+function unwrapUpgrades(input) {
+  return input.experience_upgrade_prioritizer || input.upgrades || input;
+}
+
+function parityContext(matrix, discipline, install, prioritizer) {
+  const parityGapDimensions = new Set(listValue(matrix.parity_gaps).map((gap) => stringValue(gap.dimension || gap.id)));
+  const dimensionById = new Map(listValue(matrix.dimensions).map((dimension) => [stringValue(dimension.id), dimension]));
+  const triggerPassRatio = triggerResultsPassRatio(discipline);
+  const installScore = numberValue(install.install_experience_score, 50);
+  const naturalEntryScore = numberValue(install.natural_entry_score, installScore);
+  const adapterConsistencyScore = numberValue(install.adapter_consistency_score, installScore);
+  const manualStepPenalty = Math.min(listValue(install.manual_steps_remaining).length * 4, 20);
+  const docsFrictionPenalty = Math.min(listValue(install.docs_friction).length * 3, 18);
+  const deferredIds = new Set(listValue(prioritizer.defer).map((item) => stringValue(item.candidate_id)));
+  const recommendedIds = new Set(listValue(prioritizer.recommended_stage_order).map((item) => stringValue(item.candidate_id)));
+  return {
+    parityGapDimensions,
+    dimensionById,
+    triggerPassRatio,
+    installScore,
+    naturalEntryScore,
+    adapterConsistencyScore,
+    manualStepPenalty,
+    docsFrictionPenalty,
+    deferredIds,
+    recommendedIds,
+    nextUpgradeBet: prioritizer.next_upgrade_bet || {},
+    comparisonDoNotCopy: listValue(matrix.do_not_copy),
+    comparisonAdvantages: listValue(matrix.vibecoding_advantages),
+  };
+}
+
+function axisScore(definition, context) {
+  const hasGap = context.parityGapDimensions.has(definition.id);
+  const dimension = context.dimensionById.get(definition.id) || {};
+  const base = baseScoreFor(definition, context, dimension);
+  const adjusted = clampScore(base - (hasGap ? 8 : 0));
+  return {
+    id: definition.id,
+    weight: definition.weight,
+    superpowers_advantage: definition.superpowers_advantage,
+    vibecoding_absorption: definition.vibecoding_absorption,
+    evidence_source: definition.source,
+    comparison_gap_present: hasGap,
+    axis_score: adjusted,
+    status: adjusted >= 85 ? 'absorbed' : adjusted >= 70 ? 'partially_absorbed' : 'remaining_gap',
+    evidence: evidenceFor(definition, context, adjusted),
+  };
+}
+
+function baseScoreFor(definition, context, dimension) {
+  if (definition.source === 'entry_discipline') return Math.round(62 + (context.triggerPassRatio * 38));
+  if (definition.id === 'session_start_bootstrap') return clampScore(Math.round((context.naturalEntryScore * 0.75) + (context.installScore * 0.25) - context.manualStepPenalty));
+  if (definition.id === 'adapter_packaging') return clampScore(Math.round((context.adapterConsistencyScore * 0.7) + (context.installScore * 0.3) - context.docsFrictionPenalty));
+  if (definition.id === 'hook_shape_coverage') return context.dimensionById.has('hook_shape_coverage') ? 82 : 68;
+  if (definition.id === 'eval_and_test_harness') return context.deferredIds.has('default_live_agent_eval_runner') ? 84 : 64;
+  if (definition.id === 'daily_user_friction') return context.nextUpgradeBet?.candidate_id && context.nextUpgradeBet.candidate_id !== 'none' ? 86 : 66;
+  if (definition.id === 'subagent_boundary') return context.deferredIds.has('auto_subagent_execution') ? 92 : 58;
+  if (definition.id === 'token_and_context_economy') return context.recommendedIds.has('context_budget_entry_defaults') ? 82 : 72;
+  if (definition.id === 'contributor_guardrails') return context.recommendedIds.has('contributor_guardrail_evidence') || dimension.id ? 80 : 68;
+  return 70;
+}
+
+function evidenceFor(definition, context, score) {
+  if (definition.source === 'entry_discipline') return `trigger pass ratio=${context.triggerPassRatio.toFixed(2)}; score=${score}`;
+  if (definition.source === 'install_experience') return `install=${context.installScore}; natural_entry=${context.naturalEntryScore}; adapter_consistency=${context.adapterConsistencyScore}`;
+  if (definition.id === 'subagent_boundary') return context.deferredIds.has('auto_subagent_execution') ? 'auto_subagent_execution deferred' : 'subagent boundary defer evidence missing';
+  if (definition.id === 'eval_and_test_harness') return context.deferredIds.has('default_live_agent_eval_runner') ? 'live agent eval runner deferred' : 'live eval boundary defer evidence missing';
+  if (definition.id === 'daily_user_friction') return `next_upgrade_bet=${stringValue(context.nextUpgradeBet.candidate_id) || 'none'}`;
+  return context.dimensionById.has(definition.id) ? 'comparison dimension present' : 'comparison dimension missing';
+}
+
+function weightedScore(axes) {
+  const totalWeight = axes.reduce((sum, axis) => sum + axis.weight, 0);
+  if (totalWeight <= 0) return 0;
+  return clampScore(axes.reduce((sum, axis) => sum + (axis.axis_score * axis.weight), 0) / totalWeight);
+}
+
+function vibecodingLeads(matrix, prioritizer, axes) {
+  const leads = [
+    {
+      id: 'local_deterministic_contracts',
+      evidence: 'Every Stage 133-140 artifact is computed from local files and boundary assertions.',
+      protects: 'repeatable evidence without platform or model dependency',
+    },
+    {
+      id: 'explicit_boundary_scorecard',
+      evidence: 'Scorecard separates absorbed Superpowers advantages from do-not-cross boundaries.',
+      protects: 'parity without cloning auto-execution defaults',
+    },
+  ];
+  if (listValue(matrix.vibecoding_advantages).length > 0) leads.push({
+    id: 'comparison_declared_advantages',
+    evidence: `${listValue(matrix.vibecoding_advantages).length} comparison advantages are carried into parity closeout.`,
+    protects: 'Vibecoding-specific strengths stay visible',
+  });
+  if (listValue(prioritizer.defer).some((item) => stringValue(item.candidate_id) === 'auto_subagent_execution')) leads.push({
+    id: 'permission_first_subagent_boundary',
+    evidence: 'automatic subagent execution remains deferred by Stage 139.',
+    protects: 'no hidden delegation',
+  });
+  const strongAxes = axes.filter((axis) => axis.axis_score >= 85).map((axis) => axis.id);
+  if (strongAxes.length > 0) leads.push({
+    id: 'absorbed_high_confidence_axes',
+    evidence: strongAxes.join(', '),
+    protects: 'Superpowers advantages already translated into local contracts',
+  });
+  return leads;
+}
+
+function remainingGaps(axes, prioritizer) {
+  return axes
+    .filter((axis) => axis.axis_score < 85)
+    .map((axis) => ({
+      axis_id: axis.id,
+      status: axis.status,
+      axis_score: axis.axis_score,
+      next_action: nextActionForGap(axis, prioritizer),
+      boundary: 'close via local deterministic contract only; no live hook/test/model/subagent execution by default',
+    }));
+}
+
+function nextActionForGap(axis, prioritizer) {
+  const matching = listValue(prioritizer.upgrade_candidates).find((candidate) => stringValue(candidate.source_dimension) === axis.id && !candidate.defer);
+  if (matching) return `${matching.recommended_stage}: ${matching.id}`;
+  return `document or monitor ${axis.id} in the next comparison cycle`;
+}
+
+function doNotCrossBoundaries(matrix, prioritizer) {
+  const fixed = [
+    { id: 'no_full_skill_injection', boundary: 'do not inject full using-vibecoding by default at session start' },
+    { id: 'no_auto_subagent_execution', boundary: 'do not create or dispatch subagents without explicit user permission' },
+    { id: 'no_default_live_agent_eval_runner', boundary: 'do not run live agent evals or model judges from default runtime checks' },
+    { id: 'no_platform_api_or_network', boundary: 'do not call platform APIs, external networks, remote config, or models' },
+    { id: 'no_git_pr_push_merge', boundary: 'do not commit, push, open PRs, merge, tag, or rewrite history from this scorecard' },
+    { id: 'no_prompt_or_hook_mutation', boundary: 'do not mutate prompts, hooks, plugin manifests, or skills automatically' },
+  ];
+  const copied = listValue(matrix.do_not_copy).slice(0, 4).map((item, index) => ({
+    id: `comparison_do_not_copy_${index + 1}`,
+    boundary: stringValue(item.pattern || item.do_not_copy || item.reason || item),
+  })).filter((item) => item.boundary);
+  const deferred = listValue(prioritizer.defer).slice(0, 4).map((item) => ({
+    id: `deferred_${stringValue(item.candidate_id)}`,
+    boundary: stringValue(item.reason || item.boundary),
+  })).filter((item) => item.id !== 'deferred_' && item.boundary);
+  return [...fixed, ...copied, ...deferred];
+}
+
+function nextCycleBet(axes, prioritizer) {
+  const bet = prioritizer.next_upgrade_bet || {};
+  const weakestAxis = [...axes].sort((a, b) => a.axis_score - b.axis_score)[0];
+  return {
+    target_stage: stringValue(bet.target_stage) || 'Stage 141',
+    candidate_id: stringValue(bet.candidate_id) || 'entry_trigger_tightening',
+    action: stringValue(bet.action) || 'Start the next local deterministic experience upgrade cycle.',
+    weakest_axis: weakestAxis?.id || 'none',
+    evidence_required: 'carry comparison, entry discipline, install experience, and upgrade ordering evidence into the next cycle before implementation',
+  };
+}
+
+function sourceBindingSummary(source, matrix, discipline, install, prioritizer) {
+  return {
+    comparison_file: stringValue(source.comparison_file),
+    comparison_digest: stringValue(source.comparison_digest || matrix.comparison_digest),
+    entry_discipline_file: stringValue(source.entry_discipline_file),
+    entry_discipline_digest: stringValue(source.entry_discipline_digest || discipline.discipline_digest),
+    install_experience_file: stringValue(source.install_experience_file),
+    install_experience_digest: stringValue(source.install_experience_digest || install.install_experience_digest),
+    upgrades_file: stringValue(source.upgrades_file),
+    upgrades_digest: stringValue(source.upgrades_digest || prioritizer.upgrade_digest),
+  };
+}
+
+function inputSummary(matrix, discipline, install, prioritizer) {
+  return {
+    comparison_stage: stringValue(matrix.stage),
+    comparison_kind: stringValue(matrix.comparison_kind),
+    parity_gap_count: listValue(matrix.parity_gaps).length,
+    entry_discipline_stage: stringValue(discipline.stage),
+    entry_discipline_kind: stringValue(discipline.discipline_kind),
+    missed_workflow_risk_count: listValue(discipline.missed_workflow_risks).length,
+    install_experience_stage: stringValue(install.stage),
+    install_experience_kind: stringValue(install.score_kind),
+    install_experience_score: numberValue(install.install_experience_score, 0),
+    upgrades_stage: stringValue(prioritizer.stage),
+    upgrades_kind: stringValue(prioritizer.prioritizer_kind),
+    recommended_stage_count: listValue(prioritizer.recommended_stage_order).length,
+    deferred_count: listValue(prioritizer.defer).length,
+  };
+}
+
+function triggerResultsPassRatio(discipline) {
+  const results = listValue(discipline.trigger_results);
+  if (results.length === 0) return discipline.ok === true || discipline.entry_discipline_invariants?.pass === true ? 1 : 0;
+  const passed = results.filter((result) => result.pass === true || result.status === 'pass' || result.status === 'ok').length;
+  return passed / results.length;
+}
+
+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);
+}
+
+function listValue(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function stringValue(value) {
+  return typeof value === 'string' ? value : '';
+}
+
+function numberValue(value, fallback = 0) {
+  return Number.isFinite(value) ? Number(value) : fallback;
+}
+
+function integerInRange(value, min, max) {
+  return Number.isInteger(value) && value >= min && value <= max;
+}
+
+function clampScore(value) {
+  return Math.max(0, Math.min(100, Math.round(Number.isFinite(value) ? value : 0)));
+}