@goodandready/dsh-moa 0.2.71 → 0.2.73

package/lib/pipeline/context-pruner.js

@@ -0,0 +1,323 @@
+/**
+ * Cross-Candidate Unchanged Base Context Pruning (#305)
+ *
+ * Replaces large, mostly-unchanged candidate file blocks with compact unified diffs
+ * containing only modified hunks and a configurable number of context lines.
+ * This drastically cuts Judge prompt token overhead (often by 70-85%) on large files
+ * while preserving full context for winner promotion.
+ */
+
+import { computeLineDiff } from '../workspace/diff.js'
+import { isSafeRelativePath } from '../workspace/security.js'
+
+/**
+ * Extracts code blocks along with their raw Markdown text from candidate output.
+ *
+ * @param {string} text
+ * @returns {Array<{ relativePath: string, content: string, rawBlock: string }>}
+ */
+export function extractCandidateFileBlocks(text) {
+  if (!text || typeof text !== 'string') return []
+  const blocks = []
+  const seenPaths = new Set()
+
+  const patterns = [
+    /```[\w-]*\s+(?:file|path|filepath)=["']?([^\s"'\n\r]+)["']?[\r\n]+([\s\S]*?)```/gi,
+    /(?:\/\/|#|<!--)\s*(?:File|Path):\s*([^\s\n\r>]+)(?:\s*-->)?[\r\n]+```[\w-]*[\r\n]+([\s\S]*?)```/gi,
+    /#{1,4}\s+(?:File|Path):\s*([^\s\n\r]+)[\r\n]+```[\w-]*[\r\n]+([\s\S]*?)```/gi,
+    /```[\w-]*[\r\n]+(?:\/\/|#|<!--)\s*(?:File|Path):\s*([^\s\n\r>]+)(?:\s*-->)?[\r\n]+([\s\S]*?)```/gi,
+  ]
+
+  for (const regex of patterns) {
+    let match
+    while ((match = regex.exec(text)) !== null) {
+      const rawPath = match[1].trim()
+      if (rawPath && isSafeRelativePath(rawPath) && !seenPaths.has(rawPath)) {
+        seenPaths.add(rawPath)
+        blocks.push({
+          relativePath: rawPath,
+          content: match[2].trimEnd() + '\n',
+          rawBlock: match[0],
+        })
+      }
+    }
+  }
+
+  return blocks
+}
+
+
+/**
+ * Generates unified diff hunks from line diff items with a specified context window.
+ *
+ * @param {string} oldText - Original baseline file content
+ * @param {string} newText - Candidate's proposed file content
+ * @param {object} [options]
+ * @param {number} [options.contextLines=5] - Unchanged lines before and after changes
+ * @param {string} [options.filePath='file'] - Relative file path for header
+ * @returns {string} Standard unified diff representation
+ */
+export function generateUnifiedDiff(oldText = '', newText = '', options = {}) {
+  const { contextLines = 5, filePath = 'file' } = options
+  const trimmedOld = String(oldText || '').replace(/[\r\n]+$/, '')
+  const trimmedNew = String(newText || '').replace(/[\r\n]+$/, '')
+  if (trimmedOld === trimmedNew) return ''
+
+  const diffItems = computeLineDiff(trimmedOld, trimmedNew)
+  if (!diffItems || diffItems.length === 0) return ''
+
+  // Group diff items into hunks with contextLines
+  const changeIndices = []
+  for (let i = 0; i < diffItems.length; i++) {
+    if (diffItems[i].type !== 'same') {
+      changeIndices.push(i)
+    }
+  }
+
+  if (changeIndices.length === 0) return ''
+
+  // Cluster change ranges that are closer than 2 * contextLines
+  const clusters = []
+  let currentCluster = {
+    start: Math.max(0, changeIndices[0] - contextLines),
+    end: Math.min(diffItems.length - 1, changeIndices[0] + contextLines),
+  }
+
+  for (let k = 1; k < changeIndices.length; k++) {
+    const idx = changeIndices[k]
+    const nextStart = Math.max(0, idx - contextLines)
+    const nextEnd = Math.min(diffItems.length - 1, idx + contextLines)
+
+    if (nextStart <= currentCluster.end + 1) {
+      currentCluster.end = Math.max(currentCluster.end, nextEnd)
+    } else {
+      clusters.push(currentCluster)
+      currentCluster = { start: nextStart, end: nextEnd }
+    }
+  }
+  clusters.push(currentCluster)
+
+  const hunkOutputs = []
+  for (const cluster of clusters) {
+    const slice = diffItems.slice(cluster.start, cluster.end + 1)
+    let oldStart = null
+    let newStart = null
+    let oldCount = 0
+    let newCount = 0
+    const hunkLines = []
+
+    for (const item of slice) {
+      if (item.type === 'same') {
+        if (oldStart === null && item.oldNum !== undefined) oldStart = item.oldNum
+        if (newStart === null && item.newNum !== undefined) newStart = item.newNum
+        oldCount++
+        newCount++
+        hunkLines.push(` ${item.line}`)
+      } else if (item.type === 'removed') {
+        if (oldStart === null && item.oldNum !== undefined) oldStart = item.oldNum
+        oldCount++
+        hunkLines.push(`-${item.line}`)
+      } else if (item.type === 'added') {
+        if (newStart === null && item.newNum !== undefined) newStart = item.newNum
+        newCount++
+        hunkLines.push(`+${item.line}`)
+      }
+    }
+
+    const header = `@@ -${oldStart || 1},${oldCount} +${newStart || 1},${newCount} @@`
+    hunkOutputs.push([header, ...hunkLines].join('\n'))
+  }
+
+  const prefix = `--- a/${filePath}\n+++ b/${filePath}`
+  return `${prefix}\n${hunkOutputs.join('\n')}`
+}
+
+/**
+ * Checks whether a candidate's file output qualifies for context pruning.
+ *
+ * @param {string} originalText - Original file content
+ * @param {string} candidateText - Proposed file content
+ * @param {object} [options]
+ * @param {number} [options.minLines=25] - Minimum file length to consider pruning
+ * @param {number} [options.maxChangeRatio=0.65] - Maximum proportion of changed lines
+ * @returns {boolean}
+ */
+export function shouldPruneFile(originalText, candidateText, options = {}) {
+  const { minLines = 25, maxChangeRatio = 0.65 } = options
+  if (typeof originalText !== 'string' || typeof candidateText !== 'string') return false
+  const trimmedOld = originalText.replace(/[\r\n]+$/, '')
+  const trimmedNew = candidateText.replace(/[\r\n]+$/, '')
+  if (trimmedOld === trimmedNew) return false
+
+  const oldLines = trimmedOld.split(/\r?\n/)
+  if (oldLines.length < minLines) return false
+
+  const diffItems = computeLineDiff(trimmedOld, trimmedNew)
+  let changed = 0
+  for (const item of diffItems) {
+    if (item.type !== 'same') changed++
+  }
+
+  const ratio = changed / Math.max(1, diffItems.length)
+  return ratio > 0 && ratio <= maxChangeRatio
+}
+
+/**
+ * Prunes unmodified base context from a single candidate's Markdown output.
+ *
+ * @param {string} candidateText - Raw candidate text containing file blocks
+ * @param {Map<string, string>|Record<string, string>} baseFiles - Map of relative paths to baseline file contents
+ * @param {object} [options]
+ * @param {number} [options.contextLines=5]
+ * @param {number} [options.minLines=25]
+ * @returns {{ text: string, prunedFiles: string[], savedChars: number, originalChars: number }}
+ */
+export function pruneCandidateOutput(candidateText = '', baseFiles = {}, options = {}) {
+  if (typeof candidateText !== 'string' || !candidateText.trim()) {
+    return { text: candidateText, prunedFiles: [], savedChars: 0, originalChars: 0 }
+  }
+
+  const { contextLines = 5, minLines = 25 } = options
+  const baseMap = baseFiles instanceof Map
+    ? baseFiles
+    : new Map(Object.entries(baseFiles || {}))
+
+  if (baseMap.size === 0) {
+    return { text: candidateText, prunedFiles: [], savedChars: 0, originalChars: 0 }
+  }
+
+  const fileBlocks = extractCandidateFileBlocks(candidateText)
+  if (!Array.isArray(fileBlocks) || fileBlocks.length === 0) {
+    return { text: candidateText, prunedFiles: [], savedChars: 0, originalChars: 0 }
+  }
+
+  let prunedText = candidateText
+  const prunedFiles = []
+  let savedChars = 0
+
+  for (const block of fileBlocks) {
+    const relPath = block.relativePath || block.path
+    if (!relPath || !baseMap.has(relPath)) continue
+
+    const baseContent = baseMap.get(relPath)
+    if (!shouldPruneFile(baseContent, block.content, { minLines })) continue
+
+    const unifiedDiff = generateUnifiedDiff(baseContent, block.content, {
+      contextLines,
+      filePath: relPath,
+    })
+
+    if (!unifiedDiff) continue
+
+    const originalBlockText = block.rawBlock || block.block || `\`\`\`${block.language || ''}\n${block.content}\n\`\`\``
+    const replacementBlock = `\`\`\`diff\n// Unified diff patch for ${relPath} (context pruned)\n${unifiedDiff}\n\`\`\``
+
+    if (replacementBlock.length < originalBlockText.length) {
+      prunedText = prunedText.replace(originalBlockText, replacementBlock)
+      savedChars += (originalBlockText.length - replacementBlock.length)
+      prunedFiles.push(relPath)
+    }
+  }
+
+  return {
+    text: prunedText,
+    prunedFiles,
+    savedChars,
+    originalChars: candidateText.length,
+  }
+}
+
+/**
+ * Prunes unmodified context across all successful candidate outputs.
+ *
+ * @param {Array<object>} candidates - List of candidate response objects
+ * @param {Array<object>|Map<string, string>|Record<string, string>} projectFiles - Project context files
+ * @param {object} [options]
+ * @param {boolean} [options.enabled=true]
+ * @param {number} [options.contextLines=5]
+ * @returns {{ candidates: Array<object>, totalSavedChars: number, totalSavedTokens: number, prunedFiles: string[], isPruned: boolean }}
+ */
+export function pruneCandidateEnsemble(candidates = [], projectFiles = [], options = {}) {
+  const { enabled = true, contextLines = 5, minLines = 25 } = options
+  if (!enabled || !Array.isArray(candidates) || candidates.length === 0) {
+    return {
+      candidates,
+      totalSavedChars: 0,
+      totalSavedTokens: 0,
+      prunedFiles: [],
+      isPruned: false,
+    }
+  }
+
+  // Build base files map
+  const baseMap = new Map()
+  if (Array.isArray(projectFiles)) {
+    for (const f of projectFiles) {
+      if (f && f.path && typeof f.content === 'string') {
+        baseMap.set(f.path, f.content)
+      } else if (f && f.relativePath && typeof f.content === 'string') {
+        baseMap.set(f.relativePath, f.content)
+      }
+    }
+  } else if (projectFiles instanceof Map) {
+    for (const [k, v] of projectFiles.entries()) baseMap.set(k, v)
+  } else if (projectFiles && typeof projectFiles === 'object') {
+    for (const [k, v] of Object.entries(projectFiles)) baseMap.set(k, v)
+  }
+
+  if (baseMap.size === 0) {
+    return {
+      candidates,
+      totalSavedChars: 0,
+      totalSavedTokens: 0,
+      prunedFiles: [],
+      isPruned: false,
+    }
+  }
+
+  let totalSavedChars = 0
+  const allPrunedFiles = new Set()
+
+  const prunedCandidates = candidates.map((cand) => {
+    if (!cand || typeof cand.text !== 'string') return cand
+    const result = pruneCandidateOutput(cand.text, baseMap, { contextLines, minLines })
+    if (result.savedChars > 0) {
+      totalSavedChars += result.savedChars
+      result.prunedFiles.forEach((f) => allPrunedFiles.add(f))
+      return {
+        ...cand,
+        text: result.text,
+        prunedStats: {
+          savedChars: result.savedChars,
+          prunedFiles: result.prunedFiles,
+        },
+      }
+    }
+    return cand
+  })
+
+  const totalSavedTokens = Math.round(totalSavedChars / 4)
+  return {
+    candidates: prunedCandidates,
+    totalSavedChars,
+    totalSavedTokens,
+    prunedFiles: Array.from(allPrunedFiles),
+    isPruned: totalSavedChars > 0,
+  }
+}
+
+/**
+ * Emits a structured instruction directive for the Judge when context pruning was applied.
+ *
+ * @param {Array<string>} [prunedFiles=[]] - List of pruned file paths
+ * @param {number} [savedTokens=0] - Estimated token count saved
+ * @returns {string}
+ */
+export function formatPruningDirective(prunedFiles = [], savedTokens = 0) {
+  if (!Array.isArray(prunedFiles) || prunedFiles.length === 0) return ''
+  const fileList = prunedFiles.map((f) => `\`${f}\``).join(', ')
+  return `### Context Pruning Notice
+To minimize token bloat and accelerate evaluation, large baseline files with localized modifications (${fileList}) have been pruned into standard unified diff patches (---/+++ with context hunks).
+Evaluate the precision, correctness, and edge-case safety of the added and removed lines without penalizing candidates for using diff format.`
+}
+

package/lib/pipeline/context.js

@@ -38,6 +38,13 @@ export async function stageProjectContext({
   const isBlindEvaluation = Boolean(preset?.blind_evaluation)
   const isPeerCritiqueEnabled = Boolean(preset?.peer_critique_enabled)
   const allowCandidateOverride = Boolean(preset?.allow_candidate_override)
+  const localPreflightCheck = preset?.local_preflight_check !== false
+  const earlyExitConsensusEnabled = Boolean(preset?.early_exit_consensus_enabled)
+  const earlyExitThreshold = typeof preset?.early_exit_threshold === 'number' ? preset.early_exit_threshold : 0.95
+  const contextPruningEnabled = preset?.context_pruning_enabled !== false
+  const contextPruningDiffLines = typeof preset?.context_pruning_diff_lines === 'number' ? preset.context_pruning_diff_lines : 5
+  const semanticCacheEnabled = Boolean(preset?.semantic_cache_enabled)
+  const semanticCacheTtlHours = typeof preset?.semantic_cache_ttl_hours === 'number' ? preset.semantic_cache_ttl_hours : 168
 
   const collectedCtx = await collectProjectContext(cwd, 16000)
   const isRefinement = Boolean(collectedCtx?.files?.length > 0 && isRefinementTask(userPrompt, collectedCtx.files))
@@ -123,5 +130,9 @@ export async function stageProjectContext({
     allowCandidateOverride, collectedCtx, isRefinement, projectContext,
     effectiveReferences, quotaSubstitutions, priorTurnBaseline, candidateSystemPrompt,
     needsQuestions, enrichedMessages,
+    localPreflightCheck, earlyExitConsensusEnabled, earlyExitThreshold,
+    contextPruningEnabled, contextPruningDiffLines,
+    semanticCacheEnabled, semanticCacheTtlHours,
   }
 }
+

package/lib/pipeline/early-consensus.js

@@ -0,0 +1,324 @@
+/**
+ * Early Exit upon Semantic Consensus (#299)
+ * Detects convergence between reference candidates and bypasses judge round when consensus >= threshold.
+ * Saves up to 60-80% tokens and latency on requests where candidates converge.
+ */
+
+import { logger } from '../logger.js'
+import { promoteCandidateWorkspace, cleanMoaWorkspaces } from '../workspace/fs.js'
+import { createPromotedPreview } from '../live-canvas.js'
+import { recordMoaRunAsync, candidatesForHistory } from '../history.js'
+import { emitEvent, MOA_EVENTS } from '../events.js'
+import { estimateTokenCost } from '../pricing.js'
+
+/**
+ * Normalizes text/code by stripping comments and normalizing whitespace for consensus comparison.
+ * @param {string} text
+ * @returns {string}
+ */
+export function normalizeForConsensus(text = '') {
+  if (typeof text !== 'string') return ''
+  return text
+    // Strip block comments /* ... */
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    // Strip JS/TS single line comments // ...
+    .replace(/\/\/.*$/gm, '')
+    // Strip Python/Shell comments # ...
+    .replace(/(^|\s)#.*$/gm, '$1')
+    // Normalize newlines
+    .replace(/\r?\n/g, '\n')
+    // Collapse horizontal whitespace
+    .replace(/[ \t]+/g, ' ')
+    // Collapse multi-blank lines
+    .replace(/\n\s*\n/g, '\n')
+    .trim()
+}
+
+/**
+ * Calculates Sørensen-Dice similarity coefficient between two code/text snippets (0.0 to 1.0).
+ * @param {string} textA
+ * @param {string} textB
+ * @returns {number}
+ */
+export function calculateSimilarity(textA = '', textB = '') {
+  const normA = normalizeForConsensus(textA)
+  const normB = normalizeForConsensus(textB)
+
+  if (normA === normB) return 1.0
+  if (!normA || !normB) return 0.0
+
+  const tokensA = normA.match(/[\w$]+|[^\s\w]/g) || []
+  const tokensB = normB.match(/[\w$]+|[^\s\w]/g) || []
+
+  if (tokensA.length === 0 && tokensB.length === 0) return 1.0
+  if (tokensA.length === 0 || tokensB.length === 0) return 0.0
+
+  const freqA = new Map()
+  for (const t of tokensA) freqA.set(t, (freqA.get(t) || 0) + 1)
+
+  const freqB = new Map()
+  for (const t of tokensB) freqB.set(t, (freqB.get(t) || 0) + 1)
+
+  let intersection = 0
+  for (const [token, countA] of freqA.entries()) {
+    const countB = freqB.get(token) || 0
+    intersection += Math.min(countA, countB)
+  }
+
+  const dice = (2 * intersection) / (tokensA.length + tokensB.length)
+  return Number(dice.toFixed(4))
+}
+
+/**
+ * Checks if candidates have reached semantic consensus above threshold.
+ * @param {Array<object>} candidates
+ * @param {number} [threshold=0.95]
+ * @returns {{ reached: boolean, similarity: number, winnerIndex: number, consensusIndices: number[], winnerCandidate: object | null, reason: string }}
+ */
+export function checkSemanticConsensus(candidates = [], threshold = 0.95) {
+  if (!Array.isArray(candidates) || candidates.length < 2) {
+    return {
+      reached: false,
+      similarity: 0,
+      winnerIndex: 0,
+      consensusIndices: [],
+      winnerCandidate: null,
+      reason: 'Insufficient candidates for consensus check',
+    }
+  }
+
+  const n = candidates.length
+  let maxSim = 0
+  let bestPair = [0, 1]
+  const matrix = Array.from({ length: n }, () => new Float32Array(n))
+
+  for (let i = 0; i < n; i++) {
+    matrix[i][i] = 1.0
+    for (let j = i + 1; j < n; j++) {
+      const sim = calculateSimilarity(candidates[i].text || '', candidates[j].text || '')
+      matrix[i][j] = sim
+      matrix[j][i] = sim
+      if (sim > maxSim) {
+        maxSim = sim
+        bestPair = [i, j]
+      }
+    }
+  }
+
+  if (maxSim < threshold) {
+    return {
+      reached: false,
+      similarity: maxSim,
+      winnerIndex: 0,
+      consensusIndices: [],
+      winnerCandidate: null,
+      reason: `Max pairwise similarity ${maxSim} is below consensus threshold ${threshold}`,
+    }
+  }
+
+  // Find consensus cluster matching threshold with the best pair
+  const clusterSet = new Set(bestPair)
+  for (let k = 0; k < n; k++) {
+    if (k === bestPair[0] || k === bestPair[1]) continue
+    if (matrix[k][bestPair[0]] >= threshold && matrix[k][bestPair[1]] >= threshold) {
+      clusterSet.add(k)
+    }
+  }
+
+  const consensusIndices = Array.from(clusterSet).map((idx) => candidates[idx].index ?? idx)
+  const clusterCandidates = Array.from(clusterSet).map((idx) => candidates[idx])
+
+  // Select winner from consensus cluster (prioritize valid syntax, then lowest error count)
+  let winner = clusterCandidates[0]
+  for (const c of clusterCandidates) {
+    if (c.syntaxValidation?.valid && !winner.syntaxValidation?.valid) {
+      winner = c
+    }
+  }
+
+  return {
+    reached: true,
+    similarity: maxSim,
+    winnerIndex: winner.index ?? 1,
+    consensusIndices,
+    winnerCandidate: winner,
+    reason: `Semantic consensus reached (${maxSim} >= ${threshold}) across candidates ${consensusIndices.join(', ')}`,
+  }
+}
+
+/**
+ * Estimates saved tokens and cost from bypassing the judge round.
+ * @param {Array<object>} candidates
+ * @param {string} prompt
+ * @param {number} [maxTokens=4096]
+ * @param {object} [prices={}]
+ * @returns {{ skippedTokens: number, skippedCostUsd: number }}
+ */
+export function estimateSkippedJudgeUsage(candidates = [], prompt = '', maxTokens = 4096, prices = {}) {
+  const promptChars = (prompt?.length || 0) + candidates.reduce((sum, c) => sum + (c.text?.length || 0), 0)
+  const estimatedInputTokens = Math.max(100, Math.round(promptChars / 3.8))
+  const estimatedOutputTokens = Math.min(Math.max(200, Math.round(maxTokens * 0.25)), 1000)
+  const skippedTokens = estimatedInputTokens + estimatedOutputTokens
+
+  const costEst = estimateTokenCost({ provider: 'default', model: 'judge' }, {
+    inputTokens: estimatedInputTokens,
+    outputTokens: estimatedOutputTokens,
+  }, prices)
+
+  return {
+    skippedTokens,
+    skippedCostUsd: Number((costEst?.costUsd || 0.005).toFixed(5)),
+  }
+}
+
+/**
+ * Evaluates candidates for early consensus and executes early exit bypass if reached.
+ * @param {object} params
+ * @returns {Promise<{ ok: boolean, consensusReached: boolean, payload?: object, error?: Error, abort?: boolean }>}
+ */
+export function stageEarlyConsensus({
+  successfulRefs = [],
+  referenceOutputs = [],
+  preset = {},
+  userPrompt = '',
+  prices = {},
+  maxTokens = 4096,
+  cwd = process.cwd(),
+  runId = '',
+  signal = null,
+  promoteOpts = {},
+  allowCandidateOverride = false,
+  isRefinement = false,
+  historyFilePath = null,
+  startTime = Date.now(),
+  collectedCtx = null,
+  liveCanvas = null,
+  ctx = null,
+}) {
+  const enabled = Boolean(preset?.early_exit_consensus_enabled)
+  const threshold = typeof preset?.early_exit_threshold === 'number' ? preset.early_exit_threshold : 0.95
+
+  if (!enabled || successfulRefs.length < 2) {
+    return Promise.resolve({ ok: true, consensusReached: false })
+  }
+
+  const consensus = checkSemanticConsensus(successfulRefs, threshold)
+  if (!consensus.reached || !consensus.winnerCandidate) {
+    return Promise.resolve({ ok: true, consensusReached: false, similarity: consensus.similarity })
+  }
+
+  const winner = consensus.winnerCandidate
+  emitEvent(ctx, MOA_EVENTS.EARLY_CONSENSUS, {
+    runId,
+    similarity: consensus.similarity,
+    threshold,
+    winnerIndex: consensus.winnerIndex,
+    winnerModel: winner.label,
+    consensusCandidates: consensus.consensusIndices,
+  })
+
+  // Promote winning candidate files
+  let promotedFiles = []
+  let promoteErr = null
+  const runPromotion = async () => {
+    if (winner.files?.length > 0) {
+      try {
+        promotedFiles = await promoteCandidateWorkspace(cwd, winner.index, {
+          ...promoteOpts,
+          runId,
+          keepMoa: allowCandidateOverride,
+        })
+      } catch (err) {
+        promoteErr = err
+      }
+    } else if (!allowCandidateOverride) {
+      await cleanMoaWorkspaces(cwd, { runId })
+    }
+
+    if (promoteErr) {
+      if (!allowCandidateOverride) await cleanMoaWorkspaces(cwd, { runId })
+      if (signal?.aborted || promoteErr?.message?.includes('aborted')) {
+        return { ok: false, consensusReached: true, abort: true, error: new Error('Turn aborted') }
+      }
+    }
+
+    const skippedUsage = estimateSkippedJudgeUsage(successfulRefs, userPrompt, maxTokens, prices)
+    const livePreview = await createPromotedPreview(liveCanvas, cwd, promotedFiles, referenceOutputs, {
+      winningIndex: winner.index,
+    })
+
+    const totalTokens = referenceOutputs.reduce((acc, r) => acc + (r.usage?.totalTokens || 0), 0)
+    const totalCostUsd = Number(referenceOutputs.reduce((acc, r) => acc + (r.costUsd || 0), 0).toFixed(5))
+    const durationMs = Date.now() - startTime
+
+    try {
+      await recordMoaRunAsync({
+        id: runId,
+        cwd,
+        prompt: userPrompt,
+        preset: preset?.name || 'default',
+        isRefinement,
+        isEarlyConsensus: true,
+        candidates: candidatesForHistory(referenceOutputs),
+        aggregator: 'Early Consensus (Bypassed)',
+        winnerIndex: winner.index,
+        winnerModel: winner.label,
+        promotedFiles,
+        totalTokens,
+        totalCostUsd,
+        skippedJudgeTokens: skippedUsage.skippedTokens,
+        durationMs,
+      }, historyFilePath || undefined)
+    } catch (histErr) {
+      logger.warn('[dsh-moa] Failed to record early consensus in history:', histErr?.message || histErr)
+    }
+
+    emitEvent(ctx, MOA_EVENTS.RUN_FINISH, {
+      runId,
+      durationMs,
+      totalTokens,
+      totalCostUsd,
+      promotedFiles,
+      winnerIndex: winner.index,
+      isEarlyConsensus: true,
+    })
+
+    return {
+      ok: true,
+      consensusReached: true,
+      payload: {
+        kind: 'synthesis',
+        content: winner.text,
+        aggregator: 'Early Consensus (Bypassed)',
+        references: referenceOutputs,
+        presetName: preset?.name || 'default',
+        isRefinement,
+        isEarlyConsensus: true,
+        winningIndex: winner.index,
+        winnerModel: winner.label,
+        promotedFiles,
+        runId,
+        consensusInfo: {
+          similarity: consensus.similarity,
+          threshold,
+          consensusIndices: consensus.consensusIndices,
+        },
+        ...(livePreview ? { liveCanvas: livePreview } : {}),
+        usage: {
+          totalTokens,
+          totalCostUsd,
+          skippedJudgeTokens: skippedUsage.skippedTokens,
+          skippedJudgeCostUsd: skippedUsage.skippedCostUsd,
+          candidates: referenceOutputs.map((r) => ({ label: r.label, usage: r.usage, costUsd: r.costUsd })),
+          aggregator: { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0 },
+        },
+        skippedFiles: collectedCtx?.skippedFiles || 0,
+        skippedList: collectedCtx?.skippedList || [],
+        durationMs,
+      },
+    }
+  }
+
+  return runPromotion()
+}
+