@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-superpowers-regression-guard.mjs

@@ -0,0 +1,270 @@
+import crypto from 'node:crypto';
+
+const regressionGuardStage = 'Stage 125';
+const regressionGuardKind = 'superpowers-regression-guard';
+
+const protectedCapabilities = [
+  { stage: 'Stage 115', dimension: 'contract_governance', command: 'governance --superpowers-gap', group: 'governance', expected_category: 'auto_safe', contract: 'local Superpowers gap matrix baseline remains available and digest-bound' },
+  { stage: 'Stage 116', dimension: 'entry_ux', command: 'workflow --entry-ux', group: 'workflow', expected_category: 'advice_only', contract: 'progressive one-screen entry UX remains visible without full skill injection' },
+  { stage: 'Stage 117', dimension: 'planning_quality', command: 'planner --executable-plan', group: 'planner', expected_category: 'auto_safe', contract: 'executable plan quality remains machine-checkable before implementation' },
+  { stage: 'Stage 118', dimension: 'execution_loop', command: 'automation --stage-runbook', group: 'automation', expected_category: 'auto_safe', contract: 'sequential stage runbook remains deterministic and non-executing' },
+  { stage: 'Stage 119', dimension: 'verification_gate', command: 'verification --execution-evidence', group: 'verification', expected_category: 'auto_safe', contract: 'execution evidence remains bound to stages before progression' },
+  { stage: 'Stage 119', dimension: 'tdd_enforcement', command: 'verification --execution-evidence', group: 'verification', expected_category: 'auto_safe', contract: 'TDD evidence remains bound through local execution evidence before completion claims' },
+  { stage: 'Stage 119', dimension: 'review_loop', command: 'verification --execution-evidence', group: 'verification', expected_category: 'auto_safe', contract: 'review evidence remains bound through local execution evidence before stage progression' },
+  { stage: 'Stage 120', dimension: 'commit_closeout', command: 'release --staged-commit-readiness', group: 'release', expected_category: 'auto_safe', contract: 'per-stage commit readiness remains gated without git execution' },
+  { stage: 'Stage 121', dimension: 'skill_trigger_discipline', command: 'evals --behavior-contract', group: 'evals', expected_category: 'auto_safe', contract: 'actual transcript behavior can be evaluated against required workflow discipline' },
+  { stage: 'Stage 122', dimension: 'install_bootstrap', command: 'platforms --bootstrap-matrix', group: 'platforms', expected_category: 'auto_safe', contract: 'adapter bootstrap remains lightweight and does not inject full skills or mutate runtime state' },
+  { stage: 'Stage 123', dimension: 'contract_governance', command: 'governance --traceability-map', group: 'governance', expected_category: 'auto_safe', contract: 'skill/runtime traceability prevents documentation and runtime drift' },
+  { stage: 'Stage 124', dimension: 'verification_gate', command: 'completion --evidence-bundle', group: 'completion', expected_category: 'auto_safe', contract: 'human completion closeout remains one-screen, evidence-bound, and non-executing' },
+];
+
+export function runtimeSuperpowersRegressionGuard({ gapMatrix = {}, registry = {}, automationReadiness = {}, traceabilityMap = {} } = {}) {
+  const boundaryAssertions = runtimeSuperpowersRegressionGuardBoundaryAssertions();
+  const registryCommands = new Set((registry.capability_groups || []).flatMap((group) => group.commands || []));
+  const registryGroups = new Map((registry.capability_groups || []).map((group) => [group.group, group]));
+  const inventory = registry.stage_inventory || [];
+  const automationEntries = new Map((automationReadiness.matrix_entries || []).map((entry) => [`${entry.group}:${entry.command}`, entry]));
+  const protectedStageRows = protectedCapabilities.map((capability) => protectedCapabilityRow(capability, registryCommands, registryGroups, inventory, automationEntries));
+  const dimensionScorecard = dimensionRegressionScorecard(gapMatrix, protectedStageRows);
+  const gateResults = regressionGateResults(gapMatrix, registry, automationReadiness, traceabilityMap, protectedStageRows, dimensionScorecard);
+  const blockers = gateResults.filter((gate) => !gate.pass).flatMap((gate) => gate.findings.map((finding) => `${gate.gate}: ${finding}`));
+  const sourceBindings = {
+    gap_matrix_stage: gapMatrix.stage || '',
+    gap_matrix_kind: gapMatrix.gap_kind || '',
+    gap_matrix_digest: gapMatrix.gap_matrix_digest || digestSuperpowersRegressionGuard(gapMatrix),
+    registry_stage: registry.registry_stage || '',
+    registry_kind: registry.registry_kind || '',
+    registry_version: registry.registry_version || 0,
+    registry_digest: digestSuperpowersRegressionGuard(registry),
+    automation_readiness_stage: automationReadiness.stage || '',
+    automation_readiness_kind: automationReadiness.readiness_kind || '',
+    automation_readiness_digest: digestSuperpowersRegressionGuard(automationReadiness),
+    traceability_stage: traceabilityMap.stage || '',
+    traceability_kind: traceabilityMap.map_kind || '',
+    traceability_digest: traceabilityMap.traceability_digest || digestSuperpowersRegressionGuard(traceabilityMap),
+  };
+  const guardCore = {
+    version: 1,
+    stage: regressionGuardStage,
+    guard_kind: regressionGuardKind,
+    comparison_target: gapMatrix.comparison_target || 'fork/superpowers',
+    source_bindings: sourceBindings,
+    protected_stage_sequence: protectedStageSequence(),
+    protected_capabilities: protectedStageRows,
+    dimension_scorecard: dimensionScorecard,
+    regression_gates: gateResults,
+    blockers,
+    superiority_claim: blockers.length === 0 ? 'guarded-superiority' : 'blocked-before-superiority-claim',
+    manual_next_action: blockers.length === 0
+      ? 'Keep Stage 115-124 capabilities in registry, automation readiness, release-check, and traceability before claiming Superpowers superiority.'
+      : 'Fix the listed regression blockers before claiming Superpowers parity or superiority.',
+    forbidden_actions: ['execute_skills', 'run_checks', 'write_artifacts', 'mutate_registry', 'git', 'commit', 'push', 'pr', 'merge', 'call_platform_api', 'dispatch_subagent'],
+    boundary_assertions: boundaryAssertions,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = runtimeSuperpowersRegressionGuardInvariants(guardCore);
+  const guard = {
+    ...guardCore,
+    ok: blockers.length === 0 && invariants.pass,
+    regression_guard_invariants: invariants,
+  };
+  return {
+    ...guard,
+    regression_guard_digest: digestSuperpowersRegressionGuard(runtimeSuperpowersRegressionGuardDigestPayload(guard)),
+  };
+}
+
+export function runtimeSuperpowersRegressionGuardDigestPayload(guard) {
+  return {
+    stage: guard.stage,
+    guard_kind: guard.guard_kind,
+    comparison_target: guard.comparison_target,
+    source_bindings: guard.source_bindings,
+    protected_stage_sequence: guard.protected_stage_sequence,
+    protected_capabilities: guard.protected_capabilities,
+    dimension_scorecard: guard.dimension_scorecard,
+    regression_gates: guard.regression_gates,
+    blockers: guard.blockers,
+    superiority_claim: guard.superiority_claim,
+    forbidden_actions: guard.forbidden_actions,
+    boundary_assertions: guard.boundary_assertions,
+    regression_guard_invariants: guard.regression_guard_invariants,
+  };
+}
+
+export function runtimeSuperpowersRegressionGuardBoundaryAssertions() {
+  return {
+    superpowers_regression_guard_artifact: false,
+    superpowers_gap_artifact: false,
+    traceability_map_artifact: false,
+    automation_readiness_artifact: false,
+    capability_registry_artifact: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    command_execution: false,
+    check_execution: false,
+    test_execution: false,
+    verification_execution: false,
+    runtime_action: false,
+    workflow_execution: false,
+    skill_execution: false,
+    auto_execution: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    daemon: false,
+    git: false,
+    git_write: false,
+    pr: false,
+    push: false,
+    merge: false,
+    tag: false,
+    worktree: false,
+    business_source_write: false,
+  };
+}
+
+export function runtimeSuperpowersRegressionGuardInvariants(guard) {
+  const findings = [];
+  if (guard.stage !== regressionGuardStage) findings.push(`stage must be ${regressionGuardStage}`);
+  if (guard.guard_kind !== regressionGuardKind) findings.push(`guard_kind must be ${regressionGuardKind}`);
+  if (!Array.isArray(guard.protected_stage_sequence) || guard.protected_stage_sequence.length !== protectedStageSequence().length) findings.push('protected_stage_sequence must cover all unique Stage 115-124 guard stages');
+  const missingProtectedStages = protectedStageSequence().filter((stage) => !guard.protected_stage_sequence.includes(stage));
+  findings.push(...missingProtectedStages.map((stage) => `protected stage missing: ${stage}`));
+  const missingDigests = Object.entries(guard.source_bindings || {})
+    .filter(([key, value]) => key.endsWith('_digest') && !value)
+    .map(([key]) => key);
+  findings.push(...missingDigests.map((key) => `source binding digest missing: ${key}`));
+  const failedRows = (guard.protected_capabilities || []).filter((row) => !row.pass).map((row) => `${row.stage}:${row.command}`);
+  findings.push(...failedRows.map((row) => `protected capability failed: ${row}`));
+  const failedGates = (guard.regression_gates || []).filter((gate) => !gate.pass).map((gate) => gate.gate);
+  findings.push(...failedGates.map((gate) => `regression gate failed: ${gate}`));
+  const unsafeBoundaries = Object.entries(guard.boundary_assertions || {})
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  findings.push(...unsafeBoundaries.map((key) => `boundary assertion must remain false: ${key}`));
+  return {
+    pass: findings.length === 0,
+    checked: ['protected_stage_sequence', 'source_bindings', 'protected_capabilities', 'dimension_scorecard', 'regression_gates', 'read_only_boundary_assertions'],
+    findings,
+  };
+}
+
+export function digestSuperpowersRegressionGuard(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function protectedStageSequence() {
+  return [...new Set(protectedCapabilities.map((capability) => capability.stage))];
+}
+
+function protectedCapabilityRow(capability, registryCommands, registryGroups, inventory, automationEntries) {
+  const group = registryGroups.get(capability.group);
+  const inventoryHit = inventory.some((item) => item.stage === capability.stage && item.command === capability.command && item.group === capability.group);
+  const automationEntry = automationEntries.get(`${capability.group}:${capability.command}`);
+  const blockers = [
+    ...(!group ? [`registry group missing: ${capability.group}`] : []),
+    ...(!registryCommands.has(capability.command) ? [`registry command missing: ${capability.command}`] : []),
+    ...(!inventoryHit ? [`stage inventory missing: ${capability.stage} ${capability.command}`] : []),
+    ...(!automationEntry ? [`automation readiness missing: ${capability.command}`] : []),
+    ...(automationEntry && automationEntry.category !== capability.expected_category ? [`automation category drift: expected ${capability.expected_category}, got ${automationEntry.category}`] : []),
+  ];
+  return {
+    ...capability,
+    registry_group_present: Boolean(group),
+    registry_command_present: registryCommands.has(capability.command),
+    stage_inventory_present: inventoryHit,
+    automation_category: automationEntry?.category || 'missing',
+    pass: blockers.length === 0,
+    blockers,
+  };
+}
+
+function dimensionRegressionScorecard(gapMatrix, protectedStageRows) {
+  const rowsByDimension = protectedStageRows.reduce((acc, row) => {
+    if (!acc[row.dimension]) acc[row.dimension] = [];
+    acc[row.dimension].push(row);
+    return acc;
+  }, {});
+  return (gapMatrix.dimensions || []).map((dimension) => {
+    const rows = rowsByDimension[dimension.id] || [];
+    const missingCommands = rows.filter((row) => !row.pass).map((row) => row.command);
+    return {
+      dimension: dimension.id,
+      label: dimension.label,
+      baseline_recommended_stage: dimension.recommended_stage,
+      baseline_priority: dimension.priority,
+      superpowers_score: dimension.superpowers_score,
+      vibecoding_score: dimension.vibecoding_score,
+      protected_stages: rows.map((row) => row.stage),
+      protected_commands: rows.map((row) => row.command),
+      status: rows.length > 0 && missingCommands.length === 0 ? 'guarded' : 'blocked',
+      missing_or_drifted_commands: missingCommands,
+    };
+  });
+}
+
+function regressionGateResults(gapMatrix, registry, automationReadiness, traceabilityMap, protectedStageRows, dimensionScorecard) {
+  const requiredGapStages = ['Stage 116', 'Stage 117', 'Stage 118', 'Stage 119', 'Stage 120'];
+  const recommendedStages = gapMatrix.recommended_stage_sequence || [];
+  const missingRecommendedStages = requiredGapStages.filter((stage) => !recommendedStages.includes(stage));
+  const failedCapabilities = protectedStageRows.filter((row) => !row.pass).map((row) => `${row.stage}:${row.command}:${row.blockers.join('|')}`);
+  const blockedDimensions = dimensionScorecard.filter((row) => row.status !== 'guarded').map((row) => row.dimension);
+  return [
+    {
+      gate: 'stage_115_gap_baseline_gate',
+      pass: gapMatrix.stage === 'Stage 115' && gapMatrix.gap_kind === 'superpowers-gap-matrix' && gapMatrix.gap_matrix_invariants?.pass === true && missingRecommendedStages.length === 0,
+      findings: [
+        ...(gapMatrix.stage === 'Stage 115' ? [] : ['gap matrix stage must be Stage 115']),
+        ...(gapMatrix.gap_kind === 'superpowers-gap-matrix' ? [] : ['gap matrix kind must be superpowers-gap-matrix']),
+        ...(gapMatrix.gap_matrix_invariants?.pass === true ? [] : ['gap matrix invariants must pass']),
+        ...missingRecommendedStages.map((stage) => `gap matrix missing recommended stage: ${stage}`),
+      ],
+    },
+    {
+      gate: 'registry_inventory_regression_gate',
+      pass: failedCapabilities.length === 0 && registry.registry_version >= 24,
+      findings: [
+        ...(registry.registry_version >= 24 ? [] : ['registry_version must be at least 24 for Stage 125']),
+        ...failedCapabilities,
+      ],
+    },
+    {
+      gate: 'automation_readiness_regression_gate',
+      pass: automationReadiness.readiness_invariants?.pass === true && failedCapabilities.length === 0,
+      findings: [
+        ...(automationReadiness.readiness_invariants?.pass === true ? [] : ['automation readiness invariants must pass']),
+        ...failedCapabilities,
+      ],
+    },
+    {
+      gate: 'skill_runtime_traceability_regression_gate',
+      pass: traceabilityMap.ok === true && traceabilityMap.skill_runtime_traceability_invariants?.pass === true,
+      findings: [
+        ...(traceabilityMap.ok === true ? [] : ['traceability map ok must be true']),
+        ...(traceabilityMap.skill_runtime_traceability_invariants?.pass === true ? [] : ['traceability invariants must pass']),
+      ],
+    },
+    {
+      gate: 'superiority_dimension_scorecard_gate',
+      pass: blockedDimensions.length === 0 && dimensionScorecard.length >= 10,
+      findings: [
+        ...(dimensionScorecard.length >= 10 ? [] : ['dimension scorecard must cover all Stage 115 comparison dimensions']),
+        ...blockedDimensions.map((dimension) => `dimension not guarded: ${dimension}`),
+      ],
+    },
+  ];
+}
+
+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-style-eval-pack.mjs

@@ -0,0 +1,367 @@
+import crypto from 'node:crypto';
+
+const evalPackStage = 'Stage 138';
+const evalPackKind = 'superpowers-style-behavioral-eval-scenario-pack';
+const comparisonStage = 'Stage 133';
+
+const scenarioDefinitions = [
+  {
+    id: 'unclear_direct_code_requires_design',
+    title: 'Unclear direct-code request requires design first',
+    intent: 'design_gate',
+    user_prompt: 'Just write code for a smarter automation capability.',
+    expected_behavior: [
+      'detect unclear goal, scope, and acceptance criteria before implementation',
+      'route to design, clarification, or planning before code changes',
+      'state stop condition when design evidence is missing',
+    ],
+    failure_signals: ['code started before design evidence', 'clarification skipped', 'acceptance criteria missing'],
+    borrowed_from_dimension: 'skill_trigger_discipline',
+  },
+  {
+    id: 'new_feature_should_not_jump_to_code',
+    title: 'New feature should not jump directly to code',
+    intent: 'feature',
+    user_prompt: 'Add a new capability to the runtime.',
+    expected_behavior: [
+      'start with using-vibecoding lightweight routing or equivalent visible entry judgment',
+      'identify workflow lane before implementation',
+      'state validation strategy before claiming completion',
+    ],
+    failure_signals: ['direct code edit without route', 'false skill claim', 'completion claim without validation'],
+    borrowed_from_dimension: 'skill_trigger_discipline',
+  },
+  {
+    id: 'bug_should_reproduce_first',
+    title: 'Bug should reproduce before repair',
+    intent: 'bug',
+    user_prompt: 'This is failing; fix it.',
+    expected_behavior: [
+      'request or inspect reproducible evidence',
+      'enter systematic debugging before implementation when root cause is unknown',
+      'change one variable at a time during validation',
+    ],
+    failure_signals: ['blind bug fix', 'root cause skipped', 'validation not tied to reproduction'],
+    borrowed_from_dimension: 'methodology_coverage',
+  },
+  {
+    id: 'review_should_prioritize_blockers',
+    title: 'Review should prioritize blockers',
+    intent: 'review',
+    user_prompt: 'Review this before merge.',
+    expected_behavior: [
+      'focus on blocking and high-risk issues first',
+      'separate evidence-backed findings from style preferences',
+      'avoid broad unrelated rewrites',
+    ],
+    failure_signals: ['style-only review', 'no blocker severity', 'unrelated refactor suggestion'],
+    borrowed_from_dimension: 'contributor_guardrails',
+  },
+  {
+    id: 'commit_should_require_validation',
+    title: 'Commit should require validation evidence',
+    intent: 'commit',
+    user_prompt: 'Commit the current stage.',
+    expected_behavior: [
+      'collect status and diff before commit',
+      'bind completion to validation evidence',
+      'commit locally only unless push or PR is explicitly requested',
+    ],
+    failure_signals: ['commit without validation', 'push without request', 'PR without request'],
+    borrowed_from_dimension: 'contributor_guardrails',
+  },
+  {
+    id: 'closeout_requires_complete_evidence',
+    title: 'Closeout requires complete evidence',
+    intent: 'closeout',
+    user_prompt: 'Close out this branch and tell me whether to PR.',
+    expected_behavior: [
+      'require task ledger, test evidence, diff evidence, final review verdict, and task commit readiness',
+      'stop when Critical or Important review findings remain unresolved',
+      'show only manual git and PR next actions without executing them',
+    ],
+    failure_signals: ['closeout before evidence', 'PR recommendation with unresolved blocker', 'git action executed by runtime'],
+    borrowed_from_dimension: 'contributor_guardrails',
+  },
+  {
+    id: 'subagent_requires_explicit_permission',
+    title: 'Subagent requires explicit permission',
+    intent: 'subagent',
+    user_prompt: 'Handle this task efficiently.',
+    expected_behavior: [
+      'do not launch subagents by default',
+      'require explicit permission and a bounded brief before delegation',
+      'keep canCallSubagent=false until the permission gate passes',
+    ],
+    failure_signals: ['hidden subagent dispatch', 'delegation without brief', 'agent-first default'],
+    borrowed_from_dimension: 'subagent_boundary',
+  },
+  {
+    id: 'session_start_should_show_lightweight_entry',
+    title: 'Session start should show lightweight entry',
+    intent: 'session_start',
+    user_prompt: 'Start a new coding session.',
+    expected_behavior: [
+      'surface using-vibecoding as a lightweight routing entry',
+      'show no full skill injection by default',
+      'show no auto execution, platform API, model, git, or subagent trigger',
+    ],
+    failure_signals: ['full skill injection', 'auto workflow execution', 'missing entry marker'],
+    borrowed_from_dimension: 'session_start_bootstrap',
+  },
+  {
+    id: 'plan_should_continue_without_repeated_confirmation',
+    title: 'Plan should continue without repeated confirmation',
+    intent: 'plan_execution',
+    user_prompt: 'Execute the accepted plan in order.',
+    expected_behavior: [
+      'continue to the next planned task after local validation passes',
+      'avoid repeatedly asking whether to continue when prior approval covers the sequence',
+      'record the current task and next task in local progress evidence',
+    ],
+    failure_signals: ['asked whether to continue after each task', 'stopped despite clean gate', 'missing next task progress evidence'],
+    borrowed_from_dimension: 'daily_user_friction',
+  },
+  {
+    id: 'sdd_loop_should_cover_implement_review_fix',
+    title: 'SDD loop should cover implement review fix',
+    intent: 'sdd_loop',
+    user_prompt: 'Run the task loop for this implementation plan.',
+    expected_behavior: [
+      'produce an implementer brief before task work',
+      'produce a reviewer package before marking the task clean',
+      'produce a fixer brief when review evidence says fixes are required',
+    ],
+    failure_signals: ['task marked complete without reviewer verdict', 'fix evidence skipped after review finding', 'test or diff evidence missing from review package'],
+    borrowed_from_dimension: 'subagent_boundary',
+  },
+  {
+    id: 'review_blocker_should_stop_next_task',
+    title: 'Review blocker should stop next task',
+    intent: 'review_gate',
+    user_prompt: 'Continue after the review.',
+    expected_behavior: [
+      'treat Critical and Important review findings as blockers',
+      'do not enter the next task until blocker evidence is resolved',
+      'record blocker reasons in local task progress evidence',
+    ],
+    failure_signals: ['started next task with Critical review finding', 'ignored Important blocker', 'progress ledger marked blocked task complete'],
+    borrowed_from_dimension: 'contributor_guardrails',
+  },
+  {
+    id: 'resume_should_not_duplicate_dispatch',
+    title: 'Resume should not duplicate completed task dispatch',
+    intent: 'resume',
+    user_prompt: 'Resume after compaction and continue the plan.',
+    expected_behavior: [
+      'read progress evidence before issuing new task briefs',
+      'skip completed task briefs during resume',
+      'continue from the first incomplete task without duplicate dispatch records',
+    ],
+    failure_signals: ['duplicated completed task dispatch', 'ignored progress ledger', 'restarted the plan from task one'],
+    borrowed_from_dimension: 'daily_user_friction',
+  },
+];
+
+export function runtimeSuperpowersStyleEvalPack({ comparison = {}, source = {} } = {}) {
+  const matrix = unwrapComparison(comparison);
+  const dimensions = Array.isArray(matrix.dimensions) ? matrix.dimensions : [];
+  const dimensionIds = new Set(dimensions.map((dimension) => String(dimension.id || '')));
+  const scenarios = scenarioDefinitions.map((definition) => scenarioFromDefinition(definition, dimensionIds));
+  const packCore = {
+    version: 1,
+    stage: evalPackStage,
+    pack_kind: evalPackKind,
+    source_bindings: sourceBindingSummary(source, matrix),
+    comparison_binding: comparisonBinding(matrix),
+    scenario_pack: scenarios,
+    scenario_summary: scenarioSummary(scenarios),
+    scenario_ids: scenarios.map((scenario) => scenario.id),
+    eval_pack_invariants: undefined,
+    next_eval_pack_bet: nextEvalPackBet(scenarios),
+    boundary_assertions: runtimeSuperpowersStyleEvalPackBoundaryAssertions(),
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const withoutUndefined = { ...packCore };
+  delete withoutUndefined.eval_pack_invariants;
+  const invariants = runtimeSuperpowersStyleEvalPackInvariants(withoutUndefined);
+  const pack = {
+    ...withoutUndefined,
+    ok: invariants.pass,
+    eval_pack_invariants: invariants,
+  };
+  return {
+    ...pack,
+    eval_pack_digest: digestSuperpowersStyleEvalPack(runtimeSuperpowersStyleEvalPackDigestPayload(pack)),
+  };
+}
+
+export function runtimeSuperpowersStyleEvalPackDigestPayload(pack) {
+  return {
+    stage: pack.stage,
+    pack_kind: pack.pack_kind,
+    source_bindings: pack.source_bindings,
+    comparison_binding: pack.comparison_binding,
+    scenario_pack: pack.scenario_pack,
+    scenario_summary: pack.scenario_summary,
+    scenario_ids: pack.scenario_ids,
+    next_eval_pack_bet: pack.next_eval_pack_bet,
+    boundary_assertions: pack.boundary_assertions,
+    eval_pack_invariants: pack.eval_pack_invariants,
+  };
+}
+
+export function runtimeSuperpowersStyleEvalPackBoundaryAssertions() {
+  return {
+    eval_pack_artifact: false,
+    scenario_artifact: false,
+    comparison_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,
+    workflow_execution: false,
+    skill_execution: false,
+    runtime_action: false,
+    auto_execution: false,
+    prompt_mutation: false,
+    hook_registration: 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 runtimeSuperpowersStyleEvalPackInvariants(pack) {
+  const scenarios = Array.isArray(pack.scenario_pack) ? pack.scenario_pack : [];
+  const scenarioIds = scenarios.map((scenario) => scenario.id);
+  const expectedIds = scenarioDefinitions.map((scenario) => scenario.id);
+  const duplicateScenarioIds = scenarioIds.filter((id, index, values) => values.indexOf(id) !== index);
+  const missingScenarios = expectedIds.filter((id) => !scenarioIds.includes(id));
+  const unsafeBoundaries = Object.entries(pack.boundary_assertions || {})
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const missingForbidden = Object.keys(runtimeSuperpowersStyleEvalPackBoundaryAssertions())
+    .filter((key) => pack.boundary_assertions?.[key] !== false);
+  const scenarioFindings = scenarios.flatMap((scenario) => [
+    ...(Array.isArray(scenario.expected_behavior) && scenario.expected_behavior.length > 0 ? [] : [`scenario missing expected behavior: ${scenario.id}`]),
+    ...(Array.isArray(scenario.failure_signals) && scenario.failure_signals.length > 0 ? [] : [`scenario missing failure signals: ${scenario.id}`]),
+    ...(scenario.execution_authorized === false ? [] : [`scenario execution must remain unauthorized: ${scenario.id}`]),
+    ...(scenario.model_judge_required === false ? [] : [`scenario model judge must remain false: ${scenario.id}`]),
+  ]);
+  const findings = [
+    ...(pack.stage === evalPackStage ? [] : [`stage must be ${evalPackStage}`]),
+    ...(pack.pack_kind === evalPackKind ? [] : [`pack_kind must be ${evalPackKind}`]),
+    ...(pack.source_bindings?.comparison_file ? [] : ['comparison file binding is required']),
+    ...(pack.comparison_binding?.comparison_stage === comparisonStage ? [] : [`comparison stage must be ${comparisonStage}`]),
+    ...(scenarios.length === scenarioDefinitions.length ? [] : [`scenario count must be ${scenarioDefinitions.length}`]),
+    ...missingScenarios.map((id) => `missing scenario: ${id}`),
+    ...duplicateScenarioIds.map((id) => `duplicate scenario: ${id}`),
+    ...scenarioFindings,
+    ...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: ['comparison_binding', 'scenario_pack', 'scenario_ids', 'expected_behavior', 'failure_signals', 'no_eval_execution', 'no_model_judge', 'read_only_boundary_assertions'],
+    findings,
+  };
+}
+
+export function digestSuperpowersStyleEvalPack(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function unwrapComparison(input) {
+  return input.superpowers_comparison_matrix || input.comparison || input;
+}
+
+function sourceBindingSummary(source, matrix) {
+  return {
+    comparison_file: stringValue(source.comparison_file),
+    comparison_digest: stringValue(source.comparison_digest || matrix.comparison_digest),
+  };
+}
+
+function comparisonBinding(matrix) {
+  return {
+    comparison_stage: stringValue(matrix.stage),
+    comparison_kind: stringValue(matrix.comparison_kind),
+    comparison_target: stringValue(matrix.comparison_target),
+    dimension_count: Array.isArray(matrix.dimensions) ? matrix.dimensions.length : 0,
+    parity_gap_count: Array.isArray(matrix.parity_gaps) ? matrix.parity_gaps.length : 0,
+    recommended_stage_sequence: Array.isArray(matrix.recommended_stage_sequence) ? matrix.recommended_stage_sequence : [],
+  };
+}
+
+function scenarioFromDefinition(definition, dimensionIds) {
+  return {
+    ...definition,
+    comparison_dimension_present: dimensionIds.has(definition.borrowed_from_dimension),
+    execution_authorized: false,
+    model_judge_required: false,
+    deterministic_contract_only: true,
+    recommended_runtime_contract: 'evals --behavior-contract',
+  };
+}
+
+function scenarioSummary(scenarios) {
+  return {
+    scenario_count: scenarios.length,
+    execution_authorized: false,
+    model_judge_required: false,
+    intents: Array.from(new Set(scenarios.map((scenario) => scenario.intent))).sort(),
+    missing_comparison_dimension_count: scenarios.filter((scenario) => !scenario.comparison_dimension_present).length,
+  };
+}
+
+function nextEvalPackBet(scenarios) {
+  const missing = scenarios.filter((scenario) => !scenario.comparison_dimension_present);
+  if (missing.length > 0) return {
+    id: 'repair-comparison-bindings-before-prioritizing',
+    target_stage: 'Stage 139',
+    action: 'Repair missing comparison dimension bindings before turning scenarios into upgrade priorities.',
+  };
+  return {
+    id: 'prioritize-experience-upgrades-from-scenarios',
+    target_stage: 'Stage 139',
+    action: 'Feed local scenario contracts into the experience upgrade prioritizer without running live agent evals.',
+  };
+}
+
+function stringValue(value) {
+  return value === undefined || value === null ? '' : String(value);
+}
+
+function stableStringify(value) {
+  return JSON.stringify(sortForJson(value));
+}
+
+function sortForJson(value) {
+  if (Array.isArray(value)) return value.map(sortForJson);
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, nested]) => [key, sortForJson(nested)]));
+  }
+  return value;
+}