@goodandready/dsh-moa 0.2.69 → 0.2.71

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,12 @@ 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),
+  ast_composite_merge_enabled: z.boolean().default(false),
+  speculative_moa_enabled: z.boolean().default(false),
+  speculative_draft_model: ModelSlotSchema.default({ provider: "", model: "" }),
+  adversarial_tdd_enabled: z.boolean().default(false),
 })
 
 export const Config = z.object({
@@ -86,6 +92,12 @@ 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(),
+  ast_composite_merge_enabled: z.boolean().default(false).volatile(),
+  speculative_moa_enabled: z.boolean().default(false).volatile(),
+  speculative_draft_model: ModelSlotSchema.default({ provider: "", model: "" }).volatile(),
+  adversarial_tdd_enabled: z.boolean().default(false).volatile(),
   smart_routing_model: ModelSlotSchema.default({ provider: '', model: '' }).volatile(),
   prices: z.dict(PriceRow).default({}).volatile(),
   presets: z.array(PresetSchema).default([

package/lib/moa-speculative.js

@@ -0,0 +1,195 @@
+/**
+ * Speculative MoA with Fast-Draft Model and Multi-Auditor Diffs (#247)
+ * Generates a rapid initial draft using speculative_draft_model, dispatches the draft
+ * to reference models in parallel as diff auditors (producing targeted SEARCH/REPLACE
+ * or unified diff hunks), applies valid hunks to the draft, and gracefully falls back
+ * to standard parallel MoA if the draft model fails.
+ */
+
+import { logger } from './logger.js'
+import { slotLabel } from './moa-prompts.js'
+import { estimateTokenCost } from './pricing.js'
+
+/**
+ * Applies SEARCH/REPLACE or unified diff patches onto a base draft text.
+ *
+ * @param {string} draftText
+ * @param {string} patchText
+ * @returns {{ patchedText: string, appliedCount: number }}
+ */
+export function applyAuditorPatchHunks(draftText = '', patchText = '') {
+  let result = String(draftText || '')
+  let appliedCount = 0
+
+  // 1. Support SEARCH / REPLACE blocks:
+  // <<<<<<< SEARCH
+  // ...
+  // =======
+  // ...
+  // >>>>>>> REPLACE
+  const searchReplaceRegex = /<{5,9}\s*SEARCH\r?\n([\s\S]*?)\r?\n={5,9}\r?\n([\s\S]*?)\r?\n>{5,9}\s*REPLACE/g
+  let srMatch
+  while ((srMatch = searchReplaceRegex.exec(patchText)) !== null) {
+    const searchBlock = srMatch[1]
+    const replaceBlock = srMatch[2]
+    if (searchBlock && result.includes(searchBlock)) {
+      result = result.replace(searchBlock, replaceBlock)
+      appliedCount++
+    }
+  }
+
+  // 2. Support unified diff hunks (- oldLine / + newLine)
+  if (appliedCount === 0 && /```diff[\r\n]+([\s\S]*?)```/i.test(patchText)) {
+    const diffMatch = /```diff[\r\n]+([\s\S]*?)```/i.exec(patchText)
+    const diffLines = diffMatch[1].split(/\r?\n/)
+    const removed = []
+    const added = []
+    for (const line of diffLines) {
+      if (line.startsWith('---') || line.startsWith('+++') || line.startsWith('@@')) continue
+      if (line.startsWith('-')) removed.push(line.slice(1))
+      else if (line.startsWith('+')) added.push(line.slice(1))
+    }
+    if (removed.length > 0) {
+      const targetChunk = removed.join('\n')
+      const replacementChunk = added.join('\n')
+      if (result.includes(targetChunk)) {
+        result = result.replace(targetChunk, replacementChunk)
+        appliedCount++
+      }
+    }
+  }
+
+  return { patchedText: result, appliedCount }
+}
+
+/**
+ * Executes Speculative MoA:
+ * 1. Calls fast draft model (`speculative_draft_model` or first reference slot).
+ * 2. Dispatches draft to reference models in parallel as diff auditors.
+ * 3. Applies valid diff hunks onto draft so each auditor produces a refined candidate output.
+ * 4. If the draft model fails, returns `{ fallbackToStandard: true }` so the caller runs standard parallel MoA.
+ */
+export async function runSpeculativeMoa(references = [], messages = [], options = {}, callLlm, onProgress) {
+  const draftSlot = (options.draftModel?.provider && options.draftModel?.model)
+    ? options.draftModel
+    : references[0]
+
+  if (!draftSlot || !draftSlot.provider || !draftSlot.model) {
+    return { fallbackToStandard: true, reason: 'No valid speculative draft model configured' }
+  }
+
+  const draftLabel = slotLabel(draftSlot)
+  if (typeof onProgress === 'function') {
+    onProgress(`⚡ *Speculative MoA: Generating fast initial draft with \`${draftLabel}\`...*\n`)
+  }
+
+  const draftStart = Date.now()
+  let draftText = ''
+  let draftUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0 }
+
+  try {
+    const draftRes = await callLlm({
+      provider: draftSlot.provider,
+      model: draftSlot.model,
+      messages,
+      systemPrompt: options.systemPrompt,
+      temperature: options.temperature ?? 0.3,
+      maxTokens: options.maxTokens ?? 4096,
+      signal: options.signal,
+    })
+    draftText = typeof draftRes === 'string' ? draftRes : (draftRes?.content || draftRes?.text || '')
+    if (!draftText || !draftText.trim()) {
+      throw new Error('Empty draft response from speculative draft model')
+    }
+    const rawUsage = (typeof draftRes === 'object' && draftRes?.usage) ? draftRes.usage : {
+      inputTokens: 100,
+      outputTokens: Math.max(1, Math.round(draftText.length / 4)),
+    }
+    draftUsage = estimateTokenCost(draftSlot, rawUsage, options.prices || {})
+  } catch (err) {
+    logger.warn(`[dsh-moa:speculative] Draft model ${draftLabel} failed (${err?.message || err}); falling back to standard parallel MoA.`)
+    if (typeof onProgress === 'function') {
+      onProgress(`⚠️ *Speculative draft model \`${draftLabel}\` failed; falling back to standard parallel MoA...*\n`)
+    }
+    return { fallbackToStandard: true, reason: err?.message || String(err) }
+  }
+
+  const draftDurationMs = Date.now() - draftStart
+  if (typeof onProgress === 'function') {
+    onProgress(`🔍 *Speculative MoA: Dispatching draft to ${references.length} parallel diff auditor(s)...*\n`)
+  }
+
+  const lastUserPrompt = messages[messages.length - 1]?.content || ''
+  const auditTasks = references.map(async (slot, idx) => {
+    const candidateIndex = idx + 1
+    const label = slotLabel(slot)
+    const auditStart = Date.now()
+
+    const auditPrompt = [
+      `You are Speculative Auditor #${candidateIndex} (${label}).`,
+      `Review the fast draft below for the user task and provide targeted diff fixes (logic bugs, edge cases, types, security) using SEARCH/REPLACE blocks or \`\`\`diff hunks.`,
+      `\n### Original User Task:\n${lastUserPrompt}`,
+      `\n### Fast Draft Solution (${draftLabel}):\n${draftText}`,
+      `\nOutput your audit notes and any SEARCH/REPLACE or \`\`\`diff blocks needed to perfect the draft.`,
+    ].join('\n')
+
+    try {
+      const auditRes = await callLlm({
+        provider: slot.provider,
+        model: slot.model,
+        messages: [{ role: 'user', content: auditPrompt }],
+        temperature: 0.2,
+        maxTokens: Math.min(options.maxTokens ?? 2048, 2048),
+        signal: options.signal,
+      })
+      const auditText = typeof auditRes === 'string' ? auditRes : (auditRes?.content || auditRes?.text || '')
+      const rawAuditUsage = (typeof auditRes === 'object' && auditRes?.usage) ? auditRes.usage : {
+        inputTokens: Math.max(1, Math.round(auditPrompt.length / 4)),
+        outputTokens: Math.max(1, Math.round(auditText.length / 4)),
+      }
+      const auditCost = estimateTokenCost(slot, rawAuditUsage, options.prices || {})
+
+      const { patchedText, appliedCount } = applyAuditorPatchHunks(draftText, auditText)
+      const combinedText = appliedCount > 0
+        ? `${patchedText}\n\n#### Speculative Auditor Diff Notes (${label}, ${appliedCount} hunk(s) applied):\n${auditText}`
+        : `${draftText}\n\n#### Speculative Auditor Review (${label}):\n${auditText}`
+
+      return {
+        index: candidateIndex,
+        slot,
+        label,
+        text: combinedText,
+        speculativeAppliedHunks: appliedCount,
+        speculativeDraftModel: draftLabel,
+        usage: {
+          inputTokens: auditCost.inputTokens + (idx === 0 ? draftUsage.inputTokens : 0),
+          outputTokens: auditCost.outputTokens + (idx === 0 ? draftUsage.outputTokens : 0),
+          totalTokens: auditCost.totalTokens + (idx === 0 ? draftUsage.totalTokens : 0),
+        },
+        costUsd: Number((auditCost.costUsd + (idx === 0 ? draftUsage.costUsd : 0)).toFixed(6)),
+        durationMs: (Date.now() - auditStart) + (idx === 0 ? draftDurationMs : 0),
+        ok: true,
+      }
+    } catch (err) {
+      return {
+        index: candidateIndex,
+        slot,
+        label,
+        text: draftText,
+        error: err?.message || String(err),
+        usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+        costUsd: 0,
+        durationMs: Date.now() - auditStart,
+        ok: false,
+      }
+    }
+  })
+
+  const referenceOutputs = await Promise.all(auditTasks)
+  return {
+    fallbackToStandard: false,
+    draftModel: draftLabel,
+    draftText,
+    referenceOutputs,
+  }
+}

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,24 @@ 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',
+  },
+  {
+    id: 'dsh-context-lens',
+    name: 'DSH Context Lens',
+    url: 'https://github.com/GooDAnDReaDY/dsh-context-lens',
+    description: 'Semantic AST parsing and symbol-level composite code merging',
+  },
 ]
 
 /**