@goodandready/dsh-moa 0.2.25 → 0.2.27

package/lib/moa-candidates.js

@@ -1,5 +1,6 @@
 /**
  * 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 +30,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 +89,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 +105,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 +134,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) {
+              console.warn(`[dsh-moa] Fallback ${fbLabel} also failed:`, fbErr?.message || fbErr)
+            }
+          }
+        }
+
+        if (!fallbackRecovered) {
+          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`)
+          }
+          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

@@ -57,6 +57,12 @@ export const ROLE_PERSONA_PROMPTS = {
   general: '',
 }
 
+export const TEST_GATE_DIRECTIVE = `### 🧪 Test Execution Gate Directive:
+Some or all candidates were evaluated by executing real project tests against their sandbox implementations.
+CRITICAL JUDGE DIRECTIVE: Test execution results are empirical ground truth.
+- A candidate whose code passes all tests (PASS) must be strongly favored over candidates whose code causes test failures or exceptions (FAIL).
+- If a candidate with test failures is chosen due to significantly superior architecture, you MUST explicitly identify and repair the failing test/code in your final synthesis deliverable.`
+
 export const SYNTAX_CORRECTION_DIRECTIVE = `### ⚠️ Syntax Warning & Auto-Fix Directive:
 Some candidate proposals have detected syntax flaws (annotated with [⚠️ Syntax Warning]).
 CRITICAL JUDGE DIRECTIVE: If a candidate with a syntax flaw presents superior architecture, algorithm, or engineering logic compared to other candidates, DO NOT reject them solely for this syntax flaw!
@@ -235,10 +241,14 @@ export function buildCuratorSynthesisPrompt(userPrompt, referenceOutputs = [], j
       const role = r.role_persona || r.slot?.role_persona || r.role || r.slot?.role
       const roleNote = role && role !== 'general' ? ` [Focus: ${role}]` : ''
       const syntaxNote = r.syntaxWarning ? ` [⚠️ Syntax Warning: ${r.syntaxWarning}]` : ''
+      const testNote = r.testResult ? ` [🧪 Test Gate: ${r.testResult.summary}]` : ''
       const header = isBlind
-        ? `Candidate ${i + 1}${roleNote}:${syntaxNote}${fileSummary}`
-        : `Candidate ${i + 1} — ${r.label}${roleNote}:${syntaxNote}${fileSummary}`
-      return `${header}\n${textContent}`
+        ? `Candidate ${i + 1}${roleNote}:${syntaxNote}${testNote}${fileSummary}`
+        : `Candidate ${i + 1} — ${r.label}${roleNote}:${syntaxNote}${testNote}${fileSummary}`
+      const testReport = r.testResult
+        ? `\n\n[🧪 Test Execution Gate Report]:\n- Status: ${r.testResult.passed ? 'PASSED ✅' : 'FAILED ❌'} (Exit code: ${r.testResult.exitCode})\n- Duration: ${r.testResult.durationMs}ms\n- Output:\n\`\`\`\n${r.testResult.output}\n\`\`\``
+        : ''
+      return `${header}\n${textContent}${testReport}`
     })
     .join('\n\n')
 
@@ -258,6 +268,7 @@ ${joined}
 ${ANTIPATTERNS_RUBRIC}
 
 ${LANGUAGE_MIRRORING_DIRECTIVE}
+${referenceOutputs.some((r) => r.testResult) ? `\n${TEST_GATE_DIRECTIVE}\n` : ''}
 ${referenceOutputs.some((r) => r.syntaxWarning) ? `
 ${SYNTAX_CORRECTION_DIRECTIVE}
 ` : ''}
@@ -304,10 +315,14 @@ export function buildSynthesisPrompt(userPrompt, referenceOutputs = [], judgeCri
       const role = r.role_persona || r.slot?.role_persona || r.role || r.slot?.role
       const roleNote = role && role !== 'general' ? ` [Focus: ${role}]` : ''
       const syntaxNote = r.syntaxWarning ? ` [⚠️ Syntax Warning: ${r.syntaxWarning}]` : ''
+      const testNote = r.testResult ? ` [🧪 Test Gate: ${r.testResult.summary}]` : ''
       const header = isBlind
-        ? `Reference ${i + 1}${roleNote}:${syntaxNote}${fileSummary}`
-        : `Reference ${i + 1} — ${r.label}${roleNote}:${syntaxNote}${fileSummary}`
-      return `${header}\n${textContent}`
+        ? `Reference ${i + 1}${roleNote}:${syntaxNote}${testNote}${fileSummary}`
+        : `Reference ${i + 1} — ${r.label}${roleNote}:${syntaxNote}${testNote}${fileSummary}`
+      const testReport = r.testResult
+        ? `\n\n[🧪 Test Execution Gate Report]:\n- Status: ${r.testResult.passed ? 'PASSED ✅' : 'FAILED ❌'} (Exit code: ${r.testResult.exitCode})\n- Duration: ${r.testResult.durationMs}ms\n- Output:\n\`\`\`\n${r.testResult.output}\n\`\`\``
+        : ''
+      return `${header}\n${textContent}${testReport}`
     })
     .join('\n\n')
 
@@ -326,7 +341,11 @@ ${joined}
 ${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: