@goodandready/dsh-moa 0.2.26 → 0.2.29

package/lib/moa-candidates.js

@@ -1,5 +1,7 @@
+import { logger } from './logger.js'
 /**
  * DeepSeek Harness Mixture of Agents (MoA) — Candidate Fan-Out & Retry
+ * With Per-Candidate Temperature, Temperature Gradient & Local Fallback Resilience
  */
 
 import { bestEffort } from './best-effort.js'
@@ -29,7 +31,8 @@ export async function callWithTransientRetry(callLlmFn, callArgs, maxRetries = 0
 }
 
 /**
- * Dispatches queries to all reference models in parallel with transient retry and quorum straggler mitigation.
+ * Dispatches queries to all reference models in parallel with transient retry,
+ * per-candidate temperature / gradient exploration, local fallback, and quorum mitigation.
  */
 export async function runReferencesParallel(references, messages, options = {}, callLlm, onProgress) {
   if (!Array.isArray(references) || references.length === 0) {
@@ -87,6 +90,14 @@ export async function runReferencesParallel(references, messages, options = {},
       : ''
     const slotMessages = [{ role: 'system', content: systemPrompt + persona }, ...advisoryMessages]
 
+    // Feature 7: Per-candidate temperature or temperature gradient
+    let effectiveTemperature = options.temperature ?? 0.6
+    if (typeof slot.temperature === 'number' && slot.temperature >= 0) {
+      effectiveTemperature = slot.temperature
+    } else if (options.temperature_gradient_enabled && total > 1) {
+      effectiveTemperature = Number((0.2 + (0.7 * i) / (total - 1)).toFixed(2))
+    }
+
     const runOne = async () => {
       try {
         const callPromise = callWithTransientRetry(
@@ -95,7 +106,7 @@ export async function runReferencesParallel(references, messages, options = {},
             provider: slot.provider,
             model: slot.model,
             messages: slotMessages,
-            temperature: options.temperature ?? 0.6,
+            temperature: effectiveTemperature,
             maxTokens: options.maxTokens ?? 4096,
             timeoutMs,
             signal: abortControllers[i].signal,
@@ -124,38 +135,96 @@ export async function runReferencesParallel(references, messages, options = {},
         const costInfo = estimateTokenCost(slot, fallbackUsage, options.prices)
 
         finishedCount++
-        if (typeof onProgress === 'function') {
-          const costStr = costInfo.costUsd > 0 ? ` (~\$${costInfo.costUsd.toFixed(4)})` : ''
-          onProgress(`✅ *Candidate ${i + 1}/${total} (${label}) finished${costStr}*\n`)
-        }
-
         results[i] = {
           index: i + 1,
           slot,
           label,
           role_persona: role,
+          temperature: effectiveTemperature,
           text,
           usage: costInfo,
           costUsd: costInfo.costUsd,
           ok: true,
         }
-      } catch (err) {
-        finishedCount++
-        const errMsg = err?.message || String(err)
-        console.warn(`[dsh-moa] Reference ${label} failed:`, errMsg)
+
         if (typeof onProgress === 'function') {
-          onProgress(`⚠️ *Candidate ${i + 1}/${total} (${label}) error: ${errMsg}*\n`)
+          const costStr = costInfo.costUsd > 0 ? ` (~\$${costInfo.costUsd.toFixed(4)})` : ''
+          const currentTotalCost = results.reduce((sum, r) => sum + (r?.costUsd || 0), 0)
+          onProgress(`✅ *Candidate ${i + 1}/${total} (${label}, T=${effectiveTemperature}) finished${costStr}* | Live total: ~\$${currentTotalCost.toFixed(4)}\n`)
         }
-        results[i] = {
-          index: i + 1,
-          slot,
-          label,
-          role_persona: role,
-          text: `[Model ${label} error: ${errMsg}]`,
-          usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0 },
-          costUsd: 0,
-          ok: false,
-          error: errMsg,
+      } catch (err) {
+        // Feature 10: Local fallback models if online candidate fails
+        let fallbackRecovered = false
+        if (options.local_fallback_enabled && Array.isArray(options.local_fallback_models) && options.local_fallback_models.length > 0) {
+          for (const fbSlot of options.local_fallback_models) {
+            const fbLabel = slotLabel(fbSlot)
+            try {
+              if (typeof onProgress === 'function') {
+                onProgress(`🔄 *Candidate ${i + 1} (${label}) failed, attempting local fallback to ${fbLabel}...*\n`)
+              }
+              const fbRes = await callWithTransientRetry(
+                callLlm,
+                {
+                  provider: fbSlot.provider,
+                  model: fbSlot.model,
+                  messages: slotMessages,
+                  temperature: effectiveTemperature,
+                  maxTokens: options.maxTokens ?? 4096,
+                  timeoutMs,
+                  signal: abortControllers[i].signal,
+                },
+                0
+              )
+              const fbText = typeof fbRes === 'string' ? fbRes : (fbRes?.content || fbRes?.text || '')
+              const fbUsage = (typeof fbRes === 'object' && fbRes?.usage) ? fbRes.usage : {
+                inputTokens: Math.max(1, Math.round(slotMessages.map((m) => m.content).join('').length / 4)),
+                outputTokens: Math.max(1, Math.round(fbText.length / 4)),
+              }
+              const fbCost = estimateTokenCost(fbSlot, fbUsage, options.prices)
+              finishedCount++
+              results[i] = {
+                index: i + 1,
+                slot: fbSlot,
+                label: `${fbLabel} [fallback for ${label}]`,
+                role_persona: role,
+                temperature: effectiveTemperature,
+                text: fbText,
+                usage: fbCost,
+                costUsd: fbCost.costUsd,
+                ok: true,
+                was_fallback: true,
+                original_model: label,
+              }
+              fallbackRecovered = true
+              if (typeof onProgress === 'function') {
+                onProgress(`✅ *Candidate ${i + 1}/${total} recovered using fallback (${fbLabel})*\n`)
+              }
+              break
+            } catch (fbErr) {
+              logger.warn(`[dsh-moa] Fallback ${fbLabel} also failed:`, fbErr?.message || fbErr)
+            }
+          }
+        }
+
+        if (!fallbackRecovered) {
+          finishedCount++
+          const errMsg = err?.message || String(err)
+          logger.warn(`[dsh-moa] Reference ${label} failed:`, errMsg)
+          if (typeof onProgress === 'function') {
+            onProgress(`⚠️ *Candidate ${i + 1}/${total} (${label}) error: ${errMsg}*\n`)
+          }
+          results[i] = {
+            index: i + 1,
+            slot,
+            label,
+            role_persona: role,
+            temperature: effectiveTemperature,
+            text: `[Model ${label} error: ${errMsg}]`,
+            usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0 },
+            costUsd: 0,
+            ok: false,
+            error: errMsg,
+          }
         }
       } finally {
         notifyFinished()

package/lib/moa-context.js

@@ -0,0 +1,70 @@
+/**
+ * Multi-Turn Conversation Memory & Context Pruning
+ * Feature 8 (Multi-Turn Continuity)
+ */
+
+/**
+ * Extracts concise prior turn baseline from previous conversation messages.
+ */
+export function extractPriorTurnBaseline(messages = []) {
+  if (!Array.isArray(messages) || messages.length === 0) return null
+
+  // Find the last assistant message
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i]
+    if (msg?.role === 'assistant' && typeof msg?.content === 'string') {
+      const text = msg.content.trim()
+      if (text.length > 0) {
+        // Strip out noisy banners if present
+        const cleaned = text
+          .replace(/^#+\s*🏆[^\n]+\n/m, '')
+          .replace(/<!--\s*moa-metadata[\s\S]*?-->/g, '')
+          .trim()
+        return cleaned.slice(0, 3500)
+      }
+    }
+  }
+  return null
+}
+
+/**
+ * Prunes conversation history for candidate fan-out to prevent token ballooning
+ * while preserving multi-turn context continuity.
+ */
+export function pruneMultiTurnMessages(messages = [], maxHistoryTokens = 3000) {
+  if (!Array.isArray(messages) || messages.length <= 2) {
+    return messages || []
+  }
+
+  const pruned = []
+  const sysMsg = messages.find((m) => m && m.role === 'system')
+  if (sysMsg) {
+    pruned.push(sysMsg)
+  }
+
+  // Get conversation turns excluding system
+  const nonSys = messages.filter((m) => m && m.role !== 'system')
+  if (nonSys.length === 0) return pruned
+
+  // Always keep the final 2 turns (last user and prior assistant)
+  const recentTurns = nonSys.slice(-4)
+
+  for (let idx = 0; idx < recentTurns.length; idx++) {
+    const msg = recentTurns[idx]
+    const isLatest = idx === recentTurns.length - 1
+    const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)
+
+    if (isLatest || content.length < 800) {
+      pruned.push(msg)
+    } else {
+      // Prune long prior assistant or user text to protect candidate context
+      const truncated = content.slice(0, 750) + '\n\n[...context pruned for token efficiency...]\n' + content.slice(-250)
+      pruned.push({
+        role: msg.role,
+        content: truncated,
+      })
+    }
+  }
+
+  return pruned
+}

package/lib/moa-multi-judge.js

@@ -0,0 +1,301 @@
+/**
+ * Multi-Judge Panel Consensus Voting & Composite Hybrid Synthesis
+ * Feature 2 (Multi-Judge Panel) & Feature 3 (Composite Block Synthesis)
+ */
+
+import { slotLabel } from './moa-prompts.js'
+
+/**
+ * Extracts code fences and block-level assets from markdown text.
+ */
+export function extractCodeBlocks(text = '') {
+  if (!text || typeof text !== 'string') return []
+  const blocks = []
+  const regex = /```([a-zA-Z0-9_\-\.\/:]+)?(?:\s+(?:file|path|filename)=([^\s\n]+))?\n([\s\S]*?)```/g
+  let match
+  while ((match = regex.exec(text)) !== null) {
+    const rawTag = (match[1] || '').trim()
+    const explicitFile = (match[2] || '').trim()
+    let lang = rawTag
+    let filename = explicitFile
+
+    // Handle ```ts:src/app.ts or ```typescript:app.ts
+    if (rawTag.includes(':')) {
+      const parts = rawTag.split(':')
+      lang = parts[0]
+      filename = parts.slice(1).join(':')
+    } else if (rawTag.includes('/') || rawTag.includes('.')) {
+      filename = rawTag
+    }
+
+    blocks.push({
+      lang: lang || 'text',
+      filename: filename || null,
+      code: match[3],
+      fullBlock: match[0],
+    })
+  }
+  return blocks
+}
+
+/**
+ * Builds composite block directives highlighting complementary modules across candidates.
+ */
+export function buildCompositeBlockDirectives(candidates = []) {
+  const fileMap = new Map()
+
+  for (const c of candidates) {
+    if (!c.ok || !c.text) continue
+    const blocks = extractCodeBlocks(c.text)
+    for (const b of blocks) {
+      if (b.filename) {
+        if (!fileMap.has(b.filename)) {
+          fileMap.set(b.filename, [])
+        }
+        fileMap.get(b.filename).push(c.label || `Candidate ${c.index}`)
+      }
+    }
+  }
+
+  let fileOverview = ''
+  if (fileMap.size > 0) {
+    fileOverview = '\nDetected modular file contributions across candidates:\n' +
+      Array.from(fileMap.entries())
+        .map(([file, contributors]) => `- \`${file}\`: available in ${contributors.join(', ')}`)
+        .join('\n') + '\n'
+  }
+
+  return `
+=== COMPOSITE HYBRID SYNTHESIS DIRECTIVE ===
+You must synthesize a unified, best-of-all-worlds composite solution from all candidates.
+Do NOT simply copy one candidate. Instead:
+1. Extract the cleanest and most efficient core logic/algorithm (e.g. from the candidate with the highest reasoning score).
+2. Incorporate defensive error handling, input validation, and edge-case guards.
+3. Retain complete type annotations, utility helpers, and test coverage provided by any candidate.
+4. Ensure all merged modules, functions, and files fit together into a cohesive, non-conflicting solution.
+${fileOverview}============================================
+`
+}
+
+/**
+ * Parses judge output into structured scores and candidate choice.
+ */
+export function parseJudgeEvaluation(rawText = '', candidateCount = 2) {
+  const scores = {}
+  let bestCandidate = 1
+  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)) {
+      scores[idx] = Math.min(10, Math.max(0, val))
+    }
+  }
+
+  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) {
+      bestCandidate = parsedBest
+    }
+  } else {
+    // Find candidate with max parsed score
+    let maxScore = -1
+    for (const [idxStr, s] of Object.entries(scores)) {
+      if (s > maxScore) {
+        maxScore = s
+        bestCandidate = parseInt(idxStr, 10)
+      }
+    }
+  }
+
+  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.
+ */
+export async function executeMultiJudgePanel({
+  judges = [],
+  candidates = [],
+  userPrompt = '',
+  callLlm,
+  strategy = 'majority', // 'majority' | 'highest_score' | 'unanimous'
+  timeoutMs = 45000,
+  signal,
+  onProgress,
+}) {
+  const activeCandidates = (candidates || []).filter((c) => c && c.ok)
+  if (activeCandidates.length === 0) {
+    return {
+      consensus: false,
+      winningCandidateIndex: 1,
+      strategy,
+      reason: 'no_active_candidates',
+    }
+  }
+
+  if (activeCandidates.length === 1) {
+    return {
+      consensus: true,
+      winningCandidateIndex: activeCandidates[0].index,
+      winningCandidateLabel: activeCandidates[0].label,
+      strategy,
+      reason: 'single_active_candidate',
+    }
+  }
+
+  const judgeSlots = Array.isArray(judges) && judges.length > 0
+    ? judges
+    : [{ provider: 'default', model: 'aggregator-judge', label: 'Primary Judge' }]
+
+  const candidateSummary = activeCandidates.map((c) => {
+    return `### Candidate ${c.index} (${c.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)}
+
+Candidate Solutions:
+${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.
+
+Your response MUST follow this exact format:
+SCORES:
+${activeCandidates.map((c) => `Candidate ${c.index}: [1-10]`).join('\n')}
+BEST_CANDIDATE: [index number]
+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)
+    try {
+      const abortCtrl = new AbortController()
+      if (signal) {
+        signal.addEventListener('abort', () => abortCtrl.abort(), { once: true })
+      }
+      const timer = setTimeout(() => abortCtrl.abort(new Error('Judge evaluation timeout')), timeoutMs)
+      timer.unref?.()
+
+      const res = await callLlm({
+        provider: judge.provider,
+        model: judge.model,
+        messages: [
+          { role: 'system', content: 'You are an objective expert judge in an ensemble evaluation system.' },
+          { 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)
+
+      return {
+        judgeIndex: jIdx + 1,
+        judgeLabel: label,
+        ok: true,
+        ...evalResult,
+      }
+    } catch (err) {
+      return {
+        judgeIndex: jIdx + 1,
+        judgeLabel: label,
+        ok: false,
+        bestCandidate: 1,
+        scores: {},
+        reasoning: err?.message || String(err),
+      }
+    }
+  })
+
+  const results = await Promise.all(judgePromises)
+  const validResults = results.filter((r) => r.ok)
+
+  // 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
+    }
+  }
+
+  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
+  }
+
+  let winner = activeCandidates[0].index
+  let isUnanimous = false
+
+  if (strategy === 'highest_score') {
+    let highestAvg = -1
+    for (const c of activeCandidates) {
+      const avg = averageScores[c.index] || 0
+      if (avg > highestAvg) {
+        highestAvg = avg
+        winner = c.index
+      }
+    }
+  } 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
+      }
+    }
+    isUnanimous = (votes[winner] || 0) === validResults.length && validResults.length > 0
+  }
+
+  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}.`
+
+  if (typeof onProgress === 'function') {
+    onProgress(`🏁 *${consensusReport}*\n`)
+  }
+
+  return {
+    consensus: true,
+    winningCandidateIndex: winningCand.index,
+    winningCandidateLabel: winningCand.label,
+    strategy,
+    isUnanimous,
+    votes,
+    averageScores,
+    judgesResults: results,
+    consensusReport,
+  }
+}

package/lib/moa-prompts.js

@@ -343,6 +343,9 @@ ${ANTIPATTERNS_RUBRIC}
 ${LANGUAGE_MIRRORING_DIRECTIVE}
 ${referenceOutputs.some((r) => r.testResult) ? `\n${TEST_GATE_DIRECTIVE}\n` : ''}
 ${referenceOutputs.some((r) => r.syntaxWarning) ? `\n${SYNTAX_CORRECTION_DIRECTIVE}\n` : ''}
+${options.priorTurnBaseline ? `\n### 🔄 Prior Turn Context Baseline:\n${options.priorTurnBaseline}\n` : ''}
+${options.consensusReport ? `\n### ⚖️ Multi-Judge Consensus Advisory:\n${options.consensusReport}\n` : ''}
+${options.compositeMergeDirective ? `\n${options.compositeMergeDirective}\n` : ''}
 Instructions:
 Your response MUST be structured into three clear parts:
 

package/lib/moa-report.js

@@ -0,0 +1,124 @@
+/**
+ * Automated Benchmark & Post-Mortem PR Reports
+ * Feature 9 (Automated Benchmark & Post-Mortem PR Reports)
+ */
+
+export function generateMoABenchmarkReport({
+  runId = '',
+  timestamp = new Date().toISOString(),
+  preset = 'default',
+  prompt = '',
+  durationMs = 0,
+  usage = {},
+  costUsd = 0,
+  candidates = [],
+  winningIndex = 1,
+  winningLabel = '',
+  consensus = null,
+  testGate = null,
+  isComposite = false,
+}) {
+  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 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 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 score = consensus?.averageScores?.[c.index] !== undefined
+      ? `${consensus.averageScores[c.index]}/10`
+      : 'N/A'
+    const isWin = c.index === winningIndex ? ' 🏆' : ''
+    return `| ${idx}${isWin} | \`${label}\` | ${role} | ${status} | ${candTokens} | ${candCost} | ${score} |`
+  }).join('\n')
+
+  let testGateSection = '### 🧪 Automated Test Gate\n- **Status**: Not Configured / Skipped'
+  if (testGate && testGate.enabled) {
+    const tgStatus = testGate.passed ? '✅ PASSED' : '❌ FAILED'
+    testGateSection = `### 🧪 Automated Test Gate
+- **Status**: ${tgStatus}
+- **Test Command**: \`${testGate.command || 'N/A'}\`
+- **Exit Code**: \`${testGate.exitCode ?? 0}\`
+- **Output Snippet**:
+\`\`\`
+${(testGate.output || 'No output recorded').slice(0, 500)}
+\`\`\``
+  }
+
+  let consensusSection = '### ⚖️ Multi-Judge Consensus\n- **Status**: Standard single-aggregator synthesis'
+  if (consensus && consensus.consensus) {
+    consensusSection = `### ⚖️ Multi-Judge Consensus
+- **Winning Candidate**: Candidate ${winningIndex} (${winningLabel})
+- **Strategy**: \`${consensus.strategy || 'majority'}\`
+- **Unanimous**: ${consensus.isUnanimous ? 'Yes ✅' : 'No (Majority)'}
+- **Summary**: ${consensus.consensusReport || 'Consensus reached'}
+`
+  }
+
+  const markdown = `# 🏆 Mixture of Agents (MoA) Benchmark & Post-Mortem Report
+
+> **Run ID**: \`${runId}\`  
+> **Timestamp**: \`${timestamp}\`  
+> **Preset**: \`${preset}\`  
+> **Total Latency**: \`${durationSec}s\` | **Total Cost**: \`$${totalCost}\` | **Tokens**: \`${totalTokens}\` (In: ${inTokens}, Out: ${outTokens})
+
+---
+
+## 🎯 Task Prompt
+\`\`\`text
+${prompt.slice(0, 500)}${prompt.length > 500 ? '...' : ''}
+\`\`\`
+
+---
+
+## 📊 Candidate Models Benchmark Matrix
+| # | Model / Provider | Role | Status | Tokens | Cost | Judge Score |
+|---|------------------|------|--------|--------|------|-------------|
+${candidateRows || '| - | No candidate data | - | - | - | - | - |'}
+
+---
+
+${consensusSection}
+
+---
+
+${testGateSection}
+
+---
+
+### 🧬 Synthesis Mode
+- **Mode**: ${isComposite ? 'Composite Hybrid AST/Block Merge (Multi-Candidate Synthesis)' : `Candidate Selection (Winning model: ${winningLabel || 'Aggregator'})`}
+`
+
+  const json = {
+    runId,
+    timestamp,
+    preset,
+    prompt,
+    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,
+    })),
+    winningIndex,
+    winningLabel,
+    consensus,
+    testGate,
+    isComposite,
+  }
+
+  return { markdown, json }
+}