@goodandready/dsh-moa 0.2.69 → 0.2.70

package/lib/client.js

@@ -2055,6 +2055,43 @@ 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",
@@ -2580,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"))
                   )
                 ),
@@ -2594,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-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

@@ -70,6 +70,8 @@ export const PresetSchema = z.object({
   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({
@@ -86,6 +88,8 @@ export const Config = z.object({
   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-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

@@ -39,6 +39,18 @@ export const COMPANION_PLUGINS = [
     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/promotion.js

@@ -1,3 +1,4 @@
+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'
@@ -37,6 +38,7 @@ export async function stagePromotion({
   callLlm = null,
   onProgress = null,
   execFn = null,
+  visualResult = null,
 }) {
   const winningIndex = (multiJudgeResult?.consensus && multiJudgeResult?.winningCandidateIndex)
     ? multiJudgeResult.winningCandidateIndex
@@ -122,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,
@@ -147,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, ...(selfHealingResult ? { selfHealing: selfHealingResult } : {}), ...(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'
@@ -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, callLlm, onProgress, execFn,
+    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.69",
+  "version": "0.2.70",
   "description": "Mixture of Agents (MoA) plugin for DeepSeek Harness with /moa slash command",
   "type": "module",
   "main": "lib/index.js",