@goodandready/dsh-moa 0.2.70 → 0.2.72

package/lib/moa-ast-merge.js

@@ -0,0 +1,233 @@
+/**
+ * AST-Level Composite Merge Integration via dsh-context-lens (#248)
+ * Semantically merges candidate files at the AST/declaration level (deduplicating imports,
+ * combining type signatures, JSDoc comments, and function bodies) using dsh-context-lens
+ * when available via ctx.reflect / service(ctx, 'contextLens'), with a clean fallback
+ * to structured declaration merge and standard string composite directives.
+ */
+
+import vm from 'node:vm'
+import { service } from './services.js'
+import { logger } from './logger.js'
+import { buildCompositeBlockDirectives } from './moa-multi-judge.js'
+import { extractFileBlocks } from './workspace/fs.js'
+
+/**
+ * Checks whether dsh-context-lens service is available on the Cordis context.
+ */
+export function resolveContextLensService(ctx, explicitLens = null) {
+  if (explicitLens) return explicitLens
+  const fromSvc = service(ctx, 'contextLens')
+  if (fromSvc) return fromSvc
+  try {
+    if (ctx?.reflect && typeof ctx.reflect.get === 'function') {
+      const refl = ctx.reflect.get('contextLens') || ctx.reflect.get('dsh-context-lens')
+      if (refl) return refl
+    }
+  } catch (err) {
+    logger.debug('[dsh-moa:ast] context-lens reflection error:', err?.message || err)
+  }
+  return null
+}
+
+/**
+ * Parses top-level imports, declarations, and JSDoc from JS/TS source code.
+ */
+export function parseModuleDeclarations(source = '') {
+  const lines = String(source || '').split(/\r?\n/)
+  const imports = []
+  const bodyLines = []
+
+  for (const line of lines) {
+    const trimmed = line.trim()
+    if (/^import\s+/.test(trimmed) && (trimmed.endsWith(';') || trimmed.includes(' from '))) {
+      imports.push(trimmed.replace(/;$/, ''))
+    } else {
+      bodyLines.push(line)
+    }
+  }
+
+  const bodyText = bodyLines.join('\n')
+  const declarations = new Map()
+  const declRegex = /((?:\/\*\*[\s\S]*?\*\/\s*)?)(export\s+(?:async\s+)?(?:function|class|const|let|type|interface)\s+([A-Za-z0-9_$]+)[\s\S]*?)(?=(?:\n(?:\/\*\*[\s\S]*?\*\/\s*)?export\s+(?:async\s+)?(?:function|class|const|let|type|interface)\s+)|$)/g
+  let match
+  while ((match = declRegex.exec(bodyText)) !== null) {
+    const jsdoc = (match[1] || '').trim()
+    const code = (match[2] || '').trim()
+    const name = match[3]
+    if (name) {
+      declarations.set(name, { name, jsdoc, code })
+    }
+  }
+
+  return { imports, declarations, rawBody: bodyText.trim() }
+}
+
+/**
+ * Validates JavaScript syntax using node:vm compileFunction (ignoring TypeScript-only syntax).
+ */
+export function isValidJsAstSyntax(code = '', filename = 'module.js') {
+  if (/\.tsx?$/i.test(filename)) return true
+  const stripped = String(code)
+    .replace(/^\s*import\s+[\s\S]*?from\s+['"][^'"]+['"];?\s*$/gm, '')
+    .replace(/^\s*import\s+['"][^'"]+['"];?\s*$/gm, '')
+    .replace(/^\s*export\s+default\s+/gm, 'const __default_export__ = ')
+    .replace(/^\s*export\s+(async\s+function|function|class|const|let|var)\b/gm, '$1')
+    .replace(/^\s*export\s*\{[^}]*\};?\s*$/gm, '')
+  try {
+    new vm.Script(stripped, { filename })
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Merges multiple candidate versions of the same file at declaration/AST level:
+ * - Deduplicates all import statements without collisions
+ * - Combines the richest JSDoc documentation, type signature, and implementation per symbol
+ */
+export async function mergeCandidateAstFiles(candidates = [], options = {}) {
+  const lens = resolveContextLensService(options.ctx, options.contextLens)
+  const byPath = new Map()
+
+  for (const cand of candidates) {
+    if (!cand || cand.ok === false) continue
+    const files = Array.isArray(cand.files) && cand.files.length > 0
+      ? cand.files
+      : extractFileBlocks(cand.text || '')
+    for (const f of files) {
+      const rel = f.relativePath || f.path
+      if (!rel || !f.content) continue
+      if (!byPath.has(rel)) byPath.set(rel, [])
+      byPath.get(rel).push({
+        candidateIndex: cand.index,
+        label: cand.label,
+        content: f.content,
+      })
+    }
+  }
+
+  const mergedFiles = []
+  for (const [relativePath, versions] of byPath.entries()) {
+    if (versions.length === 1) {
+      mergedFiles.push({
+        relativePath,
+        content: versions[0].content,
+        contributors: [versions[0].label || `Candidate ${versions[0].candidateIndex}`],
+        usedContextLens: Boolean(lens),
+      })
+      continue
+    }
+
+    // If dsh-context-lens provides a native mergeAst or analyzeAst method, use it first
+    if (lens && typeof lens.mergeAst === 'function') {
+      try {
+        const mergedCode = await lens.mergeAst({
+          filePath: relativePath,
+          versions: versions.map((v) => v.content),
+        })
+        if (mergedCode && typeof mergedCode === 'string' && isValidJsAstSyntax(mergedCode, relativePath)) {
+          mergedFiles.push({
+            relativePath,
+            content: mergedCode,
+            contributors: versions.map((v) => v.label || `Candidate ${v.candidateIndex}`),
+            usedContextLens: true,
+          })
+          continue
+        }
+      } catch (err) {
+        logger.warn(`[dsh-moa:ast-merge] contextLens.mergeAst failed for ${relativePath}, using declaration AST merger:`, err?.message || err)
+      }
+    }
+
+    // Declaration-level AST synthesis: deduplicate imports & merge JSDoc + bodies
+    const uniqueImports = new Set()
+    const mergedDecls = new Map()
+
+    for (const ver of versions) {
+      const parsed = parseModuleDeclarations(ver.content)
+      for (const imp of parsed.imports) uniqueImports.add(imp)
+
+      for (const [symName, decl] of parsed.declarations.entries()) {
+        if (!mergedDecls.has(symName)) {
+          mergedDecls.set(symName, { ...decl })
+        } else {
+          const existing = mergedDecls.get(symName)
+          // Keep the richest JSDoc comment from any candidate
+          if (decl.jsdoc && decl.jsdoc.length > (existing.jsdoc || '').length) {
+            existing.jsdoc = decl.jsdoc
+          }
+          // Prefer more comprehensive implementation if existing is a short stub
+          if (decl.code.length > existing.code.length && existing.code.length < 120) {
+            existing.code = decl.code
+          }
+        }
+      }
+    }
+
+    let assembled = ''
+    if (uniqueImports.size > 0) {
+      assembled += Array.from(uniqueImports).map((i) => `${i};`).join('\n') + '\n\n'
+    }
+    if (mergedDecls.size > 0) {
+      assembled += Array.from(mergedDecls.values())
+        .map((d) => (d.jsdoc ? `${d.jsdoc}\n${d.code}` : d.code))
+        .join('\n\n') + '\n'
+    } else {
+      assembled = versions[0].content
+    }
+
+    if (!isValidJsAstSyntax(assembled, relativePath)) {
+      assembled = versions[0].content
+    }
+
+    mergedFiles.push({
+      relativePath,
+      content: assembled,
+      contributors: versions.map((v) => v.label || `Candidate ${v.candidateIndex}`),
+      usedContextLens: Boolean(lens),
+    })
+  }
+
+  return mergedFiles
+}
+
+/**
+ * Builds the AST-level composite merge directive for the Judge/Curator.
+ * Gracefully falls back to standard buildCompositeBlockDirectives when dsh-context-lens is absent
+ * and no multi-version AST declarations are detected.
+ */
+export async function buildAstCompositeMergeDirective(candidates = [], options = {}) {
+  const lens = resolveContextLensService(options.ctx, options.contextLens)
+  const mergedFiles = await mergeCandidateAstFiles(candidates, options)
+  const baseDirective = buildCompositeBlockDirectives(candidates, options)
+
+  if (!lens && mergedFiles.length === 0) {
+    return {
+      degraded: true,
+      usedContextLens: false,
+      mergedFiles: [],
+      directive: baseDirective,
+    }
+  }
+
+  const astBlocks = mergedFiles
+    .map((mf) => `#### AST Pre-Merged Preview: \`${mf.relativePath}\` (Contributors: ${mf.contributors.join(', ')})\n\`\`\`js path=${mf.relativePath}\n${mf.content.trim()}\n\`\`\``)
+    .join('\n\n')
+
+  const directive = [
+    baseDirective.trim(),
+    `\n### 🌳 AST-Level Semantic Composite Merge (${lens ? 'via `dsh-context-lens`' : 'Fallback Declaration Merger'}):`,
+    'Imports have been deduplicated and declarations (JSDoc, type signatures, and function bodies) have been aligned across candidates:',
+    astBlocks,
+  ].join('\n\n')
+
+  return {
+    degraded: !lens,
+    usedContextLens: Boolean(lens),
+    mergedFiles,
+    directive,
+  }
+}
+

package/lib/moa-schema.js

@@ -72,6 +72,13 @@ export const PresetSchema = z.object({
   self_healing_command: z.string().default("npm test"),
   visual_moa_enabled: z.boolean().default(false),
   elo_ranking_enabled: z.boolean().default(true),
+  ast_composite_merge_enabled: z.boolean().default(false),
+  speculative_moa_enabled: z.boolean().default(false),
+  speculative_draft_model: ModelSlotSchema.default({ provider: "", model: "" }),
+  adversarial_tdd_enabled: z.boolean().default(false),
+  local_preflight_check: z.boolean().default(true),
+  early_exit_consensus_enabled: z.boolean().default(false),
+  early_exit_threshold: z.number().default(0.95),
 })
 
 export const Config = z.object({
@@ -90,6 +97,13 @@ export const Config = z.object({
   self_healing_command: z.string().default("npm test").volatile(),
   visual_moa_enabled: z.boolean().default(false).volatile(),
   elo_ranking_enabled: z.boolean().default(true).volatile(),
+  ast_composite_merge_enabled: z.boolean().default(false).volatile(),
+  speculative_moa_enabled: z.boolean().default(false).volatile(),
+  speculative_draft_model: ModelSlotSchema.default({ provider: "", model: "" }).volatile(),
+  adversarial_tdd_enabled: z.boolean().default(false).volatile(),
+  local_preflight_check: z.boolean().default(true).volatile(),
+  early_exit_consensus_enabled: z.boolean().default(false).volatile(),
+  early_exit_threshold: z.number().default(0.95).volatile(),
   smart_routing_model: ModelSlotSchema.default({ provider: '', model: '' }).volatile(),
   prices: z.dict(PriceRow).default({}).volatile(),
   presets: z.array(PresetSchema).default([
@@ -151,3 +165,4 @@ export function plainConfig(value) {
   }
   return value
 }
+

package/lib/moa-speculative.js

@@ -0,0 +1,195 @@
+/**
+ * Speculative MoA with Fast-Draft Model and Multi-Auditor Diffs (#247)
+ * Generates a rapid initial draft using speculative_draft_model, dispatches the draft
+ * to reference models in parallel as diff auditors (producing targeted SEARCH/REPLACE
+ * or unified diff hunks), applies valid hunks to the draft, and gracefully falls back
+ * to standard parallel MoA if the draft model fails.
+ */
+
+import { logger } from './logger.js'
+import { slotLabel } from './moa-prompts.js'
+import { estimateTokenCost } from './pricing.js'
+
+/**
+ * Applies SEARCH/REPLACE or unified diff patches onto a base draft text.
+ *
+ * @param {string} draftText
+ * @param {string} patchText
+ * @returns {{ patchedText: string, appliedCount: number }}
+ */
+export function applyAuditorPatchHunks(draftText = '', patchText = '') {
+  let result = String(draftText || '')
+  let appliedCount = 0
+
+  // 1. Support SEARCH / REPLACE blocks:
+  // <<<<<<< SEARCH
+  // ...
+  // =======
+  // ...
+  // >>>>>>> REPLACE
+  const searchReplaceRegex = /<{5,9}\s*SEARCH\r?\n([\s\S]*?)\r?\n={5,9}\r?\n([\s\S]*?)\r?\n>{5,9}\s*REPLACE/g
+  let srMatch
+  while ((srMatch = searchReplaceRegex.exec(patchText)) !== null) {
+    const searchBlock = srMatch[1]
+    const replaceBlock = srMatch[2]
+    if (searchBlock && result.includes(searchBlock)) {
+      result = result.replace(searchBlock, replaceBlock)
+      appliedCount++
+    }
+  }
+
+  // 2. Support unified diff hunks (- oldLine / + newLine)
+  if (appliedCount === 0 && /```diff[\r\n]+([\s\S]*?)```/i.test(patchText)) {
+    const diffMatch = /```diff[\r\n]+([\s\S]*?)```/i.exec(patchText)
+    const diffLines = diffMatch[1].split(/\r?\n/)
+    const removed = []
+    const added = []
+    for (const line of diffLines) {
+      if (line.startsWith('---') || line.startsWith('+++') || line.startsWith('@@')) continue
+      if (line.startsWith('-')) removed.push(line.slice(1))
+      else if (line.startsWith('+')) added.push(line.slice(1))
+    }
+    if (removed.length > 0) {
+      const targetChunk = removed.join('\n')
+      const replacementChunk = added.join('\n')
+      if (result.includes(targetChunk)) {
+        result = result.replace(targetChunk, replacementChunk)
+        appliedCount++
+      }
+    }
+  }
+
+  return { patchedText: result, appliedCount }
+}
+
+/**
+ * Executes Speculative MoA:
+ * 1. Calls fast draft model (`speculative_draft_model` or first reference slot).
+ * 2. Dispatches draft to reference models in parallel as diff auditors.
+ * 3. Applies valid diff hunks onto draft so each auditor produces a refined candidate output.
+ * 4. If the draft model fails, returns `{ fallbackToStandard: true }` so the caller runs standard parallel MoA.
+ */
+export async function runSpeculativeMoa(references = [], messages = [], options = {}, callLlm, onProgress) {
+  const draftSlot = (options.draftModel?.provider && options.draftModel?.model)
+    ? options.draftModel
+    : references[0]
+
+  if (!draftSlot || !draftSlot.provider || !draftSlot.model) {
+    return { fallbackToStandard: true, reason: 'No valid speculative draft model configured' }
+  }
+
+  const draftLabel = slotLabel(draftSlot)
+  if (typeof onProgress === 'function') {
+    onProgress(`⚡ *Speculative MoA: Generating fast initial draft with \`${draftLabel}\`...*\n`)
+  }
+
+  const draftStart = Date.now()
+  let draftText = ''
+  let draftUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0 }
+
+  try {
+    const draftRes = await callLlm({
+      provider: draftSlot.provider,
+      model: draftSlot.model,
+      messages,
+      systemPrompt: options.systemPrompt,
+      temperature: options.temperature ?? 0.3,
+      maxTokens: options.maxTokens ?? 4096,
+      signal: options.signal,
+    })
+    draftText = typeof draftRes === 'string' ? draftRes : (draftRes?.content || draftRes?.text || '')
+    if (!draftText || !draftText.trim()) {
+      throw new Error('Empty draft response from speculative draft model')
+    }
+    const rawUsage = (typeof draftRes === 'object' && draftRes?.usage) ? draftRes.usage : {
+      inputTokens: 100,
+      outputTokens: Math.max(1, Math.round(draftText.length / 4)),
+    }
+    draftUsage = estimateTokenCost(draftSlot, rawUsage, options.prices || {})
+  } catch (err) {
+    logger.warn(`[dsh-moa:speculative] Draft model ${draftLabel} failed (${err?.message || err}); falling back to standard parallel MoA.`)
+    if (typeof onProgress === 'function') {
+      onProgress(`⚠️ *Speculative draft model \`${draftLabel}\` failed; falling back to standard parallel MoA...*\n`)
+    }
+    return { fallbackToStandard: true, reason: err?.message || String(err) }
+  }
+
+  const draftDurationMs = Date.now() - draftStart
+  if (typeof onProgress === 'function') {
+    onProgress(`🔍 *Speculative MoA: Dispatching draft to ${references.length} parallel diff auditor(s)...*\n`)
+  }
+
+  const lastUserPrompt = messages[messages.length - 1]?.content || ''
+  const auditTasks = references.map(async (slot, idx) => {
+    const candidateIndex = idx + 1
+    const label = slotLabel(slot)
+    const auditStart = Date.now()
+
+    const auditPrompt = [
+      `You are Speculative Auditor #${candidateIndex} (${label}).`,
+      `Review the fast draft below for the user task and provide targeted diff fixes (logic bugs, edge cases, types, security) using SEARCH/REPLACE blocks or \`\`\`diff hunks.`,
+      `\n### Original User Task:\n${lastUserPrompt}`,
+      `\n### Fast Draft Solution (${draftLabel}):\n${draftText}`,
+      `\nOutput your audit notes and any SEARCH/REPLACE or \`\`\`diff blocks needed to perfect the draft.`,
+    ].join('\n')
+
+    try {
+      const auditRes = await callLlm({
+        provider: slot.provider,
+        model: slot.model,
+        messages: [{ role: 'user', content: auditPrompt }],
+        temperature: 0.2,
+        maxTokens: Math.min(options.maxTokens ?? 2048, 2048),
+        signal: options.signal,
+      })
+      const auditText = typeof auditRes === 'string' ? auditRes : (auditRes?.content || auditRes?.text || '')
+      const rawAuditUsage = (typeof auditRes === 'object' && auditRes?.usage) ? auditRes.usage : {
+        inputTokens: Math.max(1, Math.round(auditPrompt.length / 4)),
+        outputTokens: Math.max(1, Math.round(auditText.length / 4)),
+      }
+      const auditCost = estimateTokenCost(slot, rawAuditUsage, options.prices || {})
+
+      const { patchedText, appliedCount } = applyAuditorPatchHunks(draftText, auditText)
+      const combinedText = appliedCount > 0
+        ? `${patchedText}\n\n#### Speculative Auditor Diff Notes (${label}, ${appliedCount} hunk(s) applied):\n${auditText}`
+        : `${draftText}\n\n#### Speculative Auditor Review (${label}):\n${auditText}`
+
+      return {
+        index: candidateIndex,
+        slot,
+        label,
+        text: combinedText,
+        speculativeAppliedHunks: appliedCount,
+        speculativeDraftModel: draftLabel,
+        usage: {
+          inputTokens: auditCost.inputTokens + (idx === 0 ? draftUsage.inputTokens : 0),
+          outputTokens: auditCost.outputTokens + (idx === 0 ? draftUsage.outputTokens : 0),
+          totalTokens: auditCost.totalTokens + (idx === 0 ? draftUsage.totalTokens : 0),
+        },
+        costUsd: Number((auditCost.costUsd + (idx === 0 ? draftUsage.costUsd : 0)).toFixed(6)),
+        durationMs: (Date.now() - auditStart) + (idx === 0 ? draftDurationMs : 0),
+        ok: true,
+      }
+    } catch (err) {
+      return {
+        index: candidateIndex,
+        slot,
+        label,
+        text: draftText,
+        error: err?.message || String(err),
+        usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+        costUsd: 0,
+        durationMs: Date.now() - auditStart,
+        ok: false,
+      }
+    }
+  })
+
+  const referenceOutputs = await Promise.all(auditTasks)
+  return {
+    fallbackToStandard: false,
+    draftModel: draftLabel,
+    draftText,
+    referenceOutputs,
+  }
+}

package/lib/moa-swarm.js

@@ -114,17 +114,23 @@ export async function cleanupSwarmWorktrees(cwd, runId, worktrees = []) {
     if (wt.isGitWorktree) {
       try {
         await execFileAsync('git', ['worktree', 'remove', '--force', wt.worktreePath], { cwd, timeout: 8000 })
-      } catch {}
+      } catch (err) {
+        logger.debug('[dsh-moa:swarm] cleanup worktree remove error:', err?.message || err)
+      }
     }
     try {
       await fs.rm(wt.worktreePath, { recursive: true, force: true })
-    } catch {}
+    } catch (err) {
+      logger.debug('[dsh-moa:swarm] cleanup rm error:', err?.message || err)
+    }
   }
 
   if (await isGitRepository(cwd)) {
     try {
       await execFileAsync('git', ['worktree', 'prune'], { cwd, timeout: 5000 })
-    } catch {}
+    } catch (err) {
+      logger.debug('[dsh-moa:swarm] cleanup prune error:', err?.message || err)
+    }
   }
 
   const safeRunId = String(runId || '').replace(/[^a-zA-Z0-9_-]/g, '')
@@ -132,7 +138,9 @@ export async function cleanupSwarmWorktrees(cwd, runId, worktrees = []) {
     const swarmRoot = path.join(cwd, '.moa', `swarm-${safeRunId}`)
     try {
       await fs.rm(swarmRoot, { recursive: true, force: true })
-    } catch {}
+    } catch (err) {
+      logger.debug('[dsh-moa:swarm] cleanup swarmRoot error:', err?.message || err)
+    }
   }
 }
 
@@ -217,3 +225,4 @@ export async function runSubagentSwarm(references, messages, options = {}, callL
     await cleanupSwarmWorktrees(cwd, runId, worktrees)
   }
 }
+

package/lib/moa-workbench.js

@@ -51,6 +51,12 @@ export const COMPANION_PLUGINS = [
     url: 'https://github.com/GooDAnDReaDY/dsh-live-canvas',
     description: 'Isolated live HTML/CSS/SVG preview environment and screenshot capture',
   },
+  {
+    id: 'dsh-context-lens',
+    name: 'DSH Context Lens',
+    url: 'https://github.com/GooDAnDReaDY/dsh-context-lens',
+    description: 'Semantic AST parsing and symbol-level composite code merging',
+  },
 ]
 
 /**

package/lib/pipeline/candidates.js

@@ -1,3 +1,5 @@
+import { runSpeculativeMoa } from '../moa-speculative.js'
+import { runAdversarialTddLoop } from '../moa-adversarial-tdd.js'
 import { assignAdaptivePersonas } from '../moa-adaptive-personas.js'
 import { runSubagentSwarm } from '../moa-swarm.js'
 import { runReferencesParallel } from '../moa-candidates.js'
@@ -37,7 +39,29 @@ export async function stageCandidateRound1({
     ? assignAdaptivePersonas(effectiveReferences, typeof lastMsgText === 'string' ? lastMsgText : '').references
     : effectiveReferences
 
-  const referenceOutputs = preset?.subagent_swarm_enabled
+  let referenceOutputs = null
+  if (preset?.speculative_moa_enabled && !preset?.subagent_swarm_enabled) {
+    const specRes = await runSpeculativeMoa(
+      adaptiveRefs,
+      enrichedMessages,
+      {
+        draftModel: preset.speculative_draft_model,
+        systemPrompt: candidateSystemPrompt,
+        temperature: refTemp,
+        maxTokens,
+        prices,
+        signal,
+      },
+      callLlm,
+      onProgress
+    )
+    if (!specRes.fallbackToStandard && Array.isArray(specRes.referenceOutputs)) {
+      referenceOutputs = specRes.referenceOutputs
+    }
+  }
+
+  if (!referenceOutputs) {
+    referenceOutputs = preset?.subagent_swarm_enabled
     ? await runSubagentSwarm(adaptiveRefs, enrichedMessages, { temperature: refTemp, maxTokens, signal, cwd, runId }, callLlm, onProgress)
     : await runReferencesParallel(
     adaptiveRefs,
@@ -59,6 +83,7 @@ export async function stageCandidateRound1({
     callLlm,
     onProgress
   )
+  }
 
   if (signal?.aborted) {
     await cleanMoaWorkspaces(cwd, { runId })
@@ -104,5 +129,20 @@ export async function stageCandidateRound1({
     onProgress,
   })
 
-  return { ok: true, referenceOutputs, successfulRefs }
+  let adversarialTddResult = null
+  if (preset?.adversarial_tdd_enabled) {
+    adversarialTddResult = await runAdversarialTddLoop({
+      cwd,
+      runId,
+      userPrompt: typeof lastMsgText === "string" ? lastMsgText : "",
+      referenceOutputs,
+      preset,
+      callLlm,
+      execFn,
+      onProgress,
+      signal,
+    })
+  }
+
+  return { ok: true, referenceOutputs, successfulRefs, adversarialTddResult }
 }

package/lib/pipeline/context.js

@@ -38,6 +38,9 @@ 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 collectedCtx = await collectProjectContext(cwd, 16000)
   const isRefinement = Boolean(collectedCtx?.files?.length > 0 && isRefinementTask(userPrompt, collectedCtx.files))
@@ -123,5 +126,7 @@ export async function stageProjectContext({
     allowCandidateOverride, collectedCtx, isRefinement, projectContext,
     effectiveReferences, quotaSubstitutions, priorTurnBaseline, candidateSystemPrompt,
     needsQuestions, enrichedMessages,
+    localPreflightCheck, earlyExitConsensusEnabled, earlyExitThreshold,
   }
 }
+