@goodandready/dsh-moa 0.2.66 → 0.2.68

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 () => {
@@ -391,3 +395,21 @@ export {
   getActiveLlmProviders,
   getActiveLlmModels,
 } from './moa-model-validator.js'
+export { applyTuiSettings, buildTuiSection } from './tui-settings.js'
+export {
+  calculateTokenEntropy,
+  analyzeCandidateUncertainty,
+  formatUncertaintyAnnotations,
+} from './moa-uncertainty.js'
+export {
+  classifyPromptDomain,
+  assignAdaptivePersonas,
+  DOMAIN_PERSONA_POOLS,
+} from './moa-adaptive-personas.js'
+export {
+  isGitRepository,
+  createSwarmWorktree,
+  collectSwarmWorktreeDiff,
+  cleanupSwarmWorktrees,
+  runSubagentSwarm,
+} from './moa-swarm.js'

package/lib/moa-adaptive-personas.js

@@ -0,0 +1,176 @@
+/**
+ * Prompt-Adaptive Dynamic Persona Synthesis for Reference Models (#254)
+ * Classifies prompt technical domain and synthesizes complementary engineering personas
+ * dynamically so each candidate approaches the task from a distinct expert angle.
+ */
+
+export const DOMAIN_PERSONA_POOLS = {
+  database: [
+    {
+      id: 'dba_index_specialist',
+      title: 'DBA Index Specialist',
+      prompt: 'You are a Principal DBA Index Specialist. Focus on query execution plans, composite indexing, lock contention prevention, and optimal read/write throughput.',
+    },
+    {
+      id: 'zero_downtime_migration_guard',
+      title: 'Zero-Downtime Migration Guard',
+      prompt: 'You are a Zero-Downtime Migration Guard. Ensure backward-compatible schema evolutions, safe expand-and-contract patterns, and rollback safety.',
+    },
+    {
+      id: 'orm_query_architect',
+      title: 'ORM & Query Architect',
+      prompt: 'You are an ORM & Query Architect. Focus on eliminating N+1 queries, clean repository abstractions, transaction isolation levels, and strict data integrity.',
+    },
+  ],
+  frontend: [
+    {
+      id: 'a11y_ux_specialist',
+      title: 'Accessibility & UX Specialist',
+      prompt: 'You are an Accessibility & UX Specialist. Ensure WCAG 2.1 AA compliance, keyboard navigation, ARIA semantics, and responsive user feedback.',
+    },
+    {
+      id: 'css_design_systems_architect',
+      title: 'CSS & Design Systems Architect',
+      prompt: 'You are a CSS & Design Systems Architect. Focus on design tokens, layout resilience, fluid typography, zero layout shift, and clean component composition.',
+    },
+    {
+      id: 'state_rendering_optimizer',
+      title: 'State & Rendering Optimizer',
+      prompt: 'You are a Frontend State & Rendering Optimizer. Focus on minimizing unnecessary re-renders, memoization, deterministic state transitions, and bundle efficiency.',
+    },
+  ],
+  security: [
+    {
+      id: 'offensive_security_auditor',
+      title: 'Offensive Security Auditor',
+      prompt: 'You are an Offensive Security Auditor. Proactively hunt for injection vectors, SSRF, path traversal, auth bypass, and privilege escalation.',
+    },
+    {
+      id: 'defensive_hardening_specialist',
+      title: 'Defensive Hardening Specialist',
+      prompt: 'You are a Defensive Hardening Specialist. Enforce least-privilege access, strict input validation, fail-closed guards, and cryptographic best practices.',
+    },
+    {
+      id: 'runtime_sandbox_guardian',
+      title: 'Runtime & Sandbox Guardian',
+      prompt: 'You are a Runtime & Sandbox Guardian. Focus on resource limits, rate limiting, secret sanitization, and zero-trust boundary enforcement.',
+    },
+  ],
+  performance: [
+    {
+      id: 'algorithmic_optimizer',
+      title: 'Algorithmic Complexity Optimizer',
+      prompt: 'You are an Algorithmic Complexity Optimizer. Replace O(N^2) bottlenecks with optimal data structures, streaming pipelines, and bounded memory usage.',
+    },
+    {
+      id: 'concurrency_profiler',
+      title: 'Memory & Concurrency Profiler',
+      prompt: 'You are a Memory & Concurrency Profiler. Prevent event-loop blocking, race conditions, memory leaks, and unbounded promise queues.',
+    },
+  ],
+  testing: [
+    {
+      id: 'edge_case_fuzzer',
+      title: 'Edge-Case & Fuzzing Specialist',
+      prompt: 'You are an Edge-Case & Fuzzing Specialist. Target boundary conditions, malformed inputs, concurrency races, and failure recovery paths.',
+    },
+    {
+      id: 'contract_test_architect',
+      title: 'Integration & Contract Test Architect',
+      prompt: 'You are an Integration & Contract Test Architect. Build deterministic, isolated, fast-running test suites with zero flakiness.',
+    },
+  ],
+  architecture: [
+    {
+      id: 'ddd_architect',
+      title: 'Domain-Driven Design Architect',
+      prompt: 'You are a Domain-Driven Design Architect. Enforce clean module boundaries, single responsibility, explicit contracts, and low coupling.',
+    },
+    {
+      id: 'resilience_engineer',
+      title: 'Resilience & Fault-Tolerance Engineer',
+      prompt: 'You are a Resilience & Fault-Tolerance Engineer. Design idempotent operations, graceful degradation, circuit breakers, and clear error taxonomy.',
+    },
+  ],
+}
+
+const DOMAIN_RULES = [
+  { domain: 'database', pattern: /\b(sql|postgres|mysql|sqlite|prisma|drizzle|typeorm|migration|index|schema|table|query|database|db|transaction)\b/i },
+  { domain: 'security', pattern: /\b(security|auth|jwt|oauth|csrf|xss|ssrf|injection|traversal|permission|encrypt|hash|token|secret|vulnerability|cve)\b/i },
+  { domain: 'frontend', pattern: /\b(react|vue|svelte|css|tailwind|html|dom|component|ui|ux|button|modal|layout|responsive|aria|accessibility|style)\b/i },
+  { domain: 'performance', pattern: /\b(performance|optimize|latency|throughput|cache|memory|leak|benchmark|bottleneck|fast|profil|concurrent|parallel)\b/i },
+  { domain: 'testing', pattern: /\b(test|unit|integration|e2e|mock|assert|coverage|vitest|jest|playwright|tdd|regression)\b/i },
+]
+
+/**
+ * Classifies a user prompt into a specialized technical domain.
+ *
+ * @param {string} prompt
+ * @returns {{ domain: string, confidence: number, matchedKeywords: string[] }}
+ */
+export function classifyPromptDomain(prompt) {
+  const text = String(prompt || '').trim()
+  if (!text) return { domain: 'architecture', confidence: 0.5, matchedKeywords: [] }
+
+  let bestDomain = 'architecture'
+  let bestCount = 0
+  let bestMatches = []
+
+  for (const rule of DOMAIN_RULES) {
+    const matches = [...text.matchAll(new RegExp(rule.pattern.source, 'gi'))].map((m) => m[0].toLowerCase())
+    const unique = [...new Set(matches)]
+    if (unique.length > bestCount) {
+      bestCount = unique.length
+      bestDomain = rule.domain
+      bestMatches = unique
+    }
+  }
+
+  return {
+    domain: bestDomain,
+    confidence: bestCount > 0 ? Math.min(0.98, Number((0.6 + bestCount * 0.12).toFixed(2))) : 0.55,
+    matchedKeywords: bestMatches,
+  }
+}
+
+/**
+ * Synthesizes and assigns complementary domain-specific personas to reference model slots.
+ *
+ * @param {Array<object>} references
+ * @param {string} prompt
+ * @returns {{ domain: string, references: Array<object>, personasAssigned: Array<object> }}
+ */
+export function assignAdaptivePersonas(references, prompt) {
+  if (!Array.isArray(references) || references.length === 0) {
+    return { domain: 'architecture', references: [], personasAssigned: [] }
+  }
+
+  const { domain } = classifyPromptDomain(prompt)
+  const pool = DOMAIN_PERSONA_POOLS[domain] || DOMAIN_PERSONA_POOLS.architecture
+  const fallbackPool = DOMAIN_PERSONA_POOLS.architecture
+
+  const personasAssigned = []
+  const enrichedRefs = references.map((slot, idx) => {
+    const chosen = pool[idx % pool.length] || fallbackPool[idx % fallbackPool.length]
+    personasAssigned.push({
+      candidateIndex: idx + 1,
+      model: `${slot.provider || ''}:${slot.model || ''}`,
+      domain,
+      personaId: chosen.id,
+      personaTitle: chosen.title,
+    })
+    return {
+      ...slot,
+      adaptive_domain: domain,
+      adaptive_persona_id: chosen.id,
+      adaptive_persona_title: chosen.title,
+      adaptive_persona_prompt: `[ADAPTIVE EXPERT ROLE — ${chosen.title} (${domain.toUpperCase()})]: ${chosen.prompt}`,
+    }
+  })
+
+  return {
+    domain,
+    references: enrichedRefs,
+    personasAssigned,
+  }
+}

package/lib/moa-candidates.js

@@ -85,9 +85,9 @@ export async function runReferencesParallel(references, messages, options = {},
   references.forEach((slot, i) => {
     const label = slotLabel(slot)
     const role = slot?.role_persona || slot?.role || 'general'
-    const persona = (role && ROLE_PERSONA_PROMPTS[role])
-      ? `\n\n${ROLE_PERSONA_PROMPTS[role]}`
-      : ''
+    const basePersona = (role && ROLE_PERSONA_PROMPTS[role]) ? `\n\n${ROLE_PERSONA_PROMPTS[role]}` : ''
+    const adaptiveExtra = slot?.adaptive_persona_prompt ? `\n\n${slot.adaptive_persona_prompt}` : ''
+    const persona = basePersona + adaptiveExtra
     const slotMessages = [{ role: 'system', content: systemPrompt + persona }, ...advisoryMessages]
 
     // Feature 7: Per-candidate temperature or temperature gradient
@@ -140,13 +140,15 @@ export async function runReferencesParallel(references, messages, options = {},
           index: i + 1,
           slot,
           label,
-          role_persona: role,
+          role_persona: slot?.adaptive_persona_title || role,
+          ...(slot?.adaptive_domain ? { adaptive_domain: slot.adaptive_domain } : {}),
           temperature: effectiveTemperature,
           text,
           usage: costInfo,
           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-parser.js

@@ -56,12 +56,18 @@ export function parseMoACommand(text, presets = [], defaultPreset = undefined) {
     }
   }
 
-  const remainder = text.slice(4).trim()
+  let remainder = text.slice(4).trim()
+  let isSwarm = false
+  if (/^--swarm(?:\s+|$)/i.test(remainder)) {
+    isSwarm = true
+    remainder = remainder.replace(/^--swarm\s*/i, '').trim()
+  }
   if (!remainder) {
     return {
       presetName: defaultPreset,
       prompt: '',
       isExplicit: false,
+      ...(isSwarm ? { isSwarm: true } : {}),
     }
   }
 
@@ -71,6 +77,7 @@ export function parseMoACommand(text, presets = [], defaultPreset = undefined) {
       presetName: matchPreset[1],
       prompt: matchPreset[2] || '',
       isExplicit: true,
+      ...(isSwarm ? { isSwarm: true } : {}),
     }
   }
 
@@ -80,6 +87,7 @@ export function parseMoACommand(text, presets = [], defaultPreset = undefined) {
       presetName: matchShortPreset[1],
       prompt: matchShortPreset[2] || '',
       isExplicit: true,
+      ...(isSwarm ? { isSwarm: true } : {}),
     }
   }
 
@@ -100,6 +108,7 @@ export function parseMoACommand(text, presets = [], defaultPreset = undefined) {
     presetName: defaultPreset,
     prompt: remainder,
     isExplicit: false,
+    ...(isSwarm ? { isSwarm: true } : {}),
   }
 }
 

package/lib/moa-schema.js

@@ -63,12 +63,21 @@ 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),
+  subagent_swarm_enabled: z.boolean().default(false),
+  adaptive_personas_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(),
+  subagent_swarm_enabled: z.boolean().default(false).volatile(),
+  adaptive_personas_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-swarm.js

@@ -0,0 +1,219 @@
+/**
+ * MoA-to-Subagents Swarm with Isolated Git Worktrees (#255)
+ * Provisions isolated git worktrees (or workspace sandboxes) per candidate,
+ * dispatches autonomous subagent/candidate execution, collects git diffs,
+ * and guarantees worktree cleanup in finally blocks.
+ */
+
+import fs from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import path from 'node:path'
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+import { logger } from './logger.js'
+import { slotLabel } from './moa-prompts.js'
+import { extractFileBlocks } from './workspace/fs.js'
+
+const execFileAsync = promisify(execFile)
+
+/**
+ * Checks if a directory is inside a valid git repository.
+ */
+export async function isGitRepository(cwd) {
+  try {
+    const { stdout } = await execFileAsync('git', ['rev-parse', '--is-inside-work-tree'], { cwd, timeout: 5000 })
+    return stdout.trim() === 'true'
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Creates an isolated git worktree (or directory sandbox if not a git repo) for a swarm candidate.
+ *
+ * @param {string} cwd
+ * @param {string} runId
+ * @param {number} candidateIndex
+ * @returns {Promise<{ worktreePath: string, branchName: string, isGitWorktree: boolean }>}
+ */
+export async function createSwarmWorktree(cwd, runId, candidateIndex) {
+  const safeRunId = String(runId || Date.now()).replace(/[^a-zA-Z0-9_-]/g, '')
+  const worktreePath = path.join(cwd, '.moa', `swarm-${safeRunId}`, `candidate-${candidateIndex}`)
+  const branchName = `moa-swarm/${safeRunId}/cand-${candidateIndex}`
+
+  await fs.mkdir(path.dirname(worktreePath), { recursive: true })
+
+  if (await isGitRepository(cwd)) {
+    try {
+      await execFileAsync('git', ['worktree', 'add', '--detach', worktreePath, 'HEAD'], { cwd, timeout: 10000 })
+      return { worktreePath, branchName, isGitWorktree: true }
+    } catch (err) {
+      logger.warn(`[dsh-moa] git worktree add failed for candidate-${candidateIndex}, using isolated directory sandbox: ${err?.message || err}`)
+    }
+  }
+
+  await fs.mkdir(worktreePath, { recursive: true })
+  return { worktreePath, branchName, isGitWorktree: false }
+}
+
+/**
+ * Collects git diff and modified files from a candidate's swarm worktree.
+ *
+ * @param {string} worktreePath
+ * @param {boolean} isGitWorktree
+ * @returns {Promise<{ diffText: string, modifiedFiles: string[] }>}
+ */
+export async function collectSwarmWorktreeDiff(worktreePath, isGitWorktree = false) {
+  if (!existsSync(worktreePath)) {
+    return { diffText: '', modifiedFiles: [] }
+  }
+
+  if (isGitWorktree) {
+    try {
+      const { stdout: statusOut } = await execFileAsync('git', ['status', '--porcelain'], { cwd: worktreePath, timeout: 5000 })
+      const modifiedFiles = statusOut
+        .split('\n')
+        .map((line) => line.slice(3).trim())
+        .filter(Boolean)
+
+      const { stdout: diffOut } = await execFileAsync('git', ['diff', 'HEAD'], { cwd: worktreePath, timeout: 5000 })
+      return { diffText: diffOut.trim(), modifiedFiles }
+    } catch {
+      // Fallback to directory scan
+    }
+  }
+
+  const modifiedFiles = []
+  async function scanDir(dir, prefix = '') {
+    const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => [])
+    for (const entry of entries) {
+      if (entry.name === '.git') continue
+      const rel = prefix ? `${prefix}/${entry.name}` : entry.name
+      const full = path.join(dir, entry.name)
+      if (entry.isDirectory()) {
+        await scanDir(full, rel)
+      } else {
+        modifiedFiles.push(rel)
+      }
+    }
+  }
+  await scanDir(worktreePath)
+  return { diffText: '', modifiedFiles }
+}
+
+/**
+ * Guarantees removal of all swarm worktrees and temporary directories.
+ *
+ * @param {string} cwd
+ * @param {string} runId
+ * @param {Array<{ worktreePath: string, isGitWorktree: boolean }>} worktrees
+ */
+export async function cleanupSwarmWorktrees(cwd, runId, worktrees = []) {
+  for (const wt of worktrees) {
+    if (!wt?.worktreePath) continue
+    if (wt.isGitWorktree) {
+      try {
+        await execFileAsync('git', ['worktree', 'remove', '--force', wt.worktreePath], { cwd, timeout: 8000 })
+      } catch {}
+    }
+    try {
+      await fs.rm(wt.worktreePath, { recursive: true, force: true })
+    } catch {}
+  }
+
+  if (await isGitRepository(cwd)) {
+    try {
+      await execFileAsync('git', ['worktree', 'prune'], { cwd, timeout: 5000 })
+    } catch {}
+  }
+
+  const safeRunId = String(runId || '').replace(/[^a-zA-Z0-9_-]/g, '')
+  if (safeRunId) {
+    const swarmRoot = path.join(cwd, '.moa', `swarm-${safeRunId}`)
+    try {
+      await fs.rm(swarmRoot, { recursive: true, force: true })
+    } catch {}
+  }
+}
+
+/**
+ * Runs candidates as a swarm with isolated worktrees.
+ * Uses ctx.subagent.run if available on Cordis context, falling back to callLlm + worktree materialization.
+ */
+export async function runSubagentSwarm(references, messages, options = {}, callLlm, onProgress) {
+  const cwd = options.cwd || process.cwd()
+  const runId = options.runId || `run-${Date.now()}`
+  const worktrees = []
+
+  try {
+    if (typeof onProgress === 'function') {
+      onProgress(`🐝 *Launching MoA Subagent Swarm across ${references.length} isolated worktrees...*\n`)
+    }
+
+    const tasks = references.map(async (slot, idx) => {
+      const candidateIndex = idx + 1
+      const label = slotLabel(slot)
+      const wt = await createSwarmWorktree(cwd, runId, candidateIndex)
+      worktrees.push(wt)
+
+      const start = Date.now()
+      let responseText = ''
+      let usage = { inputTokens: 100, outputTokens: 100, totalTokens: 200, costUsd: 0 }
+
+      if (options.ctx?.subagent && typeof options.ctx.subagent.run === 'function') {
+        const subRes = await options.ctx.subagent.run({
+          provider: slot.provider,
+          model: slot.model,
+          cwd: wt.worktreePath,
+          messages,
+          signal: options.signal,
+        })
+        responseText = typeof subRes === 'string' ? subRes : (subRes?.content || subRes?.text || '')
+        if (subRes?.usage) usage = subRes.usage
+      } else {
+        const llmRes = await callLlm({
+          provider: slot.provider,
+          model: slot.model,
+          messages,
+          temperature: options.temperature ?? 0.6,
+          maxTokens: options.maxTokens ?? 4096,
+          signal: options.signal,
+        })
+        responseText = typeof llmRes === 'string' ? llmRes : (llmRes?.content || llmRes?.text || '')
+        if (llmRes?.usage) usage = llmRes.usage
+      }
+
+      // Materialize any extracted file blocks inside the isolated worktree
+      const files = extractFileBlocks(responseText)
+      for (const f of files) {
+        const targetFile = path.join(wt.worktreePath, f.relativePath || f.path || "")
+        await fs.mkdir(path.dirname(targetFile), { recursive: true })
+        await fs.writeFile(targetFile, f.content, 'utf8')
+      }
+
+      const diffInfo = await collectSwarmWorktreeDiff(wt.worktreePath, wt.isGitWorktree)
+      const enrichedText = diffInfo.diffText
+        ? `${responseText}\n\n#### Git Worktree Diff (${wt.branchName}):\n\`\`\`diff\n${diffInfo.diffText}\n\`\`\``
+        : responseText
+
+      return {
+        index: candidateIndex,
+        slot,
+        label,
+        text: enrichedText,
+        files,
+        swarmWorktree: wt.worktreePath,
+        swarmBranch: wt.branchName,
+        modifiedFiles: diffInfo.modifiedFiles,
+        usage,
+        costUsd: usage.costUsd || 0,
+        durationMs: Date.now() - start,
+        ok: true,
+      }
+    })
+
+    return await Promise.all(tasks)
+  } finally {
+    await cleanupSwarmWorktrees(cwd, runId, worktrees)
+  }
+}

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/candidates.js

@@ -1,3 +1,5 @@
+import { assignAdaptivePersonas } from '../moa-adaptive-personas.js'
+import { runSubagentSwarm } from '../moa-swarm.js'
 import { runReferencesParallel } from '../moa-candidates.js'
 import { extractFileBlocks, writeCandidateWorkspace, cleanMoaWorkspaces } from '../workspace/fs.js'
 import { verifyFileSyntax } from '../workspace/diff.js'
@@ -30,8 +32,15 @@ export async function stageCandidateRound1({
   testCommand,
   execFn,
 }) {
-  const referenceOutputs = await runReferencesParallel(
-    effectiveReferences,
+  const lastMsgText = enrichedMessages[enrichedMessages.length - 1]?.content || ''
+  const adaptiveRefs = preset?.adaptive_personas_enabled
+    ? assignAdaptivePersonas(effectiveReferences, typeof lastMsgText === 'string' ? lastMsgText : '').references
+    : effectiveReferences
+
+  const referenceOutputs = preset?.subagent_swarm_enabled
+    ? await runSubagentSwarm(adaptiveRefs, enrichedMessages, { temperature: refTemp, maxTokens, signal, cwd, runId }, callLlm, onProgress)
+    : await runReferencesParallel(
+    adaptiveRefs,
     enrichedMessages,
     {
       systemPrompt: candidateSystemPrompt,

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/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)
+  }
+}

package/package.json

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