@goodandready/dsh-moa 0.2.26 → 0.2.27

package/lib/moa-runner.js

@@ -3,12 +3,16 @@ import crypto from 'node:crypto'
 import { bestEffort } from './best-effort.js'
 import { extractFileBlocks, collectProjectContext, formatProjectContext, isRefinementTask, writeCandidateWorkspace, promoteCandidateWorkspace, cleanMoaWorkspaces, verifyFileSyntax } from './file-workspace.js'
 import { estimateTokenCost, summarizeMoAUsage } from './pricing.js'
-import { recordMoaRun, recordMoaRunAsync, candidatesForHistory } from './history.js'
+import { recordMoaRun, candidatesForHistory } from './history.js'
 import { createPromotedPreview } from './live-canvas.js'
 import { slotLabel, cleanAdvisoryMessages, isBroadPromptRequiringQuestions, buildQuestionSynthesisPrompt, buildCuratorSynthesisPrompt, buildSynthesisPrompt, buildPeerCritiquePrompt, ROLE_PERSONA_PROMPTS, SYSTEM_ROLE_PROPOSER, ANTIPATTERNS_RUBRIC } from './moa-prompts.js'
 import { parseWinnerIndex, parseRecommendedAssembler, parseMoACommand, stripOrSummarizeCode, formatMoAResponse } from './moa-parser.js'
 import { REFERENCE_SYSTEM_PROMPT, callWithTransientRetry, runReferencesParallel } from './moa-candidates.js'
 import { executeTestGateForCandidates, runCandidateTestGate } from './moa-test-gate.js'
+import { executeMultiJudgePanel, buildCompositeBlockDirectives } from './moa-multi-judge.js'
+import { applyBudgetGuardrails } from './moa-budget.js'
+import { extractPriorTurnBaseline, pruneMultiTurnMessages } from './moa-context.js'
+import { generateMoABenchmarkReport } from './moa-report.js'
 
 // Re-exports for consumers & backward compatibility
 export { slotLabel, cleanAdvisoryMessages, isBroadPromptRequiringQuestions, buildQuestionSynthesisPrompt, buildCuratorSynthesisPrompt, buildSynthesisPrompt, ANTIPATTERNS_RUBRIC } from './moa-prompts.js'
@@ -16,6 +20,7 @@ export { parseWinnerIndex, parseRecommendedAssembler, parseMoACommand, stripOrSu
 export { estimateTokenCost, summarizeMoAUsage } from './pricing.js'
 export { REFERENCE_SYSTEM_PROMPT, callWithTransientRetry, runReferencesParallel } from './moa-candidates.js'
 export { executeTestGateForCandidates, runCandidateTestGate } from './moa-test-gate.js'
+export { streamMoATurn } from './moa-stream.js'
 
 /**
  * Executes the full Mixture of Agents pipeline.
@@ -60,6 +65,38 @@ export async function runMoAPipeline({
   const isBlindEvaluation = Boolean(preset?.blind_evaluation), isPeerCritiqueEnabled = Boolean(preset?.peer_critique_enabled)
   const allowCandidateOverride = Boolean(preset?.allow_candidate_override), runId = crypto.randomUUID()
 
+  // Feature 6: Budget Guardrail check
+  const budgetCheck = applyBudgetGuardrails({
+    references: referenceModels,
+    enabled: preset?.budget_guard_enabled,
+    maxBudgetUsd: preset?.max_budget_usd,
+    action: preset?.budget_action || 'trim',
+    prices,
+    promptLength: userPrompt?.length || 1000,
+  })
+  if (!budgetCheck.allowed) {
+    return {
+      kind: 'failure',
+      content: `🛑 Budget Guardrail Abort: ${budgetCheck.reason}`,
+      aggregator: slotLabel(primaryJudge),
+      references: [],
+      presetName: preset?.name || 'default',
+      isRefinement: false,
+      isFastMode,
+      winningIndex: 0,
+      winnerModel: 'none',
+      promotedFiles: [],
+      usage: { totalTokens: 0, totalCostUsd: 0, candidates: [], aggregator: { totalTokens: 0, costUsd: 0 } },
+      skippedFiles: 0,
+      skippedList: [],
+      durationMs: Date.now() - startTime,
+    }
+  }
+  const effectiveReferences = budgetCheck.references
+  if (budgetCheck.action === 'trim' && typeof onProgress === 'function') {
+    onProgress(`✂️ *${budgetCheck.reason}*\n`)
+  }
+
   // 2. Collect project context for refinement tasks
   const collectedCtx = await collectProjectContext(cwd, 16000)
   const isRefinement = Boolean(collectedCtx?.files?.length > 0 && isRefinementTask(userPrompt, collectedCtx.files))
@@ -79,23 +116,28 @@ export async function runMoAPipeline({
     })
   }
 
-  // 3. Build prompts & evaluate broad questionnaire needs
+  // 3. Build prompts & Feature 8 multi-turn context
+  const priorTurnBaseline = preset?.multi_turn_enabled !== false ? extractPriorTurnBaseline(messages) : null
+  const prunedHistory = preset?.multi_turn_enabled !== false ? pruneMultiTurnMessages(messages) : messages
+
   const candidateSystemPrompt = projectContext
     ? `${REFERENCE_SYSTEM_PROMPT}\n\n### Current Project Files & Context:\n${projectContext}`
     : REFERENCE_SYSTEM_PROMPT
 
   const askClarifyingQuestions = preset?.ask_clarifying_questions !== false
   const needsQuestions = askClarifyingQuestions && isBroadPromptRequiringQuestions(userPrompt, messages)
+  const enrichedMessages = [...prunedHistory, { role: 'user', content: userPrompt }]
 
-  const enrichedMessages = [...messages, { role: 'user', content: userPrompt }]
-
-  // 4. Parallel fan-out to candidate models with quorum & transient retry
+  // 4. Parallel fan-out to candidate models with temperature gradient & local fallback
   const referenceOutputs = await runReferencesParallel(
-    referenceModels,
+    effectiveReferences,
     enrichedMessages,
     {
       systemPrompt: candidateSystemPrompt,
       temperature: refTemp,
+      temperature_gradient_enabled: Boolean(preset?.temperature_gradient_enabled),
+      local_fallback_enabled: Boolean(preset?.local_fallback_enabled),
+      local_fallback_models: preset?.local_fallback_models || [],
       maxTokens,
       prices,
       timeoutSec: refTimeoutSec,
@@ -347,10 +389,32 @@ export async function runMoAPipeline({
     })
   }
 
+  // 7c. Feature 2: Multi-Judge Panel & Consensus Voting
+  let multiJudgeResult = null
+  if (preset?.multi_judge_enabled && successfulRefs.length > 1) {
+    multiJudgeResult = await executeMultiJudgePanel({
+      judges: (preset.judge_models && preset.judge_models.length > 0) ? preset.judge_models : [primaryJudge],
+      candidates: successfulRefs,
+      userPrompt,
+      callLlm,
+      strategy: preset.judge_voting_strategy || 'majority',
+      signal,
+      onProgress,
+    })
+  }
+
+  // 7d. Feature 3: Composite Block Merge Directive
+  const compositeMergeDirective = (preset?.composite_merge_enabled && successfulRefs.length > 1)
+    ? buildCompositeBlockDirectives(successfulRefs)
+    : null
+
   // 8. Synthesis phase via primary judge or fallback chain
   const synthesisPrompt = buildSynthesisPrompt(userPrompt, referenceOutputs, judgeCriteria, {
     curatorSynthesis: isCuratorSynthesis,
     blindEvaluation: isBlindEvaluation,
+    priorTurnBaseline,
+    compositeMergeDirective,
+    consensusReport: multiJudgeResult?.consensusReport,
   })
   let synthesizedText = ''
   let aggUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0 }
@@ -412,7 +476,10 @@ export async function runMoAPipeline({
   }
 
   // 9. Evaluate winner & promote files
-  const winningIndex = parseWinnerIndex(synthesizedText, 1, referenceOutputs.length)
+  const winningIndex = (multiJudgeResult?.consensus && multiJudgeResult?.winningCandidateIndex)
+    ? multiJudgeResult.winningCandidateIndex
+    : parseWinnerIndex(synthesizedText, 1, referenceOutputs.length)
+
   const recommendedAssembler = isCuratorSynthesis
     ? parseRecommendedAssembler(synthesizedText, winningIndex, referenceOutputs.length)
     : null
@@ -435,13 +502,32 @@ export async function runMoAPipeline({
   }
 
   const livePreview = await createPromotedPreview(liveCanvas, cwd, promotedFiles, referenceOutputs)
-
   const durationMs = Date.now() - startTime
   const usageSummary = summarizeMoAUsage(referenceOutputs, aggUsage)
   const winningRef = referenceOutputs[winningIndex - 1]
   const winnerModel = winningRef?.label || slotLabel(referenceModels[0])
   const finalAggLabel = slotLabel(chosenJudge)
 
+  // Feature 9: Benchmark & Post-Mortem PR report
+  let benchmarkReport = null
+  if (preset?.report_generation_enabled) {
+    benchmarkReport = generateMoABenchmarkReport({
+      runId,
+      timestamp: new Date().toISOString(),
+      preset: preset?.name || 'default',
+      prompt: userPrompt,
+      durationMs,
+      usage: usageSummary,
+      costUsd: usageSummary.totalCostUsd,
+      candidates: referenceOutputs,
+      winningIndex,
+      winningLabel: winnerModel,
+      consensus: multiJudgeResult,
+      testGate: referenceOutputs.find((r) => r.testResult)?.testResult || null,
+      isComposite: Boolean(preset?.composite_merge_enabled),
+    })
+  }
+
   try {
     recordMoaRun({
       id: runId,
@@ -453,6 +539,8 @@ export async function runMoAPipeline({
       winnerIndex: winningIndex,
       winnerModel,
       promotedFiles,
+      benchmarkReport,
+      consensus: multiJudgeResult,
       totalTokens: usageSummary.totalTokens,
       totalCostUsd: usageSummary.totalCostUsd,
       durationMs,
@@ -476,6 +564,8 @@ export async function runMoAPipeline({
     promotedFiles,
     runId,
     allowCandidateOverride,
+    benchmarkReport,
+    consensus: multiJudgeResult,
     ...(livePreview ? { liveCanvas: livePreview } : {}),
     usage: usageSummary,
     skippedFiles: collectedCtx?.skippedFiles || 0,
@@ -483,113 +573,3 @@ export async function runMoAPipeline({
     durationMs,
   }
 }
-
-/**
- * Streams a full MoA turn into chat with live aggregator tokens and progress feedback.
- */
-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 started...*\n\n' }
-
-  // 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
-    }
-  }
-
-  let done = false
-  const pipelinePromise = runMoAPipeline({
-    userPrompt,
-    messages,
-    preset: targetPreset,
-    callLlm,
-    cwd,
-    onProgress: pushUpdate,
-    onStreamDelta: (delta) => pushUpdate(delta),
-    prices,
-    historyFilePath,
-    liveCanvas,
-    signal,
-  })
-    .catch((err) => ({ error: err }))
-    .finally(() => {
-      done = true
-      if (notify) {
-        notify()
-        notify = null
-      }
-    })
-
-  const startTime = Date.now()
-  let lastYieldTime = Date.now()
-
-  try {
-    while (!done || queue.length > 0) {
-      if (signal?.aborted) {
-        await cleanMoaWorkspaces(cwd)
-        return
-      }
-
-      while (queue.length > 0) {
-        const item = queue.shift()
-        yield item
-        lastYieldTime = Date.now()
-      }
-
-      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 (!done && Date.now() - lastYieldTime >= 3000) {
-        yield { type: 'text-delta', index: 0, text: `⏳ *[${elapsedSec}s] Still processing...*\n` }
-        lastYieldTime = Date.now()
-      }
-    }
-
-    const result = await pipelinePromise
-    if (signal?.aborted) {
-      await cleanMoaWorkspaces(cwd)
-      return
-    }
-
-    if (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' } }
-      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 || 0,
-        outputTokens: Math.round((formatted.length || 0) / 4),
-      },
-    }
-    yield { type: 'finish', reason: { kind: 'stop' } }
-  } finally {
-    // cleanup
-  }
-}

package/lib/moa-stream.js

@@ -0,0 +1,117 @@
+/**
+ * Zero-latency Live Streaming Generator for MoA Turns
+ */
+
+import { cleanMoaWorkspaces } from './file-workspace.js'
+import { formatMoAResponse } from './moa-parser.js'
+import { runMoAPipeline } from './moa-runner.js'
+
+/**
+ * Streams a full MoA turn into chat with live aggregator tokens and progress feedback.
+ */
+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 started...*\n\n' }
+
+  // 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
+    }
+  }
+
+  let done = false
+  const pipelinePromise = runMoAPipeline({
+    userPrompt,
+    messages,
+    preset: targetPreset,
+    callLlm,
+    cwd,
+    onProgress: pushUpdate,
+    onStreamDelta: (delta) => pushUpdate(delta),
+    prices,
+    historyFilePath,
+    liveCanvas,
+    signal,
+  })
+    .catch((err) => ({ error: err }))
+    .finally(() => {
+      done = true
+      if (notify) {
+        notify()
+        notify = null
+      }
+    })
+
+  const startTime = Date.now()
+  let lastYieldTime = Date.now()
+
+  try {
+    while (!done || queue.length > 0) {
+      if (signal?.aborted) {
+        await cleanMoaWorkspaces(cwd)
+        return
+      }
+
+      while (queue.length > 0) {
+        const item = queue.shift()
+        yield item
+        lastYieldTime = Date.now()
+      }
+
+      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 (!done && Date.now() - lastYieldTime >= 3000) {
+        yield { type: 'text-delta', index: 0, text: `⏳ *[${elapsedSec}s] Still processing...*\n` }
+        lastYieldTime = Date.now()
+      }
+    }
+
+    const result = await pipelinePromise
+    if (signal?.aborted) {
+      await cleanMoaWorkspaces(cwd)
+      return
+    }
+
+    if (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' } }
+      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 || 0,
+        outputTokens: Math.round((formatted.length || 0) / 4),
+      },
+    }
+    yield { type: 'finish', reason: { kind: 'stop' } }
+  } finally {
+    // cleanup
+  }
+}

package/lib/routes.js

@@ -11,6 +11,8 @@ import {
 import { promoteCandidateWorkspace, readCandidateFiles, computeLineDiff, isSafeRelativePath } from './file-workspace.js'
 import { isSafeWriteRequest } from './updater.js'
 import { runMoAPipeline } from './moa-runner.js'
+import { generateMoABenchmarkReport } from './moa-report.js'
+import { resolvePresetForPrompt } from './moa-router.js'
 
 let _modelsCache = { timestamp: 0, models: [] }
 const MODELS_CACHE_TTL = 60 * 1000
@@ -423,16 +425,72 @@ ctx.effect(() => {
         const urlPath = req.url.split('?')[0]
         const parts = urlPath.split('/').filter(Boolean)
         const runId = parts[2] || ''
+        const isReport = parts[3] === 'report'
         const run = runId ? getMoaRunById(runId) : null
         if (!run) {
           writeJson(res, 404, { ok: false, error: 'Run not found' })
           return
         }
+        if (isReport) {
+          const u = new URL(req.url, 'http://127.0.0.1')
+          const format = u.searchParams.get('format') || 'md'
+          const report = run.benchmarkReport || generateMoABenchmarkReport({
+            runId: run.id,
+            timestamp: run.timestamp,
+            preset: run.preset,
+            prompt: run.prompt,
+            durationMs: run.durationMs,
+            usage: { totalTokens: run.totalTokens },
+            costUsd: run.totalCostUsd,
+            candidates: run.candidates,
+            winningIndex: run.winnerIndex,
+            winningLabel: run.winnerModel,
+          })
+          if (format === 'json') {
+            writeJson(res, 200, { ok: true, report: typeof report === 'object' ? (report.json || report) : report })
+            return
+          }
+          const mdText = typeof report === 'string' ? report : (report.markdown || JSON.stringify(report, null, 2))
+          res.writeHead(200, { 'Content-Type': 'text/markdown; charset=utf-8' })
+          res.end(mdText)
+          return
+        }
         writeJson(res, 200, { ok: true, run })
       },
     })
   }, 'dsh-moa: run by id route')
 
+  // Route: /dsh-moa/route-preset
+  ctx.effect(() => {
+    return ctx.webServer.register({
+      kind: 'exact',
+      path: '/dsh-moa/route-preset',
+      handler: async (req, res) => {
+        if (req.method !== 'POST') {
+          writeJson(res, 405, { ok: false, error: 'POST required' })
+          return
+        }
+        try {
+          const raw = await readBody(req)
+          const body = JSON.parse(raw || '{}')
+          const prompt = body?.prompt || ''
+          const cfg = live()
+          const result = await resolvePresetForPrompt({
+            prompt,
+            presets: cfg.presets || [],
+            defaultPreset: cfg.default_preset || 'default',
+            routingModel: cfg.smart_routing_model,
+            callLlm,
+            enabled: true,
+          })
+          writeJson(res, 200, { ok: true, ...result })
+        } catch (err) {
+          writeJson(res, 500, { ok: false, error: err?.message || String(err) })
+        }
+      },
+    })
+  }, 'dsh-moa: route preset endpoint')
+
   // Route: /dsh-moa/run
   ctx.effect(() => {
     return ctx.webServer.register({

package/package.json

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