@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-experience-regression-dashboard.mjs

@@ -0,0 +1,398 @@
+import crypto from 'node:crypto';
+
+const experienceDashboardStage = 'Stage 132';
+const experienceDashboardKind = 'experience-regression-dashboard';
+
+const dashboardSections = [
+  'experience_scorecard',
+  'superpowers_comparison_delta',
+  'token_savior_delta',
+  'learning_loop_delta',
+  'daily_user_friction_delta',
+];
+
+export function runtimeExperienceRegressionDashboard({ friction = {}, console: consoleInput = null, tokenBudget = null, learningPattern = null, source = {} } = {}) {
+  const normalizedFriction = normalizeFriction(friction);
+  const normalizedConsole = normalizeConsole(consoleInput);
+  const normalizedTokenBudget = normalizeTokenBudget(tokenBudget);
+  const normalizedLearningPattern = normalizeLearningPattern(learningPattern);
+  const scorecard = experienceScorecard({ friction: normalizedFriction, console: normalizedConsole, tokenBudget: normalizedTokenBudget, learningPattern: normalizedLearningPattern });
+  const blockers = regressionBlockers({ friction: normalizedFriction, console: normalizedConsole, tokenBudget: normalizedTokenBudget, learningPattern: normalizedLearningPattern, scorecard });
+  const core = {
+    version: 1,
+    stage: experienceDashboardStage,
+    dashboard_kind: experienceDashboardKind,
+    source_bindings: sourceBindingSummary(source, normalizedFriction, normalizedConsole, normalizedTokenBudget, normalizedLearningPattern),
+    experience_scorecard: scorecard,
+    superpowers_comparison_delta: superpowersComparisonDelta(normalizedFriction),
+    token_savior_delta: tokenSaviorDelta(normalizedTokenBudget, normalizedFriction),
+    learning_loop_delta: learningLoopDelta(normalizedLearningPattern),
+    daily_user_friction_delta: dailyUserFrictionDelta(normalizedFriction, normalizedConsole, normalizedTokenBudget),
+    regression_blockers: blockers,
+    next_bet: nextBet({ friction: normalizedFriction, console: normalizedConsole, tokenBudget: normalizedTokenBudget, learningPattern: normalizedLearningPattern, blockers }),
+    dashboard_sections: dashboardSections,
+    boundary_assertions: runtimeExperienceRegressionDashboardBoundaryAssertions(),
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = runtimeExperienceRegressionDashboardInvariants(core);
+  const dashboard = {
+    ...core,
+    ok: invariants.pass,
+    experience_dashboard_invariants: invariants,
+  };
+  return {
+    ...dashboard,
+    dashboard_digest: digestExperienceRegressionDashboard(runtimeExperienceRegressionDashboardDigestPayload(dashboard)),
+  };
+}
+
+export function runtimeExperienceRegressionDashboardDigestPayload(dashboard) {
+  return {
+    stage: dashboard.stage,
+    dashboard_kind: dashboard.dashboard_kind,
+    source_bindings: dashboard.source_bindings,
+    experience_scorecard: dashboard.experience_scorecard,
+    superpowers_comparison_delta: dashboard.superpowers_comparison_delta,
+    token_savior_delta: dashboard.token_savior_delta,
+    learning_loop_delta: dashboard.learning_loop_delta,
+    daily_user_friction_delta: dashboard.daily_user_friction_delta,
+    regression_blockers: dashboard.regression_blockers,
+    next_bet: dashboard.next_bet,
+    dashboard_sections: dashboard.dashboard_sections,
+    boundary_assertions: dashboard.boundary_assertions,
+    experience_dashboard_invariants: dashboard.experience_dashboard_invariants,
+  };
+}
+
+export function runtimeExperienceRegressionDashboardBoundaryAssertions() {
+  return {
+    experience_dashboard_artifact: false,
+    regression_dashboard_artifact: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    source_write: false,
+    command_execution: false,
+    check_execution: false,
+    smoke_execution: false,
+    test_execution: false,
+    verification_execution: false,
+    workflow_execution: false,
+    skill_execution: false,
+    runtime_action: false,
+    auto_execution: false,
+    repair_execution: false,
+    evidence_write: false,
+    dashboard_write: 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 runtimeExperienceRegressionDashboardInvariants(dashboard) {
+  const unsafeBoundaries = Object.entries(dashboard.boundary_assertions || {})
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const missingForbidden = ['experience_dashboard_artifact', 'regression_dashboard_artifact', 'sidecar_write', 'state_directory_created', 'source_write', 'command_execution', 'check_execution', 'smoke_execution', 'test_execution', 'verification_execution', 'workflow_execution', 'skill_execution', 'runtime_action', 'auto_execution', 'evidence_write', 'dashboard_write', 'dynamic_tool_execution', 'embeddings', 'remote_config', 'platform_api', 'external_network', 'model_invocation', 'subagent', 'mcp', 'git', 'git_write', 'git_add', 'commit', 'pr', 'push', 'merge', 'business_source_write']
+    .filter((key) => dashboard.boundary_assertions?.[key] !== false);
+  const missingSections = dashboardSections.filter((section) => !dashboard.dashboard_sections?.includes(section) || !dashboard[section]);
+  const findings = [
+    ...(dashboard.stage === experienceDashboardStage ? [] : [`stage must be ${experienceDashboardStage}`]),
+    ...(dashboard.dashboard_kind === experienceDashboardKind ? [] : [`dashboard_kind must be ${experienceDashboardKind}`]),
+    ...(dashboard.source_bindings?.friction_file ? [] : ['source friction file is required']),
+    ...(dashboard.source_bindings?.friction_digest ? [] : ['source friction digest is required']),
+    ...(Number.isInteger(dashboard.experience_scorecard?.overall_experience_score) && dashboard.experience_scorecard.overall_experience_score >= 0 && dashboard.experience_scorecard.overall_experience_score <= 100 ? [] : ['overall_experience_score must be an integer between 0 and 100']),
+    ...(Array.isArray(dashboard.regression_blockers) ? [] : ['regression_blockers must be a list']),
+    ...(dashboard.next_bet?.action ? [] : ['next_bet.action is required']),
+    ...missingSections.map((section) => `missing dashboard section: ${section}`),
+    ...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: ['friction_binding', 'scorecard_bounds', 'superpowers_delta', 'token_savior_delta', 'learning_loop_delta', 'daily_user_friction_delta', 'regression_blockers', 'next_bet', 'read_only_boundary_assertions'],
+    findings,
+  };
+}
+
+export function digestExperienceRegressionDashboard(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function experienceScorecard({ friction, console, tokenBudget, learningPattern }) {
+  const frictionRelief = clamp(100 - friction.friction_score, 0, 100);
+  const nextActionClarity = console.provided ? (console.has_recommended_next_action ? 92 : 60) : 45;
+  const tokenDiscipline = tokenBudget.provided ? tokenProfileScore(tokenBudget.recommended_profile) : 50;
+  const learningDiscipline = learningPattern.provided ? (learningPattern.promotion_required && learningPattern.candidate_count > 0 ? 88 : 55) : 50;
+  const evidenceVisibility = evidenceVisibilityScore(friction, console);
+  const overall = Math.round((frictionRelief * 0.30) + (nextActionClarity * 0.22) + (tokenDiscipline * 0.18) + (learningDiscipline * 0.15) + (evidenceVisibility * 0.15));
+  return {
+    overall_experience_score: clamp(overall, 0, 100),
+    rating: scoreRating(overall),
+    friction_relief_score: frictionRelief,
+    next_action_clarity_score: nextActionClarity,
+    token_discipline_score: tokenDiscipline,
+    learning_discipline_score: learningDiscipline,
+    evidence_visibility_score: evidenceVisibility,
+    required_contracts_present: {
+      stage_126_friction: friction.provided,
+      stage_127_console: console.provided,
+      stage_128_token_budget: tokenBudget.provided,
+      stage_129_learning_pattern: learningPattern.provided,
+    },
+  };
+}
+
+function superpowersComparisonDelta(friction) {
+  const gapDimension = dimensionById(friction, 'superpowers_parity_gap');
+  const score = 100 - gapDimension.score;
+  return {
+    status: score >= 80 ? 'parity-protected' : score >= 60 ? 'watch' : 'regression-risk',
+    score: clamp(score, 0, 100),
+    superpowers_parity_gap_score: gapDimension.score,
+    protected_by: ['Stage 115 Superpowers gap matrix', 'Stage 121 behavioral evaluation contract', 'Stage 125 Superpowers regression guard'],
+    delta: gapDimension.score <= 25 ? 'Vibecoding keeps local, reviewable governance evidence while preserving Superpowers-style visible workflow pull.' : 'Superpowers parity evidence is weak or stale; refresh comparison and regression guard evidence before superiority claims.',
+  };
+}
+
+function tokenSaviorDelta(tokenBudget, friction) {
+  const tokenDimension = dimensionById(friction, 'token_overhead');
+  const profile = tokenBudget.recommended_profile || 'not_provided';
+  return {
+    status: tokenBudget.provided ? 'budget-bound' : 'budget-missing',
+    recommended_profile: profile,
+    max_context_tokens: tokenBudget.max_context_tokens,
+    token_overhead_score: tokenDimension.score,
+    expected_saving_direction: tokenBudget.provided ? 'lower entry context through deterministic skill surfacing and deferral' : 'unknown until Stage 128 token budget is supplied',
+    delta: tokenBudget.provided && tokenDimension.score <= 35 ? 'Token Savior discipline is bound to the workflow entry.' : 'Token overhead remains a visible regression risk; bind or refresh Stage 128 budget evidence.',
+  };
+}
+
+function learningLoopDelta(learningPattern) {
+  return {
+    status: learningPattern.provided ? (learningPattern.promotion_required ? 'candidate-only' : 'unsafe-promotion-risk') : 'not-bound',
+    candidate_count: learningPattern.candidate_count,
+    repeat_signal_detected: learningPattern.repeat_signal_detected,
+    promotion_required: learningPattern.promotion_required,
+    required_workflow: learningPattern.required_workflow,
+    delta: learningPattern.provided ? 'ECC-style learning is represented as local candidate patterns and still requires manual skill-authoring workflow.' : 'Learning loop evidence is not bound; repeated friction cannot be promoted safely.',
+  };
+}
+
+function dailyUserFrictionDelta(friction, console, tokenBudget) {
+  const top = friction.priority_fixes[0] || { id: 'none', severity: 'low', recommended_stage: 'none' };
+  return {
+    status: friction.friction_score <= 30 && console.provided && tokenBudget.provided ? 'reduced' : 'needs-followup',
+    friction_score: friction.friction_score,
+    friction_level: friction.friction_level,
+    top_friction: top.id,
+    top_friction_severity: top.severity,
+    command_discovery_reduced: console.command_preview_count > 0,
+    token_budget_bound: tokenBudget.provided,
+    delta: console.provided ? 'Daily next step is visible through a one-screen console and command previews.' : 'Daily next step is still fragmented; bind Stage 127 console output.',
+  };
+}
+
+function regressionBlockers({ friction, console, tokenBudget, learningPattern, scorecard }) {
+  const blockers = [];
+  if (friction.friction_score >= 70) blockers.push(blocker('high-friction-score', 'high', 'Stage 126 friction score is still high; do not claim experience regression is closed.'));
+  if (hasSevereDimension(friction, 'next_action_unclear') && !console.provided) blockers.push(blocker('missing-next-action-console', 'high', 'Stage 127 console is required when next action is unclear.'));
+  if (hasSevereDimension(friction, 'token_overhead') && !tokenBudget.provided) blockers.push(blocker('missing-token-budget', 'medium', 'Stage 128 Token Savior budget is required when token overhead is present.'));
+  if (hasSevereDimension(friction, 'superpowers_parity_gap')) blockers.push(blocker('superpowers-parity-gap', 'high', 'Refresh Stage 115/125 comparison before claiming Superpowers parity.'));
+  if (!learningPattern.provided) blockers.push(blocker('learning-pattern-not-bound', 'medium', 'Stage 129 learning pattern evidence is not bound; repeated experience regressions cannot be tracked.'));
+  if (learningPattern.provided && learningPattern.promotion_required !== true) blockers.push(blocker('unsafe-learning-promotion', 'high', 'Learning pattern must remain candidate-only and require manual promotion workflow.'));
+  if (scorecard.overall_experience_score < 60) blockers.push(blocker('low-overall-experience-score', 'high', 'Overall experience score is below the release-ready threshold.'));
+  return blockers;
+}
+
+function nextBet({ console, tokenBudget, learningPattern, blockers }) {
+  const high = blockers.find((item) => item.severity === 'high');
+  if (high) return {
+    id: high.id,
+    action: high.recommendation,
+    target_stage: stageForBlocker(high.id),
+    why: 'A high-severity regression blocker must be resolved before expanding automation.',
+  };
+  if (!console.provided) return { id: 'bind-next-action-console', action: 'Bind Stage 127 console evidence so daily next action stays one-screen.', target_stage: 'Stage 127', why: 'Dashboard confidence improves when next-step evidence is explicit.' };
+  if (!tokenBudget.provided) return { id: 'bind-token-budget', action: 'Bind Stage 128 Token Savior budget to keep entry context deterministic.', target_stage: 'Stage 128', why: 'Token-saving claims require a local budget contract.' };
+  if (!learningPattern.provided) return { id: 'bind-learning-pattern', action: 'Bind Stage 129 learning candidate pattern evidence.', target_stage: 'Stage 129', why: 'Repeated experience patterns should remain visible without automatic promotion.' };
+  return { id: 'experience-loop-ready', action: 'Use the dashboard as the Stage 132 baseline before choosing the next UX bet.', target_stage: 'Stage 132+', why: 'Core experience evidence is bound and no high-severity regression blocker remains.' };
+}
+
+function normalizeFriction(input) {
+  const matrix = objectValue(input.experience_friction_matrix || input);
+  const dimensions = listValue(matrix.dimensions).map((dimension) => ({
+    id: stringValue(dimension.id),
+    severity: stringValue(dimension.severity || 'low'),
+    score: numberValue(dimension.score),
+    weighted_score: numberValue(dimension.weighted_score),
+  })).filter((dimension) => dimension.id);
+  const priorityFixes = listValue(matrix.priority_fixes).map((fix) => ({
+    id: stringValue(fix.id),
+    severity: stringValue(fix.severity || 'low'),
+    score: numberValue(fix.score),
+    recommended_stage: stringValue(fix.recommended_stage),
+  })).filter((fix) => fix.id);
+  return {
+    provided: Boolean(matrix.stage || matrix.friction_digest || dimensions.length > 0),
+    stage: stringValue(matrix.stage || 'Stage 126'),
+    friction_score: numberValue(matrix.friction_score),
+    friction_level: stringValue(matrix.friction_level || 'unknown'),
+    dimensions,
+    priority_fixes: priorityFixes,
+    friction_digest: stringValue(matrix.friction_digest || input.friction_digest),
+  };
+}
+
+function normalizeConsole(input) {
+  if (!input) return { provided: false, command_preview_count: 0, evidence_needed_count: 0, digest: '' };
+  const panel = objectValue(input.next_action_console || input);
+  return {
+    provided: Boolean(panel.stage || panel.console_digest),
+    stage: stringValue(panel.stage || 'Stage 127'),
+    console_kind: stringValue(panel.console_kind),
+    has_recommended_next_action: Boolean(panel.recommended_next_action?.action || panel.recommended_next_action),
+    command_preview_count: listValue(panel.copy_ready_command_preview).length,
+    evidence_needed_count: listValue(panel.evidence_needed_next).length,
+    do_not_do_count: listValue(panel.do_not_do_yet).length,
+    digest: stringValue(panel.console_digest || input.console_digest),
+  };
+}
+
+function normalizeTokenBudget(input) {
+  if (!input) return { provided: false, recommended_profile: '', max_context_tokens: 0, surface_count: 0, defer_count: 0, digest: '' };
+  const budget = objectValue(input.token_savior_budget || input);
+  return {
+    provided: Boolean(budget.stage || budget.budget_digest),
+    stage: stringValue(budget.stage || 'Stage 128'),
+    recommended_profile: stringValue(budget.recommended_profile),
+    max_context_tokens: numberValue(budget.context_budget?.max_context_tokens),
+    surface_count: listValue(budget.skills_to_surface).length,
+    defer_count: listValue(budget.skills_to_defer).length,
+    command_count: listValue(budget.commands_to_surface).length,
+    digest: stringValue(budget.budget_digest || input.budget_digest),
+  };
+}
+
+function normalizeLearningPattern(input) {
+  if (!input) return { provided: false, candidate_count: 0, repeat_signal_detected: false, promotion_required: false, required_workflow: [], digest: '' };
+  const pattern = objectValue(input.experience_learning_pattern || input.learning_experience_pattern || input);
+  return {
+    provided: Boolean(pattern.stage || pattern.experience_pattern_digest),
+    stage: stringValue(pattern.stage || 'Stage 129'),
+    candidate_count: listValue(pattern.candidate_experience_patterns).length,
+    repeat_signal_detected: Boolean(pattern.repeat_signal?.detected),
+    promotion_required: pattern.promotion_required === true,
+    required_workflow: listValue(pattern.required_workflow).map(stringValue).filter(Boolean),
+    digest: stringValue(pattern.experience_pattern_digest || input.experience_pattern_digest),
+  };
+}
+
+function sourceBindingSummary(source, friction, console, tokenBudget, learningPattern) {
+  return {
+    friction_file: stringValue(source.friction_file),
+    friction_digest: stringValue(source.friction_digest || friction.friction_digest),
+    console_file: stringValue(source.console_file),
+    console_digest: stringValue(source.console_digest || console.digest),
+    token_budget_file: stringValue(source.token_budget_file),
+    token_budget_digest: stringValue(source.token_budget_digest || tokenBudget.digest),
+    learning_pattern_file: stringValue(source.learning_pattern_file),
+    learning_pattern_digest: stringValue(source.learning_pattern_digest || learningPattern.digest),
+  };
+}
+
+function dimensionById(friction, id) {
+  return friction.dimensions.find((dimension) => dimension.id === id) || { id, severity: 'low', score: 0, weighted_score: 0 };
+}
+
+function hasSevereDimension(friction, id) {
+  const dimension = dimensionById(friction, id);
+  return dimension.score >= 70 || ['high', 'severe'].includes(dimension.severity);
+}
+
+function evidenceVisibilityScore(friction, console) {
+  const evidenceGap = dimensionById(friction, 'evidence_gap').score;
+  const consoleBonus = console.provided && console.evidence_needed_count > 0 ? 18 : 0;
+  return clamp(100 - evidenceGap + consoleBonus, 0, 100);
+}
+
+function tokenProfileScore(profile) {
+  if (profile === 'tiny_entry') return 94;
+  if (profile === 'balanced_runtime') return 84;
+  if (profile === 'full_maintenance') return 74;
+  return 50;
+}
+
+function scoreRating(score) {
+  if (score >= 85) return 'strong';
+  if (score >= 70) return 'stable';
+  if (score >= 60) return 'watch';
+  return 'regression-risk';
+}
+
+function blocker(id, severity, recommendation) {
+  return { id, severity, recommendation };
+}
+
+function stageForBlocker(id) {
+  const map = {
+    'high-friction-score': 'Stage 126',
+    'missing-next-action-console': 'Stage 127',
+    'missing-token-budget': 'Stage 128',
+    'superpowers-parity-gap': 'Stage 115/125',
+    'learning-pattern-not-bound': 'Stage 129',
+    'unsafe-learning-promotion': 'Stage 129',
+    'low-overall-experience-score': 'Stage 132',
+  };
+  return map[id] || 'Stage 132';
+}
+
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, Number.isFinite(value) ? value : min));
+}
+
+function numberValue(value) {
+  const number = Number(value ?? 0);
+  return Number.isFinite(number) ? number : 0;
+}
+
+function stringValue(value) {
+  return String(value ?? '').trim();
+}
+
+function listValue(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function objectValue(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? 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);
+}

package/tools/vibe-runtime/runtime-experience-upgrade-command.mjs

@@ -0,0 +1,92 @@
+import {
+  ensureRoot,
+  localJsonFileWithinRoot,
+} from './runtime-local-json-input.mjs';
+import {
+  emitReadonlyLocalJsonOutput,
+  readonlyLocalJsonEnvelope,
+} from './runtime-readonly-local-json-output-envelope.mjs';
+import {
+  digestExperienceUpgradePrioritizer,
+  runtimeExperienceUpgradePrioritizer,
+  runtimeExperienceUpgradePrioritizerDigestPayload,
+} from './runtime-experience-upgrade-prioritizer.mjs';
+
+function printList(title, items) {
+  if (!items || items.length === 0) return;
+  console.log(`${title}:`);
+  for (const item of items) {
+    console.log(`- ${item}`);
+  }
+}
+
+export function experienceUpgradePrioritizerEnvelope(root, { comparisonFile = '', dashboardFile = '', installExperienceFile = '' } = {}) {
+  ensureRoot(root);
+  if (!comparisonFile) throw new Error('governance --experience-upgrades requires --from-comparison <local-comparison-json>');
+  if (!dashboardFile) throw new Error('governance --experience-upgrades requires --from-dashboard <local-dashboard-json>');
+  const comparisonInput = localJsonFileWithinRoot(root, comparisonFile, 'governance --experience-upgrades --from-comparison');
+  const dashboardInput = localJsonFileWithinRoot(root, dashboardFile, 'governance --experience-upgrades --from-dashboard');
+  const installInput = installExperienceFile ? localJsonFileWithinRoot(root, installExperienceFile, 'governance --experience-upgrades --from-install-experience') : null;
+  const base = runtimeExperienceUpgradePrioritizer({
+    comparison: comparisonInput.data,
+    dashboard: dashboardInput.data,
+    installExperience: installInput?.data || null,
+    source: {
+      comparison_file: comparisonInput.relative,
+      comparison_digest: comparisonInput.digest,
+      dashboard_file: dashboardInput.relative,
+      dashboard_digest: dashboardInput.digest,
+      install_experience_file: installInput?.relative || '',
+      install_experience_digest: installInput?.digest || '',
+    },
+  });
+  const prioritizer = {
+    ...base,
+    upgrade_digest: digestExperienceUpgradePrioritizer(runtimeExperienceUpgradePrioritizerDigestPayload(base)),
+  };
+  return readonlyLocalJsonEnvelope(root, {
+    mode: 'experience-upgrade-prioritizer',
+    ok: prioritizer.ok,
+    payloadKey: 'experience_upgrade_prioritizer',
+    payload: prioritizer,
+    safety: { stage: 'Stage 139', ...prioritizer.boundary_assertions },
+    quality: prioritizer.upgrade_invariants.findings,
+    action: 'experience upgrade prioritizer was computed read-only from local Stage 133 comparison JSON, local Stage 132 dashboard JSON, and optional local Stage 137 install experience JSON. It only ranks candidate upgrades and deferrals; no upgrade artifact, state directory, sidecar, command, check, smoke, test, eval, workflow skill execution, runtime action, repair, prompt mutation, hook registration, git, commit, push, PR, merge, platform API, external network, model, MCP, subagent, worktree, or business source write occurred.',
+  });
+}
+
+export function printExperienceUpgradePrioritizer(envelope) {
+  const prioritizer = envelope.experience_upgrade_prioritizer;
+  console.log('Vibecoding Runtime Experience Upgrade Prioritizer');
+  console.log(`Stage: ${prioritizer.stage}; Kind: ${prioritizer.prioritizer_kind}; pass=${prioritizer.ok}`);
+  console.log(`Inputs: comparison=${prioritizer.input_summary.comparison_stage}; dashboard=${prioritizer.input_summary.dashboard_stage}; install=${prioritizer.input_summary.install_experience_provided ? prioritizer.input_summary.install_experience_stage : 'not-provided'}`);
+  for (const candidate of prioritizer.upgrade_candidates) console.log(`- ${candidate.id}: priority=${candidate.priority_score}; impact=${candidate.impact_score}; risk=${candidate.risk_score}; cost=${candidate.implementation_cost}; defer=${candidate.defer}`);
+  printList('Recommended stage order', prioritizer.recommended_stage_order.map((item) => `${item.stage}: ${item.candidate_id}; priority=${item.priority_score}; ${item.why}`));
+  printList('Deferred upgrades', prioritizer.defer.map((item) => `${item.candidate_id}: risk=${item.risk_score}; ${item.reason}`));
+  console.log(`prioritization_policy: ${prioritizer.prioritization_policy.priority_formula}`);
+  console.log(`Next upgrade bet: ${prioritizer.next_upgrade_bet.target_stage}; ${prioritizer.next_upgrade_bet.candidate_id}; ${prioritizer.next_upgrade_bet.action}`);
+  console.log('Boundary: writes=false; upgrade_artifact=false; prioritizer_artifact=false; comparison_artifact=false; dashboard_artifact=false; install_experience_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; 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; 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(`Upgrade digest: ${prioritizer.upgrade_digest}`);
+  if (envelope.quality.length > 0) printList('Findings', envelope.quality);
+  console.log(`Action: ${envelope.action}`);
+}
+
+export function runExperienceUpgradePrioritizerCommand(options, deps) {
+  if (options.governanceReport) throw new Error('governance --experience-upgrades does not accept --report');
+  if (options.confirm || options.dryRun || options.write || options.preflight || options.dispatch || options.dispatchIntent || options.scan || options.once || options.run || options.autoRun || options.fromDispatch || options.dispatchEvent || options.actor || options.approval) throw new Error('governance --experience-upgrades is read-only and prioritizer-only');
+  if (!options.fromComparison) throw new Error('governance --experience-upgrades requires --from-comparison <local-comparison-json>');
+  if (!options.fromDashboard) throw new Error('governance --experience-upgrades requires --from-dashboard <local-dashboard-json>');
+  if (options.fromFile || options.fromSuperpowers || options.fromReadiness || options.fromFriction || options.fromConsole || options.fromTokenBudget || options.fromLearningPattern || options.fromRunbook || options.fromEvidence || options.fromExecutablePlan || options.fromPlan || options.fromBootstrapMatrix || options.fromEntryAcceptance || options.fromEntryDiscipline || options.fromUpgrades || options.selectedStage || options.task || options.commitSubject || options.confirmPlan || options.methodologyIntent || options.methodologyKind || options.learningObservationFiles.length > 0 || options.learningInstinctFile || options.tokenCompactionFiles.length > 0 || options.prompt) throw new Error('governance --experience-upgrades only accepts --from-comparison, --from-dashboard, optional --from-install-experience, --json, and --root');
+  const envelope = experienceUpgradePrioritizerEnvelope(options.root, {
+    comparisonFile: options.fromComparison,
+    dashboardFile: options.fromDashboard,
+    installExperienceFile: options.fromInstallExperience,
+  });
+  emitReadonlyLocalJsonOutput({
+    deps,
+    options,
+    channel: 'governance',
+    envelope,
+    print: printExperienceUpgradePrioritizer,
+  });
+}