@goodandready/dsh-moa 0.2.6 → 0.2.8

package/lib/client.js

@@ -650,7 +650,27 @@ window.__ModuleLoader__.load({
               placeholder: t('judgeCriteriaPlaceholder') || 'например: Приоритет — производительность, чистый код, минимум зависимостей...',
               value: judgeCriteria,
               onChange: (e) => setJudgeCriteria(e.target.value),
-            })
+            }),
+            React.createElement(
+              'div',
+              { style: { marginTop: 8, display: 'flex', flexDirection: 'column', gap: 4 } },
+              React.createElement(
+                'label',
+                { style: { display: 'flex', alignItems: 'center', gap: 8, cursor: 'pointer', fontSize: 13, fontWeight: 500 } },
+                React.createElement('input', {
+                  type: 'checkbox',
+                  checked: currentPreset.ask_clarifying_questions !== false,
+                  onChange: (e) => updateCurrentPreset((p) => ({ ...p, ask_clarifying_questions: e.target.checked })),
+                  style: { accentColor: 'var(--dsw-alias-brand-primary, var(--dsw-alias-label-primary))', cursor: 'pointer' },
+                }),
+                t('askQuestionsLabel') || 'Спрашивать уточняющие вопросы при неясных задачах (Опросник)'
+              ),
+              React.createElement(
+                'div',
+                { className: 'moa-hint', style: { marginLeft: 22 } },
+                t('askQuestionsHint') || 'Если включено: при коротких задачах судья сформирует опросник. Если выключено: MoA сразу переходит к генерации решения.'
+              )
+            )
           )
         ),
         /* Proposers / Advisors Box with Temperature Slider */

package/lib/file-workspace.js

@@ -92,7 +92,7 @@ function sanitizePath(filePath) {
 export async function collectProjectContext(baseDir, maxCharBudget = 16000) {
   if (!baseDir) return { files: [], totalChars: 0 }
 
-  const ignoreDirs = new Set(['node_modules', '.git', '.moa', '.worktrees', 'dist', 'build', '.dsh'])
+  const ignoreDirs = new Set(['node_modules', '.git', '.moa', '.worktrees', 'dist', 'build', '.dsh', '.next', '.nuxt', '.cache', 'coverage', '.turbo', '.idea', '.vscode'])
   const codeExts = new Set([
     '.html', '.htm', '.css', '.js', '.mjs', '.cjs', '.jsx', '.ts', '.tsx',
     '.vue', '.svelte', '.json', '.py', '.md', '.txt', '.sh', '.yaml', '.yml',

package/lib/index.js

@@ -16,7 +16,7 @@ import os from 'node:os'
 import {
   parseMoACommand,
   runMoAPipeline,
-  MoaRunnerAdapter,
+  streamMoATurn,
 } from './moa-runner.js'
 
 import {
@@ -44,6 +44,7 @@ export const ModelSlotSchema = z.object({
 export const PresetSchema = z.object({
   name: z.string(),
   enabled: z.boolean().default(true),
+  ask_clarifying_questions: z.boolean().default(true),
   reference_models: z.array(ModelSlotSchema).default([]),
   aggregator: ModelSlotSchema.default({ provider: 'codex', model: 'gpt-5.6-sol' }),
   reference_temperature: z.number().default(0.6),
@@ -61,6 +62,7 @@ export const Config = z.object({
     {
       name: 'default',
       enabled: true,
+      ask_clarifying_questions: true,
       reference_models: [
         { provider: 'opencode-go', model: 'deepseek-v4-flash' },
         { provider: 'grok', model: 'grok-build-0.1' },
@@ -75,6 +77,7 @@ export const Config = z.object({
     {
       name: 'fast',
       enabled: true,
+      ask_clarifying_questions: false,
       reference_models: [
         { provider: 'opencode-go', model: 'deepseek-v4-flash' },
       ],
@@ -88,6 +91,7 @@ export const Config = z.object({
     {
       name: 'deep-reasoning',
       enabled: true,
+      ask_clarifying_questions: true,
       reference_models: [
         { provider: 'grok', model: 'grok-build-0.1' },
         { provider: 'commandcode', model: 'deepseek/deepseek-v4-flash' },
@@ -449,45 +453,38 @@ export function apply(ctx, config) {
       },
     })
   }, 'dsh-moa: run pipeline route')
+  // Session turn interceptor: route turn to real aggregator model & stream MoA synthesis
+  const moaPendingTurns = new WeakMap()
+  const moaSessionTurns = new Map()
+
+  function setSessionTurn(sessionId, turnContext) {
+    if (!sessionId) return
+    const existing = moaSessionTurns.get(sessionId)
+    if (existing?.ttlTimer) clearTimeout(existing.ttlTimer)
+
+    // TTL (3 minutes) to prevent memory leaks if turn is aborted or skipped before llm/stream
+    const ttlTimer = setTimeout(() => {
+      moaSessionTurns.delete(sessionId)
+    }, 180000)
+    ttlTimer.unref?.()
+
+    moaSessionTurns.set(sessionId, { ...turnContext, ttlTimer })
+  }
 
-  // Register virtual LLM adapter for live-streaming MoA turns
-  if (ctx.llm && typeof ctx.llm.registerAdapter === 'function') {
-    ctx.effect(() => {
-      const adapter = new MoaRunnerAdapter((options) => {
-        const msgs = options.messages || []
-        const lastUser = [...msgs].reverse().find((m) => m && m.role === 'user')
-        const userText = typeof lastUser?.content === 'string'
-          ? lastUser.content
-          : (Array.isArray(lastUser?.content)
-              ? lastUser.content.filter((p) => p.type === 'text').map((p) => p.text).join('\n')
-              : '')
-
-        const cfg = live()
-        const parsed = parseMoACommand(userText, cfg.presets || []) || { prompt: userText, presetName: 'default' }
-        const targetPreset = (cfg.presets || []).find((p) => p.name === parsed.presetName) || cfg.presets?.[0]
-
-        const extraCtx = options.signal ? moaPendingContexts.get(options.signal) : null
-        const cwd = options.cwd || extraCtx?.cwd || process.cwd()
-
-        return {
-          targetPreset,
-          userPrompt: parsed.prompt || userText,
-          messages: msgs.slice(0, -1),
-          callLlm,
-          cwd,
-        }
-      })
-
-      const dispose = ctx.llm.registerAdapter(['moa-runner'], adapter)
-      return () => {
-        if (typeof dispose === 'function') dispose()
-      }
-    }, 'dsh-moa: llm adapter')
+  function getSessionTurn(sessionId) {
+    if (!sessionId) return null
+    return moaSessionTurns.get(sessionId) || null
   }
 
-  // Session turn interceptor: flag MoA turns and route to moa-runner adapter
-  const moaPendingSignals = new WeakSet()
-  const moaPendingContexts = new WeakMap()
+  function consumeSessionTurn(sessionId) {
+    if (!sessionId) return null
+    const entry = moaSessionTurns.get(sessionId)
+    if (entry) {
+      if (entry.ttlTimer) clearTimeout(entry.ttlTimer)
+      moaSessionTurns.delete(sessionId)
+    }
+    return entry
+  }
 
   ctx.on('agent/pre-step', async (event, next) => {
     const messages = event.messages || []
@@ -501,10 +498,26 @@ export function apply(ctx, config) {
     if (userText.startsWith('/moa')) {
       const cfg = live()
       if (cfg.enabled !== false) {
+        const parsed = parseMoACommand(userText, cfg.presets || []) || { prompt: userText, presetName: cfg.default_preset || 'default' }
+        const targetPreset = (cfg.presets || []).find((p) => p.name === parsed.presetName) || cfg.presets?.[0]
+        const aggProvider = targetPreset?.aggregator?.provider || 'codex'
+        const aggModel = targetPreset?.aggregator?.model || 'gpt-5.6-sol'
+        const sessCwd = event.cwd || event.session?.cwd || (event.session?.path ? path.dirname(event.session.path) : undefined) || process.cwd()
+
+        const turnContext = {
+          targetPreset,
+          userPrompt: parsed.prompt || userText,
+          messages: messages.slice(0, -1),
+          cwd: sessCwd,
+          aggregator: { provider: aggProvider, model: aggModel },
+          callLlm,
+        }
+
         if (event.signal) {
-          moaPendingSignals.add(event.signal)
-          const sessCwd = event.cwd || event.session?.cwd || (event.session?.path ? path.dirname(event.session.path) : undefined)
-          moaPendingContexts.set(event.signal, { cwd: sessCwd })
+          moaPendingTurns.set(event.signal, turnContext)
+        }
+        if (event.session?.id) {
+          setSessionTurn(event.session.id, turnContext)
         }
       }
     }
@@ -514,14 +527,32 @@ export function apply(ctx, config) {
 
   ctx.on('agent/request', async (payload, next) => {
     const resolved = await next()
-    if (payload.signal && moaPendingSignals.has(payload.signal)) {
-      moaPendingSignals.delete(payload.signal)
+    const turnContext = (payload.signal ? moaPendingTurns.get(payload.signal) : null)
+      || (payload.session?.id ? getSessionTurn(payload.session.id) : null)
+
+    if (turnContext) {
       return {
         ...resolved,
-        provider: 'moa-runner',
-        model: 'ensemble',
+        provider: turnContext.aggregator.provider,
+        model: turnContext.aggregator.model,
       }
     }
     return resolved
   })
+
+  ctx.effect(() => {
+    return ctx.on('llm/stream', (options, next) => {
+      const turnContext = (options.signal ? moaPendingTurns.get(options.signal) : null)
+        || (options.session?.id ? consumeSessionTurn(options.session.id) : null)
+
+      if (turnContext) {
+        if (options.signal) moaPendingTurns.delete(options.signal)
+        if (options.session?.id) consumeSessionTurn(options.session.id)
+
+        return streamMoATurn(turnContext, options)
+      }
+
+      return next(options)
+    })
+  }, 'dsh-moa: llm stream interceptor')
 }

package/lib/moa-runner.js

@@ -231,7 +231,7 @@ export function parseMoACommand(text, presets = []) {
     }
   }
 
-  const matchPreset = /^--preset=([a-zA-Z0-9_-]+)\s*(.*)/s.exec(remainder)
+  const matchPreset = /^--preset(?:=|\s+)([a-zA-Z0-9_-]+)\s*(.*)/s.exec(remainder)
   if (matchPreset) {
     return {
       presetName: matchPreset[1],
@@ -383,7 +383,8 @@ export async function runMoAPipeline({
   }
 
   // Phase 1: Check if clarifying questions should be asked
-  const needsQuestions = !skipQuestions && !isRefinement && isBroadPromptRequiringQuestions(userPrompt, messages)
+  const allowQuestions = preset?.ask_clarifying_questions !== false && preset?.askClarifyingQuestions !== false
+  const needsQuestions = allowQuestions && !skipQuestions && !isRefinement && isBroadPromptRequiringQuestions(userPrompt, messages)
   if (needsQuestions) {
     if (typeof onProgress === 'function') {
       onProgress('🔍 *Задача общего характера. Советники формируют ключевые развилки...*\n\n')
@@ -446,6 +447,32 @@ export async function runMoAPipeline({
     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)
+
+    return {
+      kind: 'failure',
+      content: failMessage,
+      aggregator: slotLabel(aggregator),
+      references: referenceOutputs,
+      presetName: preset?.name || 'default',
+      promotedFiles: [],
+      usage: {
+        totalTokens: 0,
+        totalCostUsd: 0,
+        candidates: referenceOutputs.map((r) => ({ label: r.label, usage: r.usage, costUsd: 0 })),
+        aggregator: { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0 },
+      },
+      durationMs: Date.now() - startTime,
+    }
+  }
   // Write files for each candidate into .moa/candidate-X/
   for (let i = 0; i < referenceOutputs.length; i++) {
     const ref = referenceOutputs[i]
@@ -684,118 +711,100 @@ export function formatMoAResponse({ moaResult, presetName }) {
   return parts.join('\n')
 }
 
-export class MoaRunnerAdapter {
-  constructor(getMoaContext) {
-    this.getMoaContext = getMoaContext
-  }
-
-  providerInfo(provider) {
-    return { id: provider, name: 'Mixture of Agents Runner' }
-  }
-
-  providerRetryPolicy(_provider) {
-    return undefined
-  }
-
-  imageRequestPricing(_provider, _model) {
-    return undefined
-  }
+export async function* streamMoATurn({ targetPreset, userPrompt, messages, callLlm, cwd }, options = {}) {
+  const signal = options?.signal
+  if (signal?.aborted) return
 
-  async listModels(provider) {
-    const prov = typeof provider === 'string' && provider.length > 0 ? provider : 'moa-runner'
-    return [{ provider: prov, id: 'ensemble', name: 'MoA Ensemble' }]
-  }
+  yield { type: 'block-start', index: 0, blockType: 'text' }
+  yield { type: 'text-delta', index: 0, text: '🧠 *Mixture of Agents запущен...*\n\n' }
 
-  async resolveModel(provider, model) {
-    return { provider, id: model, name: 'MoA Ensemble' }
-  }
+  // Async push-queue for zero-latency live delta streaming
+  const queue = []
+  let notify = null
 
-  async prepareCall(providerOrConfig, modelOrSignal, _signal) {
-    const provider = typeof providerOrConfig === 'object' && providerOrConfig !== null ? providerOrConfig.provider : providerOrConfig
-    const model = typeof providerOrConfig === 'object' && providerOrConfig !== null ? providerOrConfig.model : modelOrSignal
-    return {
-      model: { provider, id: model, name: 'MoA Ensemble' },
-      stream: (options) => this.stream(options),
+  const pushUpdate = (text) => {
+    queue.push({ type: 'text-delta', index: 0, text })
+    if (notify) {
+      notify()
+      notify = null
     }
   }
 
-  async *stream(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' }
-
-    const { targetPreset, userPrompt, messages, callLlm, cwd } = this.getMoaContext(options)
-
-    // Queue for streaming progress updates from within runMoAPipeline
-    const progressChunks = []
-    const onProgress = (text) => {
-      progressChunks.push(text)
-    }
+  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
+      }
+    })
 
-    try {
-      const pipelinePromise = runMoAPipeline({
-        userPrompt,
-        messages,
-        preset: targetPreset,
-        callLlm,
-        cwd,
-        onProgress,
-      })
+  const startTime = Date.now()
+  let lastYieldTime = Date.now()
 
-      const startTime = Date.now()
-      let lastYieldTime = Date.now()
+  try {
+    while (!done || queue.length > 0) {
+      if (signal?.aborted) {
+        await cleanMoaWorkspaces(cwd)
+        return
+      }
 
-      // Yield progressive updates while pipeline runs
-      while (true) {
-        if (signal?.aborted) return
+      while (queue.length > 0) {
+        const item = queue.shift()
+        yield item
+        lastYieldTime = Date.now()
+      }
 
-        let emittedAny = false
-        while (progressChunks.length > 0) {
-          const chunk = progressChunks.shift()
-          yield { type: 'text-delta', index: 0, text: chunk }
-          emittedAny = true
-          lastYieldTime = Date.now()
-        }
+      if (done) break
 
-        const done = await Promise.race([
-          pipelinePromise.then(() => true),
-          new Promise((r) => { const t = setTimeout(() => r(false), 500); t.unref?.(); }),
-        ])
-        if (done) break
-
-        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) {
-          yield { type: 'text-delta', index: 0, text: `⏳ *[${elapsedSec}с] Идёт обработка...*\n` }
-          lastYieldTime = Date.now()
-        }
-      }
+      // 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?.(); }),
+      ])
 
-      while (progressChunks.length > 0) {
-        const chunk = progressChunks.shift()
-        yield { type: 'text-delta', index: 0, text: chunk }
+      const elapsedSec = Math.floor((Date.now() - startTime) / 1000)
+      if (!done && Date.now() - lastYieldTime >= 3000) {
+        yield { type: 'text-delta', index: 0, text: `⏳ *[${elapsedSec}с] Идёт обработка...*\n` }
+        lastYieldTime = Date.now()
       }
+    }
 
-      const moaResult = await pipelinePromise
-      if (signal?.aborted) return
-
-      const formatted = formatMoAResponse({
-        moaResult,
-        presetName: targetPreset?.name || 'default',
-      })
+    const result = await pipelinePromise
+    if (signal?.aborted) {
+      await cleanMoaWorkspaces(cwd)
+      return
+    }
 
-      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))
+    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: 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: result?.usage?.totalTokens || 100, outputTokens: formatted.length } }
+    yield { type: 'finish', reason: { kind: 'stop' } }
+  } finally {
+    if (signal?.aborted) {
+      await cleanMoaWorkspaces(cwd)
     }
   }
 }

package/package.json

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