@goodandready/dsh-moa 0.2.72 → 0.2.74

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

@@ -1,3 +1,5 @@
+import { expandSelfConsistencySlots } from './self-consistency.js'
+import { emitEvent, MOA_EVENTS } from '../events.js'
 import { balanceCandidateQuotas } from '../moa-quota-balancer.js'
 import { collectProjectContext, formatProjectContext, isRefinementTask } from '../workspace/scanner.js'
 import { applyBudgetGuardrails, createBudgetAbortPayload } from '../moa-budget.js'
@@ -27,7 +29,40 @@ export async function stageProjectContext({
   const refTemp = typeof preset?.reference_temperature === 'number' ? preset.reference_temperature : 0.6
   const aggTemp = typeof preset?.aggregator_temperature === 'number' ? preset.aggregator_temperature : 0.4
   const judgeCriteria = preset?.judge_criteria || ''
-  let isFastMode = referenceModels.length === 1 && !preset?.curator_synthesis
+  const selfConsistencyEnabled = Boolean(preset?.self_consistency_enabled)
+  const selfConsistencySamples = typeof preset?.self_consistency_samples === 'number' ? preset.self_consistency_samples : 3
+  const selfConsistencyTemperatures = Array.isArray(preset?.self_consistency_temperatures)
+    ? preset.self_consistency_temperatures
+    : [0.2, 0.6, 0.9]
+  const escalationPolicy = preset?.escalation_policy || 'single'
+  const escalationDisagreementThreshold = typeof preset?.escalation_disagreement_threshold === 'number'
+    ? preset.escalation_disagreement_threshold
+    : 0.40
+  const escalationJudge = (preset?.escalation_judge?.model) ? preset.escalation_judge : null
+
+  let effectiveReferenceModels = referenceModels
+  let selfConsistencyExpanded = false
+  if (selfConsistencyEnabled) {
+    const scRes = expandSelfConsistencySlots(referenceModels, {
+      enabled: true,
+      samples: selfConsistencySamples,
+      temperatures: selfConsistencyTemperatures,
+    })
+    if (scRes.isExpanded) {
+      effectiveReferenceModels = scRes.references
+      selfConsistencyExpanded = true
+      emitEvent(ctx, MOA_EVENTS.SELF_CONSISTENCY_EXPAND, {
+        originalModel: referenceModels[0]?.model,
+        sampleCount: scRes.sampleCount,
+        temperatures: selfConsistencyTemperatures.slice(0, scRes.sampleCount),
+      })
+      if (typeof onProgress === 'function') {
+        onProgress(`🎲 *Self-Consistency: Expanded single model into ${scRes.sampleCount} diverse temperature samples (${selfConsistencyTemperatures.slice(0, scRes.sampleCount).join(', ')})*\n`)
+      }
+    }
+  }
+
+  let isFastMode = effectiveReferenceModels.length === 1 && !preset?.curator_synthesis
   const isCuratorSynthesis = Boolean(preset?.curator_synthesis)
   const isStreamAggregator = preset?.stream_aggregator !== false
   const isQuorumEnabled = Boolean(preset?.quorum_enabled)
@@ -41,6 +76,10 @@ export async function stageProjectContext({
   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))
@@ -61,7 +100,7 @@ export async function stageProjectContext({
   }
 
   const budgetCheck = applyBudgetGuardrails({
-    references: referenceModels,
+    references: effectiveReferenceModels,
     enabled: preset?.budget_guard_enabled,
     maxBudgetUsd: preset?.max_budget_usd,
     action: preset?.budget_action || 'trim',
@@ -127,6 +166,10 @@ export async function stageProjectContext({
     effectiveReferences, quotaSubstitutions, priorTurnBaseline, candidateSystemPrompt,
     needsQuestions, enrichedMessages,
     localPreflightCheck, earlyExitConsensusEnabled, earlyExitThreshold,
+    contextPruningEnabled, contextPruningDiffLines,
+    semanticCacheEnabled, semanticCacheTtlHours,
+    selfConsistencyEnabled, selfConsistencyExpanded, selfConsistencySamples, selfConsistencyTemperatures,
+    escalationPolicy, escalationDisagreementThreshold, escalationJudge,
   }
 }
-
+

package/lib/pipeline/escalation.js

@@ -0,0 +1,160 @@
+/**
+ * Dynamic Consensus Threshold & Multi-Judge Escalation (#300)
+ *
+ * Detects divergence among candidate outputs (Disagreement Metric).
+ * When candidate consensus is weak or contradictory, automatically escalates:
+ * - auto_upgrade: upgrades from lightweight/fast judge to flagship/senior judge
+ * - council_majority: convenes a 3-judge panel with majority voting
+ */
+
+import { calculateSimilarity } from './early-consensus.js'
+
+/**
+ * Calculates the Disagreement Metric (0.0 to 1.0) across candidate outputs.
+ * 0.0 means perfect consensus (identical solutions).
+ * 1.0 means total divergence (completely distinct solutions).
+ *
+ * @param {Array<object>} candidateOutputs
+ * @returns {number} Disagreement metric between 0.0 and 1.0
+ */
+export function calculateDisagreementMetric(candidateOutputs = []) {
+  if (!Array.isArray(candidateOutputs) || candidateOutputs.length < 2) {
+    return 0.0
+  }
+
+  const validTexts = candidateOutputs
+    .filter((c) => c && typeof c.text === 'string' && c.text.trim())
+    .map((c) => c.text)
+
+  if (validTexts.length < 2) return 0.0
+
+  let totalSim = 0
+  let pairs = 0
+
+  for (let i = 0; i < validTexts.length; i++) {
+    for (let j = i + 1; j < validTexts.length; j++) {
+      totalSim += calculateSimilarity(validTexts[i], validTexts[j])
+      pairs++
+    }
+  }
+
+  if (pairs === 0) return 0.0
+  const avgSim = totalSim / pairs
+  const disagreement = Math.max(0.0, Math.min(1.0, 1.0 - avgSim))
+  return Number(disagreement.toFixed(4))
+}
+
+/**
+ * Evaluates whether candidate divergence warrants judge escalation.
+ *
+ * @param {object} params
+ * @param {Array<object>} params.candidateOutputs - Array of successful candidate results
+ * @param {object} params.primaryJudge - Primary configured judge slot
+ * @param {Array<object>} [params.fallbackJudges=[]] - Chain of backup judges
+ * @param {object} [params.escalationJudge] - Explicit flagship upgrade judge
+ * @param {string} [params.policy='single'] - 'single' | 'auto_upgrade' | 'council_majority'
+ * @param {number} [params.threshold=0.40] - Disagreement threshold to trigger escalation
+ * @returns {object} Escalation decision and effective judge(s)
+ */
+export function evaluateJudgeEscalation({
+  candidateOutputs = [],
+  primaryJudge = { provider: '', model: '' },
+  fallbackJudges = [],
+  escalationJudge = null,
+  policy = 'single',
+  threshold = 0.40,
+} = {}) {
+  const normPolicy = String(policy || 'single').toLowerCase()
+
+  if (normPolicy === 'single' || !Array.isArray(candidateOutputs) || candidateOutputs.length < 2) {
+    return {
+      escalated: false,
+      escalatedType: 'none',
+      judge: primaryJudge,
+      councilJudges: [primaryJudge],
+      disagreement: 0.0,
+      threshold,
+      reason: 'Standard single judge evaluation',
+    }
+  }
+
+  const disagreement = calculateDisagreementMetric(candidateOutputs)
+  const isTriggered = disagreement >= threshold
+
+  if (!isTriggered) {
+    return {
+      escalated: false,
+      escalatedType: 'none',
+      judge: primaryJudge,
+      councilJudges: [primaryJudge],
+      disagreement,
+      threshold,
+      reason: `Consensus adequate: disagreement ${(disagreement * 100).toFixed(1)}% < threshold ${(threshold * 100).toFixed(1)}%`,
+    }
+  }
+
+  if (normPolicy === 'auto_upgrade') {
+    // Pick designated escalationJudge, or the first available fallbackJudge
+    let targetJudge = null
+    if (escalationJudge && escalationJudge.model) {
+      targetJudge = escalationJudge
+    } else if (Array.isArray(fallbackJudges) && fallbackJudges.length > 0 && fallbackJudges[0]?.model) {
+      targetJudge = fallbackJudges[0]
+    } else {
+      targetJudge = primaryJudge
+    }
+
+    const upgraded = targetJudge.model !== primaryJudge.model || targetJudge.provider !== primaryJudge.provider
+    return {
+      escalated: upgraded,
+      escalatedType: upgraded ? 'auto_upgrade' : 'none',
+      judge: targetJudge,
+      originalJudge: primaryJudge,
+      councilJudges: [targetJudge],
+      disagreement,
+      threshold,
+      reason: upgraded
+        ? `High candidate divergence (${(disagreement * 100).toFixed(1)}% >= ${(threshold * 100).toFixed(1)}%): upgraded judge to ${targetJudge.provider ? targetJudge.provider + ':' : ''}${targetJudge.model}`
+        : `High divergence detected (${(disagreement * 100).toFixed(1)}%), but no senior fallback judge configured`,
+    }
+  }
+
+  if (normPolicy === 'council_majority') {
+    const council = [primaryJudge]
+    if (escalationJudge && escalationJudge.model && escalationJudge.model !== primaryJudge.model) {
+      council.push(escalationJudge)
+    }
+    if (Array.isArray(fallbackJudges)) {
+      for (const fb of fallbackJudges) {
+        if (council.length >= 3) break
+        if (fb && fb.model && !council.some((c) => c.model === fb.model && c.provider === fb.provider)) {
+          council.push(fb)
+        }
+      }
+    }
+
+    const hasMulti = council.length > 1
+    return {
+      escalated: hasMulti,
+      escalatedType: hasMulti ? 'council_majority' : 'none',
+      judge: council[0],
+      originalJudge: primaryJudge,
+      councilJudges: council,
+      disagreement,
+      threshold,
+      reason: hasMulti
+        ? `High candidate divergence (${(disagreement * 100).toFixed(1)}% >= ${(threshold * 100).toFixed(1)}%): assembled ${council.length}-judge council`
+        : `High divergence detected, but fewer than 2 judges available for council`,
+    }
+  }
+
+  return {
+    escalated: false,
+    escalatedType: 'none',
+    judge: primaryJudge,
+    councilJudges: [primaryJudge],
+    disagreement,
+    threshold,
+    reason: 'Standard single judge',
+  }
+}