@goodandready/dsh-moa 0.2.26 → 0.2.27

package/README.md

@@ -142,6 +142,36 @@ Inspect line-by-line differences between candidate proposals and the curator's s
 ### 8. Pre-Promotion Git Checkpoints (`dsh-time-machine`)
 Before promoting any winning candidate files over the workspace root, `dsh-moa` invokes the local `dsh-time-machine` service to create a shadow Git checkpoint (`moa-pre-promotion: candidate-N`). If `dsh-time-machine` is absent or unreachable, file promotion proceeds seamlessly via best-effort fallback.
 
+### 9. Automated Test Execution Gate
+When `test_gate_enabled: true` and `test_command` (e.g. `npm test` or `pytest`) are configured, candidate code is executed in an ephemeral sandbox overlay. The judge receives concrete test outcomes, durations, and output logs to ground decisions in objective verification.
+
+### 10. Multi-Judge Panel & Consensus Voting
+When `multi_judge_enabled: true`, candidate solutions are independently evaluated by a panel of judge models. Winner selection supports `majority`, `highest_score`, or `unanimous` consensus strategies.
+
+### 11. Composite Hybrid Synthesis (AST / Block Merge)
+When `composite_merge_enabled: true`, the aggregator assembles a modular hybrid: combining the strongest core logic from one model, robust error handling from another, and complete types/tests from a third.
+
+### 12. Smart Dynamic Preset Router & JEV Classifier
+When invoking `/moa` without explicit preset flags, the router classifies prompt intent using keyword heuristics or a zero-shot JEV model (`smart_routing_model`) to automatically select the optimal preset.
+
+### 13. Real-Time Live Cost Counter & Streaming Ticker
+As each candidate completes, live token counts and USD costs are streamed directly into the chat based on catalog pricing and vendor rates.
+
+### 14. Cost Budget Guardrails (Trim & Abort Modes)
+`budget_guard_enabled` and `max_budget_usd` guard against accidental spend. Mode `trim` automatically reduces the candidate pool to fit the budget, while `abort` cancels execution before token consumption.
+
+### 15. Temperature Gradient Exploration & Per-Candidate Temperature
+Supports individual candidate temperatures (`slot.temperature`) and `temperature_gradient_enabled` to distribute temperatures (0.2 → 0.9) across candidates for maximum architectural diversity.
+
+### 16. Multi-Turn Conversation Memory & Context Pruning
+Seamlessly retains synthesized baseline code from prior turns while pruning intermediate noise to keep token overhead low.
+
+### 17. Automated Benchmark & Post-Mortem PR Reports
+`report_generation_enabled` generates comprehensive Markdown & JSON reports detailing candidate metrics, agreement scores, test gate results, and cost breakdowns via `GET /dsh-moa/runs/:id/report`.
+
+### 18. Graceful Degradation & Local Fallback Resilience
+When `local_fallback_enabled: true`, candidates that fail due to network outages or rate limits (429/500) automatically recover using configured local models (Ollama / MiniPC).
+
 ### 6. Live Canvas 1-Click Preview (optional)
 If `@goodandready/dsh-live-canvas` is installed in the same profile, `dsh-moa` pushes the promoted HTML file to the Live Canvas REST contract (`POST /dsh-live-canvas/api/preview`, served by the same harness webServer) and appends a one-click preview link (`/dsh-live-canvas/sandbox/<id>`) to the answer. Without the plugin the step is skipped silently — no errors in the log, no dead links.
 

package/README.ru.md

@@ -142,6 +142,36 @@ graph TD
 ### 8. Теневые Git-чекпоинты (`dsh-time-machine`)
 Перед промоушном файлов победителя в корень рабочей области `dsh-moa` автоматически обращается к сервису `dsh-time-machine` для создания снимка (`moa-pre-promotion: candidate-N`). Если плагин недоступен, промоушн штатно продолжается по схеме best-effort.
 
+### 9. Автоматический шлюз выполнения тестов (Automated Test Execution Gate)
+При включении `test_gate_enabled: true` и указании тестовой команды (`test_command`, например `npm test` или `pytest`) каждый кандидат запускается в изолированном оверлейном окружении. Судья получает объективный вердикт с кодами возврата, временем исполнения и логами тестов до вынесения итогового решения.
+
+### 10. Коллегия судей и консенсусное голосование (Multi-Judge Panel)
+При активации опции `multi_judge_enabled` решения кандидатов оценивает независимая панель судейских моделей с поддержкой стратегий голосования: `majority` (большинство), `highest_score` (наивысший средний балл) или `unanimous` (единогласный консенсус).
+
+### 11. Композитный гибридный синтез (Composite AST/Block Merge)
+Опция `composite_merge_enabled` активирует алгоритм объединения модулей: судья не просто выбирает одного кандидата, а синтезирует итоговое решение из лучших компонентов всех участников (чистейшая алгоритмическая база от одного, надежные обработчики ошибок от второго, исчерпывающие типы и тесты от третьего).
+
+### 12. Умный динамический роутинг пресетов и модель JEV
+При запуске `/moa` без явного указания флага встроенный классификатор определяет намерение (интерфейсы, безопасность, рефакторинг, баги, архитектура) по эвристическим правилам или с помощью легковесной модели JEV (`smart_routing_model`) и автоматически подбирает оптимальный пресет.
+
+### 13. Живой счетчик стоимости и потоковая телеметрия
+По мере завершения каждого кандидата плагин в реальном времени транслирует в чат накопленный расход токенов и расчетную стоимость в USD на базе встроенного каталога тарифов OpenRouter и прямых цен провайдеров.
+
+### 14. Бюджетные ограничения расходов (Cost Budget Guardrails)
+Опция `budget_guard_enabled` с лимитом `max_budget_usd` защищает от непредвиденных трат: режим `trim` автоматически сокращает пул кандидатов до самых экономичных моделей, укладывающихся в бюджет, а режим `abort` прерывает выполнение до начала генерации.
+
+### 15. Градиент температурной диверсификации и точечная температура
+Поддерживается как индивидуальная настройка температуры для каждого кандидата (`slot.temperature`), так и опция `temperature_gradient_enabled`, автоматически распределяющая температуры кандидатов по шкале от 0.2 до 0.9 для достижения максимального разнообразия инженерных подходов.
+
+### 16. Многошаговый диалоговый контекст и умное усечение
+При продолжении беседы MoA извлекает синтезированное решение предыдущего шага в качестве базовой точки отсчета, сохраняя системный контекст и предотвращая раздувание токенов.
+
+### 17. Автоматические бенчмарк-отчеты и Post-Mortem PR
+При включении `report_generation_enabled` генерируется подробный аналитический отчет с матрицей моделей, временами задержек, оценками судей, расходами и результатами тестов. Отчет доступен по API `GET /dsh-moa/runs/:id/report?format=md`.
+
+### 18. Плавная деградация и локальный фоллбэк
+Опция `local_fallback_enabled` позволяет задать резервные локальные модели (Ollama, vLLM, MiniPC), к которым плагин бесшовно обращается при сбоях сетевых API или превышении лимитов rate limit (429/500).
+
 ### 6. Live Canvas 1-клик предпросмотр (опционально)
 Если в профиле установлен `@goodandready/dsh-live-canvas`, `dsh-moa` отправляет промоученный HTML-файл в REST-контракт Live Canvas (`POST /dsh-live-canvas/api/preview`, тот же webServer харнесса) и добавляет к ответу ссылку на предпросмотр (`/dsh-live-canvas/sandbox/<id>`). Без плагина шаг пропускается тихо — без ошибок в журнале и без битых ссылок.
 

package/lib/client.js

@@ -1327,6 +1327,169 @@ window.__ModuleLoader__.load({
                     })
                   )
                 ),
+              /* Multi-Judge Panel & Consensus Voting */
+              React.createElement(
+                'div',
+                { style: { display: 'flex', flexDirection: 'column', gap: 6, padding: '8px 12px', background: 'var(--dsw-alias-bg-layer-2)', borderRadius: 8, border: '1px solid var(--dsw-alias-border-l2)', marginTop: 8 } },
+                React.createElement(
+                  'label',
+                  { style: { display: 'flex', alignItems: 'center', gap: 8, cursor: 'pointer', fontSize: 13, fontWeight: 500 } },
+                  React.createElement('input', {
+                    type: 'checkbox',
+                    checked: Boolean(currentPreset.multi_judge_enabled),
+                    onChange: (e) => updateCurrentPreset((p) => ({ ...p, multi_judge_enabled: e.target.checked })),
+                    style: { accentColor: 'var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))', cursor: 'pointer' },
+                  }),
+                  'Multi-Judge Panel & Consensus Voting'
+                ),
+                React.createElement(
+                  'div',
+                  { style: { fontSize: 12, color: 'var(--dsw-alias-label-secondary)', marginLeft: 22 } },
+                  'Deploy multiple judge models to score candidates and determine winner via consensus voting.'
+                ),
+                currentPreset.multi_judge_enabled && React.createElement(
+                  'div',
+                  { style: { marginLeft: 22, display: 'flex', alignItems: 'center', gap: 8, marginTop: 4 } },
+                  React.createElement('span', { style: { fontSize: 12, color: 'var(--dsw-alias-label-secondary)' } }, 'Voting Strategy:'),
+                  React.createElement(
+                    'select',
+                    {
+                      className: 'moa-select',
+                      style: { width: 140, height: 28, fontSize: 12, padding: '0 6px' },
+                      value: currentPreset.judge_voting_strategy || 'majority',
+                      onChange: (e) => updateCurrentPreset((p) => ({ ...p, judge_voting_strategy: e.target.value })),
+                    },
+                    React.createElement('option', { value: 'majority' }, 'Majority Vote'),
+                    React.createElement('option', { value: 'highest_score' }, 'Highest Score'),
+                    React.createElement('option', { value: 'unanimous' }, 'Unanimous')
+                  )
+                )
+              ),
+
+              /* Composite Hybrid Synthesis (AST / Block Merge) */
+              React.createElement(
+                'div',
+                { style: { display: 'flex', flexDirection: 'column', gap: 6, padding: '8px 12px', background: 'var(--dsw-alias-bg-layer-2)', borderRadius: 8, border: '1px solid var(--dsw-alias-border-l2)', marginTop: 8 } },
+                React.createElement(
+                  'label',
+                  { style: { display: 'flex', alignItems: 'center', gap: 8, cursor: 'pointer', fontSize: 13, fontWeight: 500 } },
+                  React.createElement('input', {
+                    type: 'checkbox',
+                    checked: Boolean(currentPreset.composite_merge_enabled),
+                    onChange: (e) => updateCurrentPreset((p) => ({ ...p, composite_merge_enabled: e.target.checked })),
+                    style: { accentColor: 'var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))', cursor: 'pointer' },
+                  }),
+                  'Composite Hybrid Synthesis (AST / Block Merge)'
+                ),
+                React.createElement(
+                  'div',
+                  { style: { fontSize: 12, color: 'var(--dsw-alias-label-secondary)', marginLeft: 22 } },
+                  'Synthesize modular code blocks, types, and algorithms from multiple candidates into a unified composite.'
+                )
+              ),
+
+              /* Cost Budget Guardrails & Auto-Fallback */
+              React.createElement(
+                'div',
+                { style: { display: 'flex', flexDirection: 'column', gap: 6, padding: '8px 12px', background: 'var(--dsw-alias-bg-layer-2)', borderRadius: 8, border: '1px solid var(--dsw-alias-border-l2)', marginTop: 8 } },
+                React.createElement(
+                  'label',
+                  { style: { display: 'flex', alignItems: 'center', gap: 8, cursor: 'pointer', fontSize: 13, fontWeight: 500 } },
+                  React.createElement('input', {
+                    type: 'checkbox',
+                    checked: Boolean(currentPreset.budget_guard_enabled),
+                    onChange: (e) => updateCurrentPreset((p) => ({ ...p, budget_guard_enabled: e.target.checked })),
+                    style: { accentColor: 'var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))', cursor: 'pointer' },
+                  }),
+                  'Cost Budget Guardrails & Auto-Fallback'
+                ),
+                React.createElement(
+                  'div',
+                  { style: { fontSize: 12, color: 'var(--dsw-alias-label-secondary)', marginLeft: 22 } },
+                  'Cap maximum run cost; auto-trim candidate pool or abort to prevent accidental token spend.'
+                ),
+                currentPreset.budget_guard_enabled && React.createElement(
+                  'div',
+                  { style: { marginLeft: 22, display: 'flex', alignItems: 'center', gap: 12, marginTop: 4 } },
+                  React.createElement(
+                    'div',
+                    { style: { display: 'flex', alignItems: 'center', gap: 6 } },
+                    React.createElement('span', { style: { fontSize: 12, color: 'var(--dsw-alias-label-secondary)' } }, 'Max USD ($):'),
+                    React.createElement('input', {
+                      type: 'number',
+                      step: '0.01',
+                      className: 'moa-input',
+                      style: { width: 80, height: 28, padding: '0 6px', fontSize: 12 },
+                      value: currentPreset.max_budget_usd ?? 0.1,
+                      onChange: (e) => {
+                        const val = parseFloat(e.target.value)
+                        updateCurrentPreset((p) => ({ ...p, max_budget_usd: isNaN(val) ? 0 : val }))
+                      },
+                    })
+                  ),
+                  React.createElement(
+                    'div',
+                    { style: { display: 'flex', alignItems: 'center', gap: 6 } },
+                    React.createElement('span', { style: { fontSize: 12, color: 'var(--dsw-alias-label-secondary)' } }, 'Action:'),
+                    React.createElement(
+                      'select',
+                      {
+                        className: 'moa-select',
+                        style: { width: 100, height: 28, fontSize: 12, padding: '0 6px' },
+                        value: currentPreset.budget_action || 'trim',
+                        onChange: (e) => updateCurrentPreset((p) => ({ ...p, budget_action: e.target.value })),
+                      },
+                      React.createElement('option', { value: 'trim' }, 'Trim Pool'),
+                      React.createElement('option', { value: 'abort' }, 'Abort')
+                    )
+                  )
+                )
+              ),
+
+              /* Automated Benchmark & Post-Mortem Report */
+              React.createElement(
+                'div',
+                { style: { display: 'flex', flexDirection: 'column', gap: 6, padding: '8px 12px', background: 'var(--dsw-alias-bg-layer-2)', borderRadius: 8, border: '1px solid var(--dsw-alias-border-l2)', marginTop: 8 } },
+                React.createElement(
+                  'label',
+                  { style: { display: 'flex', alignItems: 'center', gap: 8, cursor: 'pointer', fontSize: 13, fontWeight: 500 } },
+                  React.createElement('input', {
+                    type: 'checkbox',
+                    checked: Boolean(currentPreset.report_generation_enabled),
+                    onChange: (e) => updateCurrentPreset((p) => ({ ...p, report_generation_enabled: e.target.checked })),
+                    style: { accentColor: 'var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))', cursor: 'pointer' },
+                  }),
+                  'Automated Benchmark & Post-Mortem Report'
+                ),
+                React.createElement(
+                  'div',
+                  { style: { fontSize: 12, color: 'var(--dsw-alias-label-secondary)', marginLeft: 22 } },
+                  'Generate downloadable Markdown & JSON reports detailing candidate latency, agreement, test gate, and cost breakdown.'
+                )
+              ),
+
+              /* Graceful Degradation & Local Fallback */
+              React.createElement(
+                'div',
+                { style: { display: 'flex', flexDirection: 'column', gap: 6, padding: '8px 12px', background: 'var(--dsw-alias-bg-layer-2)', borderRadius: 8, border: '1px solid var(--dsw-alias-border-l2)', marginTop: 8 } },
+                React.createElement(
+                  'label',
+                  { style: { display: 'flex', alignItems: 'center', gap: 8, cursor: 'pointer', fontSize: 13, fontWeight: 500 } },
+                  React.createElement('input', {
+                    type: 'checkbox',
+                    checked: Boolean(currentPreset.local_fallback_enabled),
+                    onChange: (e) => updateCurrentPreset((p) => ({ ...p, local_fallback_enabled: e.target.checked })),
+                    style: { accentColor: 'var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))', cursor: 'pointer' },
+                  }),
+                  'Graceful Degradation & Local Fallback'
+                ),
+                React.createElement(
+                  'div',
+                  { style: { fontSize: 12, color: 'var(--dsw-alias-label-secondary)', marginLeft: 22 } },
+                  'Automatically fall back to local Ollama / MiniPC models when online candidate APIs fail.'
+                )
+              ),
+
               /* Fallback Judges Chain */
               React.createElement(
                 'div',
@@ -1481,6 +1644,17 @@ window.__ModuleLoader__.load({
                   updateCurrentPreset((p) => ({ ...p, reference_timeout_sec: isNaN(val) ? 60 : val }))
                 },
               })
+            ),
+            React.createElement(
+              'label',
+              { style: { display: 'flex', alignItems: 'center', gap: 8, cursor: 'pointer', fontSize: 13, fontWeight: 500, marginTop: 4 } },
+              React.createElement('input', {
+                type: 'checkbox',
+                checked: Boolean(currentPreset.temperature_gradient_enabled),
+                onChange: (e) => updateCurrentPreset((p) => ({ ...p, temperature_gradient_enabled: e.target.checked })),
+                style: { accentColor: 'var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))', cursor: 'pointer' },
+              }),
+              'Temperature Gradient Exploration (0.2 → 0.9 across candidates)'
             )
           ),
           React.createElement(
@@ -1502,6 +1676,26 @@ window.__ModuleLoader__.load({
                     t,
                   })
                 ),
+                React.createElement('input', {
+                  type: 'number',
+                  step: '0.1',
+                  min: '0',
+                  max: '2',
+                  placeholder: 'Temp',
+                  title: 'Candidate Temperature (leave empty for default/gradient)',
+                  className: 'moa-input',
+                  style: { width: 50, height: 32, fontSize: 12, padding: '0 4px', textAlign: 'center' },
+                  value: (typeof ref.temperature === 'number' && ref.temperature >= 0) ? ref.temperature : '',
+                  onChange: (e) => {
+                    const raw = e.target.value
+                    const parsedVal = raw === '' ? -1 : parseFloat(raw)
+                    updateCurrentPreset((p) => {
+                      const refs = [...(p.reference_models || [])]
+                      refs[idx] = { ...refs[idx], temperature: isNaN(parsedVal) ? -1 : parsedVal }
+                      return { ...p, reference_models: refs }
+                    })
+                  },
+                }),
                 React.createElement(
                   'select',
                   {

package/lib/history.js

@@ -86,6 +86,8 @@ function normalizeRunRecord(record) {
     totalTokens: Number(record.totalTokens || 0),
     totalCostUsd: Number(record.totalCostUsd || 0),
     durationMs: Number(record.durationMs || 0),
+    benchmarkReport: record.benchmarkReport || null,
+    consensus: record.consensus || null,
   }
 }
 
@@ -413,6 +415,9 @@ export function candidatesForHistory(referenceOutputs) {
     provider: r.slot?.provider || "",
     model: r.slot?.model || "",
     role: r.role_persona || r.slot?.role_persona || r.slot?.role || "general",
+    temperature: r.temperature,
+    wasFallback: Boolean(r.was_fallback),
+    originalModel: r.original_model || null,
     files: (r.files || []).map((f) => f.relativePath),
     usage: r.usage || { inputTokens: 0, outputTokens: 0 },
     costUsd: r.costUsd || 0,

package/lib/index.js

@@ -32,6 +32,7 @@ import {
 } from './moa-runner.js'
 
 import { registerMoaRoutes } from './routes.js'
+import { resolvePresetForPrompt } from './moa-router.js'
 
 import { createLiveCanvasClient } from './live-canvas.js'
 import { registerPluginUpdater, isSafeWriteRequest } from './updater.js'
@@ -52,6 +53,7 @@ export const ModelSlotSchema = z.object({
   provider: z.string().default('opencode-go'),
   model: z.string().default('deepseek-v4-flash'),
   role_persona: z.string().default(''),
+  temperature: z.number().default(-1),
 })
 
 export const PresetSchema = z.object({
@@ -77,11 +79,27 @@ export const PresetSchema = z.object({
   test_gate_enabled: z.boolean().default(false),
   test_command: z.string().default(''),
   test_gate_timeout_sec: z.number().default(15),
+  multi_judge_enabled: z.boolean().default(false),
+  judge_models: z.array(ModelSlotSchema).default([]),
+  judge_voting_strategy: z.string().default('majority'),
+  composite_merge_enabled: z.boolean().default(false),
+  smart_routing_enabled: z.boolean().default(false),
+  smart_routing_model: ModelSlotSchema.default({ provider: 'opencode-go', model: 'jev' }),
+  budget_guard_enabled: z.boolean().default(false),
+  max_budget_usd: z.number().default(0),
+  budget_action: z.string().default('trim'),
+  temperature_gradient_enabled: z.boolean().default(false),
+  multi_turn_enabled: z.boolean().default(true),
+  report_generation_enabled: z.boolean().default(false),
+  local_fallback_enabled: z.boolean().default(false),
+  local_fallback_models: z.array(ModelSlotSchema).default([]),
 })
 
 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(),
+  smart_routing_model: ModelSlotSchema.default({ provider: 'opencode-go', model: 'jev' }).volatile(),
   prices: z.dict(PriceRow).default({}).volatile(),
   presets: z.array(PresetSchema).default([
     {
@@ -338,6 +356,24 @@ export function apply(ctx, config) {
       const cfg = live()
       if (cfg.enabled !== false) {
         const parsed = parseMoACommand(userText, cfg.presets || []) || { prompt: userText, presetName: cfg.default_preset || 'default' }
+        const isExplicitPreset = userText.includes('--preset') || userText.includes('-p ')
+        if (!isExplicitPreset && (cfg.smart_routing_enabled || cfg.presets?.some((p) => p.smart_routing_enabled))) {
+          try {
+            const routed = await resolvePresetForPrompt({
+              prompt: parsed.prompt || userText,
+              presets: cfg.presets || [],
+              defaultPreset: parsed.presetName || cfg.default_preset || 'default',
+              routingModel: cfg.smart_routing_model,
+              callLlm,
+              enabled: true,
+            })
+            if (routed?.isAutoRouted && routed.presetName) {
+              parsed.presetName = routed.presetName
+            }
+          } catch {
+            // fallback silently
+          }
+        }
         const targetPreset = (cfg.presets || []).find((p) => p.name === parsed.presetName) || cfg.presets?.[0]
         const aggProvider = targetPreset?.aggregator?.provider || 'codex'
         const aggModel = targetPreset?.aggregator?.model || 'gpt-5.6-sol'

package/lib/moa-budget.js

@@ -0,0 +1,97 @@
+/**
+ * Cost Budget Guardrails & Auto-Trimming
+ * Feature 6 (Cost Budget Guardrails)
+ */
+
+import { estimateTokenCost } from './pricing.js'
+
+/**
+ * Calculates conservative upfront cost estimate for a list of candidate slots.
+ */
+export function estimateCandidateRunCost(slots = [], prices = {}, promptTokens = 500, expectedOutputTokens = 2048) {
+  let totalUsd = 0
+  const slotEstimates = []
+
+  for (const slot of slots) {
+    const costInfo = estimateTokenCost(
+      slot,
+      { inputTokens: promptTokens, outputTokens: expectedOutputTokens },
+      prices
+    )
+    const cost = costInfo?.costUsd || 0
+    totalUsd += cost
+    slotEstimates.push({ slot, costUsd: cost })
+  }
+
+  return {
+    totalEstimatedUsd: Number(totalUsd.toFixed(6)),
+    slotEstimates,
+  }
+}
+
+/**
+ * Applies budget guardrails before initiating parallel candidate execution.
+ */
+export function applyBudgetGuardrails({
+  references = [],
+  enabled = false,
+  maxBudgetUsd = 0,
+  action = 'trim', // 'trim' | 'abort'
+  prices = {},
+  promptLength = 1000,
+}) {
+  if (!enabled || typeof maxBudgetUsd !== 'number' || maxBudgetUsd <= 0 || references.length === 0) {
+    return {
+      allowed: true,
+      references,
+      action: 'none',
+      estimatedCostUsd: 0,
+    }
+  }
+
+  const promptTokens = Math.max(50, Math.round(promptLength / 4))
+  const { totalEstimatedUsd, slotEstimates } = estimateCandidateRunCost(references, prices, promptTokens)
+
+  if (totalEstimatedUsd <= maxBudgetUsd) {
+    return {
+      allowed: true,
+      references,
+      action: 'pass',
+      estimatedCostUsd: totalEstimatedUsd,
+    }
+  }
+
+  if (action === 'abort') {
+    return {
+      allowed: false,
+      references: [],
+      action: 'abort',
+      estimatedCostUsd: totalEstimatedUsd,
+      maxBudgetUsd,
+      reason: `Estimated MoA run cost ($${totalEstimatedUsd.toFixed(4)}) exceeds configured max budget ($${maxBudgetUsd.toFixed(4)}).`,
+    }
+  }
+
+  // Action is 'trim': Sort by estimated cost ascending (cheapest first)
+  const sorted = [...slotEstimates].sort((a, b) => a.costUsd - b.costUsd)
+  const kept = []
+  let cumulative = 0
+
+  for (const item of sorted) {
+    if (cumulative + item.costUsd <= maxBudgetUsd || kept.length === 0) {
+      kept.push(item.slot)
+      cumulative += item.costUsd
+    }
+  }
+
+  return {
+    allowed: true,
+    references: kept,
+    action: 'trim',
+    originalCount: references.length,
+    trimmedCount: kept.length,
+    estimatedCostUsd: Number(cumulative.toFixed(6)),
+    maxBudgetUsd,
+    reason: `Trimmed candidate pool from ${references.length} to ${kept.length} models to stay within budget ($${maxBudgetUsd.toFixed(4)}).`,
+  }
+}

package/lib/moa-candidates.js

@@ -1,5 +1,6 @@
 /**
  * DeepSeek Harness Mixture of Agents (MoA) — Candidate Fan-Out & Retry
+ * With Per-Candidate Temperature, Temperature Gradient & Local Fallback Resilience
  */
 
 import { bestEffort } from './best-effort.js'
@@ -29,7 +30,8 @@ export async function callWithTransientRetry(callLlmFn, callArgs, maxRetries = 0
 }
 
 /**
- * Dispatches queries to all reference models in parallel with transient retry and quorum straggler mitigation.
+ * Dispatches queries to all reference models in parallel with transient retry,
+ * per-candidate temperature / gradient exploration, local fallback, and quorum mitigation.
  */
 export async function runReferencesParallel(references, messages, options = {}, callLlm, onProgress) {
   if (!Array.isArray(references) || references.length === 0) {
@@ -87,6 +89,14 @@ export async function runReferencesParallel(references, messages, options = {},
       : ''
     const slotMessages = [{ role: 'system', content: systemPrompt + persona }, ...advisoryMessages]
 
+    // Feature 7: Per-candidate temperature or temperature gradient
+    let effectiveTemperature = options.temperature ?? 0.6
+    if (typeof slot.temperature === 'number' && slot.temperature >= 0) {
+      effectiveTemperature = slot.temperature
+    } else if (options.temperature_gradient_enabled && total > 1) {
+      effectiveTemperature = Number((0.2 + (0.7 * i) / (total - 1)).toFixed(2))
+    }
+
     const runOne = async () => {
       try {
         const callPromise = callWithTransientRetry(
@@ -95,7 +105,7 @@ export async function runReferencesParallel(references, messages, options = {},
             provider: slot.provider,
             model: slot.model,
             messages: slotMessages,
-            temperature: options.temperature ?? 0.6,
+            temperature: effectiveTemperature,
             maxTokens: options.maxTokens ?? 4096,
             timeoutMs,
             signal: abortControllers[i].signal,
@@ -124,38 +134,96 @@ export async function runReferencesParallel(references, messages, options = {},
         const costInfo = estimateTokenCost(slot, fallbackUsage, options.prices)
 
         finishedCount++
-        if (typeof onProgress === 'function') {
-          const costStr = costInfo.costUsd > 0 ? ` (~\$${costInfo.costUsd.toFixed(4)})` : ''
-          onProgress(`✅ *Candidate ${i + 1}/${total} (${label}) finished${costStr}*\n`)
-        }
-
         results[i] = {
           index: i + 1,
           slot,
           label,
           role_persona: role,
+          temperature: effectiveTemperature,
           text,
           usage: costInfo,
           costUsd: costInfo.costUsd,
           ok: true,
         }
-      } catch (err) {
-        finishedCount++
-        const errMsg = err?.message || String(err)
-        console.warn(`[dsh-moa] Reference ${label} failed:`, errMsg)
+
         if (typeof onProgress === 'function') {
-          onProgress(`⚠️ *Candidate ${i + 1}/${total} (${label}) error: ${errMsg}*\n`)
+          const costStr = costInfo.costUsd > 0 ? ` (~\$${costInfo.costUsd.toFixed(4)})` : ''
+          const currentTotalCost = results.reduce((sum, r) => sum + (r?.costUsd || 0), 0)
+          onProgress(`✅ *Candidate ${i + 1}/${total} (${label}, T=${effectiveTemperature}) finished${costStr}* | Live total: ~\$${currentTotalCost.toFixed(4)}\n`)
         }
-        results[i] = {
-          index: i + 1,
-          slot,
-          label,
-          role_persona: role,
-          text: `[Model ${label} error: ${errMsg}]`,
-          usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0 },
-          costUsd: 0,
-          ok: false,
-          error: errMsg,
+      } catch (err) {
+        // Feature 10: Local fallback models if online candidate fails
+        let fallbackRecovered = false
+        if (options.local_fallback_enabled && Array.isArray(options.local_fallback_models) && options.local_fallback_models.length > 0) {
+          for (const fbSlot of options.local_fallback_models) {
+            const fbLabel = slotLabel(fbSlot)
+            try {
+              if (typeof onProgress === 'function') {
+                onProgress(`🔄 *Candidate ${i + 1} (${label}) failed, attempting local fallback to ${fbLabel}...*\n`)
+              }
+              const fbRes = await callWithTransientRetry(
+                callLlm,
+                {
+                  provider: fbSlot.provider,
+                  model: fbSlot.model,
+                  messages: slotMessages,
+                  temperature: effectiveTemperature,
+                  maxTokens: options.maxTokens ?? 4096,
+                  timeoutMs,
+                  signal: abortControllers[i].signal,
+                },
+                0
+              )
+              const fbText = typeof fbRes === 'string' ? fbRes : (fbRes?.content || fbRes?.text || '')
+              const fbUsage = (typeof fbRes === 'object' && fbRes?.usage) ? fbRes.usage : {
+                inputTokens: Math.max(1, Math.round(slotMessages.map((m) => m.content).join('').length / 4)),
+                outputTokens: Math.max(1, Math.round(fbText.length / 4)),
+              }
+              const fbCost = estimateTokenCost(fbSlot, fbUsage, options.prices)
+              finishedCount++
+              results[i] = {
+                index: i + 1,
+                slot: fbSlot,
+                label: `${fbLabel} [fallback for ${label}]`,
+                role_persona: role,
+                temperature: effectiveTemperature,
+                text: fbText,
+                usage: fbCost,
+                costUsd: fbCost.costUsd,
+                ok: true,
+                was_fallback: true,
+                original_model: label,
+              }
+              fallbackRecovered = true
+              if (typeof onProgress === 'function') {
+                onProgress(`✅ *Candidate ${i + 1}/${total} recovered using fallback (${fbLabel})*\n`)
+              }
+              break
+            } catch (fbErr) {
+              console.warn(`[dsh-moa] Fallback ${fbLabel} also failed:`, fbErr?.message || fbErr)
+            }
+          }
+        }
+
+        if (!fallbackRecovered) {
+          finishedCount++
+          const errMsg = err?.message || String(err)
+          console.warn(`[dsh-moa] Reference ${label} failed:`, errMsg)
+          if (typeof onProgress === 'function') {
+            onProgress(`⚠️ *Candidate ${i + 1}/${total} (${label}) error: ${errMsg}*\n`)
+          }
+          results[i] = {
+            index: i + 1,
+            slot,
+            label,
+            role_persona: role,
+            temperature: effectiveTemperature,
+            text: `[Model ${label} error: ${errMsg}]`,
+            usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0 },
+            costUsd: 0,
+            ok: false,
+            error: errMsg,
+          }
         }
       } finally {
         notifyFinished()