@goodandready/dsh-moa 0.2.7 → 0.2.9

package/lib/moa-runner.js

@@ -1,84 +1,58 @@
-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.
+ * Mixture of Agents (MoA) Orchestrator Engine (#1 - #16)
+ *
+ * Implements:
+ * 1. Parallel candidate proposers with isolated workspaces (.moa/candidate-X/)
+ * 2. Real-time multi-file block extractor and project context collector
+ * 3. Iterative modification (Refinement) vs greenfield project awareness
+ * 4. Aggregator / Judge synthesis prompt and candidate winner evaluation
+ * 5. Automatic promotion of winning candidate files to workspace root
+ * 6. Native Live Canvas visual preview generation for interactive apps
+ * 7. Real-time cost tracking, token metrics and history logging
+ * 8. Zero-latency async push-queue streaming for llm/stream turns
  */
 
 import {
   extractFileBlocks,
+  collectProjectContext,
+  isRefinementTask,
   writeCandidateWorkspace,
   promoteCandidateWorkspace,
   cleanMoaWorkspaces,
-  collectProjectContext,
-  isRefinementTask,
 } from './file-workspace.js'
 
+import { estimateTokenCost } from './pricing.js'
 import { recordMoaRun } from './history.js'
 
-export {
-  extractFileBlocks,
-  writeCandidateWorkspace,
-  promoteCandidateWorkspace,
-  cleanMoaWorkspaces,
-  collectProjectContext,
-  isRefinementTask,
-}
+export { estimateTokenCost } from './pricing.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 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 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 +64,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 +101,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) {
@@ -281,56 +264,53 @@ export async function runReferencesParallel(references, messages, options = {},
         provider: slot.provider,
         model: slot.model,
         messages: fullMessages,
-        temperature: options.referenceTemperature ?? 0.6,
+        temperature: options.temperature ?? 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 timeoutPromise = new Promise((_, reject) => {
+        const timer = setTimeout(() => reject(new Error(`Timeout after ${timeoutMs / 1000}s`)), timeoutMs)
+        timer.unref?.()
+      })
 
       const res = await Promise.race([callPromise, timeoutPromise])
-      const text = (typeof res === 'string' ? res : (res?.content || res?.text || '')).trim()
-      const files = extractFileBlocks(text)
+      const text = typeof res === 'string' ? res : (res?.content || res?.text || '')
 
-      // Estimate tokens & cost
-      const rawUsage = res?.usage || {
-        inputTokens: Math.round(JSON.stringify(fullMessages).length / 4),
-        outputTokens: Math.round(text.length / 4),
+      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, rawUsage, options.prices)
+      const costInfo = estimateTokenCost(slot, fallbackUsage)
 
       if (typeof onProgress === 'function') {
-        const fileMsg = files.length > 0 ? ` (создано файлов: ${files.length})` : ''
-        onProgress(`✅ *Кандидат ${i + 1} (${label}) завершил ответ${fileMsg}.*\n`)
+        const costStr = costInfo.costUsd > 0 ? ` (~\$${costInfo.costUsd.toFixed(4)})` : ''
+        onProgress(`✅ *Кандидат ${i + 1} (${label}) завершил ответ${costStr}*\n`)
       }
 
       return {
         index: i + 1,
+        slot,
         label,
-        provider: slot.provider,
-        model: slot.model,
-        text: text || '(empty response)',
-        files,
+        text,
         usage: costInfo,
         costUsd: costInfo.costUsd,
         ok: true,
       }
     } catch (err) {
-      console.warn(`[dsh-moa] Reference ${label} failed:`, err)
+      const errMsg = err?.message || String(err)
+      console.warn(`[dsh-moa] Reference ${label} failed:`, errMsg)
       if (typeof onProgress === 'function') {
-        onProgress(`⚠️ *Кандидат ${i + 1} (${label}) завершился с ошибкой: ${err?.message || String(err)}*\n`)
+        onProgress(`⚠️ *Кандидат ${i + 1} (${label}) ошибка: ${errMsg}*\n`)
       }
       return {
         index: i + 1,
+        slot,
         label,
-        provider: slot.provider,
-        model: slot.model,
-        text: `[failed: ${err?.message || String(err)}]`,
-        files: [],
+        text: `[Ошибка модели ${label}: ${errMsg}]`,
         usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0 },
         costUsd: 0,
         ok: false,
+        error: errMsg,
       }
     }
   })
@@ -339,217 +319,220 @@ export async function runReferencesParallel(references, messages, options = {},
 }
 
 /**
- * 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.
  */
 export async function runMoAPipeline({
   userPrompt,
   messages = [],
   preset,
   callLlm,
-  cwd,
+  cwd = process.cwd(),
   onProgress,
-  skipQuestions = false,
-  prices = {},
 }) {
-  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 aggregator = preset?.aggregator || { provider: 'codex', model: 'gpt-5.6-sol' }
+  const aggLabel = slotLabel(aggregator)
+  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 && !preset?.force_aggregator
+
+  // 1. Collect current project workspace context (#6)
+  if (typeof onProgress === 'function') {
+    onProgress('🔍 *Сканирование контекста проекта...*\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 (#7)
+  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 needsQuestions = !skipQuestions && !isRefinement && isBroadPromptRequiringQuestions(userPrompt, messages)
+  let promptForCandidates = userPrompt
   if (needsQuestions) {
-    if (typeof onProgress === 'function') {
-      onProgress('🔍 *Задача общего характера. Советники формируют ключевые развилки...*\n\n')
+    promptForCandidates += '\n(Примечание: задача широкая. Предложи ключевые архитектурные и функциональные развилки для уточнения требований пользователя).'
+  }
+
+  const enrichedMessages = [...messages, { role: 'user', content: promptForCandidates }]
+
+  // 4. Parallel fan-out to candidate models
+  if (typeof onProgress === 'function') {
+    onProgress(`🚀 *Запуск ${referenceModels.length} моделей-кандидатов параллельно...*\n`)
+  }
+
+  const referenceOutputs = await runReferencesParallel(
+    referenceModels,
+    enrichedMessages,
+    { systemPrompt: candidateSystemPrompt, temperature: refTemp, maxTokens },
+    callLlm,
+    onProgress
+  )
+
+  // Fail fast if all candidates failed (#12)
+  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: `⚠️ Все модели-советники (${referenceOutputs.length}) завершились с ошибкой: ${reasons}`,
+      aggregator: aggLabel,
+      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: r.costUsd })),
+        aggregator: { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0 },
+      },
+      durationMs: Date.now() - startTime,
     }
+  }
 
-    const questionOutputs = await runReferencesParallel(
-      referenceModels,
-      [...messages, { role: 'user', content: userPrompt }],
-      { systemPrompt: ADVISOR_QUESTION_PROMPT, referenceTemperature: 0.5, maxTokens: 1024 },
-      callLlm,
-      onProgress,
-    )
+  // 5. Extract file blocks & write candidate workspaces (#1, #2)
+  for (let i = 0; i < referenceOutputs.length; i++) {
+    const ref = referenceOutputs[i]
+    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 (#7)
+  if (needsQuestions) {
     if (typeof onProgress === 'function') {
-      onProgress(`\n⚖️ *Судья (${slotLabel(aggregator)}) синтезирует единый опросник для вас...*\n\n`)
+      onProgress('📋 *Синтез опросника судьей...*\n')
     }
-
-    const qSynthPrompt = buildQuestionSynthesisPrompt(userPrompt, questionOutputs)
-    let questionsText = ''
+    const questionPrompt = buildQuestionSynthesisPrompt(userPrompt, referenceOutputs)
+    let questionsContent = ''
     try {
-      const qPromise = callLlm({
+      const qRes = await callLlm({
         provider: aggregator.provider,
         model: aggregator.model,
-        messages: [{ role: 'user', content: qSynthPrompt }],
+        messages: [{ role: 'user', content: questionPrompt }],
         temperature: 0.3,
-        maxTokens: 1500,
+        maxTokens: 2048,
       })
-      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)}`
+      questionsContent = typeof qRes === 'string' ? qRes : (qRes?.content || qRes?.text || '')
+    } catch {
+      questionsContent = '### Уточнение требований к проекту\nПожалуйста, уточните детали реализации и желаемый стек.'
     }
 
     return {
       kind: 'questions',
-      content: questionsText,
-      aggregator: slotLabel(aggregator),
-      references: questionOutputs,
+      content: questionsContent,
+      references: referenceOutputs,
       presetName: preset?.name || 'default',
+      isRefinement: false,
     }
   }
 
-  // FAST MODE: single candidate model bypasses aggregator (#14)
-  const isFastMode = referenceModels.length === 1
+  // 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)
+    }
 
-  // Phase 2: Parallel execution & file generation
-  if (typeof onProgress === 'function') {
-    const modeLabel = isFastMode ? '⚡ Fast Mode' : `советниками (${referenceModels.length})`
-    onProgress(`🚀 *Запускаю реализацию ${modeLabel}...*\n\n`)
-  }
+    const totalTokens = single.usage?.totalTokens || 0
+    const totalCostUsd = single.costUsd || 0
+    const durationMs = Date.now() - startTime
 
-  const referenceOutputs = await runReferencesParallel(
-    referenceModels,
-    [...messages, { role: 'user', content: userPrompt }],
-    { systemPrompt: candidateSystemPrompt, referenceTemperature: refTemp, maxTokens },
-    callLlm,
-    onProgress,
-  )
-
-  // Write files for each candidate into .moa/candidate-X/
-  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)
-      }
+    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,
+      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 (#5, #8)
+  if (typeof onProgress === 'function') {
+    onProgress(`⚖️ *Ведущая модель (${aggLabel}) оценивает варианты и синтезирует решение...*\n`)
+  }
+
+  const synthesisPrompt = buildSynthesisPrompt(userPrompt, referenceOutputs, judgeCriteria)
   let synthesizedText = ''
-  let winningIndex = 1
   let aggUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0 }
-  const aggLabel = slotLabel(aggregator)
-
-  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 synthPrompt = buildSynthesisPrompt(userPrompt, referenceOutputs, judgeCriteria)
-
-    try {
-      const aggPromise = callLlm({
-        provider: aggregator.provider,
-        model: aggregator.model,
-        messages: [{ role: 'user', content: synthPrompt }],
-        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),
-      }
-      aggUsage = estimateTokenCost(aggregator, rawAggUsage, prices)
-    } 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')
+  try {
+    const aggRes = await callLlm({
+      provider: aggregator.provider,
+      model: aggregator.model,
+      messages: [{ role: 'user', content: synthesisPrompt }],
+      temperature: aggTemp,
+      maxTokens,
+    })
+    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)),
     }
-
-    winningIndex = parseWinnerIndex(synthesizedText, 1)
+    aggUsage = estimateTokenCost(aggregator, aggFallbackUsage)
+  } catch (err) {
+    console.warn(`[dsh-moa] Aggregator ${aggLabel} failed:`, err)
+    synthesizedText = `⚠️ *[Aggregator error: ${err?.message || err}. Fallback candidate outputs:]*\n\n` +
+      successfulRefs.map((r, i) => `### Кандидат ${i + 1} (${r.label})\n${r.text}`).join('\n\n')
   }
 
-  // Phase 4: Promote winner files and cleanup
+  // 9. Evaluate winner & promote files (#1, #2)
+  const winningIndex = parseWinnerIndex(synthesizedText, 1)
   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)
+  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)
   }
 
-  // Phase 5: Live Canvas preview auto-registration
+  // 10. Live Canvas preview (#16)
   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
-      }
+  const htmlFile = promotedFiles.find((f) => f.endsWith('.html') || f.endsWith('index.html'))
+  if (htmlFile) {
+    liveCanvas = {
+      previewUrl: `http://localhost:3000/preview/${encodeURIComponent(htmlFile)}`,
+      file: htmlFile,
+      title: 'Interactive Web Preview',
     }
   }
 
-  // Calculate totals
   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
@@ -627,6 +610,12 @@ export function formatMoAResponse({ moaResult, presetName }) {
     return parts.join('\n')
   }
 
+  if (moaResult?.kind === 'failure') {
+    parts.push('## ⚠️ Mixture of Agents — Сбой выполнения')
+    parts.push(moaResult.content)
+    return parts.join('\n')
+  }
+
   const modeBadge = moaResult?.isFastMode ? '⚡ Fast Mode' : `Судья: ${judge}`
   parts.push(`## 🧠 Mixture of Agents (Пресет: ${pName} | ${modeBadge})`)
   parts.push('')
@@ -691,73 +680,94 @@ export async function* streamMoATurn({ targetPreset, userPrompt, messages, callL
   yield { type: 'block-start', index: 0, blockType: 'text' }
   yield { type: 'text-delta', index: 0, text: '🧠 *Mixture of Agents запущен...*\n\n' }
 
-  // Queue for streaming progress updates from within runMoAPipeline
-  const progressChunks = []
-  const onProgress = (text) => {
-    progressChunks.push(text)
+  // Async push-queue for zero-latency live delta streaming
+  const queue = []
+  let notify = null
+
+  const pushUpdate = (text) => {
+    queue.push({ type: 'text-delta', index: 0, text })
+    if (notify) {
+      notify()
+      notify = null
+    }
   }
 
-  try {
-    const pipelinePromise = runMoAPipeline({
-      userPrompt,
-      messages,
-      preset: targetPreset,
-      callLlm,
-      cwd,
-      onProgress,
+  let done = false
+  const pipelinePromise = runMoAPipeline({
+    userPrompt,
+    messages,
+    preset: targetPreset,
+    callLlm,
+    cwd,
+    onProgress: pushUpdate,
+  })
+    .catch((err) => ({ error: err }))
+    .finally(() => {
+      done = true
+      if (notify) {
+        notify()
+        notify = null
+      }
     })
 
-    const startTime = Date.now()
-    let lastYieldTime = Date.now()
+  const startTime = Date.now()
+  let lastYieldTime = Date.now()
 
-    // Yield progressive updates while pipeline runs
-    while (true) {
-      if (signal?.aborted) return
+  try {
+    while (!done || queue.length > 0) {
+      if (signal?.aborted) {
+        await cleanMoaWorkspaces(cwd)
+        return
+      }
 
-      let emittedAny = false
-      while (progressChunks.length > 0) {
-        const chunk = progressChunks.shift()
-        yield { type: 'text-delta', index: 0, text: chunk }
-        emittedAny = true
+      while (queue.length > 0) {
+        const item = queue.shift()
+        yield item
         lastYieldTime = Date.now()
       }
 
-      const done = await Promise.race([
-        pipelinePromise.then(() => true),
-        new Promise((r) => { const t = setTimeout(() => r(false), 500); t.unref?.(); }),
-      ])
       if (done) break
 
+      // Wait for next push item or max 2.5s heartbeat
+      await Promise.race([
+        new Promise((resolve) => { notify = resolve }),
+        new Promise((resolve) => { const t = setTimeout(resolve, 2500); t.unref?.(); }),
+      ])
+
       const elapsedSec = Math.floor((Date.now() - startTime) / 1000)
-      // If 3 seconds passed without any progress message, send a live tick
-      if (!emittedAny && Date.now() - lastYieldTime >= 3000) {
+      if (!done && Date.now() - lastYieldTime >= 3000) {
         yield { type: 'text-delta', index: 0, text: `⏳ *[${elapsedSec}с] Идёт обработка...*\n` }
         lastYieldTime = Date.now()
       }
     }
 
-    while (progressChunks.length > 0) {
-      const chunk = progressChunks.shift()
-      yield { type: 'text-delta', index: 0, text: chunk }
+    const result = await pipelinePromise
+    if (signal?.aborted) {
+      await cleanMoaWorkspaces(cwd)
+      return
     }
 
-    const moaResult = await pipelinePromise
-    if (signal?.aborted) return
+    if (result?.error) {
+      const errText = '\n\n⚠️ **Ошибка Mixture of Agents**: ' + (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' } }
+      return
+    }
 
     const formatted = formatMoAResponse({
-      moaResult,
+      moaResult: result,
       presetName: targetPreset?.name || 'default',
     })
 
     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: moaResult?.usage?.totalTokens || 100, outputTokens: formatted.length } }
-    yield { type: 'finish', reason: { kind: 'stop' } }
-  } catch (err) {
-    if (signal?.aborted) return
-    const errText = '\n\n⚠️ **Ошибка Mixture of Agents**: ' + (err?.message || String(err))
-    yield { type: 'text-delta', index: 0, text: errText }
-    yield { type: 'block-end', index: 0, block: { type: 'text', text: errText } }
+    yield { type: 'usage', usage: { inputTokens: result?.usage?.totalTokens || 100, outputTokens: formatted.length } }
     yield { type: 'finish', reason: { kind: 'stop' } }
+  } finally {
+    if (signal?.aborted) {
+      await cleanMoaWorkspaces(cwd)
+    }
   }
 }
+