@goodandready/dsh-moa 0.2.40 → 0.2.42

package/lib/moa-multi-judge.js

@@ -4,6 +4,7 @@
  */
 
 import { slotLabel } from './moa-prompts.js'
+import { estimateTokenCost } from './pricing.js'
 
 /**
  * Extracts code fences and block-level assets from markdown text.
@@ -40,8 +41,10 @@ export function extractCodeBlocks(text = '') {
 
 /**
  * Builds composite block directives highlighting complementary modules across candidates.
+ * Supports blind evaluation (#167).
  */
-export function buildCompositeBlockDirectives(candidates = []) {
+export function buildCompositeBlockDirectives(candidates = [], options = {}) {
+  const isBlind = Boolean(options === true || options?.blind)
   const fileMap = new Map()
 
   for (const c of candidates) {
@@ -52,7 +55,7 @@ export function buildCompositeBlockDirectives(candidates = []) {
         if (!fileMap.has(b.filename)) {
           fileMap.set(b.filename, [])
         }
-        fileMap.get(b.filename).push(c.label || `Candidate ${c.index}`)
+        fileMap.get(b.filename).push(isBlind ? `Candidate ${c.index}` : (c.label || `Candidate ${c.index}`))
       }
     }
   }
@@ -79,17 +82,38 @@ ${fileOverview}============================================
 
 /**
  * Parses judge output into structured scores and candidate choice.
+ * Accepts either candidateCount or candidate array/set to support active candidate indexing (#166).
  */
-export function parseJudgeEvaluation(rawText = '', candidateCount = 2) {
+export function parseJudgeEvaluation(rawText = '', candidatesOrCount = 2) {
+  let allowedIndices = null
+  let defaultCandidate = 1
+
+  if (Array.isArray(candidatesOrCount)) {
+    const active = candidatesOrCount.filter((c) => c && c.ok !== false)
+    allowedIndices = new Set(active.map((c) => c.index))
+    if (active.length > 0 && typeof active[0].index === 'number') {
+      defaultCandidate = active[0].index
+    }
+  } else if (candidatesOrCount instanceof Set) {
+    allowedIndices = candidatesOrCount
+    defaultCandidate = Array.from(allowedIndices)[0] || 1
+  } else if (typeof candidatesOrCount === 'number') {
+    allowedIndices = new Set(Array.from({ length: candidatesOrCount }, (_, i) => i + 1))
+    defaultCandidate = 1
+  } else {
+    allowedIndices = new Set([1, 2])
+    defaultCandidate = 1
+  }
+
   const scores = {}
-  let bestCandidate = 1
+  let bestCandidate = defaultCandidate
   let reasoning = ''
 
   const scoreMatches = rawText.matchAll(/Candidate\s*(\d+)[:\s]+(?:Score\s*[:\s]*)?([0-9]+(?:\.[0-9]+)?)/gi)
   for (const m of scoreMatches) {
     const idx = parseInt(m[1], 10)
     const val = parseFloat(m[2])
-    if (idx >= 1 && idx <= candidateCount && !Number.isNaN(val)) {
+    if (allowedIndices.has(idx) && !Number.isNaN(val)) {
       scores[idx] = Math.min(10, Math.max(0, val))
     }
   }
@@ -97,16 +121,17 @@ export function parseJudgeEvaluation(rawText = '', candidateCount = 2) {
   const bestMatch = rawText.match(/BEST_CANDIDATE\s*[:\s]+(?:Candidate\s*)?(\d+)/i)
   if (bestMatch) {
     const parsedBest = parseInt(bestMatch[1], 10)
-    if (parsedBest >= 1 && parsedBest <= candidateCount) {
+    if (allowedIndices.has(parsedBest)) {
       bestCandidate = parsedBest
     }
   } else {
-    // Find candidate with max parsed score
+    // Find candidate with max parsed score among allowed indices
     let maxScore = -1
     for (const [idxStr, s] of Object.entries(scores)) {
-      if (s > maxScore) {
+      const idxNum = parseInt(idxStr, 10)
+      if (allowedIndices.has(idxNum) && s > maxScore) {
         maxScore = s
-        bestCandidate = parseInt(idxStr, 10)
+        bestCandidate = idxNum
       }
     }
   }
@@ -114,25 +139,27 @@ export function parseJudgeEvaluation(rawText = '', candidateCount = 2) {
   const reasonMatch = rawText.match(/CONSENSUS_REASONING\s*[:\s]+([^\n\r]+)/i)
   if (reasonMatch) {
     reasoning = reasonMatch[1].trim()
-  } else {
-    reasoning = rawText.slice(0, 180).replace(/\n/g, ' ').trim()
   }
 
   return { scores, bestCandidate, reasoning }
 }
 
 /**
- * Executes a panel of judges to reach consensus on candidate solutions.
+ * Runs a multi-judge consensus panel across candidate solutions.
+ * Supports majority, unanimous, and highest_score strategies.
+ * Returns consensus, votes, usage, and cost tracking (#165, #167, #168).
  */
 export async function executeMultiJudgePanel({
   judges = [],
   candidates = [],
   userPrompt = '',
   callLlm,
-  strategy = 'majority', // 'majority' | 'highest_score' | 'unanimous'
+  strategy = 'majority',
   timeoutMs = 45000,
   signal,
   onProgress,
+  prices = {},
+  blind = false,
 }) {
   const activeCandidates = (candidates || []).filter((c) => c && c.ok)
   if (activeCandidates.length === 0) {
@@ -140,6 +167,12 @@ export async function executeMultiJudgePanel({
       consensus: false,
       winningCandidateIndex: 1,
       strategy,
+      isUnanimous: false,
+      votes: {},
+      averageScores: {},
+      judgesResults: [],
+      totalUsage: { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0 },
+      totalCostUsd: 0,
       reason: 'no_active_candidates',
     }
   }
@@ -150,46 +183,52 @@ export async function executeMultiJudgePanel({
       winningCandidateIndex: activeCandidates[0].index,
       winningCandidateLabel: activeCandidates[0].label,
       strategy,
+      isUnanimous: true,
+      votes: { [activeCandidates[0].index]: 1 },
+      averageScores: { [activeCandidates[0].index]: 10.0 },
+      judgesResults: [],
+      totalUsage: { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0 },
+      totalCostUsd: 0,
       reason: 'single_active_candidate',
     }
   }
 
-  const judgeSlots = Array.isArray(judges) && judges.length > 0
+  const judgePanel = (judges && judges.length > 0)
     ? judges
     : [{ provider: 'default', model: 'aggregator-judge', label: 'Primary Judge' }]
 
+  // Blind evaluation: mask model labels in judge prompt (#167)
   const candidateSummary = activeCandidates.map((c) => {
-    return `### Candidate ${c.index} (${c.label}):\n${(c.text || '').slice(0, 4000)}`
+    const label = blind ? `Candidate ${c.index}` : `Candidate ${c.index} (${c.label})`
+    return `### ${label}:\n${(c.text || '').slice(0, 4000)}`
   }).join('\n\n---\n\n')
 
   const judgePrompt = `You are an impartial Expert Code & Logic Judge evaluating multiple AI candidate solutions.
-User Prompt:
-${userPrompt.slice(0, 1000)}
+User Task:
+${userPrompt}
 
-Candidate Solutions:
+Candidates Under Review:
 ${candidateSummary}
 
-Evaluate the solutions on correctness, architecture, edge cases, and maintainability.
-Rate each candidate on a scale of 1 to 10.
-Pick the single best candidate.
+INSTRUCTIONS:
+1. Carefully compare all candidates on correctness, efficiency, architectural cleanliness, and edge-case resilience.
+2. Assign each candidate a score from 0.0 to 10.0.
+3. State your chosen best candidate and a brief reasoning sentence.
 
-Your response MUST follow this exact format:
-SCORES:
-${activeCandidates.map((c) => `Candidate ${c.index}: [1-10]`).join('\n')}
-BEST_CANDIDATE: [index number]
+Format your response EXACTLY as follows:
+CANDIDATE_EVALUATION:
+Candidate [index]: Score [0-10]
+...
+BEST_CANDIDATE: Candidate [winning index]
 CONSENSUS_REASONING: [one concise sentence explaining your pick]
 `
 
-  if (typeof onProgress === 'function') {
-    onProgress(`⚖️ *Convening Multi-Judge Panel (${judgeSlots.length} judges, strategy: ${strategy})...*\n`)
-  }
-
-  const judgePromises = judgeSlots.map(async (judge, jIdx) => {
-    const label = slotLabel(judge)
+  const judgePromises = judgePanel.map(async (judge, jIdx) => {
+    const label = judge.label || slotLabel(judge)
     try {
       const abortCtrl = new AbortController()
       if (signal) {
-        signal.addEventListener('abort', () => abortCtrl.abort(), { once: true })
+        signal.addEventListener('abort', () => abortCtrl.abort(signal.reason || new Error('Turn aborted')), { once: true })
       }
       const timer = setTimeout(() => abortCtrl.abort(new Error('Judge evaluation timeout')), timeoutMs)
       timer.unref?.()
@@ -198,22 +237,31 @@ CONSENSUS_REASONING: [one concise sentence explaining your pick]
         provider: judge.provider,
         model: judge.model,
         messages: [
-          { role: 'system', content: 'You are an objective expert judge in an ensemble evaluation system.' },
+          { role: 'system', content: 'You are an objective AI code evaluation judge.' },
           { role: 'user', content: judgePrompt },
         ],
-        temperature: 0.1,
-        maxTokens: 512,
         signal: abortCtrl.signal,
       })
+
       clearTimeout(timer)
 
       const text = typeof res === 'string' ? res : (res?.content || res?.text || '')
-      const evalResult = parseJudgeEvaluation(text, candidates.length)
+      // Preserve active candidate indices rather than assuming 1..N (#166)
+      const evalResult = parseJudgeEvaluation(text, activeCandidates)
+
+      // Track usage and cost (#168)
+      const usage = (typeof res === 'object' && res?.usage) ? res.usage : {
+        inputTokens: Math.max(1, Math.round((judgePrompt.length + 50) / 4)),
+        outputTokens: Math.max(1, Math.round(text.length / 4)),
+      }
+      const costInfo = estimateTokenCost(judge, usage, prices)
 
       return {
         judgeIndex: jIdx + 1,
         judgeLabel: label,
         ok: true,
+        usage,
+        costUsd: costInfo.costUsd || 0,
         ...evalResult,
       }
     } catch (err) {
@@ -221,8 +269,10 @@ CONSENSUS_REASONING: [one concise sentence explaining your pick]
         judgeIndex: jIdx + 1,
         judgeLabel: label,
         ok: false,
-        bestCandidate: 1,
+        bestCandidate: activeCandidates[0].index,
         scores: {},
+        usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+        costUsd: 0,
         reasoning: err?.message || String(err),
       }
     }
@@ -231,64 +281,104 @@ CONSENSUS_REASONING: [one concise sentence explaining your pick]
   const results = await Promise.all(judgePromises)
   const validResults = results.filter((r) => r.ok)
 
+  // Accumulate total usage and cost across all judges (#168)
+  let sumInTokens = 0
+  let sumOutTokens = 0
+  let sumCostUsd = 0
+  for (const r of results) {
+    if (r.usage) {
+      sumInTokens += r.usage.inputTokens || r.usage.promptTokens || 0
+      sumOutTokens += r.usage.outputTokens || r.usage.completionTokens || 0
+    }
+    if (typeof r.costUsd === 'number') {
+      sumCostUsd += r.costUsd
+    }
+  }
+  const totalUsage = {
+    inputTokens: sumInTokens,
+    outputTokens: sumOutTokens,
+    totalTokens: sumInTokens + sumOutTokens,
+    costUsd: Number(sumCostUsd.toFixed(5)),
+  }
+  const totalCostUsd = totalUsage.costUsd
+
+  // #165: If all judges failed, consensus is false with 0 votes
+  if (validResults.length === 0) {
+    return {
+      consensus: false,
+      winningCandidateIndex: activeCandidates[0].index,
+      winningCandidateLabel: activeCandidates[0].label,
+      strategy,
+      isUnanimous: false,
+      votes: {},
+      averageScores: {},
+      judgesResults: results,
+      totalUsage,
+      totalCostUsd,
+      reason: 'all_judges_failed',
+    }
+  }
+
   // Tally votes and compute average scores
   const votes = {}
   const totalScores = {}
   const scoreCounts = {}
 
-  for (const r of validResults) {
-    votes[r.bestCandidate] = (votes[r.bestCandidate] || 0) + 1
-    for (const [cIdx, s] of Object.entries(r.scores || {})) {
-      totalScores[cIdx] = (totalScores[cIdx] || 0) + s
-      scoreCounts[cIdx] = (scoreCounts[cIdx] || 0) + 1
+  for (const vr of validResults) {
+    votes[vr.bestCandidate] = (votes[vr.bestCandidate] || 0) + 1
+    for (const [candIdx, sc] of Object.entries(vr.scores)) {
+      totalScores[candIdx] = (totalScores[candIdx] || 0) + sc
+      scoreCounts[candIdx] = (scoreCounts[candIdx] || 0) + 1
     }
   }
 
   const averageScores = {}
-  for (const c of activeCandidates) {
-    const cnt = scoreCounts[c.index] || 0
-    averageScores[c.index] = cnt > 0 ? Number((totalScores[c.index] / cnt).toFixed(2)) : 5.0
+  for (const [candIdx, sum] of Object.entries(totalScores)) {
+    averageScores[candIdx] = Number((sum / (scoreCounts[candIdx] || 1)).toFixed(2))
   }
 
   let winner = activeCandidates[0].index
   let isUnanimous = false
+  let hasConsensus = true
 
   if (strategy === 'highest_score') {
     let highestAvg = -1
     for (const c of activeCandidates) {
-      const avg = averageScores[c.index] || 0
+      const avg = averageScores[c.index] ?? -1
       if (avg > highestAvg) {
         highestAvg = avg
         winner = c.index
       }
     }
+    hasConsensus = validResults.length > 0
   } else {
     // majority or unanimous
     let maxVotes = -1
-    for (const c of activeCandidates) {
-      const v = votes[c.index] || 0
-      if (v > maxVotes) {
-        maxVotes = v
-        winner = c.index
-      } else if (v === maxVotes && (averageScores[c.index] || 0) > (averageScores[winner] || 0)) {
-        winner = c.index
+    for (const [cIdxStr, count] of Object.entries(votes)) {
+      const cIdx = parseInt(cIdxStr, 10)
+      if (count > maxVotes) {
+        maxVotes = count
+        winner = cIdx
       }
     }
     isUnanimous = (votes[winner] || 0) === validResults.length && validResults.length > 0
+    if (strategy === 'unanimous') {
+      hasConsensus = isUnanimous && validResults.length > 0
+    } else {
+      hasConsensus = maxVotes > (validResults.length / 2) || validResults.length === 1
+    }
   }
 
   const winningCand = activeCandidates.find((c) => c.index === winner) || activeCandidates[0]
-
-  const consensusReport = `Multi-Judge Consensus (${validResults.length}/${judgeSlots.length} judges): ` +
-    `Winner is Candidate ${winningCand.index} (${winningCand.label}) with ${votes[winner] || 0} votes, ` +
-    `avg score ${averageScores[winner] || 0}/10. Strategy: ${strategy}.`
+  const winnerVotes = votes[winner] || 0
+  const consensusReport = `Multi-judge consensus (${strategy}): Candidate ${winner} (${winningCand.label}) won with ${winnerVotes}/${validResults.length} votes.`
 
   if (typeof onProgress === 'function') {
-    onProgress(`🏁 *${consensusReport}*\n`)
+    onProgress(`⚖️ *${consensusReport}*\n`)
   }
 
   return {
-    consensus: true,
+    consensus: hasConsensus,
     winningCandidateIndex: winningCand.index,
     winningCandidateLabel: winningCand.label,
     strategy,
@@ -296,6 +386,8 @@ CONSENSUS_REASONING: [one concise sentence explaining your pick]
     votes,
     averageScores,
     judgesResults: results,
+    totalUsage,
+    totalCostUsd,
     consensusReport,
   }
 }

package/lib/moa-report.js

@@ -20,17 +20,19 @@ export function generateMoABenchmarkReport({
 }) {
   const durationSec = (durationMs / 1000).toFixed(2)
   const totalCost = typeof costUsd === 'number' ? costUsd.toFixed(4) : '0.0000'
-  const inTokens = usage?.inputTokens || 0
-  const outTokens = usage?.outputTokens || 0
-  const totalTokens = usage?.totalTokens || (inTokens + outTokens)
+  const inTokens = usage?.inputTokens ?? usage?.totalInputTokens ?? usage?.prompt_tokens ?? 0
+  const outTokens = usage?.outputTokens ?? usage?.totalOutputTokens ?? usage?.completion_tokens ?? 0
+  const totalTokens = usage?.totalTokens ?? (inTokens + outTokens)
 
   const candidateRows = (candidates || []).map((c) => {
     const idx = c.index || '?'
     const label = c.label || `${c.slot?.provider}:${c.slot?.model}`
-    const role = c.role_persona || 'general'
+    const role = c.role_persona || c.role || 'general'
     const status = c.ok ? '✅ OK' : '❌ Failed'
-    const candTokens = c.usage?.totalTokens || (c.usage?.inputTokens || 0) + (c.usage?.outputTokens || 0)
-    const candCost = c.costUsd ? `$${c.costUsd.toFixed(4)}` : '$0.0000'
+    const cIn = c.usage?.inputTokens ?? c.usage?.totalInputTokens ?? c.usage?.prompt_tokens ?? 0
+    const cOut = c.usage?.outputTokens ?? c.usage?.totalOutputTokens ?? c.usage?.completion_tokens ?? 0
+    const candTokens = c.usage?.totalTokens ?? (cIn + cOut)
+    const candCost = typeof c.costUsd === 'number' ? `$${c.costUsd.toFixed(4)}` : '$0.0000'
     const score = consensus?.averageScores?.[c.index] !== undefined
       ? `${consensus.averageScores[c.index]}/10`
       : 'N/A'
@@ -39,16 +41,31 @@ export function generateMoABenchmarkReport({
   }).join('\n')
 
   let testGateSection = '### 🧪 Automated Test Gate\n- **Status**: Not Configured / Skipped'
-  if (testGate && testGate.enabled) {
-    const tgStatus = testGate.passed ? '✅ PASSED' : '❌ FAILED'
+  const gates = Array.isArray(testGate) ? testGate : (testGate ? [testGate] : [])
+  const activeGates = gates.filter((tg) => tg && (tg.enabled !== false || tg.passed !== undefined))
+  if (activeGates.length === 1) {
+    const tg = activeGates[0]
+    const tgStatus = tg.passed ? '✅ PASSED' : '❌ FAILED'
     testGateSection = `### 🧪 Automated Test Gate
 - **Status**: ${tgStatus}
-- **Test Command**: \`${testGate.command || 'N/A'}\`
-- **Exit Code**: \`${testGate.exitCode ?? 0}\`
+- **Test Command**: \`${tg.command || 'N/A'}\`
+- **Exit Code**: \`${tg.exitCode ?? 0}\`
 - **Output Snippet**:
 \`\`\`
-${(testGate.output || 'No output recorded').slice(0, 500)}
+${(tg.output || tg.summary || 'No output recorded').slice(0, 500)}
 \`\`\``
+  } else if (activeGates.length > 1) {
+    const allPassed = activeGates.every((tg) => tg.passed)
+    const passedCount = activeGates.filter((tg) => tg.passed).length
+    const overallStatus = allPassed ? '✅ ALL PASSED' : `❌ ${activeGates.length - passedCount}/${activeGates.length} FAILED`
+    const details = activeGates.map((tg, idx) => {
+      const label = tg.label || tg.model || `Candidate ${tg.candidateIndex ?? idx + 1}`
+      const tgStatus = tg.passed ? '✅ PASSED' : '❌ FAILED'
+      return `- **${label}**: ${tgStatus} (Command: \`${tg.command || 'N/A'}\`, Exit Code: \`${tg.exitCode ?? 0}\`)\n\`\`\`\n${(tg.output || tg.summary || 'No output recorded').slice(0, 300)}\n\`\`\``
+    }).join('\n')
+    testGateSection = `### 🧪 Automated Test Gate
+- **Status**: ${overallStatus}
+${details}`
   }
 
   let consensusSection = '### ⚖️ Multi-Judge Consensus\n- **Status**: Standard single-aggregator synthesis'
@@ -104,15 +121,19 @@ ${testGateSection}
     durationMs,
     usage: { inputTokens: inTokens, outputTokens: outTokens, totalTokens },
     costUsd,
-    candidates: (candidates || []).map((c) => ({
-      index: c.index,
-      label: c.label,
-      role: c.role_persona,
-      ok: c.ok,
-      costUsd: c.costUsd || 0,
-      usage: c.usage,
-      score: consensus?.averageScores?.[c.index] ?? null,
-    })),
+    candidates: (candidates || []).map((c) => {
+      const cIn = c.usage?.inputTokens ?? c.usage?.totalInputTokens ?? c.usage?.prompt_tokens ?? 0
+      const cOut = c.usage?.outputTokens ?? c.usage?.totalOutputTokens ?? c.usage?.completion_tokens ?? 0
+      return {
+        index: c.index,
+        label: c.label,
+        role: c.role_persona || c.role,
+        ok: c.ok,
+        costUsd: typeof c.costUsd === 'number' ? c.costUsd : 0,
+        usage: { inputTokens: cIn, outputTokens: cOut, totalTokens: c.usage?.totalTokens ?? (cIn + cOut) },
+        score: consensus?.averageScores?.[c.index] ?? null,
+      }
+    }),
     winningIndex,
     winningLabel,
     consensus,

package/lib/moa-runner.js

@@ -18,7 +18,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'
+export { streamMoATurn, streamPromoteTurn } from './moa-stream.js'
 /**
  * Executes the full Mixture of Agents pipeline.
  */
@@ -229,6 +229,7 @@ export async function runMoAPipeline({
     const durationMs = Date.now() - startTime
     try {
       await recordMoaRunAsync({
+        cwd,
         prompt: userPrompt,
         preset: preset?.name || 'default',
         isRefinement,
@@ -281,13 +282,14 @@ export async function runMoAPipeline({
       await cleanMoaWorkspaces(cwd, { runId })
     }
 
-    const livePreview = await createPromotedPreview(liveCanvas, cwd, promotedFiles, referenceOutputs)
+    const livePreview = await createPromotedPreview(liveCanvas, cwd, promotedFiles, referenceOutputs, { winningIndex: single.index })
     const totalTokens = single.usage?.totalTokens || 0
     const totalCostUsd = Number((single.costUsd || 0).toFixed(5))
     const durationMs = Date.now() - startTime
 
     try {
       await recordMoaRunAsync({
+        cwd,
         prompt: userPrompt,
         preset: preset?.name || 'default',
         isRefinement,
@@ -402,6 +404,8 @@ export async function runMoAPipeline({
       userPrompt,
       callLlm,
       strategy: preset.judge_voting_strategy || 'majority',
+      prices: prices || {},
+      blind: Boolean(preset.blind_evaluation),
       signal,
       onProgress,
     })
@@ -409,7 +413,7 @@ export async function runMoAPipeline({
 
   // 7d. Feature 3: Composite Block Merge Directive
   const compositeMergeDirective = (preset?.composite_merge_enabled && successfulRefs.length > 1)
-    ? buildCompositeBlockDirectives(successfulRefs)
+    ? buildCompositeBlockDirectives(successfulRefs, { blind: Boolean(preset.blind_evaluation) })
     : null
 
   // 8. Synthesis phase via primary judge or fallback chain
@@ -510,9 +514,9 @@ export async function runMoAPipeline({
     await cleanMoaWorkspaces(cwd, { runId })
   }
 
-  const livePreview = await createPromotedPreview(liveCanvas, cwd, promotedFiles, referenceOutputs)
+  const livePreview = await createPromotedPreview(liveCanvas, cwd, promotedFiles, referenceOutputs, { winningIndex, synthesizedFiles })
   const durationMs = Date.now() - startTime
-  const usageSummary = summarizeMoAUsage(referenceOutputs, aggUsage)
+  const usageSummary = summarizeMoAUsage(referenceOutputs, aggUsage, multiJudgeResult?.totalUsage)
   const winningRef = referenceOutputs[winningIndex - 1]
   const winnerModel = winningRef?.label || slotLabel(effectiveReferences[0] || referenceModels[0])
   const finalAggLabel = slotLabel(chosenJudge)
@@ -532,7 +536,7 @@ export async function runMoAPipeline({
       winningIndex,
       winningLabel: winnerModel,
       consensus: multiJudgeResult,
-      testGate: referenceOutputs.find((r) => r.testResult)?.testResult || null,
+      testGate: referenceOutputs.filter((r) => r.testResult).map((r) => r.testResult),
       isComposite: Boolean(preset?.composite_merge_enabled),
     })
   }
@@ -540,6 +544,7 @@ export async function runMoAPipeline({
   try {
     await recordMoaRunAsync({
       id: runId,
+      cwd,
       prompt: userPrompt,
       preset: preset?.name || 'default',
       isRefinement,

package/lib/moa-stream.js

@@ -3,7 +3,8 @@ import crypto from 'node:crypto'
  * Zero-latency Live Streaming Generator for MoA Turns
  */
 
-import { cleanMoaWorkspaces } from './file-workspace.js'
+import { cleanMoaWorkspaces, promoteCandidateWorkspace } from './file-workspace.js'
+import { isTestEnvironment } from './history.js'
 import { formatMoAResponse } from './moa-parser.js'
 import { runMoAPipeline } from './moa-runner.js'
 
@@ -132,3 +133,58 @@ export async function* streamMoATurn({ targetPreset, userPrompt, messages, callL
     }
   }
 }
+
+/**
+ * Streams a /moa promote candidate turn directly to chat with zero LLM calls (#177).
+ */
+export async function* streamPromoteTurn({ runId, candidateIndex, cwd, webServerPort, timeMachineEngine, force = isTestEnvironment() }, options = {}) {
+  const signal = options?.signal
+  if (signal?.aborted) return
+
+  yield { type: 'block-start', index: 0, blockType: 'text' }
+
+  if (typeof candidateIndex !== 'number' || isNaN(candidateIndex) || candidateIndex < 1) {
+    const errText = '⚠️ **MoA Promote Error**: Valid candidate index required (>= 1).'
+    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
+  }
+
+  try {
+    yield { type: 'text-delta', index: 0, text: `🔄 *Promoting candidate ${candidateIndex}${runId ? ` for run \`${runId}\`` : ''}...*\n\n` }
+
+    const promotedFiles = await promoteCandidateWorkspace(cwd, candidateIndex, {
+      runId,
+      keepMoa: true,
+      port: webServerPort,
+      timeMachineEngine,
+      force: Boolean(force || options?.force),
+    })
+
+    if (!promotedFiles || promotedFiles.length === 0) {
+      const noFilesText = `⚠️ **MoA Promote Notice**: No candidate files found for candidate ${candidateIndex}${runId ? ` in run \`${runId}\`` : ''}. Workspace may have expired or run does not exist.`
+      yield { type: 'text-delta', index: 0, text: noFilesText }
+      yield { type: 'block-end', index: 0, block: { type: 'text', text: noFilesText } }
+      yield { type: 'finish', reason: { kind: 'stop' } }
+      return
+    }
+
+    const fileList = promotedFiles.map((f) => `\`${f}\``).join(', ')
+    const checkpointId = promotedFiles.checkpoint || null
+    let successMsg = `✅ **MoA Candidate ${candidateIndex} promoted successfully!**\n\n`
+    successMsg += `> 📦 **Files applied to workspace**: ${fileList}\n`
+    if (checkpointId) {
+      successMsg += `> 🛡️ **Time Machine Checkpoint**: \`${checkpointId}\`\n`
+    }
+
+    yield { type: 'text-delta', index: 0, text: successMsg }
+    yield { type: 'block-end', index: 0, block: { type: 'text', text: successMsg } }
+    yield { type: 'finish', reason: { kind: 'stop' } }
+  } catch (err) {
+    const errText = `⚠️ **MoA Promote Failed**: ${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: 'finish', reason: { kind: 'stop' } }
+  }
+}

package/lib/pricing.js

@@ -310,12 +310,16 @@ export function estimateTokenCost(slot = {}, usage = {}, customPrices = {}, cach
 
 
 
-export function summarizeMoAUsage(referenceOutputs = [], aggUsage = null) {
+export function summarizeMoAUsage(referenceOutputs = [], aggUsage = null, multiJudgeUsage = null) {
   const normAgg = aggUsage || { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0 }
-  const totalInputTokens = (referenceOutputs || []).reduce((acc, r) => acc + (r.usage?.inputTokens || r.usage?.promptTokens || 0), 0) + (normAgg.inputTokens || normAgg.promptTokens || 0)
-  const totalOutputTokens = (referenceOutputs || []).reduce((acc, r) => acc + (r.usage?.outputTokens || r.usage?.completionTokens || 0), 0) + (normAgg.outputTokens || normAgg.completionTokens || 0)
-  const totalTokens = (referenceOutputs || []).reduce((acc, r) => acc + (r.usage?.totalTokens || 0), 0) + (normAgg.totalTokens || (totalInputTokens + totalOutputTokens))
-  const totalCostUsd = Number(((referenceOutputs || []).reduce((acc, r) => acc + (r.costUsd || 0), 0) + normAgg.costUsd).toFixed(5))
+  const normMj = multiJudgeUsage || { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0 }
+  const totalInputTokens = (referenceOutputs || []).reduce((acc, r) => acc + (r.usage?.inputTokens || r.usage?.promptTokens || r.usage?.prompt_tokens || 0), 0) + (normAgg.inputTokens || normAgg.promptTokens || normAgg.prompt_tokens || 0) + (normMj.inputTokens || normMj.promptTokens || normMj.prompt_tokens || 0)
+  const totalOutputTokens = (referenceOutputs || []).reduce((acc, r) => acc + (r.usage?.outputTokens || r.usage?.completionTokens || r.usage?.completion_tokens || 0), 0) + (normAgg.outputTokens || normAgg.completionTokens || normAgg.completion_tokens || 0) + (normMj.outputTokens || normMj.completionTokens || normMj.completion_tokens || 0)
+  const candTokens = (referenceOutputs || []).reduce((acc, r) => acc + (r.usage?.totalTokens ?? ((r.usage?.inputTokens || 0) + (r.usage?.outputTokens || 0))), 0)
+  const aggTokens = normAgg.totalTokens ?? ((normAgg.inputTokens || 0) + (normAgg.outputTokens || 0))
+  const mjTokens = normMj.totalTokens ?? ((normMj.inputTokens || 0) + (normMj.outputTokens || 0))
+  const totalTokens = candTokens + aggTokens + mjTokens || (totalInputTokens + totalOutputTokens)
+  const totalCostUsd = Number(((referenceOutputs || []).reduce((acc, r) => acc + (r.costUsd || 0), 0) + (normAgg.costUsd || 0) + (normMj.costUsd || 0)).toFixed(5))
   const candidates = (referenceOutputs || []).map((r) => ({ label: r.label, usage: r.usage, costUsd: r.costUsd }))
-  return { totalTokens, totalInputTokens, totalOutputTokens, totalCostUsd, candidates, aggregator: normAgg }
+  return { totalTokens, totalInputTokens, totalOutputTokens, totalCostUsd, candidates, aggregator: normAgg, multiJudge: normMj }
 }