@goodandready/dsh-moa 0.2.78 → 0.2.80

package/lib/pipeline/rebuttal-debate.js

@@ -0,0 +1,335 @@
+/**
+ * Multi-Round Rebuttal Debate between Candidates (#298)
+ *
+ * Implements multi-round cross-examination and rebuttal discussion between candidate models
+ * before final arbitration by the Judge. Candidates anonymize and analyze peer solutions,
+ * identify flaws, security edge-cases, and hallucinations, and refine their own answers.
+ * The structured debate protocol is then passed to the Judge for weighted arbitration.
+ */
+
+import { logger } from '../logger.js'
+import { callWithTransientRetry } from '../moa-candidates.js'
+import { extractFileBlocks, writeCandidateWorkspace } from '../workspace/fs.js'
+import { verifyFileSyntax } from '../workspace/diff.js'
+import { estimateTokenCost } from '../pricing.js'
+import { emitEvent, MOA_EVENTS } from '../events.js'
+
+/**
+ * Builds the rebuttal prompt for a candidate in a given debate round.
+ * @param {object} params
+ * @returns {string}
+ */
+export function buildRebuttalPrompt({
+  userPrompt,
+  candidateText,
+  opponentAnswers,
+  roundNumber = 1,
+  totalRounds = 1,
+  isBlind = true,
+}) {
+  const opponentsFormatted = opponentAnswers
+    .map((op, idx) => {
+      const label = op.label || `Candidate ${idx + 1}`
+      const persona = op.role_persona ? ` [Persona: ${op.role_persona}]` : ''
+      return `### ⚔️ Peer Solution [${label}]${persona}:\n${op.text}`
+    })
+    .join('\n\n')
+
+  return `You are an expert software engineer participating in a rigorous Multi-Agent Consilium Rebuttal Debate (Round ${roundNumber} of ${totalRounds}).
+Your objective is to stress-test peer solutions, expose bugs, logical vulnerabilities, and hallucinations, and defend and refine your own solution.
+
+=== ORIGINAL USER REQUEST ===
+${userPrompt}
+
+=== YOUR PREVIOUS PROPOSAL ===
+${candidateText}
+
+=== ALTERNATIVE PEER SOLUTIONS ===
+${opponentsFormatted}
+
+=== REBUTTAL DEBATE INSTRUCTIONS ===
+Analyze the peer solutions with uncompromising technical rigor.
+Structure your response EXACTLY into these three labeled sections:
+
+### CRITIQUE OF PEERS
+For each peer candidate, cite concrete issues:
+- Identify logic bugs, off-by-one errors, uncaught exceptions, or security holes.
+- Highlight missing edge cases or unhandled failure states.
+- Point out inaccurate assumptions or hallucinations.
+
+### REBUTTAL & DEFENSE
+- Address the potential weaknesses or tradeoffs in your own approach.
+- Explain why your architectural or algorithmic choices are superior or more maintainable.
+
+### REFINED SOLUTION
+- Provide your complete, improved, and final solution incorporating valid insights from the debate.
+- Output complete code without placeholders or omissions.`
+}
+
+/**
+ * Parses structured rebuttal debate output from a model response.
+ * @param {string} rawText
+ * @returns {{ critiqueText: string, defenseText: string, refinedText: string }}
+ */
+export function parseRebuttalResponse(rawText = '') {
+  if (typeof rawText !== 'string') {
+    return { critiqueText: '', defenseText: '', refinedText: '' }
+  }
+
+  let critiqueText = ''
+  let defenseText = ''
+  let refinedText = rawText
+
+  const critiqueMatch = rawText.match(/### CRITIQUE OF PEERS\s*([\s\S]*?)(?=### REBUTTAL & DEFENSE|### REFINED SOLUTION|$)/i)
+  if (critiqueMatch) {
+    critiqueText = critiqueMatch[1].trim()
+  }
+
+  const defenseMatch = rawText.match(/### REBUTTAL & DEFENSE\s*([\s\S]*?)(?=### REFINED SOLUTION|$)/i)
+  if (defenseMatch) {
+    defenseText = defenseMatch[1].trim()
+  }
+
+  const refinedMatch = rawText.match(/### REFINED SOLUTION\s*([\s\S]*)$/i)
+  if (refinedMatch && refinedMatch[1].trim().length > 50) {
+    refinedText = refinedMatch[1].trim()
+  }
+
+  return {
+    critiqueText,
+    defenseText,
+    refinedText,
+  }
+}
+
+/**
+ * Executes a single round of rebuttal debate across all active candidates.
+ * @param {object} params
+ * @returns {Promise<{ round: number, critiques: Array<object>, updatedCandidates: Array<object> }>}
+ */
+export async function executeDebateRound({
+  candidates = [],
+  userPrompt = '',
+  roundNumber = 1,
+  totalRounds = 1,
+  isBlindEvaluation = true,
+  callLlm,
+  refTemp = 0.5,
+  maxTokens = 4096,
+  refTimeoutSec = 60,
+  candidateRetries = 2,
+  prices = {},
+  signal = null,
+  onProgress = null,
+  cwd = process.cwd(),
+  runId = '',
+  ctx = null,
+}) {
+  if (typeof onProgress === 'function') {
+    onProgress(`🗣️ *Rebuttal Debate Round ${roundNumber}/${totalRounds}: Candidates cross-examining peer solutions in parallel...*\n`)
+  }
+
+  const roundCritiques = []
+
+  const debatePromises = candidates.map(async (cand) => {
+    const opponents = candidates
+      .filter((c) => c.index !== cand.index)
+      .map((c) => ({
+        index: c.index,
+        label: isBlindEvaluation ? `Candidate ${c.index}` : c.label,
+        role_persona: c.role_persona || c.slot?.role_persona,
+        text: c.text,
+      }))
+
+    const rebuttalPrompt = buildRebuttalPrompt({
+      userPrompt,
+      candidateText: cand.text,
+      opponentAnswers: opponents,
+      roundNumber,
+      totalRounds,
+      isBlind: isBlindEvaluation,
+    })
+
+    const slot = cand.slot || { provider: cand.provider, model: cand.model }
+
+    try {
+      const res = await callWithTransientRetry(
+        callLlm,
+        {
+          provider: slot.provider,
+          model: slot.model,
+          messages: [{ role: 'user', content: rebuttalPrompt }],
+          temperature: refTemp,
+          maxTokens,
+          timeoutMs: refTimeoutSec * 1000,
+          signal,
+          onProgress,
+        },
+        candidateRetries
+      )
+
+      const parsed = parseRebuttalResponse(res.text)
+      const costEst = estimateTokenCost({
+        provider: slot.provider,
+        model: slot.model,
+        inputTokens: res.usage?.inputTokens || 0,
+        outputTokens: res.usage?.outputTokens || 0,
+        cacheHitTokens: res.usage?.cacheHitTokens || 0,
+        prices,
+      })
+
+      const newFiles = extractFileBlocks(parsed.refinedText)
+      if (newFiles.length > 0) {
+        await writeCandidateWorkspace(cwd, cand.index, newFiles, { runId })
+      }
+
+      const syntaxValidation = verifyFileSyntax(newFiles)
+
+      const critiqueRecord = {
+        candidateIndex: cand.index,
+        candidateLabel: isBlindEvaluation ? `Candidate ${cand.index}` : cand.label,
+        critique: parsed.critiqueText,
+        defense: parsed.defenseText,
+      }
+      roundCritiques.push(critiqueRecord)
+
+      return {
+        ...cand,
+        text: parsed.refinedText,
+        files: newFiles.length > 0 ? newFiles : cand.files,
+        syntaxValidation: syntaxValidation.valid ? syntaxValidation : cand.syntaxValidation,
+        usage: {
+          inputTokens: (cand.usage?.inputTokens || 0) + (res.usage?.inputTokens || 0),
+          outputTokens: (cand.usage?.outputTokens || 0) + (res.usage?.outputTokens || 0),
+          totalTokens: (cand.usage?.totalTokens || 0) + (res.usage?.totalTokens || 0),
+        },
+        costUsd: Number(((cand.costUsd || 0) + (costEst?.costUsd || 0)).toFixed(5)),
+        lastDebateCritique: parsed.critiqueText,
+        lastDebateDefense: parsed.defenseText,
+      }
+    } catch (err) {
+      logger.warn(`[dsh-moa] Candidate ${cand.index} rebuttal debate round ${roundNumber} failed:`, err?.message || err)
+      return cand
+    }
+  })
+
+  const updatedCandidates = await Promise.all(debatePromises)
+
+  emitEvent(ctx, MOA_EVENTS.DEBATE_ROUND, {
+    runId,
+    roundNumber,
+    totalRounds,
+    critiquesCount: roundCritiques.length,
+    activeCandidates: updatedCandidates.length,
+  })
+
+  return {
+    round: roundNumber,
+    critiques: roundCritiques,
+    updatedCandidates,
+  }
+}
+
+/**
+ * Formats accumulated debate protocol into a clean markdown directive for the Judge.
+ * @param {Array<object>} debateRounds
+ * @returns {string}
+ */
+export function formatDebateDirective(debateRounds = []) {
+  if (!Array.isArray(debateRounds) || debateRounds.length === 0) return ''
+
+  const sections = []
+  sections.push('=== ⚔️ MULTI-ROUND REBUTTAL DEBATE PROTOCOL ===')
+  sections.push('The candidate models engaged in peer cross-examination prior to arbitration.')
+  sections.push('CRITICAL JUDGE DIRECTIVE: Heavily weight valid vulnerabilities or bugs identified by peers.')
+
+  for (const r of debateRounds) {
+    sections.push(`\n--- Debate Round ${r.round} ---`)
+    for (const c of r.critiques || []) {
+      if (c.critique) {
+        sections.push(`[${c.candidateLabel}] Critiques of peers:\n${c.critique}`)
+      }
+      if (c.defense) {
+        sections.push(`[${c.candidateLabel}] Defense & Justification:\n${c.defense}`)
+      }
+    }
+  }
+
+  sections.push('\n==============================================')
+  return sections.join('\n')
+}
+
+/**
+ * Orchestrates multi-round rebuttal debate phase (#298).
+ * @param {object} params
+ * @returns {Promise<{ ok: boolean, updatedCandidates: Array<object>, debateDirective: string, totalCritiques: number, rounds: Array<object> }>}
+ */
+export async function runRebuttalDebatePhase({
+  candidates = [],
+  userPrompt = '',
+  preset = {},
+  prices = {},
+  maxTokens = 4096,
+  isBlindEvaluation = true,
+  callLlm,
+  signal = null,
+  onProgress = null,
+  cwd = process.cwd(),
+  runId = '',
+  ctx = null,
+}) {
+  const enabled = Boolean(preset?.rebuttal_debate_enabled || preset?.rebuttalDebateEnabled)
+  if (!enabled || candidates.length < 2) {
+    return {
+      ok: true,
+      updatedCandidates: candidates,
+      debateDirective: '',
+      totalCritiques: 0,
+      rounds: [],
+    }
+  }
+
+  const configuredRounds = preset?.rebuttal_rounds ?? preset?.rebuttalRounds ?? 1
+  const totalRounds = Math.min(3, Math.max(1, Number(configuredRounds) || 1))
+
+  let currentCandidates = [...candidates]
+  const debateRounds = []
+
+  for (let r = 1; r <= totalRounds; r++) {
+    if (signal?.aborted) {
+      break
+    }
+
+    const roundResult = await executeDebateRound({
+      candidates: currentCandidates,
+      userPrompt,
+      roundNumber: r,
+      totalRounds,
+      isBlindEvaluation,
+      callLlm,
+      refTemp: preset?.reference_temperature ?? 0.5,
+      maxTokens,
+      refTimeoutSec: preset?.reference_timeout_sec ?? 60,
+      prices,
+      signal,
+      onProgress,
+      cwd,
+      runId,
+      ctx,
+    })
+
+    debateRounds.push(roundResult)
+    currentCandidates = roundResult.updatedCandidates
+  }
+
+  const totalCritiques = debateRounds.reduce((acc, r) => acc + (r.critiques?.length || 0), 0)
+  const debateDirective = formatDebateDirective(debateRounds)
+
+  return {
+    ok: true,
+    updatedCandidates: currentCandidates,
+    debateDirective,
+    totalCritiques,
+    rounds: debateRounds,
+  }
+}

package/lib/pipeline/runner.js

@@ -1,3 +1,5 @@
+import { applyParetoAdjustment } from './pareto-frontier.js'
+import { evaluateHardBudgetLimit } from './budget-guard.js'
 import { sanitizeCandidatesForCloudJudge } from './privacy-sanitizer.js'
 import { evaluateJudgeEscalation } from './escalation.js'
 import { calculateSelfConsistencyAgreement } from './self-consistency.js'
@@ -23,6 +25,8 @@ import { runSecurityAuditGate } from './security-fuzzer.js'
 import { runCoveVerificationGate } from './cove-verifier.js'
 import { runProfilerGate } from './runtime-profiler.js'
 import { runMutationGate } from './mutation-tester.js'
+import { stageEmbeddingClustering } from './embedding-clustering.js'
+import { runRebuttalDebatePhase } from './rebuttal-debate.js'
 import { emitEvent, MOA_EVENTS } from '../events.js'
 
 export async function runMoAPipeline({
@@ -50,9 +54,36 @@ export async function runMoAPipeline({
     timestamp: new Date(startTime).toISOString(),
   })
 
+  // Pre-Stage 0.5: Pareto Frontier Slider & Hard Budget Guard (#307, #319)
+  let effectivePreset = preset
+  if (effectivePreset?.pareto_slider_enabled) {
+    effectivePreset = applyParetoAdjustment(effectivePreset, { ctx, runId, onProgress, prices })
+  }
+
+  if (effectivePreset?.hard_budget_guard_enabled) {
+    const budgetRes = evaluateHardBudgetLimit({
+      references: effectivePreset.reference_models || [],
+      aggregator: effectivePreset.aggregator || {},
+      limitUsd: effectivePreset.hard_budget_limit_usd ?? 0.02,
+      policy: effectivePreset.hard_budget_policy || 'auto_downgrade',
+      prices,
+      options: { ctx, runId, onProgress },
+    })
+    if (!budgetRes.ok) {
+      return { error: new Error(budgetRes.error) }
+    }
+    if (budgetRes.scaled) {
+      effectivePreset = {
+        ...effectivePreset,
+        reference_models: budgetRes.references,
+        aggregator: budgetRes.aggregator,
+      }
+    }
+  }
+
   // Stage 1: Context & Configuration
   const ctxStage = await stageProjectContext({
-    userPrompt, messages, preset, cwd, prices, maxTokens: preset?.max_tokens, startTime, onProgress, ctx,
+    userPrompt, messages, preset: effectivePreset, cwd, prices, maxTokens: effectivePreset?.max_tokens, startTime, onProgress, ctx,
   })
   if (!ctxStage.ok) return ctxStage.abortPayload
 
@@ -90,7 +121,7 @@ export async function runMoAPipeline({
     })
     return candStage.failurePayload
   }
-  const { referenceOutputs, successfulRefs, adversarialTddResult } = candStage
+  let { referenceOutputs, successfulRefs, adversarialTddResult } = candStage
 
   for (const ref of referenceOutputs) {
     emitEvent(ctx, MOA_EVENTS.CANDIDATE_COMPLETE, {
@@ -173,6 +204,32 @@ export async function runMoAPipeline({
     }
   }
 
+  // Pre-Judge Stage 4.6: Blind Embedding Clustering for Zero-LLM Fast Consensus (#312)
+  if ((preset?.embedding_clustering_enabled || preset?.embeddingClusteringEnabled) && successfulRefs.length > 1) {
+    const embedRes = await stageEmbeddingClustering({
+      successfulRefs: syntaxResult.validCandidates.length > 0 ? syntaxResult.validCandidates : successfulRefs,
+      referenceOutputs,
+      preset,
+      userPrompt,
+      prices,
+      maxTokens: ctxStage.maxTokens,
+      cwd,
+      runId,
+      signal,
+      promoteOpts,
+      allowCandidateOverride: ctxStage.allowCandidateOverride,
+      isRefinement: ctxStage.isRefinement,
+      historyFilePath,
+      startTime,
+      collectedCtx: ctxStage.collectedCtx,
+      liveCanvas,
+      ctx,
+    })
+    if (embedRes.consensusReached) {
+      return embedRes.payload
+    }
+  }
+
   if (signal?.aborted) {
     await cleanMoaWorkspaces(cwd, { runId })
     return { error: new Error('Turn aborted') }
@@ -199,6 +256,35 @@ export async function runMoAPipeline({
     })
   }
 
+  // Stage 5.2: Multi-Round Rebuttal Debate between Candidates (#298)
+  let debateDirective = null
+  if ((preset?.rebuttal_debate_enabled || preset?.rebuttalDebateEnabled) && successfulRefs.length > 1) {
+    const debateRes = await runRebuttalDebatePhase({
+      candidates: syntaxResult.validCandidates.length > 0 ? syntaxResult.validCandidates : successfulRefs,
+      userPrompt,
+      preset,
+      prices,
+      maxTokens: ctxStage.maxTokens,
+      isBlindEvaluation: ctxStage.isBlindEvaluation,
+      callLlm,
+      signal,
+      onProgress,
+      cwd,
+      runId,
+      ctx,
+    })
+    if (debateRes.ok && debateRes.debateDirective) {
+      debateDirective = debateRes.debateDirective
+      if (debateRes.updatedCandidates?.length > 0) {
+        successfulRefs = debateRes.updatedCandidates
+        referenceOutputs = referenceOutputs.map((r) => {
+          const matching = successfulRefs.find((c) => c.index === r.index || c.label === r.label)
+          return matching ? { ...r, text: matching.text } : r
+        })
+      }
+    }
+  }
+
   if (signal?.aborted) {
     await cleanMoaWorkspaces(cwd, { runId })
     return { error: new Error('Turn aborted') }
@@ -307,7 +393,6 @@ export async function runMoAPipeline({
   let effectivePrimaryJudge = ctxStage.primaryJudge
   let effectiveFallbackJudges = ctxStage.fallbackJudges
   let effectiveJudgesChain = ctxStage.judgesChain
-  let effectivePreset = preset
 
   if (escalationResult.escalated) {
     emitEvent(ctx, MOA_EVENTS.JUDGE_ESCALATION, {
@@ -344,7 +429,7 @@ export async function runMoAPipeline({
     preset: effectivePreset,
     successfulRefs: candidatesForJudge,
     referenceOutputs: sanitizedReferenceOutputs, primaryJudge: effectivePrimaryJudge,
-    userPrompt, judgeCriteria: [ctxStage.judgeCriteria, coveDirective, securityDirective, profilerDirective, mutationDirective, privacyDirective].filter(Boolean).join('\n\n'), prices, maxTokens: ctxStage.maxTokens,
+    userPrompt, judgeCriteria: [ctxStage.judgeCriteria, debateDirective, coveDirective, securityDirective, profilerDirective, mutationDirective, privacyDirective].filter(Boolean).join('\n\n'), prices, maxTokens: ctxStage.maxTokens,
     callLlm, signal, onProgress, cwd, runId, isRefinement: ctxStage.isRefinement,
     isFastMode: ctxStage.isFastMode, collectedCtx: ctxStage.collectedCtx, startTime,
   })
@@ -402,7 +487,7 @@ export async function runMoAPipeline({
     }
   }
 
-  const fileScoringDirective = [rawFileDirective, visualResult?.directive, adversarialTddResult?.directive, syntaxDirective, coveDirective, securityDirective, profilerDirective, mutationDirective, privacyDirective, pruningDirective, ctxStage.stackAwareDirective, ctxStage.developerPreferencesDirective].filter(Boolean).join("\n\n") || null
+  const fileScoringDirective = [rawFileDirective, visualResult?.directive, adversarialTddResult?.directive, syntaxDirective, debateDirective, coveDirective, securityDirective, profilerDirective, mutationDirective, privacyDirective, pruningDirective, ctxStage.stackAwareDirective, ctxStage.developerPreferencesDirective].filter(Boolean).join("\n\n") || null
 
   // Stage 7: Synthesis Phase
   const synthRes = await stageSynthesis({

package/lib/pricing.js

@@ -152,6 +152,11 @@ export function resolveModelRates(slot = {}, customPrices = {}, cachePath = getD
   const fullKey = provider ? `${provider}/${model}` : model
   const colonKey = provider ? `${provider}:${model}` : model
 
+  // 0. Free local edge providers
+  if (provider === 'ollama' || provider === 'local') {
+    return { input: 0, output: 0, cacheHit: 0 }
+  }
+
   // 1. Check custom user overrides in config
   if (customPrices && typeof customPrices === 'object') {
     if (customPrices[fullKey]) return normalizeRates(customPrices[fullKey])
@@ -278,9 +283,9 @@ export function resolveModelRates(slot = {}, customPrices = {}, cachePath = getD
 function normalizeRates(rate) {
   if (!rate || typeof rate !== 'object') return { ...FALLBACK_RATES }
   return {
-    input: Number(rate.input ?? rate.prompt ?? FALLBACK_RATES.input),
-    output: Number(rate.output ?? rate.completion ?? FALLBACK_RATES.output),
-    cacheHit: Number(rate.cacheHit ?? rate.cache_hit ?? FALLBACK_RATES.cacheHit),
+    input: Number(rate.input ?? rate.prompt ?? rate.prompt_per_million ?? FALLBACK_RATES.input),
+    output: Number(rate.output ?? rate.completion ?? rate.completion_per_million ?? FALLBACK_RATES.output),
+    cacheHit: Number(rate.cacheHit ?? rate.cache_hit ?? rate.cache_hit_per_million ?? FALLBACK_RATES.cacheHit),
   }
 }
 

package/package.json

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