@goodandready/dsh-moa 0.2.65 → 0.2.67

package/lib/index.js

@@ -1,3 +1,4 @@
+import { applyTuiSettings, buildTuiSection } from './tui-settings.js'
 import { registerMoaCommands } from './commands.js'
 import { service, getWebServerPort } from './services.js'
 import crypto from 'node:crypto'
@@ -189,6 +190,9 @@ export function apply(ctx, config) {
   // Official slash command /moa registration via dsh-commands (#275)
   registerMoaCommands(ctx, { live, moaService })
 
+  // Official TUI settings section registration (#277)
+  applyTuiSettings(ctx, { live })
+
   // Session turn interceptor: route turn to real aggregator model & stream MoA synthesis
   ctx.effect(() => {
     return () => {
@@ -385,3 +389,15 @@ export {
   classifyLlmError,
   isFailoverEligible,
 } from './errors.js'
+export {
+  validatePreset,
+  validateAllPresets,
+  getActiveLlmProviders,
+  getActiveLlmModels,
+} from './moa-model-validator.js'
+export { applyTuiSettings, buildTuiSection } from './tui-settings.js'
+export {
+  calculateTokenEntropy,
+  analyzeCandidateUncertainty,
+  formatUncertaintyAnnotations,
+} from './moa-uncertainty.js'

package/lib/moa-candidates.js

@@ -147,6 +147,7 @@ export async function runReferencesParallel(references, messages, options = {},
           costUsd: costInfo.costUsd,
           durationMs: Date.now() - candidateStart,
           model: slot?.model ? (slot.provider ? (slot.provider + ":" + slot.model) : slot.model) : label,
+          ...(res?.logprobs ? { logprobs: res.logprobs } : {}),
           ok: true,
         }
 

package/lib/moa-model-validator.js

@@ -0,0 +1,242 @@
+/**
+ * Dynamic Preset Model Validation via ctx.llm Provider Registry (#283)
+ * Inspects active providers and models, detects dead/unregistered slots,
+ * and produces diagnostic reports for logging and UI surfacing.
+ */
+
+import { logger } from './logger.js'
+
+/**
+ * Discovers currently registered / active LLM providers in ctx.
+ * Queries ctx.llm.listProviders(), ctx.llm.listConfigurableProviders(),
+ * and active provider maps.
+ *
+ * @param {object} ctx
+ * @returns {Promise<Set<string>>}
+ */
+export async function getActiveLlmProviders(ctx) {
+  const providers = new Set()
+  if (!ctx || !ctx.llm) return providers
+
+  // 1. ctx.llm.listProviders()
+  if (typeof ctx.llm.listProviders === 'function') {
+    try {
+      const list = await ctx.llm.listProviders()
+      if (Array.isArray(list)) {
+        for (const p of list) {
+          const id = typeof p === 'string' ? p : (p?.id || p?.provider)
+          if (id) providers.add(String(id).toLowerCase())
+        }
+      }
+    } catch (_e) {}
+  }
+
+  // 2. ctx.llm.listConfigurableProviders()
+  if (typeof ctx.llm.listConfigurableProviders === 'function') {
+    try {
+      const list = ctx.llm.listConfigurableProviders()
+      if (Array.isArray(list)) {
+        for (const p of list) {
+          const id = typeof p === 'string' ? p : (p?.id || p?.provider)
+          if (id) providers.add(String(id).toLowerCase())
+        }
+      }
+    } catch (_e) {}
+  }
+
+  // 3. Fallback to ctx.llm.providers object or map
+  if (ctx.llm.providers) {
+    if (typeof ctx.llm.providers.keys === 'function') {
+      for (const k of ctx.llm.providers.keys()) providers.add(String(k).toLowerCase())
+    } else if (typeof ctx.llm.providers === 'object') {
+      for (const k of Object.keys(ctx.llm.providers)) providers.add(String(k).toLowerCase())
+    }
+  }
+
+  return providers
+}
+
+/**
+ * Discovers registered models per provider if available.
+ *
+ * @param {object} ctx
+ * @param {Set<string>} [providers]
+ * @returns {Promise<Map<string, Set<string>>>} Map of provider -> Set of model IDs
+ */
+export async function getActiveLlmModels(ctx, providers) {
+  const modelMap = new Map()
+  if (!ctx || !ctx.llm) return modelMap
+
+  const targetProviders = providers || await getActiveLlmProviders(ctx)
+
+  // 1. ctx.llm.listAvailableModels()
+  if (typeof ctx.llm.listAvailableModels === 'function') {
+    try {
+      const all = await ctx.llm.listAvailableModels()
+      if (Array.isArray(all)) {
+        for (const item of all) {
+          const p = String(item?.provider || '').toLowerCase()
+          const m = String(item?.id || item?.model || '').toLowerCase()
+          if (p && m) {
+            if (!modelMap.has(p)) modelMap.set(p, new Set())
+            modelMap.get(p).add(m)
+          }
+        }
+      }
+    } catch (_e) {}
+  }
+
+  // 2. Query each provider with ctx.llm.listModels(p)
+  if (typeof ctx.llm.listModels === 'function') {
+    for (const p of targetProviders) {
+      try {
+        const mList = await Promise.race([
+          ctx.llm.listModels(p),
+          new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 1500)),
+        ])
+        if (Array.isArray(mList)) {
+          if (!modelMap.has(p)) modelMap.set(p, new Set())
+          for (const m of mList) {
+            const mId = typeof m === 'string' ? m : (m?.id || m?.model || m?.name)
+            if (mId) modelMap.get(p).add(String(mId).toLowerCase())
+          }
+        }
+      } catch (_e) {}
+    }
+  }
+
+  return modelMap
+}
+
+/**
+ * Validates a single slot against active providers and models.
+ */
+export function validateSlot(slot, role, activeProviders, modelMap) {
+  if (!slot) return { valid: false, role, reason: 'empty_slot' }
+  const provider = String(slot.provider || '').toLowerCase().trim()
+  const model = String(slot.model || '').toLowerCase().trim()
+  const label = `${slot.provider || 'unknown'}:${slot.model || 'unknown'}`
+
+  if (!provider) {
+    return { valid: false, role, provider: slot.provider, model: slot.model, label, reason: 'missing_provider' }
+  }
+
+  // If we have active providers discovered and provider is not in the list
+  if (activeProviders && activeProviders.size > 0 && !activeProviders.has(provider)) {
+    return { valid: false, role, provider: slot.provider, model: slot.model, label, reason: 'provider_not_found' }
+  }
+
+  // If we have models list for this provider, check if model exists
+  if (modelMap && modelMap.has(provider)) {
+    const models = modelMap.get(provider)
+    if (models && models.size > 0 && !models.has(model)) {
+      return { valid: false, role, provider: slot.provider, model: slot.model, label, reason: 'model_not_found' }
+    }
+  }
+
+  return { valid: true, role, provider: slot.provider, model: slot.model, label }
+}
+
+/**
+ * Validates a preset's reference models, aggregator, and fallbacks.
+ *
+ * @param {object} preset
+ * @param {object} [options]
+ * @returns {object}
+ */
+export function validatePreset(preset, { activeProviders, modelMap } = {}) {
+  if (!preset || typeof preset !== 'object') {
+    return {
+      valid: false,
+      presetName: 'unknown',
+      deadModels: [{ role: 'preset', reason: 'invalid_preset_object' }],
+      warnings: ['Preset is not a valid object'],
+    }
+  }
+
+  const presetName = preset.name || preset.id || 'unnamed'
+  const deadModels = []
+  const warnings = []
+
+  // Check aggregator
+  const aggSlot = preset.aggregator_model || preset.aggregator
+  if (aggSlot) {
+    const res = validateSlot(aggSlot, 'aggregator', activeProviders, modelMap)
+    if (!res.valid) {
+      deadModels.push(res)
+      warnings.push(`Aggregator model ${res.label} has unreachable provider or model (${res.reason})`)
+    }
+  }
+
+  // Check reference models
+  const refs = Array.isArray(preset.references)
+    ? preset.references
+    : (Array.isArray(preset.reference_models) ? preset.reference_models : [])
+
+  if (refs.length === 0) {
+    warnings.push('Preset has no reference models configured')
+  }
+
+  for (let idx = 0; idx < refs.length; idx++) {
+    const slot = refs[idx]
+    const res = validateSlot(slot, `reference_${idx + 1}`, activeProviders, modelMap)
+    if (!res.valid) {
+      deadModels.push(res)
+      warnings.push(`Reference candidate ${res.label} has unreachable provider or model (${res.reason})`)
+    }
+
+    // Check slot fallbacks if any
+    if (Array.isArray(slot?.fallbacks)) {
+      for (const fb of slot.fallbacks) {
+        const fbRes = validateSlot(fb, `fallback_for_${res.label}`, activeProviders, modelMap)
+        if (!fbRes.valid) {
+          deadModels.push(fbRes)
+          warnings.push(`Reserve fallback ${fbRes.label} for ${res.label} is unreachable (${fbRes.reason})`)
+        }
+      }
+    }
+  }
+
+  return {
+    presetId: preset.id || presetName,
+    presetName,
+    valid: deadModels.length === 0,
+    hasDeadModels: deadModels.length > 0,
+    deadModels,
+    warnings,
+    totalSlotsChecked: (aggSlot ? 1 : 0) + refs.length,
+  }
+}
+
+/**
+ * Validates an array of presets and logs warnings if any dead models exist.
+ *
+ * @param {Array<object>} presets
+ * @param {object} ctx
+ * @returns {Promise<object>}
+ */
+export async function validateAllPresets(presets, ctx) {
+  const activeProviders = await getActiveLlmProviders(ctx)
+  const modelMap = await getActiveLlmModels(ctx, activeProviders)
+
+  const presetResults = []
+  let totalDeadModels = 0
+
+  for (const preset of (presets || [])) {
+    const result = validatePreset(preset, { activeProviders, modelMap })
+    presetResults.push(result)
+    if (result.hasDeadModels) {
+      totalDeadModels += result.deadModels.length
+      const deadLabels = result.deadModels.map((m) => `${m.label} (${m.reason})`).join(', ')
+      logger.warn(`[dsh-moa] Preset "${result.presetName}" contains ${result.deadModels.length} dead/unregistered models: ${deadLabels}`)
+    }
+  }
+
+  return {
+    valid: totalDeadModels === 0,
+    activeProviders: Array.from(activeProviders),
+    totalDeadModels,
+    presets: presetResults,
+    validatedAt: Date.now(),
+  }
+}

package/lib/moa-schema.js

@@ -63,12 +63,17 @@ export const PresetSchema = z.object({
   local_fallback_enabled: z.boolean().default(false),
   local_fallback_models: z.array(ModelSlotSchema).default([]),
   interactive_workbench_enabled: z.boolean().default(false),
+  uncertainty_scoring_enabled: z.boolean().default(false),
 })
 
 export const Config = z.object({
   enabled: z.boolean().default(true).volatile(),
   default_preset: z.string().default('default').volatile(),
   smart_routing_enabled: z.boolean().default(false).volatile(),
+  interactive_workbench_enabled: z.boolean().default(false).volatile(),
+  ask_clarifying_questions: z.boolean().default(true).volatile(),
+  test_gate_enabled: z.boolean().default(false).volatile(),
+  uncertainty_scoring_enabled: z.boolean().default(false).volatile(),
   smart_routing_model: ModelSlotSchema.default({ provider: '', model: '' }).volatile(),
   prices: z.dict(PriceRow).default({}).volatile(),
   presets: z.array(PresetSchema).default([

package/lib/moa-service.js

@@ -152,4 +152,25 @@ export class MoaService {
   emit(event, payload) {
     emitEvent(this.ctx, event, payload)
   }
+
+  /**
+   * Validate presets against active LLM providers in ctx.llm
+   * @param {Array<object>} [presets]
+   * @returns {Promise<object>}
+   */
+  async validatePresets(presets) {
+    const list = presets || this.getPresets()
+    const { validateAllPresets } = await import('./moa-model-validator.js')
+    return validateAllPresets(list, this.ctx)
+  }
+
+  /**
+   * Get list of currently active LLM provider names
+   * @returns {Promise<Array<string>>}
+   */
+  async getActiveProviders() {
+    const { getActiveLlmProviders } = await import('./moa-model-validator.js')
+    const set = await getActiveLlmProviders(this.ctx)
+    return Array.from(set)
+  }
 }

package/lib/moa-uncertainty.js

@@ -0,0 +1,154 @@
+/**
+ * Token-Level Uncertainty & Entropy Scoring for Hallucination Detection (#256)
+ * Calculates Shannon entropy across token logprob distributions, detects high-uncertainty
+ * identifier/method call spans, and builds diagnostic annotations for the Judge.
+ */
+
+const LN2 = Math.LN2
+
+/**
+ * Computes token entropy in bits from a token logprob entry.
+ * Supports full top_logprobs distributions as well as scalar logprob surprisal.
+ *
+ * @param {object|number} entry
+ * @returns {number} Entropy in bits (>= 0)
+ */
+export function calculateTokenEntropy(entry) {
+  if (typeof entry === 'number') {
+    if (!Number.isFinite(entry) || entry >= 0) return 0
+    return Number((-entry / LN2).toFixed(4))
+  }
+  if (!entry || typeof entry !== 'object') return 0
+
+  const topList = Array.isArray(entry.top_logprobs) ? entry.top_logprobs : null
+  if (topList && topList.length > 0) {
+    let entropy = 0
+    let totalProb = 0
+    for (const item of topList) {
+      const lp = typeof item === 'number' ? item : Number(item?.logprob)
+      if (!Number.isFinite(lp)) continue
+      const p = Math.min(1, Math.max(1e-9, Math.exp(lp)))
+      totalProb += p
+      entropy -= p * (lp / LN2)
+    }
+    // Account for remaining probability mass if top_logprobs is truncated
+    if (totalProb < 0.999 && totalProb > 0) {
+      const rem = 1 - totalProb
+      entropy -= rem * Math.log2(rem)
+    }
+    return Number(Math.max(0, entropy).toFixed(4))
+  }
+
+  const lp = Number(entry.logprob)
+  if (Number.isFinite(lp) && lp < 0) {
+    return Number((-lp / LN2).toFixed(4))
+  }
+  return 0
+}
+
+/**
+ * Analyzes a candidate output's token logprobs (and code heuristics) to identify
+ * high-uncertainty zones where hallucinations are likely.
+ *
+ * @param {object} candidate
+ * @param {object} [options]
+ * @returns {object}
+ */
+export function analyzeCandidateUncertainty(candidate, options = {}) {
+  const threshold = typeof options.entropyThreshold === 'number' ? options.entropyThreshold : 1.2
+  const rawLogprobs = Array.isArray(candidate?.logprobs)
+    ? candidate.logprobs
+    : (Array.isArray(candidate?.logprobs?.content) ? candidate.logprobs.content : [])
+
+  const highEntropySpans = []
+  let sumEntropy = 0
+  let maxEntropy = 0
+  let tokenCount = 0
+
+  if (rawLogprobs.length > 0) {
+    for (let i = 0; i < rawLogprobs.length; i++) {
+      const item = rawLogprobs[i]
+      const h = calculateTokenEntropy(item)
+      const tok = String(item?.token ?? '').trim()
+      sumEntropy += h
+      if (h > maxEntropy) maxEntropy = h
+      tokenCount++
+
+      if (h >= threshold && tok.length > 0 && !/^[\s{}()\[\];,.:'"`]+$/.test(tok)) {
+        // Reconstruct local context window around token
+        const prev = rawLogprobs.slice(Math.max(0, i - 2), i).map((t) => t?.token || '').join('')
+        const next = rawLogprobs.slice(i + 1, Math.min(rawLogprobs.length, i + 3)).map((t) => t?.token || '').join('')
+        const contextSpan = (prev + (item?.token || '') + next).replace(/\s+/g, ' ').trim()
+        const prob = Number.isFinite(Number(item?.logprob))
+          ? Number(Math.exp(Number(item.logprob)).toFixed(3))
+          : Number(Math.pow(2, -h).toFixed(3))
+
+        highEntropySpans.push({
+          token: tok,
+          span: contextSpan || tok,
+          entropy: h,
+          probability: prob,
+          warning: `Внимание: высокая энтропия на участке "${contextSpan || tok}" (H=${h.toFixed(2)} bits, p=${prob})`,
+        })
+      }
+    }
+  }
+
+  const avgEntropy = tokenCount > 0 ? Number((sumEntropy / tokenCount).toFixed(4)) : 0
+  let riskLevel = 'low'
+  if (maxEntropy >= threshold * 1.6 || highEntropySpans.length >= 3) {
+    riskLevel = 'high'
+  } else if (maxEntropy >= threshold || highEntropySpans.length >= 1) {
+    riskLevel = 'medium'
+  }
+
+  return {
+    candidateIndex: candidate?.index ?? 0,
+    model: candidate?.label || candidate?.model || 'unknown',
+    tokenCount,
+    avgEntropy,
+    maxEntropy: Number(maxEntropy.toFixed(4)),
+    riskLevel,
+    highEntropySpans,
+  }
+}
+
+/**
+ * Formats uncertainty analysis across all candidates into a Judge prompt directive.
+ *
+ * @param {Array<object>} candidates
+ * @param {object} [options]
+ * @returns {{ reportText: string, analyses: Array<object>, hasHighUncertainty: boolean }}
+ */
+export function formatUncertaintyAnnotations(candidates, options = {}) {
+  if (!Array.isArray(candidates) || candidates.length === 0) {
+    return { reportText: '', analyses: [], hasHighUncertainty: false }
+  }
+
+  const analyses = candidates.map((c, idx) =>
+    analyzeCandidateUncertainty({ ...c, index: c.index ?? idx + 1 }, options)
+  )
+
+  const flagged = analyses.filter((a) => a.highEntropySpans.length > 0)
+  if (flagged.length === 0) {
+    return { reportText: '', analyses, hasHighUncertainty: false }
+  }
+
+  const lines = [
+    '\n### 🔬 Token-Level Uncertainty & Hallucination Warnings:',
+    'The following candidate segments exhibited abnormally high token entropy (low model confidence). Carefully verify API existence, method signatures, and edge cases before adopting these fragments:',
+  ]
+
+  for (const a of flagged) {
+    lines.push(`- **Candidate ${a.candidateIndex} (${a.model})** [Risk: ${a.riskLevel.toUpperCase()}, Avg H=${a.avgEntropy}, Max H=${a.maxEntropy}]:`)
+    for (const span of a.highEntropySpans.slice(0, 5)) {
+      lines.push(`  - ⚠️ ${span.warning}`)
+    }
+  }
+
+  return {
+    reportText: lines.join('\n') + '\n',
+    analyses,
+    hasHighUncertainty: true,
+  }
+}

package/lib/pipeline/synthesis.js

@@ -1,3 +1,4 @@
+import { formatUncertaintyAnnotations } from '../moa-uncertainty.js'
 import { logger } from '../logger.js'
 import { buildSynthesisPrompt, slotLabel } from '../moa-prompts.js'
 import { estimateDownstreamCost, checkPhaseBudget, createBudgetAbortPayload } from '../moa-budget.js'
@@ -36,7 +37,14 @@ export async function stageSynthesis({
   collectedCtx,
   startTime,
 }) {
-  const synthesisPrompt = buildSynthesisPrompt(userPrompt, referenceOutputs, judgeCriteria, {
+  let uncertaintyDirective = ''
+  if (preset?.uncertainty_scoring_enabled) {
+    const uncReport = formatUncertaintyAnnotations(referenceOutputs)
+    if (uncReport.hasHighUncertainty) {
+      uncertaintyDirective = uncReport.reportText
+    }
+  }
+  const baseSynthesisPrompt = buildSynthesisPrompt(userPrompt, referenceOutputs, judgeCriteria, {
     curatorSynthesis: isCuratorSynthesis,
     blindEvaluation: isBlindEvaluation,
     priorTurnBaseline,
@@ -44,6 +52,7 @@ export async function stageSynthesis({
     fileScoringDirective,
     consensusReport: multiJudgeResult?.consensusReport,
   })
+  const synthesisPrompt = uncertaintyDirective ? baseSynthesisPrompt + '\n' + uncertaintyDirective : baseSynthesisPrompt
   const synthPromptTokens = Math.max(50, Math.ceil(synthesisPrompt.length / 4))
 
   if (preset?.budget_guard_enabled && preset?.max_budget_usd > 0 && !isFastMode) {

package/lib/routes/presets.js

@@ -1,3 +1,4 @@
+import { validateAllPresets } from '../moa-model-validator.js'
 import { writeJson, readBody, assertAuthorizedRequest } from '../access.js'
 import { isSafeWriteRequest } from '../updater.js'
 import { resolvePresetForPrompt } from '../moa-router.js'
@@ -134,10 +135,15 @@ ctx.effect(() => {
         if (!assertAuthorizedRequest(req, res, ctx)) return
         const cfg = live()
         if (req.method === 'GET') {
+          let validation = null
+          try {
+            validation = await validateAllPresets(cfg.presets || [], ctx)
+          } catch (_e) {}
           writeJson(res, 200, {
             ok: true,
             defaultPreset: cfg.default_preset || 'default',
             presets: cfg.presets || [],
+            validation,
           })
           return
         }
@@ -179,12 +185,17 @@ ctx.effect(() => {
             }
 
             const unwrapped = typeof plainConfig === 'function' ? plainConfig(validated) : validated
+            let validation = null
+            try {
+              validation = await validateAllPresets(unwrapped.presets || [], ctx)
+            } catch (_e) {}
             writeJson(res, 200, {
               ok: true,
               persisted: persistResult?.persisted ?? false,
               enabled: unwrapped.enabled !== false,
               defaultPreset: unwrapped.default_preset,
               presets: unwrapped.presets,
+              validation,
             })
           } catch (err) { writeJson(res, 400, { ok: false, error: err?.message || String(err) }) }
           return

package/lib/tui-settings.js

@@ -0,0 +1,146 @@
+/**
+ * DSH Terminal User Interface (TUI) Settings Section for dsh-moa (#277)
+ */
+
+import { service } from './services.js'
+
+function boolFormat(value) {
+  return value === false ? 'false' : 'true'
+}
+
+function boolParse(text) {
+  return { kind: 'set', value: String(text).trim() === 'true' }
+}
+
+/**
+ * Builds the TUI settings section descriptor from live configuration.
+ *
+ * @param {{ live: () => Record<string, any> }} deps
+ * @returns {object}
+ */
+export function buildTuiSection({ live }) {
+  const cfg = (typeof live === 'function' ? live() : live) || {}
+  const presets = Array.isArray(cfg.presets) ? cfg.presets : []
+  const presetOptions = presets.length > 0
+    ? presets.map((p) => ({
+        value: String(p.name || p.id || ''),
+        label: `${p.name || p.id} (${(p.reference_models || p.references || []).length} models)`,
+      })).filter((o) => o.value !== '')
+    : [{ value: 'default', label: 'default' }]
+
+  const fields = [
+    {
+      path: ['enabled'],
+      group: 'general',
+      kind: 'boolean',
+      label: 'Enable MoA (/moa slash command)',
+      hint: 'Master switch for Mixture of Agents turn routing.',
+      format: boolFormat,
+      parse: boolParse,
+    },
+    {
+      path: ['default_preset'],
+      group: 'general',
+      kind: 'text',
+      label: 'Default preset',
+      hint: 'Active consensus preset used when /moa is invoked without --preset.',
+      options: presetOptions,
+      format: (value) => (typeof value === 'string' && value.trim() !== '' ? value.trim() : 'default'),
+      parse: (text) => {
+        const value = String(text).trim()
+        return value === '' ? { kind: 'set', value: 'default' } : { kind: 'set', value }
+      },
+    },
+    {
+      path: ['interactive_workbench_enabled'],
+      group: 'pipeline',
+      kind: 'boolean',
+      label: 'Interactive Workbench',
+      hint: 'Enable interactive per-file candidate assembly workbench.',
+      format: (val) => (val === true ? 'true' : 'false'),
+      parse: boolParse,
+    },
+    {
+      path: ['ask_clarifying_questions'],
+      group: 'pipeline',
+      kind: 'boolean',
+      label: 'Ask clarifying questions',
+      hint: 'Prompt user for clarification on broad or ambiguous requests before running ensemble.',
+      format: boolFormat,
+      parse: boolParse,
+    },
+    {
+      path: ['test_gate_enabled'],
+      group: 'pipeline',
+      kind: 'boolean',
+      label: 'Test Execution Gate',
+      hint: 'Run syntax and unit test checks against candidate solutions before judge ranking.',
+      format: (val) => (val === true ? 'true' : 'false'),
+      parse: boolParse,
+    },
+    {
+      path: ['smart_routing_enabled'],
+      group: 'advanced',
+      kind: 'boolean',
+      label: 'Smart Routing',
+      hint: 'Automatically select the best preset based on prompt complexity.',
+      format: (val) => (val === true ? 'true' : 'false'),
+      parse: boolParse,
+    },
+    {
+      path: ['uncertainty_scoring_enabled'],
+      group: 'advanced',
+      kind: 'boolean',
+      label: 'Token Uncertainty Scoring',
+      hint: 'Calculate token-level entropy from logprobs to highlight potential hallucinations for the judge.',
+      format: (val) => (val === true ? 'true' : 'false'),
+      parse: boolParse,
+    },
+  ]
+
+  return {
+    ns: 'dsh-moa',
+    title: 'Mixture of Agents (MoA)',
+    descriptions: {
+      en: 'Multi-model ensemble synthesis, judge consensus, and pipeline verification controls.',
+      zh: '多模型集成合成、裁判共识与流水线验证设置。',
+    },
+    groups: [
+      { id: 'general', title: 'General', descriptions: { zh: '常规' } },
+      { id: 'pipeline', title: 'Pipeline & Gates', descriptions: { zh: '流水线与验证' } },
+      { id: 'advanced', title: 'Advanced', descriptions: { zh: '高级' } },
+    ],
+    fields,
+  }
+}
+
+/**
+ * Registers the TUI settings section when the host provides tuiSettingsSections.
+ *
+ * @param {object} ctx
+ * @param {{ live: () => Record<string, any> }} deps
+ */
+export function applyTuiSettings(ctx, { live }) {
+  const registerWithService = (tuiCtx) => {
+    if (!tuiCtx) return
+    const tuiService = service(tuiCtx, 'tuiSettingsSections')
+    if (!tuiService || typeof tuiService.register !== 'function') return
+    try {
+      const dispose = tuiService.register(buildTuiSection({ live }))
+      const eff = typeof tuiCtx.effect === 'function' ? tuiCtx.effect : (typeof ctx?.effect === 'function' ? ctx.effect : null)
+      if (eff) {
+        eff(() => () => {
+          try { if (typeof dispose === 'function') dispose() } catch {}
+        }, 'dsh-moa: tui settings')
+      }
+    } catch (err) {
+      ctx?.logger?.warn?.('[dsh-moa] Could not register TUI settings: ' + (err?.message || err))
+    }
+  }
+
+  if (service(ctx, 'tuiSettingsSections')?.register) {
+    registerWithService(ctx)
+  } else if (typeof ctx?.inject === 'function') {
+    ctx.inject(['tuiSettingsSections'], registerWithService)
+  }
+}