@goodandready/dsh-moa 0.2.39 → 0.2.41

package/lib/history.js

@@ -41,7 +41,6 @@ export function getDefaultHistoryFile() {
   return path.join(getDefaultHistoryDir(), 'moa-history.jsonl')
 }
 
-
 /** Max history file size before rotation (10 MB) */
 export const MAX_HISTORY_BYTES = 10 * 1024 * 1024
 
@@ -77,6 +76,7 @@ export function rotateHistoryFileIfNeeded(filePath = getDefaultHistoryFile(), ma
 
 /**
  * Prepares a normalized history record entry.
+ * Preserves candidate persona, temperature, fallback, testResult, and slot details (#169).
  */
 function normalizeRunRecord(record) {
   return {
@@ -87,18 +87,31 @@ function normalizeRunRecord(record) {
     isRefinement: Boolean(record.isRefinement),
     isFastMode: Boolean(record.isFastMode),
     candidates: Array.isArray(record.candidates)
-      ? record.candidates.map((c) => ({
-          provider: c.provider || '',
-          model: c.model || '',
+      ? record.candidates.map((c, idx) => ({
+          index: typeof c.index === 'number' ? c.index : (idx + 1),
+          provider: c.provider || c.slot?.provider || '',
+          model: c.model || c.slot?.model || '',
+          slot: c.slot ? { provider: c.slot.provider, model: c.slot.model } : (c.provider && c.model ? { provider: c.provider, model: c.model } : undefined),
+          role: c.role || c.role_persona || 'general',
+          temperature: typeof c.temperature === 'number' ? c.temperature : undefined,
+          wasFallback: Boolean(c.wasFallback || c.was_fallback),
+          originalModel: c.originalModel || c.original_model || null,
           filesCount: Array.isArray(c.files) ? c.files.length : (c.filesCount || 0),
+          files: Array.isArray(c.files) ? c.files : undefined,
           usage: c.usage || { inputTokens: 0, outputTokens: 0 },
           costUsd: Number(c.costUsd || 0),
+          testResult: c.testResult ? {
+            passed: Boolean(c.testResult.passed),
+            exitCode: c.testResult.exitCode ?? 0,
+            summary: c.testResult.summary || '',
+            durationMs: c.testResult.durationMs ?? 0,
+          } : null,
         }))
       : [],
     aggregator: record.aggregator
       ? {
-          provider: record.aggregator.provider || '',
-          model: record.aggregator.model || '',
+          provider: record.aggregator.provider || record.aggregator.slot?.provider || '',
+          model: record.aggregator.model || record.aggregator.slot?.model || '',
           usage: record.aggregator.usage || { inputTokens: 0, outputTokens: 0 },
           costUsd: Number(record.aggregator.costUsd || 0),
         }
@@ -162,6 +175,7 @@ export async function recordMoaRunAsync(record, filePath = getDefaultHistoryFile
 /**
  * Reads lines from the end of a file in reverse order in chunks.
  * Avoids loading multi-megabyte JSONL files into V8 heap strings.
+ * Buffer-safe: never splits multi-byte UTF-8 sequences at chunk boundaries (#184).
  */
 export function readTailLinesSync(filePath, countNeeded = 50) {
   const CHUNK_SIZE = 64 * 1024
@@ -169,7 +183,7 @@ export function readTailLinesSync(filePath, countNeeded = 50) {
   try {
     const stat = fs.fstatSync(fd)
     let pos = stat.size
-    let remainder = ''
+    let remainderBuf = Buffer.alloc(0)
     const collectedLines = []
 
     while (pos > 0 && collectedLines.length < countNeeded) {
@@ -177,29 +191,107 @@ export function readTailLinesSync(filePath, countNeeded = 50) {
       pos -= bytesToRead
       const buf = Buffer.alloc(bytesToRead)
       fs.readSync(fd, buf, 0, bytesToRead, pos)
-      const chunkStr = buf.toString('utf8') + remainder
-      const lines = chunkStr.split('\n')
-      if (pos > 0) {
-        remainder = lines.shift()
-      } else {
-        remainder = ''
+      const totalBuf = remainderBuf.length > 0 ? Buffer.concat([buf, remainderBuf]) : buf
+
+      let endIdx = totalBuf.length
+      for (let i = totalBuf.length - 1; i >= 0; i--) {
+        if (totalBuf[i] === 0x0A) {
+          if (i + 1 < endIdx) {
+            const lineBuf = totalBuf.subarray(i + 1, endIdx)
+            const lineStr = lineBuf.toString('utf8').trim()
+            if (lineStr) {
+              collectedLines.push(lineStr)
+              if (collectedLines.length >= countNeeded) break
+            }
+          }
+          endIdx = i
+        }
+      }
+
+      if (collectedLines.length >= countNeeded) {
+        remainderBuf = Buffer.alloc(0)
+        break
       }
 
-      for (let i = lines.length - 1; i >= 0; i--) {
-        const trimmed = lines[i].trim()
-        if (trimmed) {
-          collectedLines.push(trimmed)
-          if (collectedLines.length >= countNeeded) break
+      if (pos > 0) {
+        remainderBuf = totalBuf.subarray(0, endIdx)
+      } else {
+        if (endIdx > 0) {
+          const firstLineStr = totalBuf.subarray(0, endIdx).toString('utf8').trim()
+          if (firstLineStr && collectedLines.length < countNeeded) {
+            collectedLines.push(firstLineStr)
+          }
         }
+        remainderBuf = Buffer.alloc(0)
       }
     }
-    if (remainder && remainder.trim() && collectedLines.length < countNeeded) {
-      collectedLines.push(remainder.trim())
+
+    if (remainderBuf.length > 0 && collectedLines.length < countNeeded) {
+      const lineStr = remainderBuf.toString('utf8').trim()
+      if (lineStr) collectedLines.push(lineStr)
     }
+
     return collectedLines
   } finally {
-    fs.closeSync(fd)
+    try { fs.closeSync(fd) } catch { /* best effort */ }
+  }
+}
+
+/**
+ * Counts lines in a file by scanning for 0x0A newline bytes in chunks.
+ * Fast, memory-efficient, and caches result in _historyCache (#183).
+ */
+export function countFileLinesSync(filePath, stat) {
+  if (
+    _historyCache &&
+    _historyCache.filePath === filePath &&
+    _historyCache.mtimeMs === stat.mtimeMs &&
+    _historyCache.size === stat.size &&
+    typeof _historyCache.totalCount === 'number'
+  ) {
+    return _historyCache.totalCount
+  }
+
+  let count = 0
+  const fd = fs.openSync(filePath, 'r')
+  try {
+    const CHUNK_SIZE = 64 * 1024
+    const buf = Buffer.alloc(CHUNK_SIZE)
+    let pos = 0
+    let lastByte = 0
+    while (pos < stat.size) {
+      const bytesToRead = Math.min(CHUNK_SIZE, stat.size - pos)
+      fs.readSync(fd, buf, 0, bytesToRead, pos)
+      for (let i = 0; i < bytesToRead; i++) {
+        if (buf[i] === 0x0A) count++
+      }
+      lastByte = buf[bytesToRead - 1]
+      pos += bytesToRead
+    }
+    if (stat.size > 0 && lastByte !== 0x0A) {
+      count++
+    }
+  } finally {
+    try { fs.closeSync(fd) } catch { /* best effort */ }
   }
+
+  if (
+    !_historyCache ||
+    _historyCache.filePath !== filePath ||
+    _historyCache.mtimeMs !== stat.mtimeMs ||
+    _historyCache.size !== stat.size
+  ) {
+    _historyCache = {
+      filePath,
+      mtimeMs: stat.mtimeMs,
+      size: stat.size,
+      leaderboards: new Map(),
+      totalCount: count,
+    }
+  } else {
+    _historyCache.totalCount = count
+  }
+  return count
 }
 
 /**
@@ -220,6 +312,23 @@ export function getMoaHistory(limit = 20, offset = 0, filePath = getDefaultHisto
       const lines = raw.trim().split('\n').filter(Boolean)
       const total = lines.length
 
+      if (
+        !_historyCache ||
+        _historyCache.filePath !== filePath ||
+        _historyCache.mtimeMs !== stat.mtimeMs ||
+        _historyCache.size !== stat.size
+      ) {
+        _historyCache = {
+          filePath,
+          mtimeMs: stat.mtimeMs,
+          size: stat.size,
+          leaderboards: new Map(),
+          totalCount: total,
+        }
+      } else {
+        _historyCache.totalCount = total
+      }
+
       const sliced = lines
         .slice(Math.max(0, total - offset - limit), total - offset)
         .reverse()
@@ -250,7 +359,7 @@ export function getMoaHistory(limit = 20, offset = 0, filePath = getDefaultHisto
 
     let total = _historyCache?.totalCount
     if (typeof total !== 'number') {
-      total = tailLines.length >= needed ? Math.max(tailLines.length, Math.round(stat.size / 250)) : tailLines.length
+      total = tailLines.length < needed ? tailLines.length : countFileLinesSync(filePath, stat)
     }
 
     return { total, runs }
@@ -263,6 +372,7 @@ export function getMoaHistory(limit = 20, offset = 0, filePath = getDefaultHisto
 /**
  * Calculates win-rate leaderboard and model performance statistics across history.
  * Employs in-memory caching keyed by file mtime and size for O(1) repeated queries.
+ * Robust matching for aliases, fallbacks, and winnerIndex (#185).
  */
 export function getMoaLeaderboard(filePath = getDefaultHistoryFile(), options = {}) {
   try {
@@ -307,10 +417,15 @@ export function getMoaLeaderboard(filePath = getDefaultHistoryFile(), options =
         if (presetFilter && presetFilter !== 'all' && item.preset !== presetFilter) continue
         filteredRuns++
 
-        const winner = item.winnerModel ? String(item.winnerModel).trim() : null
+        const rawWinner = item.winnerModel ? String(item.winnerModel).trim() : null
+        const cleanWinner = rawWinner ? rawWinner.replace(/\s*\[fallback for .*\]$/i, '').trim() : null
+        const normWinner = cleanWinner && cleanWinner !== 'none' && cleanWinner !== 'unknown'
+          ? cleanWinner.replace(/[\/:]/g, ':').toLowerCase()
+          : null
 
         if (Array.isArray(item.candidates)) {
-          for (const cand of item.candidates) {
+          for (let candIdx = 0; candIdx < item.candidates.length; candIdx++) {
+            const cand = item.candidates[candIdx]
             const key = cand.provider && cand.model ? `${cand.provider}:${cand.model}` : (cand.model || 'unknown')
             if (!modelStats.has(key)) {
               modelStats.set(key, {
@@ -326,12 +441,25 @@ export function getMoaLeaderboard(filePath = getDefaultHistoryFile(), options =
             const st = modelStats.get(key)
             st.runs += 1
 
-            const inTok = cand.usage?.inputTokens || 0
-            const outTok = cand.usage?.outputTokens || 0
+            const inTok = cand.usage?.inputTokens ?? cand.usage?.totalInputTokens ?? cand.usage?.prompt_tokens ?? 0
+            const outTok = cand.usage?.outputTokens ?? cand.usage?.totalOutputTokens ?? cand.usage?.completion_tokens ?? 0
             st.totalTokens += inTok + outTok
             st.totalCostUsd += Number(cand.costUsd || 0)
 
-            if (winner && cand.model && (winner === key || winner === cand.model)) {
+            let isWin = false
+            if (normWinner) {
+              const normKey = key.replace(/[\/:]/g, ':').toLowerCase()
+              const normModel = String(cand.model || '').replace(/[\/:]/g, ':').toLowerCase()
+              if (normWinner === normKey || normWinner === normModel || normWinner.endsWith(`:${normModel}`)) {
+                isWin = true
+              }
+            }
+            if (!isWin && typeof item.winnerIndex === 'number' && item.winnerIndex > 0) {
+              if (cand.index === item.winnerIndex || candIdx === item.winnerIndex - 1) {
+                isWin = true
+              }
+            }
+            if (isWin) {
               st.wins += 1
             }
           }
@@ -433,22 +561,27 @@ export function exportMoaHistory(filePath = getDefaultHistoryFile(), options = {
   }
 }
 
+/**
+ * Formats candidate outputs for history storage (#169).
+ */
 export function candidatesForHistory(referenceOutputs) {
-  return (referenceOutputs || []).map((r) => ({
-    provider: r.slot?.provider || "",
-    model: r.slot?.model || "",
+  return (referenceOutputs || []).map((r, i) => ({
+    index: r.index ?? (i + 1),
+    provider: r.slot?.provider || r.provider || "",
+    model: r.slot?.model || r.model || "",
+    slot: r.slot ? { provider: r.slot.provider, model: r.slot.model } : undefined,
     role: r.role_persona || r.slot?.role_persona || r.slot?.role || "general",
     temperature: r.temperature,
     wasFallback: Boolean(r.was_fallback),
     originalModel: r.original_model || null,
-    files: (r.files || []).map((f) => f.relativePath),
+    files: (r.files || []).map((f) => f.relativePath || f),
     usage: r.usage || { inputTokens: 0, outputTokens: 0 },
     costUsd: r.costUsd || 0,
     testResult: r.testResult ? {
-      passed: r.testResult.passed,
-      exitCode: r.testResult.exitCode,
-      summary: r.testResult.summary,
-      durationMs: r.testResult.durationMs,
+      passed: Boolean(r.testResult.passed),
+      exitCode: r.testResult.exitCode ?? 0,
+      summary: r.testResult.summary || '',
+      durationMs: r.testResult.durationMs ?? 0,
     } : null,
   }))
 }

package/lib/index.js

@@ -17,6 +17,7 @@ import { registerMoaRoutes } from './routes.js'
 import { resolvePresetForPrompt } from './moa-router.js'
 import { createLiveCanvasClient } from './live-canvas.js'
 import { registerPluginUpdater } from './updater.js'
+import { bestEffort } from './best-effort.js'
 
 export const name = '@goodandready/dsh-moa'
 export { collectProjectContext, formatProjectContext } from './file-workspace.js'
@@ -38,7 +39,11 @@ export function apply(ctx, config) {
 
   let localOverrides = null
   const getSourceConfig = () => {
-    const liveSource = plainConfig(ctx.config ?? config ?? {})
+    let liveCandidate = ctx.fiber?.config
+    if (!liveCandidate && ('config' in ctx)) {
+      bestEffort('ctx.config probe', () => { liveCandidate = ctx.config }, ctx.logger)
+    }
+    const liveSource = plainConfig(liveCandidate ?? config ?? {})
     return localOverrides ? { ...liveSource, ...localOverrides } : liveSource
   }
   const live = () => {
@@ -110,7 +115,7 @@ export function apply(ctx, config) {
     Config,
     plainConfig,
     webServerPort: ctx.webServer?.port,
-    timeMachineEngine: ctx.get?.('timeMachineEngine') || ctx.timeMachineEngine,
+    timeMachineEngine: ctx.reflect?.get?.('timeMachineEngine', false),
   })
 
   // Session turn interceptor: route turn to real aggregator model & stream MoA synthesis
@@ -207,7 +212,7 @@ export function apply(ctx, config) {
             prices: cfg.prices || {},
             liveCanvas,
             webServerPort: ctx.webServer?.port,
-            timeMachineEngine: ctx.get?.('timeMachineEngine') || ctx.timeMachineEngine,
+            timeMachineEngine: ctx.reflect?.get?.('timeMachineEngine', false),
           }
 
           if (event.signal) {

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

@@ -402,6 +402,8 @@ export async function runMoAPipeline({
       userPrompt,
       callLlm,
       strategy: preset.judge_voting_strategy || 'majority',
+      prices: prices || {},
+      blind: Boolean(preset.blind_evaluation),
       signal,
       onProgress,
     })
@@ -409,7 +411,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
@@ -512,7 +514,7 @@ export async function runMoAPipeline({
 
   const livePreview = await createPromotedPreview(liveCanvas, cwd, promotedFiles, referenceOutputs)
   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 +534,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),
     })
   }

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 }
 }

package/lib/routes.js

@@ -333,7 +333,7 @@ ctx.effect(() => {
             runId,
             keepMoa: true,
             port: ctx.webServer?.port,
-            timeMachineEngine: ctx.get?.('timeMachineEngine') || ctx.timeMachineEngine,
+            timeMachineEngine: timeMachineEngine || ctx.reflect?.get?.('timeMachineEngine', false),
             force: Boolean(body?.force),
           })
           writeJson(res, 200, { ok: true, candidateIndex, promotedFiles, checkpoint: promotedFiles?.checkpoint || null })
@@ -571,7 +571,7 @@ ctx.effect(() => {
             userPrompt: prompt, messages: payload.messages || [], preset, callLlm,
             cwd: payload.cwd || process.cwd(), prices: cfg.prices || {}, liveCanvas,
             webServerPort: webServerPort || ctx.webServer?.port,
-            timeMachineEngine: timeMachineEngine || ctx.get?.('timeMachineEngine') || ctx.timeMachineEngine,
+            timeMachineEngine: timeMachineEngine || ctx.reflect?.get?.('timeMachineEngine', false),
             timeMachineUrl: payload.timeMachineUrl, force: payload.force,
             checkpoint: payload.checkpoint, checkpointFn: payload.checkpointFn,
           })

package/package.json

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