@goodandready/dsh-moa 0.2.68 → 0.2.70

package/lib/client.js

@@ -2017,6 +2017,7 @@ window.__ModuleLoader__.load({
                   t("aggregator.report_desc") || "Generate downloadable Markdown & JSON reports detailing candidate latency, agreement, test gate, and cost breakdown."
                 )
               ),
+              // --- src/client/85-card-aggregator-ext.js ---
               /* Interactive Workbench & File Scoring (#251) */
               React.createElement(
                 "div",
@@ -2054,6 +2055,111 @@ window.__ModuleLoader__.load({
                   "(" + (t("aggregator.workbench_companion_note") || "safe shadow Git checkpoints before file promotion") + ")"
                 )
               ),
+              /* Multimodal Visual MoA Consensus (#250) */
+              React.createElement(
+                "div",
+                { style: { display: "flex", flexDirection: "column", gap: 6, padding: "8px 12px", background: "var(--dsw-alias-bg-layer-2)", borderRadius: 8, border: "1px solid var(--dsw-alias-border-l2)", marginTop: 8 } },
+                React.createElement(
+                  "label",
+                  { style: { display: "flex", alignItems: "center", gap: 8, cursor: "pointer", fontSize: 13, fontWeight: 500 } },
+                  React.createElement("input", {
+                    type: "checkbox",
+                    checked: Boolean(currentPreset.visual_moa_enabled),
+                    onChange: (e) => updateCurrentPreset((p) => ({ ...p, visual_moa_enabled: e.target.checked })),
+                    style: { accentColor: "var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))", cursor: "pointer" }
+                  }),
+                  t("aggregator.visual_moa_title") || "\u{1F441}\uFE0F Multimodal Visual MoA Consensus"
+                ),
+                React.createElement(
+                  "div",
+                  { style: { fontSize: 12, color: "var(--dsw-alias-label-secondary)", marginLeft: 22 } },
+                  t("aggregator.visual_moa_desc") || "Render UI candidates in Live Canvas and evaluate visual layout fidelity via Vision Bridge VLM."
+                ),
+                React.createElement(
+                  "div",
+                  { style: { fontSize: 11, color: "var(--dsw-alias-label-tertiary)", marginLeft: 22, marginTop: 2, display: "flex", alignItems: "center", gap: 6, flexWrap: "wrap" } },
+                  "\u{1F517} Companion Plugins:",
+                  React.createElement(
+                    "a",
+                    { href: "https://github.com/GooDAnDReaDY/dsh-vision-bridge", target: "_blank", rel: "noopener noreferrer", style: { color: "var(--dsw-alias-state-brand-primary)", textDecoration: "underline" } },
+                    "@goodandready/dsh-vision-bridge"
+                  ),
+                  "/",
+                  React.createElement(
+                    "a",
+                    { href: "https://github.com/GooDAnDReaDY/dsh-live-canvas", target: "_blank", rel: "noopener noreferrer", style: { color: "var(--dsw-alias-state-brand-primary)", textDecoration: "underline" } },
+                    "@goodandready/dsh-live-canvas"
+                  )
+                )
+              ),
+              /* Quota-Aware Provider Balancing (#253) */
+              React.createElement(
+                "div",
+                { style: { display: "flex", flexDirection: "column", gap: 6, padding: "8px 12px", background: "var(--dsw-alias-bg-layer-2)", borderRadius: 8, border: "1px solid var(--dsw-alias-border-l2)", marginTop: 8 } },
+                React.createElement(
+                  "label",
+                  { style: { display: "flex", alignItems: "center", gap: 8, cursor: "pointer", fontSize: 13, fontWeight: 500 } },
+                  React.createElement("input", {
+                    type: "checkbox",
+                    checked: Boolean(currentPreset.quota_aware_balancing_enabled),
+                    onChange: (e) => updateCurrentPreset((p) => ({ ...p, quota_aware_balancing_enabled: e.target.checked })),
+                    style: { accentColor: "var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))", cursor: "pointer" }
+                  }),
+                  t("aggregator.quota_balancing_title") || "\u2696\uFE0F Quota-Aware Provider Balancing"
+                ),
+                React.createElement(
+                  "div",
+                  { style: { fontSize: 12, color: "var(--dsw-alias-label-secondary)", marginLeft: 22 } },
+                  t("aggregator.quota_balancing_desc") || "Automatically substitute low-quota candidate models in Layer 1 to preserve rate limits for the final aggregator."
+                ),
+                React.createElement(
+                  "div",
+                  { style: { fontSize: 11, color: "var(--dsw-alias-label-tertiary)", marginLeft: 22, marginTop: 2, display: "flex", alignItems: "center", gap: 6, flexWrap: "wrap" } },
+                  "\u{1F517} Companion Plugins:",
+                  React.createElement(
+                    "a",
+                    { href: "https://github.com/GooDAnDReaDY/dsh-key-limits", target: "_blank", rel: "noopener noreferrer", style: { color: "var(--dsw-alias-state-brand-primary)", textDecoration: "underline" } },
+                    "@goodandready/dsh-key-limits"
+                  ),
+                  "/",
+                  React.createElement(
+                    "a",
+                    { href: "https://github.com/GooDAnDReaDY/dsh-subscriptions", target: "_blank", rel: "noopener noreferrer", style: { color: "var(--dsw-alias-state-brand-primary)", textDecoration: "underline" } },
+                    "@goodandready/dsh-subscriptions"
+                  )
+                )
+              ),
+              /* Self-Healing Post-Promotion Build Loop (#252) */
+              React.createElement(
+                "div",
+                { style: { display: "flex", flexDirection: "column", gap: 6, padding: "8px 12px", background: "var(--dsw-alias-bg-layer-2)", borderRadius: 8, border: "1px solid var(--dsw-alias-border-l2)", marginTop: 8 } },
+                React.createElement(
+                  "label",
+                  { style: { display: "flex", alignItems: "center", gap: 8, cursor: "pointer", fontSize: 13, fontWeight: 500 } },
+                  React.createElement("input", {
+                    type: "checkbox",
+                    checked: Boolean(currentPreset.self_healing_enabled),
+                    onChange: (e) => updateCurrentPreset((p) => ({ ...p, self_healing_enabled: e.target.checked })),
+                    style: { accentColor: "var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))", cursor: "pointer" }
+                  }),
+                  t("aggregator.self_healing_title") || "\u{1FA7A} Self-Healing Post-Promotion Build Loop"
+                ),
+                React.createElement(
+                  "div",
+                  { style: { fontSize: 12, color: "var(--dsw-alias-label-secondary)", marginLeft: 22 } },
+                  t("aggregator.self_healing_desc") || "Verify promoted files with a test command, request hotfix patches from the aggregator on failure, or auto-rollback to the Time Machine checkpoint."
+                ),
+                React.createElement(
+                  "div",
+                  { style: { fontSize: 11, color: "var(--dsw-alias-label-tertiary)", marginLeft: 22, marginTop: 2, display: "flex", alignItems: "center", gap: 6 } },
+                  "\u{1F517} Companion Plugin:",
+                  React.createElement(
+                    "a",
+                    { href: "https://github.com/GooDAnDReaDY/dsh-time-machine", target: "_blank", rel: "noopener noreferrer", style: { color: "var(--dsw-alias-state-brand-primary)", textDecoration: "underline" } },
+                    "@goodandready/dsh-time-machine"
+                  )
+                )
+              ),
               /* Graceful Degradation & Local Fallback (#175, #176) */
               React.createElement(
                 "div",
@@ -2511,6 +2617,7 @@ window.__ModuleLoader__.load({
                     React.createElement("th", { style: { padding: "6px 8px" } }, t("leaderboard.runs")),
                     React.createElement("th", { style: { padding: "6px 8px" } }, t("leaderboard.wins")),
                     React.createElement("th", { style: { padding: "6px 8px" } }, t("leaderboard.winrate")),
+                    React.createElement("th", { style: { padding: "6px 8px" } }, "Elo"),
                     React.createElement("th", { style: { padding: "6px 10px" } }, t("leaderboard.cost"))
                   )
                 ),
@@ -2525,6 +2632,7 @@ window.__ModuleLoader__.load({
                       React.createElement("td", { style: { padding: "6px 8px", color: "var(--dsw-alias-label-secondary)" } }, String(m.runs)),
                       React.createElement("td", { style: { padding: "6px 8px", color: "var(--dsw-alias-state-success-primary)" } }, String(m.wins)),
                       React.createElement("td", { style: { padding: "6px 8px", fontWeight: 600 } }, (m.winRate ?? 0) + "%"),
+                      React.createElement("td", { style: { padding: "6px 8px", fontWeight: 600, color: "var(--dsw-alias-state-brand-primary)" } }, String(m.elo ?? 1500)),
                       React.createElement("td", { style: { padding: "6px 10px", color: "var(--dsw-alias-label-secondary)" } }, m.avgCostUsd > 0 ? "$" + m.avgCostUsd.toFixed(4) : "Free")
                     )
                   )

package/lib/history.js

@@ -1,3 +1,4 @@
+import { classifyEloCategory, computeEloFromRuns, INITIAL_ELO } from './moa-elo.js'
 import { logger } from './logger.js'
 /**
  * MoA Run History & Analytics Module
@@ -355,6 +356,7 @@ export function getMoaLeaderboard(filePath = getDefaultHistoryFile(), options =
     _historyCache.totalCount = totalRuns
 
     const modelStats = new Map()
+    const parsedRuns = []
     let filteredRuns = 0
     for (const line of lines) {
       try {
@@ -362,6 +364,7 @@ export function getMoaLeaderboard(filePath = getDefaultHistoryFile(), options =
         if (!item) continue
         if (presetFilter && presetFilter !== 'all' && item.preset !== presetFilter) continue
         filteredRuns++
+        parsedRuns.push(item)
 
         const rawWinner = item.winnerModel ? String(item.winnerModel).trim() : null
         const cleanWinner = rawWinner ? rawWinner.replace(/\s*\[fallback for .*\]$/i, '').trim() : null
@@ -415,13 +418,25 @@ export function getMoaLeaderboard(filePath = getDefaultHistoryFile(), options =
       }
     }
 
+    const { globalRatings, categoryRatings } = computeEloFromRuns(parsedRuns)
     const models = Array.from(modelStats.values())
-      .map((st) => ({
-        ...st,
-        winRate: st.runs > 0 ? Number(((st.wins / st.runs) * 100).toFixed(1)) : 0,
-        avgTokens: st.runs > 0 ? Math.round(st.totalTokens / st.runs) : 0,
-        avgCostUsd: st.runs > 0 ? Number((st.totalCostUsd / st.runs).toFixed(4)) : 0,
-      }))
+      .map((st) => {
+        const elo = Math.round(globalRatings.get(st.modelKey) ?? INITIAL_ELO)
+        const categoryElo = {}
+        for (const [cat, cMap] of categoryRatings.entries()) {
+          if (cMap.has(st.modelKey)) {
+            categoryElo[cat] = Math.round(cMap.get(st.modelKey))
+          }
+        }
+        return {
+          ...st,
+          elo,
+          categoryElo,
+          winRate: st.runs > 0 ? Number(((st.wins / st.runs) * 100).toFixed(1)) : 0,
+          avgTokens: st.runs > 0 ? Math.round(st.totalTokens / st.runs) : 0,
+          avgCostUsd: st.runs > 0 ? Number((st.totalCostUsd / st.runs).toFixed(4)) : 0,
+        }
+      })
       .sort((a, b) => b.wins - a.wins || b.winRate - a.winRate)
 
     const result = {

package/lib/moa-elo.js

@@ -0,0 +1,189 @@
+/**
+ * Empirical Elo Rating and Active Learning Leaderboard by Task Category (#249)
+ * Calculates pairwise Elo ratings (K-factor = 32, baseline = 1500) segmented by
+ * task category (frontend, backend, refactoring, testing, sql, general),
+ * and exposes category leaders to Smart Routing.
+ */
+
+export const INITIAL_ELO = 1500
+export const DEFAULT_K_FACTOR = 32
+
+const CATEGORY_PATTERNS = [
+  { category: 'sql', regex: /\b(sql|postgres|sqlite|mysql|query|database|schema|migration|prisma|index|table)\b/i },
+  { category: 'frontend', regex: /\b(frontend|ui|css|html|react|vue|tailwind|component|button|layout|modal|svg|dom)\b/i },
+  { category: 'testing', regex: /\b(test|unit\s*test|e2e|vitest|jest|playwright|assert|coverage|mock|tdd)\b/i },
+  { category: 'refactoring', regex: /\b(refactor|clean|simplify|dedup|modular|rename|extract|decompose|yagni)\b/i },
+  { category: 'backend', regex: /\b(backend|api|endpoint|server|route|auth|jwt|middleware|express|http|rest|webhook|stream)\b/i },
+]
+
+/**
+ * Classifies a prompt into one of the standard Elo leaderboard categories.
+ *
+ * @param {string} prompt
+ * @returns {'frontend' | 'backend' | 'refactoring' | 'testing' | 'sql' | 'general'}
+ */
+export function classifyEloCategory(prompt = '') {
+  const text = String(prompt || '').trim()
+  if (!text) return 'general'
+  for (const rule of CATEGORY_PATTERNS) {
+    if (rule.regex.test(text)) return rule.category
+  }
+  return 'general'
+}
+
+/**
+ * Calculates expected win probability of player A against player B.
+ */
+export function expectedEloScore(ratingA, ratingB) {
+  return 1 / (1 + Math.pow(10, (ratingB - ratingA) / 400))
+}
+
+/**
+ * Updates pairwise Elo ratings when winnerKey beats all other participantKeys in a round.
+ *
+ * @param {Map<string, number>} ratingMap
+ * @param {string} winnerKey
+ * @param {string[]} participantKeys
+ * @param {number} [kFactor=32]
+ */
+export function applyRoundEloUpdate(ratingMap, winnerKey, participantKeys = [], kFactor = DEFAULT_K_FACTOR) {
+  if (!winnerKey || participantKeys.length < 2) return
+  const opponents = participantKeys.filter((k) => k && k !== winnerKey)
+  if (opponents.length === 0) return
+
+  // Normalize K-factor across the number of pairwise comparisons in the multi-candidate round
+  const effectiveK = kFactor / opponents.length
+  let winnerRating = ratingMap.get(winnerKey) ?? INITIAL_ELO
+  let winnerDelta = 0
+
+  for (const oppKey of opponents) {
+    const oppRating = ratingMap.get(oppKey) ?? INITIAL_ELO
+    const expWin = expectedEloScore(winnerRating, oppRating)
+    const expOpp = 1 - expWin
+
+    winnerDelta += effectiveK * (1 - expWin)
+    const nextOpp = oppRating + effectiveK * (0 - expOpp)
+    ratingMap.set(oppKey, nextOpp)
+  }
+
+  ratingMap.set(winnerKey, winnerRating + winnerDelta)
+}
+
+/**
+ * Computes global and per-category Elo ratings across a chronological list of MoA runs.
+ *
+ * @param {Array<object>} runs - Array of history run objects (oldest to newest)
+ * @param {number} [kFactor=32]
+ * @returns {{
+ *   globalRatings: Map<string, number>,
+ *   categoryRatings: Map<string, Map<string, number>>
+ * }}
+ */
+export function computeEloFromRuns(runs = [], kFactor = DEFAULT_K_FACTOR) {
+  const globalRatings = new Map()
+  const categoryRatings = new Map()
+
+  for (const run of runs) {
+    if (!run || !Array.isArray(run.candidates) || run.candidates.length === 0) continue
+
+    const category = run.category || classifyEloCategory(run.prompt || '')
+    if (!categoryRatings.has(category)) {
+      categoryRatings.set(category, new Map())
+    }
+    const catMap = categoryRatings.get(category)
+
+    const participantKeys = []
+    let winnerKey = null
+
+    const rawWinner = run.winnerModel ? String(run.winnerModel).trim() : null
+    const cleanWinner = rawWinner ? rawWinner.replace(/\s*\[fallback for .*\]$/i, '').trim() : null
+    const normWinner = cleanWinner && cleanWinner !== 'none' && cleanWinner !== 'unknown'
+      ? cleanWinner.replace(/[\/:]/g, ':').toLowerCase()
+      : null
+
+    for (let idx = 0; idx < run.candidates.length; idx++) {
+      const cand = run.candidates[idx]
+      const key = cand.provider && cand.model ? `${cand.provider}:${cand.model}` : (cand.model || 'unknown')
+      participantKeys.push(key)
+      if (!globalRatings.has(key)) globalRatings.set(key, INITIAL_ELO)
+      if (!catMap.has(key)) catMap.set(key, INITIAL_ELO)
+
+      if (!winnerKey) {
+        if (normWinner) {
+          const normKey = key.replace(/[\/:]/g, ':').toLowerCase()
+          const normModel = String(cand.model || '').replace(/[\/:]/g, ':').toLowerCase()
+          if (normWinner === normKey || normWinner === normModel || normWinner.endsWith(`:${normModel}`)) {
+            winnerKey = key
+          }
+        }
+        if (!winnerKey && typeof run.winnerIndex === 'number' && run.winnerIndex > 0) {
+          if (cand.index === run.winnerIndex || idx === run.winnerIndex - 1) {
+            winnerKey = key
+          }
+        }
+      }
+    }
+
+    if (winnerKey && participantKeys.length >= 2) {
+      applyRoundEloUpdate(globalRatings, winnerKey, participantKeys, kFactor)
+      applyRoundEloUpdate(catMap, winnerKey, participantKeys, kFactor)
+    }
+  }
+
+  return { globalRatings, categoryRatings }
+}
+
+/**
+ * Selects the best preset for a prompt category based on historical Elo ratings of its reference models.
+ *
+ * @param {string} prompt
+ * @param {Array<object>} presets
+ * @param {object} leaderboard - Result from getMoaLeaderboard()
+ * @returns {{ presetName: string, category: string, avgElo: number } | null}
+ */
+export function selectBestPresetByElo(prompt = '', presets = [], leaderboard = null) {
+  if (!leaderboard || !Array.isArray(leaderboard.models) || leaderboard.models.length === 0) return null
+  if (!Array.isArray(presets) || presets.length === 0) return null
+
+  const category = classifyEloCategory(prompt)
+  const modelMap = new Map()
+  for (const m of leaderboard.models) {
+    modelMap.set(m.modelKey, m)
+  }
+
+  let bestPreset = null
+  let bestElo = -Infinity
+
+  for (const preset of presets) {
+    if (preset.enabled === false) continue
+    const refs = Array.isArray(preset.reference_models) ? preset.reference_models : []
+    if (refs.length === 0) continue
+
+    let sumElo = 0
+    let matchedCount = 0
+    for (const ref of refs) {
+      const key = ref.provider && ref.model ? `${ref.provider}:${ref.model}` : ref.model
+      const st = modelMap.get(key)
+      if (st) {
+        const catElo = st.categoryElo?.[category] ?? st.elo ?? INITIAL_ELO
+        sumElo += catElo
+        matchedCount++
+      }
+    }
+
+    if (matchedCount > 0) {
+      const avgElo = sumElo / matchedCount
+      if (avgElo > bestElo && avgElo > INITIAL_ELO) {
+        bestElo = avgElo
+        bestPreset = preset.name
+      }
+    }
+  }
+
+  if (!bestPreset) return null
+  return {
+    presetName: bestPreset,
+    category,
+    avgElo: Math.round(bestElo),
+  }
+}

package/lib/moa-quota-balancer.js

@@ -0,0 +1,188 @@
+/**
+ * Quota-Aware Provider Balancing (#253)
+ * Queries provider/model rate limits and quota health via dsh-key-limits and dsh-subscriptions.
+ * Dynamically substitutes exhausted or low-quota reference slots with healthy fallback models
+ * to protect the final aggregator quota and prevent 429 pipeline aborts.
+ */
+
+import { service } from './services.js'
+import { logger } from './logger.js'
+import { slotLabel } from './moa-prompts.js'
+
+const DEFAULT_FALLBACK_POOL = [
+  { provider: 'deepseek', model: 'deepseek-reasoner' },
+  { provider: 'deepseek', model: 'deepseek-chat' },
+  { provider: 'qwen', model: 'qwen-2.5-coder-32b-instruct' },
+  { provider: 'openrouter', model: 'deepseek/deepseek-r1' },
+  { provider: 'ollama', model: 'qwen2.5-coder:32b' },
+]
+
+/**
+ * Inspects quota status for a given { provider, model } slot via dsh-key-limits or dsh-subscriptions.
+ *
+ * @param {object} ctx - Cordis context
+ * @param {{ provider: string, model: string }} slot
+ * @param {object} [options]
+ * @returns {Promise<{ exhausted: boolean, remainingRatio: number, reason: string | null }>}
+ */
+export async function checkSlotQuotaStatus(ctx, slot, options = {}) {
+  const provider = String(slot?.provider || '').trim()
+  const model = String(slot?.model || '').trim()
+  if (!provider) return { exhausted: false, remainingRatio: 1, reason: null }
+
+  const minRemainingRatio = Number.isFinite(options.minRemainingRatio) ? options.minRemainingRatio : 0.1
+
+  const keyLimits = options.keyLimitsService || service(ctx, 'keyLimits')
+  if (keyLimits) {
+    try {
+      let status = null
+      if (typeof keyLimits.getQuotaStatus === 'function') {
+        status = await keyLimits.getQuotaStatus(provider, model)
+      } else if (typeof keyLimits.checkLimit === 'function') {
+        status = await keyLimits.checkLimit(provider, model)
+      } else if (typeof keyLimits.getProviderStatus === 'function') {
+        status = await keyLimits.getProviderStatus(provider)
+      }
+
+      if (status) {
+        if (status.exhausted === true || status.rateLimited === true || status.blocked === true) {
+          return {
+            exhausted: true,
+            remainingRatio: 0,
+            reason: status.reason || 'Quota exhausted or rate-limited in dsh-key-limits',
+          }
+        }
+        const rem = Number(status.remaining ?? status.remainingRequests ?? status.remainingTokens)
+        const lim = Number(status.limit ?? status.maxRequests ?? status.maxTokens)
+        if (Number.isFinite(rem) && Number.isFinite(lim) && lim > 0) {
+          const ratio = rem / lim
+          if (ratio < minRemainingRatio) {
+            return {
+              exhausted: true,
+              remainingRatio: ratio,
+              reason: `Low quota remaining (${Math.round(ratio * 100)}%) in dsh-key-limits`,
+            }
+          }
+          return { exhausted: false, remainingRatio: ratio, reason: null }
+        }
+        if (Number.isFinite(status.remainingRatio)) {
+          if (status.remainingRatio < minRemainingRatio) {
+            return {
+              exhausted: true,
+              remainingRatio: status.remainingRatio,
+              reason: `Low quota ratio (${Math.round(status.remainingRatio * 100)}%) in dsh-key-limits`,
+            }
+          }
+          return { exhausted: false, remainingRatio: status.remainingRatio, reason: null }
+        }
+      }
+    } catch (err) {
+      logger.warn(`[dsh-moa:quota] Error querying dsh-key-limits for ${provider}:${model}:`, err?.message || err)
+    }
+  }
+
+  const subscriptions = options.subscriptionsService || service(ctx, 'subscriptions')
+  if (subscriptions) {
+    try {
+      let subStatus = null
+      if (typeof subscriptions.getSubscriptionStatus === 'function') {
+        subStatus = await subscriptions.getSubscriptionStatus(provider, model)
+      } else if (typeof subscriptions.checkQuota === 'function') {
+        subStatus = await subscriptions.checkQuota(provider, model)
+      }
+
+      if (subStatus) {
+        if (subStatus.exhausted === true || subStatus.active === false || subStatus.expired === true) {
+          return {
+            exhausted: true,
+            remainingRatio: 0,
+            reason: subStatus.reason || 'Subscription quota exhausted or inactive in dsh-subscriptions',
+          }
+        }
+        if (Number.isFinite(subStatus.remainingRatio) && subStatus.remainingRatio < minRemainingRatio) {
+          return {
+            exhausted: true,
+            remainingRatio: subStatus.remainingRatio,
+            reason: `Low subscription quota (${Math.round(subStatus.remainingRatio * 100)}%) in dsh-subscriptions`,
+          }
+        }
+      }
+    } catch (err) {
+      logger.warn(`[dsh-moa:quota] Error querying dsh-subscriptions for ${provider}:${model}:`, err?.message || err)
+    }
+  }
+
+  return { exhausted: false, remainingRatio: 1, reason: null }
+}
+
+/**
+ * Balances candidate reference slots before Layer 1 execution.
+ * Preserves quota for the aggregator by substituting low-quota/exhausted slots
+ * with healthy fallback models.
+ *
+ * @param {Array<{ provider: string, model: string }>} references
+ * @param {object} options
+ * @returns {Promise<{ balancedReferences: Array<{ provider: string, model: string }>, substitutions: Array<object> }>}
+ */
+export async function balanceCandidateQuotas(references = [], options = {}) {
+  if (!Array.isArray(references) || references.length === 0) {
+    return { balancedReferences: [], substitutions: [] }
+  }
+
+  const ctx = options.ctx || null
+  const aggregator = options.aggregator || null
+  const customFallbacks = Array.isArray(options.fallbackPool) && options.fallbackPool.length > 0
+    ? options.fallbackPool
+    : DEFAULT_FALLBACK_POOL
+
+  const usedKeys = new Set(references.map((r) => slotLabel(r)))
+  const balancedReferences = []
+  const substitutions = []
+
+  for (let i = 0; i < references.length; i++) {
+    const slot = references[i]
+    const label = slotLabel(slot)
+
+    // Reserve higher threshold (25%) if this candidate uses the exact same provider:model as the final aggregator
+    const isSameAsAggregator = aggregator && slotLabel(aggregator) === label
+    const minRemainingRatio = isSameAsAggregator ? 0.25 : (options.minRemainingRatio ?? 0.1)
+
+    const status = await checkSlotQuotaStatus(ctx, slot, {
+      ...options,
+      minRemainingRatio,
+    })
+
+    if (!status.exhausted) {
+      balancedReferences.push(slot)
+      continue
+    }
+
+    // Find a healthy replacement from customFallbacks
+    let replacement = null
+    for (const candidateFallback of customFallbacks) {
+      const fbLabel = slotLabel(candidateFallback)
+      if (fbLabel === label) continue
+      const fbStatus = await checkSlotQuotaStatus(ctx, candidateFallback, options)
+      if (!fbStatus.exhausted) {
+        replacement = { ...slot, provider: candidateFallback.provider, model: candidateFallback.model, replacedFrom: label }
+        usedKeys.add(fbLabel)
+        break
+      }
+    }
+
+    if (replacement) {
+      balancedReferences.push(replacement)
+      substitutions.push({
+        index: i + 1,
+        original: slot,
+        replacement: { provider: replacement.provider, model: replacement.model },
+        reason: status.reason,
+      })
+      logger.info(`[dsh-moa:quota] Replaced slot #${i + 1} (${label}) -> ${slotLabel(replacement)} (${status.reason})`)
+    } else {
+      balancedReferences.push(slot)
+    }
+  }
+
+  return { balancedReferences, substitutions }
+}

package/lib/moa-router.js

@@ -1,3 +1,4 @@
+import { selectBestPresetByElo } from './moa-elo.js'
 /**
  * Smart Preset Router for Mixture of Agents (MoA).
  * Supports heuristic keyword classification and optional LLM zero-shot routing.
@@ -32,15 +33,18 @@ export function classifyPromptIntent(prompt = '') {
 /**
  * Resolves the optimal preset for a given user prompt.
  */
-export async function resolvePresetForPrompt({
-  prompt = '',
-  presets = [],
-  defaultPreset = 'default',
-  routingModel = null,
-  callLlm = null,
-  enabled = false,
-  timeoutMs = 2000,
-}) {
+export async function resolvePresetForPrompt(arg1 = {}, arg2, arg3, arg4 = {}) {
+  const isPositional = typeof arg1 === "string"
+  const prompt = isPositional ? arg1 : (arg1.prompt || "")
+  const presets = isPositional ? (arg2 || []) : (arg1.presets || [])
+  const defaultPreset = isPositional ? (arg3 || "default") : (arg1.defaultPreset || "default")
+  const opts = isPositional ? (arg4 || {}) : arg1
+  const routingModel = opts.routingModel || null
+  const callLlm = opts.callLlm || null
+  const enabled = Boolean(opts.enabled ?? opts.smartRoutingEnabled ?? false)
+  const timeoutMs = opts.timeoutMs ?? 2000
+  const leaderboard = opts.leaderboard || null
+  const eloRankingEnabled = opts.eloRankingEnabled !== false
   const availableNames = (presets || []).map((p) => p.name).filter(Boolean)
   const safeDefault = availableNames.includes(defaultPreset) ? defaultPreset : (availableNames[0] || 'default')
 
@@ -87,6 +91,20 @@ Respond with ONLY the chosen preset name and nothing else.`
     }
   }
 
+  // 1.5. Active Learning Elo Leaderboard routing (#249)
+  if (leaderboard && eloRankingEnabled) {
+    const eloChoice = selectBestPresetByElo(prompt, presets, leaderboard)
+    if (eloChoice && availableNames.includes(eloChoice.presetName)) {
+      return {
+        presetName: eloChoice.presetName,
+        reason: "elo_active_learning",
+        category: eloChoice.category,
+        avgElo: eloChoice.avgElo,
+        isAutoRouted: true,
+      }
+    }
+  }
+
   // 2. Keyword heuristic classifier
   const heuristic = classifyPromptIntent(prompt)
   if (heuristic && availableNames.includes(heuristic)) {

package/lib/moa-schema.js

@@ -66,6 +66,12 @@ export const PresetSchema = z.object({
   uncertainty_scoring_enabled: z.boolean().default(false),
   subagent_swarm_enabled: z.boolean().default(false),
   adaptive_personas_enabled: z.boolean().default(false),
+  quota_aware_balancing_enabled: z.boolean().default(false),
+  self_healing_enabled: z.boolean().default(false),
+  self_healing_max_retries: z.number().default(2),
+  self_healing_command: z.string().default("npm test"),
+  visual_moa_enabled: z.boolean().default(false),
+  elo_ranking_enabled: z.boolean().default(true),
 })
 
 export const Config = z.object({
@@ -78,6 +84,12 @@ export const Config = z.object({
   uncertainty_scoring_enabled: z.boolean().default(false).volatile(),
   subagent_swarm_enabled: z.boolean().default(false).volatile(),
   adaptive_personas_enabled: z.boolean().default(false).volatile(),
+  quota_aware_balancing_enabled: z.boolean().default(false).volatile(),
+  self_healing_enabled: z.boolean().default(false).volatile(),
+  self_healing_max_retries: z.number().default(2).volatile(),
+  self_healing_command: z.string().default("npm test").volatile(),
+  visual_moa_enabled: z.boolean().default(false).volatile(),
+  elo_ranking_enabled: z.boolean().default(true).volatile(),
   smart_routing_model: ModelSlotSchema.default({ provider: '', model: '' }).volatile(),
   prices: z.dict(PriceRow).default({}).volatile(),
   presets: z.array(PresetSchema).default([

package/lib/moa-self-healing.js

@@ -0,0 +1,258 @@
+/**
+ * Self-Healing Post-Promotion Build Loop with dsh-time-machine Auto-Rollback (#252)
+ * Executes verification command after file promotion, dispatches compiler/test error logs
+ * to the MoA aggregator for hotfix generation up to maxRetries times, and automatically
+ * rolls back to the pre-promotion dsh-time-machine snapshot if verification still fails.
+ */
+
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { logger } from './logger.js'
+import { bestEffort } from './best-effort.js'
+import { extractFileBlocks } from './workspace/fs.js'
+import { isSafeRelativePath, assertPathContained, isLoopbackUrl } from './workspace/security.js'
+
+const execFileAsync = promisify(execFile)
+
+/**
+ * Runs a verification command in the target workspace.
+ *
+ * @param {string} cwd
+ * @param {string} commandStr
+ * @param {object} [options]
+ * @returns {Promise<{ passed: boolean, exitCode: number, output: string }>}
+ */
+export async function runVerificationCommand(cwd, commandStr = 'npm test', options = {}) {
+  if (typeof options.execFn === 'function') {
+    return await options.execFn(cwd, commandStr)
+  }
+
+  const trimmed = String(commandStr || 'npm test').trim()
+  const isWin = process.platform === 'win32'
+  const shell = isWin ? 'cmd.exe' : '/bin/sh'
+  const shellArgs = isWin ? ['/d', '/s', '/c', trimmed] : ['-c', trimmed]
+
+  try {
+    const { stdout, stderr } = await execFileAsync(shell, shellArgs, {
+      cwd,
+      timeout: (options.timeoutSec ?? 60) * 1000,
+      maxBuffer: 4 * 1024 * 1024,
+      signal: options.signal,
+    })
+    return {
+      passed: true,
+      exitCode: 0,
+      output: `${stdout || ''}\n${stderr || ''}`.trim(),
+    }
+  } catch (err) {
+    const out = `${err?.stdout || ''}\n${err?.stderr || ''}\n${err?.message || ''}`.trim()
+    return {
+      passed: false,
+      exitCode: typeof err?.code === 'number' ? err.code : 1,
+      output: out.slice(0, 12000),
+    }
+  }
+}
+
+/**
+ * Triggers an automatic rollback to a pre-promotion dsh-time-machine snapshot.
+ *
+ * @param {string} baseDir
+ * @param {object} snapshot
+ * @param {object} [options]
+ * @returns {Promise<{ rolledBack: boolean, snapshotId: string | null }>}
+ */
+export async function rollbackToTimeMachineSnapshot(baseDir, snapshot, options = {}) {
+  const snapshotId = typeof snapshot === 'string'
+    ? snapshot
+    : (snapshot?.id || snapshot?.snapshotId || snapshot?.commit || snapshot?.hash || null)
+
+  if (typeof options.rollbackFn === 'function') {
+    const res = await bestEffort('custom rollbackFn', () => options.rollbackFn(baseDir, snapshotId, snapshot))
+    return { rolledBack: Boolean(res), snapshotId }
+  }
+
+  if (options.timeMachineEngine) {
+    const fn = options.timeMachineEngine.restoreSnapshot || options.timeMachineEngine.rollback
+    if (typeof fn === 'function') {
+      const res = await bestEffort('dsh-time-machine direct restoreSnapshot', () =>
+        fn.call(options.timeMachineEngine, snapshotId, { cwd: baseDir })
+      )
+      if (res) return { rolledBack: true, snapshotId }
+    }
+  }
+
+  const port = options.port || options.webServerPort || process.env.DSH_PORT || process.env.PORT
+  if (!port && !options.timeMachineRollbackUrl) {
+    logger.warn('[dsh-moa:self-healing] Cannot rollback: webServerPort is unknown and no timeMachineEngine/rollbackFn provided')
+    return { rolledBack: false, snapshotId }
+  }
+
+  const endpoint = options.timeMachineRollbackUrl || `http://127.0.0.1:${port}/dsh-time-machine/restore`
+  if (!isLoopbackUrl(endpoint)) {
+    logger.warn(`[dsh-moa:self-healing] Blocked non-loopback rollback URL: ${endpoint}`)
+    return { rolledBack: false, snapshotId }
+  }
+
+  const restored = await bestEffort('dsh-time-machine HTTP rollback', async () => {
+    const res = await fetch(endpoint, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ id: snapshotId, snapshotId, cwd: baseDir }),
+      signal: AbortSignal.timeout(options.timeoutMs ?? 5000),
+      redirect: 'error',
+    })
+    return res.ok
+  })
+
+  return { rolledBack: Boolean(restored), snapshotId }
+}
+
+/**
+ * Applies extracted hotfix files directly to the workspace directory.
+ */
+async function applyHotfixFiles(cwd, files = []) {
+  const written = []
+  for (const f of files) {
+    const rel = f.relativePath || f.path
+    if (!rel || !isSafeRelativePath(rel)) continue
+    const targetPath = assertPathContained(cwd, rel)
+    await fs.mkdir(path.dirname(targetPath), { recursive: true })
+    await fs.writeFile(targetPath, f.content, 'utf8')
+    written.push(rel)
+  }
+  return written
+}
+
+/**
+ * Runs the post-promotion self-healing build loop.
+ *
+ * @param {object} params
+ * @returns {Promise<{
+ *   enabled: boolean,
+ *   passed: boolean,
+ *   attempts: number,
+ *   rolledBack: boolean,
+ *   snapshotId: string | null,
+ *   hotfixFiles: string[],
+ *   lastOutput: string
+ * }>}
+ */
+export async function runSelfHealingLoop({
+  cwd,
+  command = 'npm test',
+  maxRetries = 2,
+  aggregatorSlot,
+  callLlm,
+  userPrompt = '',
+  promotedFiles = [],
+  checkpoint = null,
+  promoteOpts = {},
+  onProgress = null,
+  signal = null,
+  execFn = null,
+  rollbackFn = null,
+}) {
+  const retries = Math.max(0, Math.min(5, Number(maxRetries ?? 2)))
+  const hotfixFiles = new Set()
+
+  if (typeof onProgress === 'function') {
+    onProgress(`🩺 *Self-Healing Verification: Running \`${command}\`...*\n`)
+  }
+
+  let check = await runVerificationCommand(cwd, command, { execFn, signal })
+  if (check.passed) {
+    return {
+      enabled: true,
+      passed: true,
+      attempts: 0,
+      rolledBack: false,
+      snapshotId: null,
+      hotfixFiles: [],
+      lastOutput: check.output,
+    }
+  }
+
+  let attempts = 0
+  while (!check.passed && attempts < retries) {
+    if (signal?.aborted) break
+    attempts++
+
+    if (typeof onProgress === 'function') {
+      onProgress(`🔧 *Self-Healing Attempt ${attempts}/${retries}: Requesting hotfix patch from aggregator...*\n`)
+    }
+
+    const fileList = Array.isArray(promotedFiles)
+      ? promotedFiles.map((f) => (typeof f === 'string' ? f : f.relativePath || f.path)).filter(Boolean)
+      : []
+
+    const hotfixPrompt = [
+      `The promoted MoA changes failed the verification command \`${command}\` (exit code ${check.exitCode}).`,
+      `Original User Task: ${userPrompt}`,
+      `Promoted Files: ${fileList.join(', ') || 'workspace files'}`,
+      `\n### Compiler / Test Failure Output:\n\`\`\`\n${check.output}\n\`\`\``,
+      `\nProvide a minimal hotfix patch using markdown code blocks with \`path=<relative/path>\` header so the build and tests pass.`,
+    ].join('\n')
+
+    const llmRes = await callLlm({
+      provider: aggregatorSlot?.provider || 'default',
+      model: aggregatorSlot?.model || 'default',
+      messages: [
+        {
+          role: 'system',
+          content: 'You are an expert automated build healer. Fix compilation or unit test errors by outputting complete corrected files with ```lang path=relative/path.ext fences.',
+        },
+        { role: 'user', content: hotfixPrompt },
+      ],
+      temperature: 0.2,
+      maxTokens: 4096,
+      signal,
+    })
+
+    const patchText = typeof llmRes === 'string' ? llmRes : (llmRes?.content || llmRes?.text || '')
+    const extracted = extractFileBlocks(patchText)
+    if (extracted.length > 0) {
+      const applied = await applyHotfixFiles(cwd, extracted)
+      for (const f of applied) hotfixFiles.add(f)
+    }
+
+    check = await runVerificationCommand(cwd, command, { execFn, signal })
+    if (check.passed) {
+      if (typeof onProgress === 'function') {
+        onProgress(`✅ *Self-Healing Succeeded on attempt ${attempts}/${retries}!*\n`)
+      }
+      return {
+        enabled: true,
+        passed: true,
+        attempts,
+        rolledBack: false,
+        snapshotId: null,
+        hotfixFiles: [...hotfixFiles],
+        lastOutput: check.output,
+      }
+    }
+  }
+
+  // Verification still failed after maxRetries -> unconditional Time Machine rollback
+  const snapshotObj = checkpoint || promoteOpts?.checkpointSnapshot || (Array.isArray(promotedFiles) && promotedFiles._checkpoint) || null
+  if (typeof onProgress === 'function') {
+    onProgress(`⏪ *Self-Healing exhausted (${attempts}/${retries}). Rolling back workspace via dsh-time-machine...*\n`)
+  }
+
+  const rb = await rollbackToTimeMachineSnapshot(cwd, snapshotObj, {
+    ...promoteOpts,
+    rollbackFn,
+  })
+
+  return {
+    enabled: true,
+    passed: false,
+    attempts,
+    rolledBack: rb.rolledBack,
+    snapshotId: rb.snapshotId,
+    hotfixFiles: [...hotfixFiles],
+    lastOutput: check.output,
+  }
+}

package/lib/moa-visual-consensus.js

@@ -0,0 +1,187 @@
+/**
+ * Multimodal Visual MoA Consensus via dsh-vision-bridge and dsh-live-canvas (#250)
+ * Renders UI/Frontend candidates (HTML, React, CSS, SVG) via dsh-live-canvas,
+ * captures headless screenshots, and evaluates layout/responsiveness via dsh-vision-bridge.
+ * Gracefully degrades to text evaluation when companion plugins are unavailable.
+ */
+
+import { service } from './services.js'
+import { logger } from './logger.js'
+import { slotLabel } from './moa-prompts.js'
+
+const UI_TASK_REGEX = /\b(html|css|svg|ui|frontend|react|vue|tailwind|layout|landing|page|component|button|modal|responsive|card|dashboard|widget)\b/i
+
+/**
+ * Checks whether a prompt or candidate output involves UI/Frontend rendering.
+ */
+export function isVisualUiTask(prompt = '', referenceOutputs = []) {
+  if (UI_TASK_REGEX.test(String(prompt || ''))) return true
+  for (const ref of referenceOutputs || []) {
+    const files = Array.isArray(ref?.files) ? ref.files : []
+    if (files.some((f) => /\.(html?|css|svg|jsx|tsx|vue)$/i.test(f.relativePath || f.path || ''))) {
+      return true
+    }
+  }
+  return false
+}
+
+/**
+ * Extracts renderable HTML/SVG preview markup from a candidate output.
+ */
+export function extractRenderableMarkup(candidate = {}) {
+  const files = Array.isArray(candidate.files) ? candidate.files : []
+  const htmlFile = files.find((f) => /\.(html?|svg)$/i.test(f.relativePath || f.path || ''))
+  if (htmlFile?.content) {
+    return { title: htmlFile.relativePath || 'index.html', content: htmlFile.content }
+  }
+
+  const cssFile = files.find((f) => /\.css$/i.test(f.relativePath || f.path || ''))
+  const jsFile = files.find((f) => /\.(jsx?|tsx?)$/i.test(f.relativePath || f.path || ''))
+  if (cssFile || jsFile) {
+    const html = [
+      '<!DOCTYPE html><html><head><meta charset="utf-8">',
+      cssFile ? `<style>${cssFile.content}</style>` : '',
+      '</head><body><div id="app">UI Preview</div>',
+      '</body></html>',
+    ].join('\n')
+    return { title: 'synthesized-preview.html', content: html }
+  }
+
+  const text = String(candidate.text || '')
+  const fenceMatch = /```(?:html|svg)\s*([\s\S]*?)```/i.exec(text)
+  if (fenceMatch) {
+    return { title: 'inline-preview.html', content: fenceMatch[1].trim() }
+  }
+  return null
+}
+
+/**
+ * Evaluates candidates visually using dsh-live-canvas and dsh-vision-bridge.
+ * Returns { degraded: true } if companion services are absent so the caller falls back cleanly.
+ *
+ * @param {object} params
+ * @returns {Promise<{
+ *   degraded: boolean,
+ *   reason?: string,
+ *   visualScores: Array<{ candidateIndex: number, label: string, visualScore: number, critique: string, previewUrl: string | null }>,
+ *   directive: string
+ * }>}
+ */
+export async function runVisualMoaConsensus({
+  ctx = null,
+  liveCanvas = null,
+  visionBridge = null,
+  userPrompt = '',
+  referenceOutputs = [],
+  onProgress = null,
+}) {
+  const resolvedCanvas = liveCanvas || service(ctx, 'liveCanvas')
+  const resolvedVision = visionBridge || service(ctx, 'visionBridge')
+
+  if (!resolvedCanvas && !resolvedVision) {
+    return {
+      degraded: true,
+      reason: 'Companion plugins dsh-live-canvas and dsh-vision-bridge are not active; using standard text evaluation.',
+      visualScores: [],
+      directive: '',
+    }
+  }
+
+  if (typeof onProgress === 'function') {
+    onProgress('👁️ *Visual MoA Consensus: Rendering UI candidates in Live Canvas & evaluating via Vision Bridge...*\n')
+  }
+
+  const visualScores = []
+  for (let i = 0; i < referenceOutputs.length; i++) {
+    const ref = referenceOutputs[i]
+    if (!ref || ref.ok === false) continue
+    const idx = ref.index ?? (i + 1)
+    const label = ref.label || slotLabel(ref.slot || ref)
+    const markup = extractRenderableMarkup(ref)
+    if (!markup) continue
+
+    let previewUrl = null
+    let screenshot = null
+
+    if (resolvedCanvas) {
+      try {
+        if (typeof resolvedCanvas.createPreviewFromContent === 'function') {
+          const prev = await resolvedCanvas.createPreviewFromContent({
+            content: markup.content,
+            title: `Candidate #${idx} (${label}) - ${markup.title}`,
+          })
+          previewUrl = prev?.previewUrl || null
+          screenshot = prev?.screenshot || prev?.imageBase64 || null
+        }
+        if (!screenshot && typeof resolvedCanvas.captureScreenshot === 'function') {
+          screenshot = await resolvedCanvas.captureScreenshot({
+            content: markup.content,
+            previewUrl,
+          })
+        }
+      } catch (err) {
+        logger.warn(`[dsh-moa:visual] Live Canvas preview failed for candidate #${idx}:`, err?.message || err)
+      }
+    }
+
+    let visualScore = 7.5
+    let critique = 'Rendered cleanly in Live Canvas preview.'
+
+    if (resolvedVision) {
+      try {
+        const evalFn = resolvedVision.evaluateVisualLayout || resolvedVision.analyzeImage || resolvedVision.inspectUi
+        if (typeof evalFn === 'function') {
+          const vRes = await evalFn.call(resolvedVision, {
+            prompt: userPrompt,
+            candidateIndex: idx,
+            html: markup.content,
+            previewUrl,
+            screenshot,
+          })
+          if (vRes) {
+            if (Number.isFinite(Number(vRes.score))) {
+              visualScore = Math.max(1, Math.min(10, Number(vRes.score)))
+            }
+            if (vRes.critique || vRes.summary || vRes.feedback) {
+              critique = String(vRes.critique || vRes.summary || vRes.feedback).trim()
+            }
+          }
+        }
+      } catch (err) {
+        logger.warn(`[dsh-moa:visual] Vision Bridge evaluation failed for candidate #${idx}:`, err?.message || err)
+      }
+    }
+
+    visualScores.push({
+      candidateIndex: idx,
+      label,
+      visualScore: Number(visualScore.toFixed(1)),
+      critique,
+      previewUrl,
+    })
+  }
+
+  if (visualScores.length === 0) {
+    return {
+      degraded: true,
+      reason: 'No renderable HTML/CSS/SVG artifacts found in candidates.',
+      visualScores: [],
+      directive: '',
+    }
+  }
+
+  const lines = [
+    '### 👁️ Multimodal Visual MoA Consensus (`dsh-live-canvas` + `dsh-vision-bridge`):',
+    'The following UI candidates were rendered and visually inspected for layout, responsiveness, and design fidelity:',
+    ...visualScores.map(
+      (v) => `- **Candidate #${v.candidateIndex} (${v.label})**: Visual Score **${v.visualScore}/10** — ${v.critique}${v.previewUrl ? ` ([Live Preview](${v.previewUrl}))` : ''}`
+    ),
+    'Prioritize candidates with higher visual layout fidelity and zero rendering defects.',
+  ]
+
+  return {
+    degraded: false,
+    visualScores,
+    directive: lines.join('\n'),
+  }
+}

package/lib/moa-workbench.js

@@ -27,6 +27,30 @@ export const COMPANION_PLUGINS = [
     url: 'https://github.com/goodandready/dsh-time-machine',
     description: 'Pre-promotion shadow Git checkpoints and rollback points',
   },
+  {
+    id: 'dsh-key-limits',
+    name: 'DSH Key Limits',
+    url: 'https://github.com/GooDAnDReaDY/dsh-key-limits',
+    description: 'Provider API key rate-limit and quota telemetry',
+  },
+  {
+    id: 'dsh-subscriptions',
+    name: 'DSH Subscriptions',
+    url: 'https://github.com/GooDAnDReaDY/dsh-subscriptions',
+    description: 'Subscription tier and quota tracking for LLM providers',
+  },
+  {
+    id: 'dsh-vision-bridge',
+    name: 'DSH Vision Bridge',
+    url: 'https://github.com/GooDAnDReaDY/dsh-vision-bridge',
+    description: 'Multimodal VLM visual evaluation for UI/Frontend artifacts',
+  },
+  {
+    id: 'dsh-live-canvas',
+    name: 'DSH Live Canvas',
+    url: 'https://github.com/GooDAnDReaDY/dsh-live-canvas',
+    description: 'Isolated live HTML/CSS/SVG preview environment and screenshot capture',
+  },
 ]
 
 /**

package/lib/pipeline/context.js

@@ -1,3 +1,4 @@
+import { balanceCandidateQuotas } from '../moa-quota-balancer.js'
 import { collectProjectContext, formatProjectContext, isRefinementTask } from '../workspace/scanner.js'
 import { applyBudgetGuardrails, createBudgetAbortPayload } from '../moa-budget.js'
 import { extractPriorTurnBaseline, pruneMultiTurnMessages } from '../moa-context.js'
@@ -13,6 +14,7 @@ export async function stageProjectContext({
   maxTokens,
   startTime,
   onProgress,
+  ctx = null,
 }) {
   const rawRefs = (Array.isArray(preset?.reference_models) && preset.reference_models.length > 0)
     ? preset.reference_models
@@ -79,7 +81,23 @@ export async function stageProjectContext({
     return { ok: false, abortPayload }
   }
 
-  const effectiveReferences = budgetCheck.references
+  let effectiveReferences = budgetCheck.references
+  let quotaSubstitutions = []
+  if (preset?.quota_aware_balancing_enabled) {
+    const fallbackPool = Array.isArray(preset?.local_fallback_models) && preset.local_fallback_models.length > 0
+      ? preset.local_fallback_models
+      : undefined
+    const bal = await balanceCandidateQuotas(effectiveReferences, {
+      ctx,
+      aggregator: primaryJudge,
+      fallbackPool,
+    })
+    effectiveReferences = bal.balancedReferences
+    quotaSubstitutions = bal.substitutions
+    if (quotaSubstitutions.length > 0 && typeof onProgress === "function") {
+      onProgress(`⚖️ *Quota-Aware Balancing: Replaced ${quotaSubstitutions.length} low-quota slot(s) to preserve aggregator budget.*\n`)
+    }
+  }
   if (effectiveReferences.length === 1 && !preset?.curator_synthesis) {
     isFastMode = true
   }
@@ -103,7 +121,7 @@ export async function stageProjectContext({
     isStreamAggregator, isQuorumEnabled, gracePeriodSec, candidateRetries,
     refTimeoutSec, aggTimeoutSec, isBlindEvaluation, isPeerCritiqueEnabled,
     allowCandidateOverride, collectedCtx, isRefinement, projectContext,
-    effectiveReferences, priorTurnBaseline, candidateSystemPrompt,
+    effectiveReferences, quotaSubstitutions, priorTurnBaseline, candidateSystemPrompt,
     needsQuestions, enrichedMessages,
   }
 }

package/lib/pipeline/promotion.js

@@ -1,3 +1,5 @@
+import { classifyEloCategory } from '../moa-elo.js'
+import { runSelfHealingLoop } from '../moa-self-healing.js'
 import { logger } from '../logger.js'
 import { parseWinnerIndex, parseRecommendedAssembler } from '../moa-parser.js'
 import { extractFileBlocks, writeCandidateWorkspace, promoteCandidateWorkspace, cleanMoaWorkspaces } from '../workspace/fs.js'
@@ -33,6 +35,10 @@ export async function stagePromotion({
   historyFilePath,
   collectedCtx,
   ctx = null,
+  callLlm = null,
+  onProgress = null,
+  execFn = null,
+  visualResult = null,
 }) {
   const winningIndex = (multiJudgeResult?.consensus && multiJudgeResult?.winningCandidateIndex)
     ? multiJudgeResult.winningCandidateIndex
@@ -69,6 +75,24 @@ export async function stagePromotion({
     throw promoteErr
   }
 
+  let selfHealingResult = null
+  if (preset?.self_healing_enabled && promotedFiles.length > 0 && typeof callLlm === "function") {
+    selfHealingResult = await runSelfHealingLoop({
+      cwd,
+      command: preset.self_healing_command || "npm test",
+      maxRetries: preset.self_healing_max_retries ?? 2,
+      aggregatorSlot: chosenJudge,
+      callLlm,
+      userPrompt,
+      promotedFiles,
+      checkpoint: promotedFiles.checkpoint || null,
+      promoteOpts,
+      onProgress,
+      signal,
+      execFn,
+    })
+  }
+
   const livePreview = await createPromotedPreview(liveCanvas, cwd, promotedFiles, referenceOutputs, { winningIndex, synthesizedFiles })
   const durationMs = Date.now() - startTime
   const usageSummary = summarizeMoAUsage(referenceOutputs, aggUsage, multiJudgeResult?.totalUsage)
@@ -100,7 +124,7 @@ export async function stagePromotion({
 
   try {
     await recordMoaRunAsync({
-      id: runId, cwd, prompt: userPrompt, preset: preset?.name || 'default', isRefinement,
+      id: runId, cwd, prompt: userPrompt, category: classifyEloCategory(userPrompt), preset: preset?.name || 'default', isRefinement,
       candidates: candidatesForHistory(referenceOutputs),
       aggregator: { provider: chosenJudge.provider, model: chosenJudge.model, usage: aggUsage, costUsd: aggUsage.costUsd },
       winnerIndex: winningIndex, winnerModel, promotedFiles, benchmarkReport, consensus: multiJudgeResult,
@@ -125,7 +149,7 @@ export async function stagePromotion({
       kind: 'synthesis', content: synthesizedText, aggregator: isFastMode ? 'Fast Mode (Direct)' : finalAggLabel,
       references: referenceOutputs, presetName: preset?.name || 'default', isRefinement, isFastMode, isCuratorSynthesis,
       recommendedAssembler, winningIndex, winnerModel, promotedFiles, runId, allowCandidateOverride,
-      benchmarkReport, consensus: multiJudgeResult, fileScores, ...(livePreview ? { liveCanvas: livePreview } : {}),
+      benchmarkReport, consensus: multiJudgeResult, fileScores, ...(selfHealingResult ? { selfHealing: selfHealingResult } : {}), ...(visualResult ? { visualConsensus: visualResult } : {}), ...(livePreview ? { liveCanvas: livePreview } : {}),
       usage: usageSummary, skippedFiles: collectedCtx?.skippedFiles || 0, skippedList: collectedCtx?.skippedList || [], durationMs,
     }
   }

package/lib/pipeline/runner.js

@@ -1,3 +1,4 @@
+import { runVisualMoaConsensus } from '../moa-visual-consensus.js'
 import crypto from 'node:crypto'
 import { isTestEnvironment } from '../history.js'
 import { cleanMoaWorkspaces } from '../workspace/fs.js'
@@ -40,7 +41,7 @@ export async function runMoAPipeline({
 
   // Stage 1: Context & Configuration
   const ctxStage = await stageProjectContext({
-    userPrompt, messages, preset, cwd, prices, maxTokens: preset?.max_tokens, startTime, onProgress,
+    userPrompt, messages, preset, cwd, prices, maxTokens: preset?.max_tokens, startTime, onProgress, ctx,
   })
   if (!ctxStage.ok) return ctxStage.abortPayload
 
@@ -157,9 +158,20 @@ export async function runMoAPipeline({
   const compositeMergeDirective = (preset?.composite_merge_enabled && successfulRefs.length > 1)
     ? buildCompositeBlockDirectives(successfulRefs, { blind: Boolean(preset.blind_evaluation) })
     : null
-  const fileScoringDirective = (preset?.interactive_workbench_enabled)
+  let visualResult = null
+  if (preset?.visual_moa_enabled) {
+    visualResult = await runVisualMoaConsensus({
+      ctx,
+      liveCanvas,
+      userPrompt,
+      referenceOutputs,
+      onProgress,
+    })
+  }
+  const rawFileDirective = (preset?.interactive_workbench_enabled)
     ? formatFileScoresDirective()
     : null
+  const fileScoringDirective = [rawFileDirective, visualResult?.directive].filter(Boolean).join("\n\n") || null
 
   // Stage 7: Synthesis Phase
   const synthRes = await stageSynthesis({
@@ -189,7 +201,7 @@ export async function runMoAPipeline({
     promoteOpts, cwd, runId, signal, liveCanvas, startTime, chosenJudge, aggUsage,
     userPrompt, preset, isRefinement: ctxStage.isRefinement, isFastMode: ctxStage.isFastMode,
     effectiveReferences: ctxStage.effectiveReferences, referenceModels: ctxStage.referenceModels,
-    historyFilePath, collectedCtx: ctxStage.collectedCtx, ctx,
+    historyFilePath, collectedCtx: ctxStage.collectedCtx, ctx, callLlm, onProgress, execFn, visualResult,
   })
   if (!promRes.ok) {
     if (promRes.abort) return { error: promRes.error }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-moa",
-  "version": "0.2.68",
+  "version": "0.2.70",
   "description": "Mixture of Agents (MoA) plugin for DeepSeek Harness with /moa slash command",
   "type": "module",
   "main": "lib/index.js",