@goodandready/dsh-moa 0.2.7 → 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

@@ -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,11 +453,39 @@ 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 })
+  }
+
+  function getSessionTurn(sessionId) {
+    if (!sessionId) return null
+    return moaSessionTurns.get(sessionId) || null
+  }
+
+  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 || []
     const lastUserMsg = [...messages].reverse().find((m) => m && m.role === 'user')
@@ -485,7 +517,7 @@ export function apply(ctx, config) {
           moaPendingTurns.set(event.signal, turnContext)
         }
         if (event.session?.id) {
-          moaSessionTurns.set(event.session.id, turnContext)
+          setSessionTurn(event.session.id, turnContext)
         }
       }
     }
@@ -496,7 +528,7 @@ export function apply(ctx, config) {
   ctx.on('agent/request', async (payload, next) => {
     const resolved = await next()
     const turnContext = (payload.signal ? moaPendingTurns.get(payload.signal) : null)
-      || (payload.session?.id ? moaSessionTurns.get(payload.session.id) : null)
+      || (payload.session?.id ? getSessionTurn(payload.session.id) : null)
 
     if (turnContext) {
       return {
@@ -511,11 +543,11 @@ export function apply(ctx, config) {
   ctx.effect(() => {
     return ctx.on('llm/stream', (options, next) => {
       const turnContext = (options.signal ? moaPendingTurns.get(options.signal) : null)
-        || (options.session?.id ? moaSessionTurns.get(options.session.id) : null)
+        || (options.session?.id ? consumeSessionTurn(options.session.id) : null)
 
       if (turnContext) {
         if (options.signal) moaPendingTurns.delete(options.signal)
-        if (options.session?.id) moaSessionTurns.delete(options.session.id)
+        if (options.session?.id) consumeSessionTurn(options.session.id)
 
         return streamMoATurn(turnContext, options)
       }

package/lib/moa-runner.js

@@ -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]
@@ -691,73 +718,93 @@ 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)
+    }
   }
 }

package/package.json

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