@goodandready/dsh-moa 0.2.8 → 0.2.10

package/lib/moa-runner.js

@@ -1,84 +1,75 @@
-import { estimateTokenCost as calculateTokenCost, resolveModelRates, refreshCatalogInBackground, DIRECT_VENDOR_RATES, FALLBACK_RATES } from './pricing.js'
 /**
- * Mixture of Agents (MoA) execution engine with Interactive Questioning,
- * Isolated Multi-Candidate File Execution, Native Cost Tracking,
- * Refinement Mode, and Multi-Candidate Scalability.
+ * DeepSeek Harness Mixture of Agents (MoA) — Runner Engine
+ *
+ * Implements the full ensemble pipeline:
+ * - Parallel fan-out to reference models with transient retry & quorum straggler mitigation
+ * - Prompt caching aligned message structures
+ * - Curator synthesis & antipatterns evaluation
+ * - Aggregator fallback chain for resilience
+ * - Live token streaming for aggregator
+ * - File promotion & Live Canvas sandbox preview
  */
 
+import path from 'node:path'
 import {
   extractFileBlocks,
-  writeCandidateWorkspace,
-  promoteCandidateWorkspace,
-  cleanMoaWorkspaces,
   collectProjectContext,
   isRefinementTask,
-} from './file-workspace.js'
-
-import { recordMoaRun } from './history.js'
-
-export {
-  extractFileBlocks,
   writeCandidateWorkspace,
   promoteCandidateWorkspace,
   cleanMoaWorkspaces,
-  collectProjectContext,
-  isRefinementTask,
-}
+} from './file-workspace.js'
+import { estimateTokenCost } from './pricing.js'
+import { recordMoaRun } from './history.js'
 
-export const REFERENCE_SYSTEM_PROMPT = `You are an expert candidate engineer model in a Mixture of Agents (MoA) architecture.
-You are directly implementing the solution for the user's task.
-
-RULES:
-1. Do NOT emit internal planning or pretend tool calls (no xml, no <invoke>, no brainstorming delays).
-2. Write complete, production-ready, functional code.
-3. Every file you produce MUST be formatted in markdown code blocks with clear file path annotation, e.g.:
-   \`\`\`html file="index.html"
-   ...
-   \`\`\`
-   or
-   \`\`\`javascript file="src/app.js"
-   ...
-   \`\`\`
-4. If the user request is broad, make opinionated, high-quality technical decisions and deliver a complete working project.
-5. Never leave placeholders like "// TODO" or "... rest of code". Deliver exhaustive, working code.`
-
-export const REFINEMENT_SYSTEM_PROMPT = `You are an expert software engineer performing an iterative modification / refinement on an existing project.
-You are provided with the current codebase files and the user's delta request.
-
-RULES:
-1. Modify the existing files or create new files to fulfill the user's change request.
-2. Deliver complete, production-ready updated code for every modified file.
-3. Format each updated file in markdown code blocks with explicit file attribute:
-   \`\`\`javascript file="src/app.js"
-   ...
-   \`\`\`
-4. Keep the existing architecture, styling conventions and dependencies consistent.`
-
-export const ADVISOR_QUESTION_PROMPT = `You are a senior technical advisor in a Mixture of Agents (MoA) architecture.
-The user has provided a prompt that may have multiple design choices, architectural paths, or underspecified requirements.
-
-Review the user prompt and identify 1 to 3 critical, high-impact clarifying questions or architectural options that would define the implementation (e.g. framework/vanilla, features, design style, target environment).
-Keep questions very clear, structured, and actionable. Avoid trivial questions. Respond directly in Russian.`
-
-export { resolveModelRates, refreshCatalogInBackground, DIRECT_VENDOR_RATES, FALLBACK_RATES }
-
-export function estimateTokenCost(slot, usage = {}, customPrices = {}) {
-  return calculateTokenCost(slot, usage, customPrices)
-}
+export { estimateTokenCost } from './pricing.js'
+
+export const DEFAULT_PROMPT = 'Please propose an optimal, well-structured, production-ready solution with full code and explanations.'
+
+export const REFERENCE_SYSTEM_PROMPT = `You are an expert AI software architect and senior engineer acting as a candidate proposer in a Mixture of Agents (MoA) ensemble.
+Your task is to provide the highest-quality, robust, complete, production-ready solution to the user request.
+Write clean, modern, fully functional code without placeholders or shortcuts.
+When generating files for a project, explicitly specify file paths using fenced code blocks with file annotations, e.g.:
+\`\`\`html file="index.html"
+\`\`\`
+\`\`\`javascript file="script.js"
+\`\`\`
+\`\`\`css file="style.css"
+\`\`\``
+
+export const ANTIPATTERNS_RUBRIC = `### 🚫 Strict Antipatterns Evaluation Checklist
+Penalize and strictly downgrade candidates exhibiting any of the following flaws:
+1. 🚫 Lazy Code & Placeholders:
+   - Phrases like "// ... rest of code unchanged", "/* TODO: implement */", incomplete functions or stubs returning null/mock without notice.
+2. 🚫 Blind Mocking:
+   - Hardcoded dummy arrays instead of real dynamic logic, user input handling, or real API integration.
+3. 🚫 Silent Failures & Missing Error Handling:
+   - Missing try/catch around async calls, fetch, JSON.parse; lack of user-facing fallback or retry states.
+4. 🚫 AI Slop UI & Poor Ergonomics:
+   - Generic purple/cyan gradients on pure black backgrounds, blurry drop-shadows without borders, lack of typographic hierarchy, low contrast (e.g. light gray text on white).
+5. 🚫 Missing UI States:
+   - Lack of loading state (spinner/skeleton), error display with retry action, or empty state when no data exists.
+6. 🚫 Broken Layout & Mobile Incompatibility:
+   - Fixed pixel widths (e.g. width: 800px) overflowing small viewports; unscrollable modal dialogs.
+7. 🚫 Monolithic God Objects & Overengineering:
+   - Dumping 1000+ lines into a single unmaintainable file, or building 10+ abstraction layers for a 2-function task.
+8. 🚫 Context Amnesia & Regressions:
+   - Dropping or breaking previously functioning project features while adding new code.`
 
 export function slotLabel(slot) {
-  if (!slot || typeof slot !== 'object') return 'unknown'
-  const prov = String(slot.provider || '').trim()
-  const model = String(slot.model || '').trim()
-  if (prov && model) return `${prov}:${model}`
-  return prov || model || 'unknown'
+  if (!slot) return 'unknown'
+  if (typeof slot === 'string') return slot
+  if (slot.provider && slot.model) return `${slot.provider}:${slot.model}`
+  return slot.model || slot.provider || 'unknown'
 }
 
 /**
- * Strips tool results, system prompts, and tool calls from history
- * to give reference advisors a clean, advisory-safe context.
+ * Extracts and sanitizes conversation history for candidate models.
+ * Robust against complex DSH message content types (strings, part arrays, objects, tool calls).
  */
-export function cleanAdvisoryMessages(messages = [], maxCharBudget = 4000) {
+export function cleanAdvisoryMessages(messages = [], maxCharBudget = 24000) {
+  if (!Array.isArray(messages)) return []
+
   const trimmed = []
   for (const msg of messages) {
     if (!msg || typeof msg !== 'object') continue
@@ -90,12 +81,21 @@ export function cleanAdvisoryMessages(messages = [], maxCharBudget = 4000) {
       text = msg.content
     } else if (Array.isArray(msg.content)) {
       text = msg.content
-        .filter((part) => part && part.type === 'text' && typeof part.text === 'string')
+        .filter((part) => part && typeof part === 'object' && part.type === 'text' && typeof part.text === 'string')
         .map((part) => part.text)
         .join('\n')
+    } else if (msg.content && typeof msg.content === 'object') {
+      if (typeof msg.content.text === 'string') {
+        text = msg.content.text
+      } else if (typeof msg.content.content === 'string') {
+        text = msg.content.content
+      }
+    } else if (typeof msg.text === 'string') {
+      text = msg.text
     }
 
-    if (!text.trim()) continue
+    text = text.trim()
+    if (!text) continue
 
     if (text.length > maxCharBudget) {
       const head = text.slice(0, Math.floor(maxCharBudget * 0.7))
@@ -118,7 +118,7 @@ export function isBroadPromptRequiringQuestions(userPrompt = '', messages = [])
   }
 
   const hasRecentQuestion = messages.some((m) => {
-    const text = typeof m.content === 'string' ? m.content : JSON.stringify(m.content || '')
+    const text = typeof m?.content === 'string' ? m.content : JSON.stringify(m?.content || '')
     return text.includes('Уточнение требований') || text.includes('опросник') || text.includes('Вариант 1')
   })
   if (hasRecentQuestion) {
@@ -145,28 +145,81 @@ export function isBroadPromptRequiringQuestions(userPrompt = '', messages = [])
 
 export function buildQuestionSynthesisPrompt(userPrompt, referenceOutputs = []) {
   const joined = referenceOutputs
-    .map((r, i) => `Советник ${i + 1} (${r.label}):\n${r.text}`)
+    .map((r, i) => `Advisor ${i + 1} (${r.label}):\n${r.text}`)
     .join('\n\n')
 
-  return `Ты — ведущий архитектор и судья в архитектуре Mixture of Agents (MoA).
-Пользователь дал задачу:
+  return `You are the lead architect and judge in a Mixture of Agents (MoA) ensemble.
+The user gave the task:
 "${userPrompt}"
 
-Советники предложили следующие развилки и уточнения:
+The advisors proposed the following decision points and clarifications:
 ${joined}
 
-Твоя задача — синтезировать единый, компактный, дружелюбный и структурированный опросник (2-4 вопроса) для пользователя на русском языке.
-Каждый вопрос должен предлагать 2-3 конкретных рекомендуемых варианта ответа (например: 1. Формат: HTML/JS в одном файле или React? 2. Стиль: Минимализм, iOS или Необрутализм?).
-В конце добавь примечание, что пользователь может ответить кратко (например: "1, 2, темная тема") или довериться выбору по умолчанию.`
+Your task is to synthesize a single, compact, friendly and structured questionnaire (2-4 questions) in the same language as the user's prompt.
+Each question must offer 2-3 concrete recommended answer options (e.g.: 1. Format: single-file HTML/JS or React? 2. Style: minimalism, iOS or neubrutalism?).
+At the end, add a note that the user can answer briefly (e.g.: "1, 2, dark theme") or trust the defaults.`
 }
 
-export function buildSynthesisPrompt(userPrompt, referenceOutputs = [], judgeCriteria = '') {
+export function buildCuratorSynthesisPrompt(userPrompt, referenceOutputs = [], judgeCriteria = '') {
   const joined = referenceOutputs
     .map((r, i) => {
       const fileSummary = (r.files && r.files.length > 0)
-        ? ` [Созданные файлы: ${r.files.map((f) => f.relativePath).join(', ')}]`
+        ? ` [Files created: ${r.files.map((f) => f.relativePath).join(', ')}]`
+        : ''
+      let textContent = r.text
+      if (referenceOutputs.length >= 3 && textContent.length > 3000) {
+        textContent = stripOrSummarizeCode(textContent)
+      }
+      return `Candidate ${i + 1} — ${r.label}:${fileSummary}\n${textContent}`
+    })
+    .join('\n\n')
+
+  const criteriaBlock = judgeCriteria && judgeCriteria.trim()
+    ? `\n### 🎯 Additional evaluation criteria:\n${judgeCriteria.trim()}\n`
+    : ''
+
+  return `You are the expert Lead Technical Curator and Solution Architect in a Mixture of Agents (MoA) ensemble.
+Your mission is not merely to select one candidate, but to synthesize the optimal solution by extracting the finest components from each candidate's response, identifying potential flaws using the strict antipatterns rubric, and selecting/advising which single agent model is best suited to assemble the final unified deliverable.
+
+User Request:
+${userPrompt}
+${criteriaBlock}
+Candidate proposals:
+${joined}
+
+${ANTIPATTERNS_RUBRIC}
+
+Instructions:
+Your response MUST be structured into three clear parts (respond in the same language as the user's prompt, e.g. Russian):
+
+### 1. 🔍 Curator Analysis & Component Breakdown
+- For EACH candidate, provide:
+  - ⭐ **Strongest aspects** (e.g. robust architecture, superior UI/CSS design, clean data validation).
+  - ⚠️ **Defects or Antipatterns** found from the checklist above.
+- Highlight which candidate provides the best foundation for each component (e.g. Candidate 1 for core logic, Candidate 2 for visual UI).
+
+### 2. 🧩 Assembly Recipe & Recommended Master Assembler
+- Recommend the best single agent model to assemble and finalize the solution:
+  RECOMMENDED_ASSEMBLER: <number from 1 to N> (<provider:model>)
+- State the machine winner index marker for file promotion:
+  WINNER_CANDIDATE_INDEX: <number from 1 to N>
+- Provide the exact blueprint / instructions for combining the best pieces into a unified deliverable.
+
+### 3. 🚀 Unified Solution & Execution Guide
+- Present the final synthesized code or complete instructions combining the best candidate features.
+- How to run, verify, and use the deliverable.`
+}
+
+export function buildSynthesisPrompt(userPrompt, referenceOutputs = [], judgeCriteria = '', options = {}) {
+  if (options.curatorSynthesis) {
+    return buildCuratorSynthesisPrompt(userPrompt, referenceOutputs, judgeCriteria)
+  }
+
+  const joined = referenceOutputs
+    .map((r, i) => {
+      const fileSummary = (r.files && r.files.length > 0)
+        ? ` [Files created: ${r.files.map((f) => f.relativePath).join(', ')}]`
         : ''
-      // If 3+ candidates, summarize text to prevent judge context overflow (#13)
       let textContent = r.text
       if (referenceOutputs.length >= 3 && textContent.length > 3000) {
         textContent = stripOrSummarizeCode(textContent)
@@ -176,7 +229,7 @@ export function buildSynthesisPrompt(userPrompt, referenceOutputs = [], judgeCri
     .join('\n\n')
 
   const criteriaBlock = judgeCriteria && judgeCriteria.trim()
-    ? `\n### 🎯 Дополнительные критерии оценки от пользователя:\n${judgeCriteria.trim()}\n`
+    ? `\n### 🎯 Additional evaluation criteria from the user:\n${judgeCriteria.trim()}\n`
     : ''
 
   return `You are the expert aggregator/judge in a Mixture of Agents (MoA) process. You evaluate solutions from multiple candidate models, judge which one is best (or how to combine their best parts), and deliver the final authoritative verdict and solution.
@@ -187,37 +240,53 @@ ${criteriaBlock}
 Reference responses from candidate models:
 ${joined}
 
+${ANTIPATTERNS_RUBRIC}
+
 Instructions:
 Your response MUST be structured into three clear parts (respond in the same language as the user's prompt, e.g. Russian):
 
-### 1. ⚖️ Вердикт судьи и анализ вариантов
-- **Чей вариант выбран**: Чётко укажи имя модели и номер кандидата (например: "Победитель: Кандидат 1 (opencode-go:deepseek-v4-flash)" или "Выбран вариант модели Reference 1 (label)").
-- Обязательно добавь машинный маркер выбора победителя:
-  WINNER_CANDIDATE_INDEX: <число от 1 до N>
-- **Почему сделан этот выбор**: Подробно сравни код, архитектуру, сильные стороны, недочёты и надёжность всех кандидатов.
+### 1. ⚖️ Judge verdict and comparative analysis
+- **Winner**: clearly name the model and candidate number (e.g. "Winner: Candidate 1 (opencode-go:deepseek-v4-flash)" or "Reference 1 (label) is chosen").
+- Always add the machine winner-selection marker:
+  WINNER_CANDIDATE_INDEX: <number from 1 to N>
+- **Why this choice**: compare code, architecture, strengths, weaknesses and reliability of all candidates in detail.
 
-### 2. 📁 Созданные файлы проекта
-- Перечисли файлы победителя, которые были перенесены в корень проекта, и их назначение.
+### 2. 📁 Project files created
+- List the winner files promoted to the project root and their purpose.
 
-### 3. 🚀 Инструкция по запуску и использованию
-- Опиши, как открыть и запустить созданный проект.`
+### 3. 🚀 How to run and use
+- Describe how to open and run the created project.`
 }
 
-export function parseWinnerIndex(judgeText, defaultIndex = 1) {
+export function parseWinnerIndex(judgeText, defaultIndex = 1, candidateCount = Infinity) {
   if (!judgeText || typeof judgeText !== 'string') return defaultIndex
+  const inRange = (idx) => !isNaN(idx) && idx >= 1 && idx <= candidateCount
   const match = /WINNER_CANDIDATE_INDEX:\s*(\d+)/i.exec(judgeText)
   if (match) {
     const idx = parseInt(match[1], 10)
-    if (!isNaN(idx) && idx >= 1) return idx
+    if (inRange(idx)) return idx
   }
-  const candMatch = /(?:Кандидат|Reference)\s*(\d+)\b/i.exec(judgeText)
+  const candMatch = /(?:Кандидат|Candidate|Reference)\s*(\d+)\b/i.exec(judgeText)
   if (candMatch) {
     const idx = parseInt(candMatch[1], 10)
-    if (!isNaN(idx) && idx >= 1) return idx
+    if (inRange(idx)) return idx
   }
   return defaultIndex
 }
 
+export function parseRecommendedAssembler(judgeText, defaultIndex = 1, candidateCount = Infinity) {
+  if (!judgeText || typeof judgeText !== 'string') return { index: defaultIndex, label: '' }
+  const inRange = (idx) => !isNaN(idx) && idx >= 1 && idx <= candidateCount
+  const match = /RECOMMENDED_ASSEMBLER:\s*(\d+)(?:\s*\(([^)]+)\))?/i.exec(judgeText)
+  if (match) {
+    const idx = parseInt(match[1], 10)
+    if (inRange(idx)) {
+      return { index: idx, label: match[2]?.trim() || '' }
+    }
+  }
+  return { index: defaultIndex, label: '' }
+}
+
 export function parseMoACommand(text, presets = []) {
   if (typeof text !== 'string' || !text.startsWith('/moa')) {
     return null
@@ -258,7 +327,28 @@ export function parseMoACommand(text, presets = []) {
 }
 
 /**
- * Dispatches queries to all reference models in parallel.
+ * Invokes LLM call with transient retry for recoverable network/rate-limit errors.
+ */
+export async function callWithTransientRetry(callLlmFn, callArgs, maxRetries = 0, retryDelayMs = 1200) {
+  let attempt = 0
+  while (true) {
+    try {
+      return await callLlmFn(callArgs)
+    } catch (err) {
+      attempt++
+      const msg = err?.message || String(err)
+      const isTransient = /429|rate limit|502|503|504|econnreset|etimedout|socket hang up/i.test(msg)
+      if (attempt <= maxRetries && isTransient) {
+        await new Promise((r) => setTimeout(r, retryDelayMs))
+        continue
+      }
+      throw err
+    }
+  }
+}
+
+/**
+ * Dispatches queries to all reference models in parallel with transient retry and quorum straggler mitigation.
  */
 export async function runReferencesParallel(references, messages, options = {}, callLlm, onProgress) {
   if (!Array.isArray(references) || references.length === 0) {
@@ -267,338 +357,535 @@ export async function runReferencesParallel(references, messages, options = {},
 
   const advisoryMessages = cleanAdvisoryMessages(messages)
   const systemPrompt = options.systemPrompt || REFERENCE_SYSTEM_PROMPT
+  // Deterministic prefix for optimal prompt caching hit rate (#2.3)
   const fullMessages = [{ role: 'system', content: systemPrompt }, ...advisoryMessages]
   const timeoutMs = options.timeoutMs ?? 75000
+  const maxRetries = options.maxRetries ?? 0
+  const quorumEnabled = Boolean(options.quorumEnabled)
+  const gracePeriodMs = (options.gracePeriodSec ?? 10) * 1000
+
+  const total = references.length
+  let finishedCount = 0
+  const results = new Array(total)
+  const abortControllers = references.map(() => new AbortController())
+
+  let onTaskFinished = null
+  const notifyFinished = () => {
+    if (typeof onTaskFinished === 'function') onTaskFinished()
+  }
 
-  const tasks = references.map(async (slot, i) => {
+  if (typeof onProgress === 'function') {
+    onProgress(`⚡ *Launching ${total} candidate models in parallel...*\n`)
+  }
+
+  references.forEach((slot, i) => {
     const label = slotLabel(slot)
-    if (typeof onProgress === 'function') {
-      onProgress(`⚡ *Кандидат ${i + 1} (${label}) начал генерацию...*\n`)
-    }
 
-    try {
-      const callPromise = callLlm({
-        provider: slot.provider,
-        model: slot.model,
-        messages: fullMessages,
-        temperature: options.referenceTemperature ?? 0.6,
-        maxTokens: options.maxTokens ?? 4096,
-      })
-
-      const timeoutPromise = new Promise((_, reject) =>
-        setTimeout(() => reject(new Error(`Timeout after ${Math.round(timeoutMs / 1000)}s waiting for ${label}`)), timeoutMs).unref()
-      )
-
-      const res = await Promise.race([callPromise, timeoutPromise])
-      const text = (typeof res === 'string' ? res : (res?.content || res?.text || '')).trim()
-      const files = extractFileBlocks(text)
-
-      // Estimate tokens & cost
-      const rawUsage = res?.usage || {
-        inputTokens: Math.round(JSON.stringify(fullMessages).length / 4),
-        outputTokens: Math.round(text.length / 4),
-      }
-      const costInfo = estimateTokenCost(slot, rawUsage, options.prices)
+    const runOne = async () => {
+      try {
+        const callPromise = callWithTransientRetry(
+          callLlm,
+          {
+            provider: slot.provider,
+            model: slot.model,
+            messages: fullMessages,
+            temperature: options.temperature ?? 0.6,
+            maxTokens: options.maxTokens ?? 4096,
+            signal: abortControllers[i].signal,
+          },
+          maxRetries
+        )
+
+        const timeoutPromise = new Promise((_, reject) => {
+          const timer = setTimeout(() => reject(new Error(`Timeout after ${timeoutMs / 1000}s`)), timeoutMs)
+          timer.unref?.()
+        })
 
-      if (typeof onProgress === 'function') {
-        const fileMsg = files.length > 0 ? ` (создано файлов: ${files.length})` : ''
-        onProgress(`✅ *Кандидат ${i + 1} (${label}) завершил ответ${fileMsg}.*\n`)
-      }
+        const res = await Promise.race([callPromise, timeoutPromise])
+        const text = typeof res === 'string' ? res : (res?.content || res?.text || '')
 
-      return {
-        index: i + 1,
-        label,
-        provider: slot.provider,
-        model: slot.model,
-        text: text || '(empty response)',
-        files,
-        usage: costInfo,
-        costUsd: costInfo.costUsd,
-        ok: true,
+        const fallbackUsage = (typeof res === 'object' && res?.usage) ? res.usage : {
+          inputTokens: Math.max(1, Math.round(fullMessages.map((m) => m.content).join('').length / 4)),
+          outputTokens: Math.max(1, Math.round(text.length / 4)),
+        }
+        const costInfo = estimateTokenCost(slot, fallbackUsage, options.prices)
+
+        finishedCount++
+        if (typeof onProgress === 'function') {
+          const costStr = costInfo.costUsd > 0 ? ` (~\${costInfo.costUsd.toFixed(4)})` : ''
+          onProgress(`✅ *Candidate ${i + 1}/${total} (${label}) finished${costStr}*\n`)
+        }
+
+        results[i] = {
+          index: i + 1,
+          slot,
+          label,
+          text,
+          usage: costInfo,
+          costUsd: costInfo.costUsd,
+          ok: true,
+        }
+      } catch (err) {
+        finishedCount++
+        const errMsg = err?.message || String(err)
+        console.warn(`[dsh-moa] Reference ${label} failed:`, errMsg)
+        if (typeof onProgress === 'function') {
+          onProgress(`⚠️ *Candidate ${i + 1}/${total} (${label}) error: ${errMsg}*\n`)
+        }
+        results[i] = {
+          index: i + 1,
+          slot,
+          label,
+          text: `[Model ${label} error: ${errMsg}]`,
+          usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0 },
+          costUsd: 0,
+          ok: false,
+          error: errMsg,
+        }
+      } finally {
+        notifyFinished()
       }
-    } catch (err) {
-      console.warn(`[dsh-moa] Reference ${label} failed:`, err)
-      if (typeof onProgress === 'function') {
-        onProgress(`⚠️ *Кандидат ${i + 1} (${label}) завершился с ошибкой: ${err?.message || String(err)}*\n`)
+    }
+
+    runOne()
+  })
+
+  // Quorum straggler mitigation: exit as soon as grace period expires
+  if (quorumEnabled && total >= 3) {
+    const quorumTarget = Math.max(2, Math.min(total - 1, Math.ceil(total * 0.6)))
+    let graceTimer = null
+    let quorumTriggered = false
+
+    await new Promise((resolve) => {
+      const checkQuorum = () => {
+        if (finishedCount >= total) {
+          if (graceTimer) clearTimeout(graceTimer)
+          return resolve()
+        }
+        if (finishedCount >= quorumTarget && !quorumTriggered) {
+          quorumTriggered = true
+          if (typeof onProgress === 'function') {
+            onProgress(`⏳ *Quorum reached (${finishedCount}/${total}). Grace period ${gracePeriodMs / 1000}s for remaining models...*\n`)
+          }
+          graceTimer = setTimeout(() => {
+            if (typeof onProgress === 'function' && finishedCount < total) {
+              onProgress(`⏩ *Grace period expired. Proceeding with ${finishedCount}/${total} ready candidates.*\n`)
+            }
+            for (let k = 0; k < total; k++) {
+              if (!results[k]) {
+                try { abortControllers[k].abort(new Error('Quorum grace period timed out')) } catch {}
+              }
+            }
+            resolve()
+          }, gracePeriodMs)
+          // active timer keeps event loop alive
+        }
       }
-      return {
-        index: i + 1,
-        label,
-        provider: slot.provider,
-        model: slot.model,
-        text: `[failed: ${err?.message || String(err)}]`,
-        files: [],
-        usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0 },
-        costUsd: 0,
-        ok: false,
+
+      onTaskFinished = checkQuorum
+      checkQuorum()
+    })
+
+    for (let i = 0; i < total; i++) {
+      if (!results[i]) {
+        const slot = references[i]
+        const label = slotLabel(slot)
+        results[i] = {
+          index: i + 1,
+          slot,
+          label,
+          text: `[Model ${label} timed out (quorum grace period exceeded)]`,
+          usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0 },
+          costUsd: 0,
+          ok: false,
+          error: 'Quorum grace period timed out',
+        }
       }
     }
+    return results
+  }
+
+  // Standard mode: wait for all tasks to complete
+  await new Promise((resolve) => {
+    const checkAll = () => {
+      if (finishedCount >= total) resolve()
+    }
+    onTaskFinished = checkAll
+    checkAll()
   })
 
-  return Promise.all(tasks)
+  return results
+}
+
+function candidatesForHistory(referenceOutputs) {
+  return (referenceOutputs || []).map((r) => ({
+    provider: r.slot?.provider || '',
+    model: r.slot?.model || '',
+    files: (r.files || []).map((f) => f.relativePath),
+    usage: r.usage || { inputTokens: 0, outputTokens: 0 },
+    costUsd: r.costUsd || 0,
+  }))
+}
+
+async function createPromotedPreview(liveCanvas, cwd, promotedFiles, referenceOutputs) {
+  if (!liveCanvas || typeof liveCanvas.createPreviewFromContent !== 'function') return null
+  const htmlRel = (promotedFiles || []).find((f) => f.endsWith('.html') || f.endsWith('.htm'))
+  if (!htmlRel) return null
+  let content = null
+  for (const r of referenceOutputs || []) {
+    const block = (r?.files || []).find((f) => f.relativePath === htmlRel)
+    if (block?.content) {
+      content = block.content
+      break
+    }
+  }
+  if (!content) return null
+  try {
+    return await liveCanvas.createPreviewFromContent({ content, title: htmlRel, filePath: path.join(cwd, htmlRel) })
+  } catch {
+    return null
+  }
 }
 
 /**
- * Runs the full Mixture of Agents pipeline:
- * 1. Checks if questions or refinement needed
- * 2. Parallel candidate proposers write to .moa/candidate-X/
- * 3. Aggregator judges and picks winner (or bypassed in Fast Mode)
- * 4. Promotes winner files, records history and calculates costs
+ * Main MoA pipeline runner with Curator Synthesis, Fallback Chains, and Live Token Streaming.
  */
 export async function runMoAPipeline({
   userPrompt,
   messages = [],
   preset,
   callLlm,
-  cwd,
+  cwd = process.cwd(),
   onProgress,
-  skipQuestions = false,
+  onStreamDelta,
   prices = {},
+  historyFilePath,
+  liveCanvas = null,
 }) {
-  if (typeof callLlm !== 'function') {
-    throw new Error('callLlm function is required for runMoAPipeline')
+  const startTime = Date.now()
+  const referenceModels = preset?.reference_models || [
+    { provider: 'opencode-go', model: 'deepseek-v4-flash' },
+    { provider: 'grok', model: 'grok-build-0.1' },
+  ]
+  const primaryJudge = preset?.aggregator || { provider: 'codex', model: 'gpt-5.6-sol' }
+  const fallbackJudges = Array.isArray(preset?.aggregator_fallbacks) ? preset.aggregator_fallbacks : []
+  const judgesChain = [primaryJudge, ...fallbackJudges]
+
+  const refTemp = preset?.reference_temperature ?? 0.6
+  const aggTemp = preset?.aggregator_temperature ?? 0.4
+  const maxTokens = preset?.max_tokens ?? 4096
+  const judgeCriteria = preset?.judge_criteria ?? ''
+  const isFastMode = referenceModels.length === 1
+  const isCuratorSynthesis = Boolean(preset?.curator_synthesis)
+  const isStreamAggregator = preset?.stream_aggregator !== false
+  const isQuorumEnabled = Boolean(preset?.quorum_enabled)
+  const gracePeriodSec = preset?.grace_period_sec ?? 10
+  const candidateRetries = preset?.retry_count ?? 1
+
+  // 1. Collect current project workspace context
+  if (typeof onProgress === 'function') {
+    onProgress('🔍 *Scanning project context...*\n')
   }
+  const projectContext = await collectProjectContext(cwd)
+  const isRefinement = isRefinementTask(userPrompt, projectContext.files)
 
-  const startTime = Date.now()
-  const referenceModels = preset?.reference_models || preset?.referenceModels || []
-  const aggregator = preset?.aggregator || { provider: 'default', model: 'default' }
-  const refTemp = preset?.reference_temperature ?? preset?.referenceTemperature ?? 0.6
-  const aggTemp = preset?.aggregator_temperature ?? preset?.aggregatorTemperature ?? 0.4
-  const maxTokens = preset?.max_tokens ?? preset?.maxTokens ?? 4096
-  const judgeCriteria = preset?.judge_criteria || preset?.judgeCriteria || ''
-  const workDir = cwd || process.cwd()
-
-  // Collect project context (#6) and check refinement task (#4)
-  const projectCtx = await collectProjectContext(workDir, 16000)
-  const isRefinement = isRefinementTask(userPrompt, projectCtx.files)
-
-  // System prompt selection
+  // 2. Check if broad prompt requires user questionnaire
+  const askQuestions = preset?.ask_clarifying_questions !== false
+  const needsQuestions = !isFastMode && askQuestions && !isRefinement && isBroadPromptRequiringQuestions(userPrompt, messages)
+
+  // 3. Build enriched prompt for candidates
   let candidateSystemPrompt = REFERENCE_SYSTEM_PROMPT
-  if (isRefinement && projectCtx.files.length > 0) {
-    const fileList = projectCtx.files.map((f) => `### File: ${f.relativePath}\n\`\`\`\n${f.content}\n\`\`\``).join('\n\n')
-    candidateSystemPrompt = `${REFINEMENT_SYSTEM_PROMPT}\n\n## Existing Project Files:\n${fileList}`
-    if (typeof onProgress === 'function') {
-      onProgress(`🔄 *[Refinement Mode]: Обнаружен существующий проект (${projectCtx.files.length} файлов). Кандидаты вносят точечные изменения...*\n\n`)
-    }
+  if (isRefinement && projectContext.files.length > 0) {
+    const fileList = projectContext.files.map((f) => `- \`${f.relativePath}\` (${f.content.length} chars)`).join('\n')
+    const fileContents = projectContext.files.map((f) => `### File: ${f.relativePath}\n\`\`\`\n${f.content}\n\`\`\``).join('\n\n')
+    candidateSystemPrompt += `\n\nExisting project structure:\n${fileList}\n\nProject files:\n${fileContents}\n\nYou are modifying an existing project. Output modified or new files with explicit file paths.`
   }
 
-  // Phase 1: Check if clarifying questions should be asked
-  const allowQuestions = preset?.ask_clarifying_questions !== false && preset?.askClarifyingQuestions !== false
-  const needsQuestions = allowQuestions && !skipQuestions && !isRefinement && isBroadPromptRequiringQuestions(userPrompt, messages)
+  let promptForCandidates = userPrompt
   if (needsQuestions) {
-    if (typeof onProgress === 'function') {
-      onProgress('🔍 *Задача общего характера. Советники формируют ключевые развилки...*\n\n')
-    }
-
-    const questionOutputs = await runReferencesParallel(
-      referenceModels,
-      [...messages, { role: 'user', content: userPrompt }],
-      { systemPrompt: ADVISOR_QUESTION_PROMPT, referenceTemperature: 0.5, maxTokens: 1024 },
-      callLlm,
-      onProgress,
-    )
-
-    if (typeof onProgress === 'function') {
-      onProgress(`\n⚖️ *Судья (${slotLabel(aggregator)}) синтезирует единый опросник для вас...*\n\n`)
-    }
-
-    const qSynthPrompt = buildQuestionSynthesisPrompt(userPrompt, questionOutputs)
-    let questionsText = ''
-    try {
-      const qPromise = callLlm({
-        provider: aggregator.provider,
-        model: aggregator.model,
-        messages: [{ role: 'user', content: qSynthPrompt }],
-        temperature: 0.3,
-        maxTokens: 1500,
-      })
-      const qTimeout = new Promise((_, reject) =>
-        setTimeout(() => reject(new Error('Timeout waiting for judge questions synthesis')), 60000).unref()
-      )
-      const res = await Promise.race([qPromise, qTimeout])
-      questionsText = (typeof res === 'string' ? res : (res?.content || res?.text || '')).trim()
-    } catch (err) {
-      questionsText = `Не удалось сформировать вопросы судьи: ${err?.message || String(err)}`
-    }
-
-    return {
-      kind: 'questions',
-      content: questionsText,
-      aggregator: slotLabel(aggregator),
-      references: questionOutputs,
-      presetName: preset?.name || 'default',
-    }
+    promptForCandidates += "\n(Note: the task is broad. Propose the key architectural and functional decision points to clarify the user's requirements.)"
   }
 
-  // FAST MODE: single candidate model bypasses aggregator (#14)
-  const isFastMode = referenceModels.length === 1
-
-  // Phase 2: Parallel execution & file generation
-  if (typeof onProgress === 'function') {
-    const modeLabel = isFastMode ? '⚡ Fast Mode' : `советниками (${referenceModels.length})`
-    onProgress(`🚀 *Запускаю реализацию ${modeLabel}...*\n\n`)
-  }
+  const enrichedMessages = [...messages, { role: 'user', content: promptForCandidates }]
 
+  // 4. Parallel fan-out to candidate models with quorum & transient retry
   const referenceOutputs = await runReferencesParallel(
     referenceModels,
-    [...messages, { role: 'user', content: userPrompt }],
-    { systemPrompt: candidateSystemPrompt, referenceTemperature: refTemp, maxTokens },
+    enrichedMessages,
+    {
+      systemPrompt: candidateSystemPrompt,
+      temperature: refTemp,
+      maxTokens,
+      prices,
+      quorumEnabled: isQuorumEnabled,
+      gracePeriodSec,
+      maxRetries: candidateRetries,
+    },
     callLlm,
-    onProgress,
+    onProgress
   )
 
-  // Fast-fail: If all candidates failed, do not call judge to save tokens and avoid synthesized hallucinations
-  const allFailed = referenceOutputs.length > 0 && referenceOutputs.every((r) => !r.ok)
-  if (allFailed) {
-    const errorDetails = referenceOutputs
-      .map((r, i) => `• Кандидат ${i + 1} (${r.label}): ${r.text}`)
-      .join('\n')
-    const failMessage = `⚠️ **Все модели-советники (${referenceOutputs.length}) завершились с ошибкой**.\n\nСудья не вызывался для предотвращения бессмысленного расхода токенов.\n\n### Детали ошибок:\n${errorDetails}`
-
-    await cleanMoaWorkspaces(workDir)
-
+  // Fail fast if all candidates failed
+  const successfulRefs = referenceOutputs.filter((r) => r.ok)
+  if (successfulRefs.length === 0) {
+    const reasons = referenceOutputs.map((r) => `${r.label}: ${r.error || 'unknown error'}`).join('; ')
     return {
       kind: 'failure',
-      content: failMessage,
-      aggregator: slotLabel(aggregator),
+      content: `⚠️ All advisor models (${referenceOutputs.length}) failed: ${reasons}`,
+      aggregator: slotLabel(primaryJudge),
       references: referenceOutputs,
       presetName: preset?.name || 'default',
+      isRefinement,
+      isFastMode,
+      winningIndex: 0,
+      winnerModel: 'none',
       promotedFiles: [],
       usage: {
         totalTokens: 0,
         totalCostUsd: 0,
-        candidates: referenceOutputs.map((r) => ({ label: r.label, usage: r.usage, costUsd: 0 })),
+        candidates: referenceOutputs.map((r) => ({ label: r.label, usage: r.usage, costUsd: r.costUsd })),
         aggregator: { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0 },
       },
       durationMs: Date.now() - startTime,
     }
   }
-  // Write files for each candidate into .moa/candidate-X/
+
+  // 5. Extract file blocks & write candidate workspaces
   for (let i = 0; i < referenceOutputs.length; i++) {
     const ref = referenceOutputs[i]
-    if (ref.ok && ref.files && ref.files.length > 0) {
-      try {
-        await writeCandidateWorkspace(workDir, i + 1, ref.files)
-        if (typeof onProgress === 'function') {
-          onProgress(`📁 *Кандидат ${i + 1} (${ref.label}) сохранил ${ref.files.length} файл(а) в .moa/candidate-${i + 1}/*\n`)
-        }
-      } catch (writeErr) {
-        console.warn(`[dsh-moa] Failed to write candidate ${i + 1} workspace:`, writeErr)
+    if (!ref.ok) continue
+    const files = extractFileBlocks(ref.text)
+    ref.files = files
+    if (files.length > 0) {
+      await writeCandidateWorkspace(cwd, i + 1, files)
+    }
+  }
+
+  // 6. Questionnaire synthesis branch
+  if (needsQuestions) {
+    if (typeof onProgress === 'function') {
+      onProgress('📋 *Judge synthesizes the clarification questionnaire...*\n')
+    }
+    const questionPrompt = buildQuestionSynthesisPrompt(userPrompt, referenceOutputs)
+    let questionsContent = ''
+    let qUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0 }
+    try {
+      const qRes = await callWithTransientRetry(callLlm, {
+        provider: primaryJudge.provider,
+        model: primaryJudge.model,
+        messages: [{ role: 'user', content: questionPrompt }],
+        temperature: 0.3,
+        maxTokens: 2048,
+      }, 1)
+      questionsContent = typeof qRes === 'string' ? qRes : (qRes?.content || qRes?.text || '')
+      const qFallback = (typeof qRes === 'object' && qRes?.usage) ? qRes.usage : {
+        inputTokens: Math.max(1, Math.round(questionPrompt.length / 4)),
+        outputTokens: Math.max(1, Math.round(questionsContent.length / 4)),
       }
+      qUsage = estimateTokenCost(primaryJudge, qFallback, prices)
+    } catch {
+      questionsContent = '### Project requirements clarification\nPlease specify the implementation details and the desired stack.'
+    }
+
+    await cleanMoaWorkspaces(cwd)
+
+    const qTokens = referenceOutputs.reduce((acc, r) => acc + (r.usage?.totalTokens || 0), 0) + qUsage.totalTokens
+    const qCostUsd = Number((referenceOutputs.reduce((acc, r) => acc + (r.costUsd || 0), 0) + qUsage.costUsd).toFixed(5))
+
+    try {
+      recordMoaRun({
+        prompt: userPrompt,
+        preset: preset?.name || 'default',
+        isRefinement,
+        candidates: candidatesForHistory(referenceOutputs),
+        aggregator: null,
+        winnerIndex: -1,
+        winnerModel: '',
+        promotedFiles: [],
+        totalTokens: qTokens,
+        totalCostUsd: qCostUsd,
+        durationMs: Date.now() - startTime,
+      }, historyFilePath)
+    } catch (histErr) {
+      console.warn('[dsh-moa] Failed to record questionnaire run in history:', histErr)
+    }
+
+    return {
+      kind: 'questions',
+      content: questionsContent,
+      references: referenceOutputs,
+      presetName: preset?.name || 'default',
+      isRefinement: false,
     }
   }
 
+  // 7. Fast mode bypass for single candidate
+  if (isFastMode) {
+    const single = referenceOutputs[0]
+    let promotedFiles = []
+    if (single.files && single.files.length > 0) {
+      promotedFiles = await promoteCandidateWorkspace(cwd, 1)
+    } else {
+      await cleanMoaWorkspaces(cwd)
+    }
+
+    const totalTokens = single.usage?.totalTokens || 0
+    const totalCostUsd = single.costUsd || 0
+    const durationMs = Date.now() - startTime
+    const livePreview = await createPromotedPreview(liveCanvas, cwd, promotedFiles, referenceOutputs)
+
+    try {
+      recordMoaRun({
+        prompt: userPrompt,
+        preset: preset?.name || 'default',
+        isRefinement,
+        isFastMode: true,
+        candidates: candidatesForHistory(referenceOutputs),
+        aggregator: null,
+        winnerIndex: 1,
+        winnerModel: single.label,
+        promotedFiles,
+        totalTokens,
+        totalCostUsd,
+        durationMs,
+      }, historyFilePath)
+    } catch (histErr) {
+      console.warn('[dsh-moa] Failed to record fast-mode run in history:', histErr)
+    }
+
+    return {
+      kind: 'synthesis',
+      content: single.text,
+      aggregator: 'Fast Mode (Direct)',
+      references: referenceOutputs,
+      presetName: preset?.name || 'default',
+      isRefinement,
+      isFastMode: true,
+      winningIndex: 1,
+      winnerModel: single.label,
+      promotedFiles,
+      ...(livePreview ? { liveCanvas: livePreview } : {}),
+      usage: {
+        totalTokens,
+        totalCostUsd,
+        candidates: [{ label: single.label, usage: single.usage, costUsd: single.costUsd }],
+        aggregator: { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0 },
+      },
+      durationMs,
+    }
+  }
+
+  // 8. Aggregator / Judge synthesis with fallback chain (#3.3) & streaming (#2.1)
+  const synthesisPrompt = buildSynthesisPrompt(
+    userPrompt,
+    referenceOutputs,
+    judgeCriteria,
+    { curatorSynthesis: isCuratorSynthesis }
+  )
+
   let synthesizedText = ''
-  let winningIndex = 1
   let aggUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0 }
-  const aggLabel = slotLabel(aggregator)
+  let chosenJudge = primaryJudge
+  let judgeSuccess = false
+  let lastJudgeError = null
+
+  for (let jIdx = 0; jIdx < judgesChain.length; jIdx++) {
+    const currentJudge = judgesChain[jIdx]
+    const currentLabel = slotLabel(currentJudge)
 
-  if (isFastMode) {
-    // Fast mode: promote candidate 1 directly without judge
-    synthesizedText = referenceOutputs[0]?.text || '(empty fast response)'
-    winningIndex = 1
-  } else {
-    // Phase 3: Aggregator evaluation
     if (typeof onProgress === 'function') {
-      onProgress(`\n⚖️ *Все кандидаты завершили генерацию. Судья (${aggLabel}) оценивает код и файлы...*\n\n`)
+      const judgeTitle = isCuratorSynthesis ? 'Lead Curator' : 'Judge'
+      const fallbackBadge = jIdx > 0 ? ` (Fallback #${jIdx})` : ''
+      onProgress(`⚖️ *${judgeTitle} (${currentLabel})${fallbackBadge} evaluates candidates and synthesizes the solution...*\n`)
     }
 
-    const synthPrompt = buildSynthesisPrompt(userPrompt, referenceOutputs, judgeCriteria)
-
     try {
-      const aggPromise = callLlm({
-        provider: aggregator.provider,
-        model: aggregator.model,
-        messages: [{ role: 'user', content: synthPrompt }],
+      const aggRes = await callWithTransientRetry(callLlm, {
+        provider: currentJudge.provider,
+        model: currentJudge.model,
+        messages: [{ role: 'user', content: synthesisPrompt }],
         temperature: aggTemp,
         maxTokens,
-      })
-      const aggTimeout = new Promise((_, reject) =>
-        setTimeout(() => reject(new Error(`Timeout after 90s waiting for aggregator ${aggLabel}`)), 90000).unref()
-      )
-      const res = await Promise.race([aggPromise, aggTimeout])
-      synthesizedText = (typeof res === 'string' ? res : (res?.content || res?.text || '')).trim()
-
-      const rawAggUsage = res?.usage || {
-        inputTokens: Math.round(synthPrompt.length / 4),
-        outputTokens: Math.round(synthesizedText.length / 4),
+        onStreamDelta: (delta) => {
+          if (isStreamAggregator && typeof onStreamDelta === 'function') {
+            onStreamDelta(delta)
+          }
+        },
+      }, 0)
+
+      synthesizedText = typeof aggRes === 'string' ? aggRes : (aggRes?.content || aggRes?.text || '')
+      const aggFallbackUsage = (typeof aggRes === 'object' && aggRes?.usage) ? aggRes.usage : {
+        inputTokens: Math.max(1, Math.round(synthesisPrompt.length / 4)),
+        outputTokens: Math.max(1, Math.round(synthesizedText.length / 4)),
       }
-      aggUsage = estimateTokenCost(aggregator, rawAggUsage, prices)
+      aggUsage = estimateTokenCost(currentJudge, aggFallbackUsage, prices)
+      chosenJudge = currentJudge
+      judgeSuccess = true
+      break
     } catch (err) {
-      synthesizedText = `[Aggregator error: ${err?.message || String(err)}]\n\nFallback candidate outputs:\n\n` +
-        referenceOutputs.map((r, i) => `### ${r.label}\n${r.text}`).join('\n\n')
+      lastJudgeError = err
+      console.warn(`[dsh-moa] Judge ${currentLabel} failed:`, err)
+      if (typeof onProgress === 'function') {
+        const nextJudge = judgesChain[jIdx + 1]
+        const nextHint = nextJudge ? ` Trying fallback ${slotLabel(nextJudge)}...` : ''
+        onProgress(`⚠️ *Judge ${currentLabel} failed: ${err?.message || err}.${nextHint}*\n`)
+      }
     }
+  }
 
-    winningIndex = parseWinnerIndex(synthesizedText, 1)
+  if (!judgeSuccess) {
+    const firstErr = lastJudgeError ? (lastJudgeError.message || String(lastJudgeError)) : 'unknown error'
+    synthesizedText = `⚠️ *[Aggregator error: ${firstErr}. Fallback candidate outputs:]*\n\n` +
+      successfulRefs.map((r, i) => `### Candidate ${i + 1} (${r.label})\n${r.text}`).join('\n\n')
   }
 
-  // Phase 4: Promote winner files and cleanup
+  // 9. Evaluate winner & promote files
+  const winningIndex = parseWinnerIndex(synthesizedText, 1, referenceOutputs.length)
+  const recommendedAssembler = isCuratorSynthesis
+    ? parseRecommendedAssembler(synthesizedText, winningIndex, referenceOutputs.length)
+    : null
+
+  // Check if aggregator synthesized unified file blocks directly
+  const synthesizedFiles = extractFileBlocks(synthesizedText)
   let promotedFiles = []
-  try {
-    promotedFiles = await promoteCandidateWorkspace(workDir, winningIndex)
-    if (typeof onProgress === 'function' && promotedFiles.length > 0) {
-      onProgress(`\n✅ *Файлы победителя (Кандидат ${winningIndex}) перенесены в проект: ${promotedFiles.join(', ')}*\n\n`)
-    }
-  } catch (promoteErr) {
-    console.warn('[dsh-moa] Error promoting candidate files:', promoteErr)
-  }
 
-  // Phase 5: Live Canvas preview auto-registration
-  let liveCanvas = null
-  if (promotedFiles && promotedFiles.length > 0) {
-    const previewCandidate = promotedFiles.find(f => /\.(html|htm|jsx|tsx|vue|svelte)$/i.test(f)) || promotedFiles[0]
-    if (previewCandidate) {
-      try {
-        const port = process.env.PORT || 3080
-        const lcRes = await fetch(`http://127.0.0.1:${port}/dsh-live-canvas/api/open-file`, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ filePath: previewCandidate }),
-          signal: AbortSignal.timeout(500),
-        })
-        if (lcRes.ok) {
-          const lcData = await lcRes.json()
-          if (lcData?.canvasId) {
-            liveCanvas = {
-              canvasId: lcData.canvasId,
-              title: lcData.title || previewCandidate,
-              filePath: previewCandidate,
-              previewUrl: lcData.previewUrl || `/dsh-live-canvas/sandbox/${lcData.canvasId}`
-            }
-            if (typeof onProgress === 'function') {
-              onProgress(`\n🎨 *[Live Canvas]: Файл ${previewCandidate} открыт для предпросмотра!*\n\n`)
-            }
-          }
-        }
-      } catch (err) {
-        // live-canvas plugin might not be installed or reachable, non-fatal
-      }
-    }
+  if (synthesizedFiles.length > 0) {
+    await writeCandidateWorkspace(cwd, 'curator-synthesis', synthesizedFiles)
+    promotedFiles = await promoteCandidateWorkspace(cwd, 'curator-synthesis')
+  } else if (referenceOutputs[winningIndex - 1]?.files?.length > 0) {
+    promotedFiles = await promoteCandidateWorkspace(cwd, winningIndex)
+  } else if (successfulRefs[0]?.files?.length > 0) {
+    const fallbackIdx = successfulRefs[0].index
+    promotedFiles = await promoteCandidateWorkspace(cwd, fallbackIdx)
+  } else {
+    await cleanMoaWorkspaces(cwd)
   }
 
-  // Calculate totals
+  const livePreview = await createPromotedPreview(liveCanvas, cwd, promotedFiles, referenceOutputs)
+
   const totalTokens = referenceOutputs.reduce((acc, r) => acc + (r.usage?.totalTokens || 0), 0) + aggUsage.totalTokens
   const totalCostUsd = Number((referenceOutputs.reduce((acc, r) => acc + (r.costUsd || 0), 0) + aggUsage.costUsd).toFixed(5))
   const durationMs = Date.now() - startTime
 
   const winningRef = referenceOutputs[winningIndex - 1]
   const winnerModel = winningRef?.label || slotLabel(referenceModels[0])
+  const finalAggLabel = slotLabel(chosenJudge)
 
-  // Record run to history (#9, #10, #11)
+  // Record run to history
   try {
     recordMoaRun({
       prompt: userPrompt,
       preset: preset?.name || 'default',
       isRefinement,
-      candidates: referenceOutputs,
-      aggregator: isFastMode ? null : { provider: aggregator.provider, model: aggregator.model, usage: aggUsage, costUsd: aggUsage.costUsd },
+      candidates: candidatesForHistory(referenceOutputs),
+      aggregator: { provider: chosenJudge.provider, model: chosenJudge.model, usage: aggUsage, costUsd: aggUsage.costUsd },
       winnerIndex: winningIndex,
       winnerModel,
       promotedFiles,
       totalTokens,
       totalCostUsd,
       durationMs,
-    })
+    }, historyFilePath)
   } catch (histErr) {
     console.warn('[dsh-moa] Failed to record run in history:', histErr)
   }
@@ -606,19 +893,21 @@ export async function runMoAPipeline({
   return {
     kind: 'synthesis',
     content: synthesizedText,
-    aggregator: isFastMode ? 'Fast Mode (Direct)' : aggLabel,
+    aggregator: isFastMode ? 'Fast Mode (Direct)' : finalAggLabel,
     references: referenceOutputs,
     presetName: preset?.name || 'default',
     isRefinement,
     isFastMode,
+    isCuratorSynthesis,
+    recommendedAssembler,
     winningIndex,
     winnerModel,
     promotedFiles,
-    liveCanvas,
+    ...(livePreview ? { liveCanvas: livePreview } : {}),
     usage: {
       totalTokens,
       totalCostUsd,
-      candidates: referenceOutputs.map(r => ({ label: r.label, usage: r.usage, costUsd: r.costUsd })),
+      candidates: referenceOutputs.map((r) => ({ label: r.label, usage: r.usage, costUsd: r.costUsd })),
       aggregator: aggUsage,
     },
     durationMs,
@@ -636,8 +925,8 @@ export function stripOrSummarizeCode(text) {
       return match
     }
     const fileHint = fileTag || (code.match(/^\s*(?:\/\/|#|<!--|\/\*)\s*(?:file|filepath|path):\s*([^\s*]+)/im)?.[1])
-    const label = fileHint ? `файл \`${fileHint}\`` : (lang ? `код \`${lang}\`` : 'код')
-    return `\n> 📄 *[${label} — ${lines.length} строк сохранены на диск]*\n`
+    const label = fileHint ? `file \`${fileHint}\`` : (lang ? `code \`${lang}\`` : 'code')
+    return `\n> 📄 *[${label} - ${lines.length} lines saved to disk]*\n`
   })
 }
 
@@ -648,41 +937,53 @@ export function formatMoAResponse({ moaResult, presetName }) {
   const refs = moaResult?.references || []
 
   if (moaResult?.kind === 'questions') {
-    parts.push('## 🧠 Mixture of Agents — Уточнение требований')
-    parts.push(`*Судья (${judge}) и советники проанализировали задачу:*\n`)
+    parts.push('## 🧠 Mixture of Agents — Requirements Clarification')
+    parts.push(`*Judge (${judge}) and the advisors analyzed the task:*\n`)
+    parts.push(moaResult.content)
+    return parts.join('\n')
+  }
+
+  if (moaResult?.kind === 'failure') {
+    parts.push('## ⚠️ Mixture of Agents — Execution Failed')
     parts.push(moaResult.content)
     return parts.join('\n')
   }
 
-  const modeBadge = moaResult?.isFastMode ? '⚡ Fast Mode' : `Судья: ${judge}`
-  parts.push(`## 🧠 Mixture of Agents (Пресет: ${pName} | ${modeBadge})`)
+  const modeBadge = moaResult?.isFastMode
+    ? '⚡ Fast Mode'
+    : (moaResult?.isCuratorSynthesis ? `🧠 Curator: ${judge}` : `Judge: ${judge}`)
+  parts.push(`## 🧠 Mixture of Agents (Preset: ${pName} | ${modeBadge})`)
   parts.push('')
 
   if (moaResult?.isRefinement) {
-    parts.push('> 🔄 **Режим**: Итеративная доработка проекта (Refinement)')
+    parts.push('> 🔄 **Mode**: Iterative project refinement (Refinement)')
   }
 
   const hasPromoted = moaResult?.promotedFiles && moaResult.promotedFiles.length > 0
   if (hasPromoted) {
-    parts.push(`> 📦 **Созданы файлы в проекте**: \`${moaResult.promotedFiles.join('`, `')}\``)
+    parts.push(`> 📦 **Files created in the project**: \`${moaResult.promotedFiles.join('`, `')}\``)
+  }
+
+  if (moaResult?.recommendedAssembler?.label) {
+    parts.push(`> 🎯 **Recommended Master Assembler**: Candidate ${moaResult.recommendedAssembler.index} (\`${moaResult.recommendedAssembler.label}\`)`)
   }
 
   if (moaResult?.liveCanvas?.previewUrl) {
     parts.push(`> 🎨 **Live Canvas**: [🚀 Открыть ${moaResult.liveCanvas.title || 'превью'} в Live Canvas](${moaResult.liveCanvas.previewUrl}) | [↗ Открыть в новой вкладке](${moaResult.liveCanvas.previewUrl})`)
   }
 
-  // Cost tracking card (#10)
+  // Cost tracking card
   if (moaResult?.usage) {
     const u = moaResult.usage
-    const costStr = u.totalCostUsd > 0 ? `~\$${u.totalCostUsd.toFixed(4)}` : 'Бесплатно'
+    const costStr = u.totalCostUsd > 0 ? `~\$${u.totalCostUsd.toFixed(4)}` : 'Free'
     const tokStr = u.totalTokens >= 1000 ? `${(u.totalTokens / 1000).toFixed(1)}k` : `${u.totalTokens}`
-    parts.push(`> 💰 **Стоимость запуска**: ${costStr} (всего ${tokStr} токенов)`)
+    parts.push(`> 💰 **Run cost**: ${costStr} (${tokStr} tokens total)`)
   }
 
   parts.push('')
 
   if (!moaResult?.isFastMode) {
-    parts.push(`### ⚖️ Вердикт судьи и итоговое решение (Синтез: ${judge})`)
+    parts.push(`### ⚖️ Judge verdict and final synthesis (Synthesis: ${judge})`)
     parts.push('')
     const cleanJudgeContent = hasPromoted
       ? stripOrSummarizeCode(moaResult?.content || '')
@@ -692,14 +993,14 @@ export function formatMoAResponse({ moaResult, presetName }) {
   }
 
   if (Array.isArray(refs) && refs.length > 0) {
-    const title = moaResult?.isFastMode ? '### 🚀 Результат генерации кандидата:' : `### 👥 Ответы моделей-советников (${refs.length}):`
+    const title = moaResult?.isFastMode ? '### 🚀 Candidate generation result:' : `### 👥 Advisor responses (${refs.length}):`
     parts.push(title)
     parts.push('')
     refs.forEach((ref, i) => {
       const statusIcon = ref.ok ? '✅' : '⚠️'
       const fileBadge = ref.files?.length ? ` (${ref.files.length} файл(ов))` : ''
       const costBadge = ref.costUsd > 0 ? ` [~\$${ref.costUsd.toFixed(4)}]` : ''
-      parts.push(`#### ${statusIcon} Модель ${i + 1}: ${ref.label}${fileBadge}${costBadge}`)
+      parts.push(`#### ${statusIcon} Model ${i + 1}: ${ref.label}${fileBadge}${costBadge}`)
       parts.push('')
       parts.push(stripOrSummarizeCode(ref.text))
       parts.push('')
@@ -711,12 +1012,12 @@ export function formatMoAResponse({ moaResult, presetName }) {
   return parts.join('\n')
 }
 
-export async function* streamMoATurn({ targetPreset, userPrompt, messages, callLlm, cwd }, options = {}) {
+export async function* streamMoATurn({ targetPreset, userPrompt, messages, callLlm, cwd, prices, historyFilePath, liveCanvas }, options = {}) {
   const signal = options?.signal
   if (signal?.aborted) return
 
   yield { type: 'block-start', index: 0, blockType: 'text' }
-  yield { type: 'text-delta', index: 0, text: '🧠 *Mixture of Agents запущен...*\n\n' }
+  yield { type: 'text-delta', index: 0, text: '🧠 *Mixture of Agents started...*\n\n' }
 
   // Async push-queue for zero-latency live delta streaming
   const queue = []
@@ -738,6 +1039,12 @@ export async function* streamMoATurn({ targetPreset, userPrompt, messages, callL
     callLlm,
     cwd,
     onProgress: pushUpdate,
+    onStreamDelta: (delta) => {
+      pushUpdate(delta)
+    },
+    prices,
+    historyFilePath,
+    liveCanvas,
   })
     .catch((err) => ({ error: err }))
     .finally(() => {
@@ -774,7 +1081,7 @@ export async function* streamMoATurn({ targetPreset, userPrompt, messages, callL
 
       const elapsedSec = Math.floor((Date.now() - startTime) / 1000)
       if (!done && Date.now() - lastYieldTime >= 3000) {
-        yield { type: 'text-delta', index: 0, text: `⏳ *[${elapsedSec}с] Идёт обработка...*\n` }
+        yield { type: 'text-delta', index: 0, text: `⏳ *[${elapsedSec}s] Still processing...*\n` }
         lastYieldTime = Date.now()
       }
     }
@@ -786,7 +1093,7 @@ export async function* streamMoATurn({ targetPreset, userPrompt, messages, callL
     }
 
     if (result?.error) {
-      const errText = '\n\n⚠️ **Ошибка Mixture of Agents**: ' + (result.error?.message || String(result.error))
+      const errText = '\n\n⚠️ **Mixture of Agents error**: ' + (result.error?.message || String(result.error))
       yield { type: 'text-delta', index: 0, text: errText }
       yield { type: 'block-end', index: 0, block: { type: 'text', text: errText } }
       yield { type: 'finish', reason: { kind: 'stop' } }
@@ -800,7 +1107,13 @@ export async function* streamMoATurn({ targetPreset, userPrompt, messages, callL
 
     yield { type: 'text-delta', index: 0, text: '\n---\n\n' + formatted }
     yield { type: 'block-end', index: 0, block: { type: 'text', text: formatted } }
-    yield { type: 'usage', usage: { inputTokens: result?.usage?.totalTokens || 100, outputTokens: formatted.length } }
+    yield {
+      type: 'usage',
+      usage: {
+        inputTokens: result?.usage?.totalTokens || 0,
+        outputTokens: Math.round((formatted.length || 0) / 4),
+      },
+    }
     yield { type: 'finish', reason: { kind: 'stop' } }
   } finally {
     if (signal?.aborted) {
@@ -808,3 +1121,4 @@ export async function* streamMoATurn({ targetPreset, userPrompt, messages, callL
     }
   }
 }
+