@goodandready/dsh-moa 0.2.25 → 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

@@ -63,6 +63,10 @@ window.__ModuleLoader__.load({
       'aggregator.peer_hint': 'Candidates critique each other\'s solutions and refine their code before final judge synthesis.',
       'aggregator.override_label': 'Allow Candidate Override Actions',
       'aggregator.override_hint': 'Keeps candidate workspaces in .moa to let you apply any candidate files via chat command.',
+      'aggregator.test_gate_label': 'Test Execution Gate (Automatic Sandbox Testing)',
+      'aggregator.test_gate_hint': 'Executes test suite inside candidate sandboxes before judge review. Real test results guide winner selection.',
+      'aggregator.test_cmd_placeholder': 'e.g. npm test or node --test',
+      'aggregator.test_timeout_label': 'Test timeout (sec):',
       'proposers.role_label': 'Persona:',
       'proposers.role_general': 'General',
       'proposers.role_minimalist': 'Minimalist',
@@ -177,6 +181,10 @@ window.__ModuleLoader__.load({
       'aggregator.peer_hint': '在主裁判终审前，各候选模型互相审阅并改进彼此的方案代码。',
       'aggregator.override_label': '允许手动候选方案提拔操作 (Override)',
       'aggregator.override_hint': '在 .moa 目录中保留候选模型的工作区，允许通过聊天命令提拔任意候选模型的文件。',
+      'aggregator.test_gate_label': '测试门禁 (沙箱自动化测试)',
+      'aggregator.test_gate_hint': '在裁判评审前在候选沙箱中执行测试套件，真实测试结果将指导获胜者评选。',
+      'aggregator.test_cmd_placeholder': '例如 npm test 或 node --test',
+      'aggregator.test_timeout_label': '测试超时时间 (秒):',
       'proposers.role_label': '工程角色画像：',
       'proposers.role_general': '通用平衡 (General)',
       'proposers.role_minimalist': '极简标准库 (Minimalist)',
@@ -1273,6 +1281,215 @@ window.__ModuleLoader__.load({
                 { style: { fontSize: 12, color: 'var(--dsw-alias-label-secondary)', marginLeft: 22 } },
                 t('aggregator.override_hint')
               ),
+              React.createElement(
+                'label',
+                { style: { display: 'flex', alignItems: 'center', gap: 8, cursor: 'pointer', fontSize: 13, fontWeight: 500, marginTop: 8 } },
+                React.createElement('input', {
+                  type: 'checkbox',
+                  checked: Boolean(currentPreset.test_gate_enabled),
+                  onChange: (e) => updateCurrentPreset((p) => ({ ...p, test_gate_enabled: e.target.checked })),
+                  style: { accentColor: 'var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))', cursor: 'pointer' },
+                }),
+                t('aggregator.test_gate_label')
+              ),
+              React.createElement(
+                'div',
+                { style: { fontSize: 12, color: 'var(--dsw-alias-label-secondary)', marginLeft: 22 } },
+                t('aggregator.test_gate_hint')
+              ),
+              Boolean(currentPreset.test_gate_enabled) &&
+                React.createElement(
+                  'div',
+                  { style: { marginLeft: 22, marginTop: 6, display: 'flex', flexDirection: 'column', gap: 6 } },
+                  React.createElement('input', {
+                    type: 'text',
+                    className: 'moa-input',
+                    style: { fontSize: 12, height: 28 },
+                    placeholder: t('aggregator.test_cmd_placeholder'),
+                    value: currentPreset.test_command || '',
+                    onChange: (e) => updateCurrentPreset((p) => ({ ...p, test_command: e.target.value })),
+                  }),
+                  React.createElement(
+                    'div',
+                    { style: { display: 'flex', alignItems: 'center', gap: 8 } },
+                    React.createElement('span', { style: { fontSize: 12, color: 'var(--dsw-alias-label-secondary)' } }, t('aggregator.test_timeout_label')),
+                    React.createElement('input', {
+                      type: 'number',
+                      className: 'moa-input',
+                      style: { width: 70, height: 26, fontSize: 12 },
+                      min: 5,
+                      max: 120,
+                      value: currentPreset.test_gate_timeout_sec ?? 15,
+                      onChange: (e) => {
+                        const val = parseInt(e.target.value, 10)
+                        updateCurrentPreset((p) => ({ ...p, test_gate_timeout_sec: isNaN(val) ? 15 : val }))
+                      },
+                    })
+                  )
+                ),
+              /* 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',
@@ -1427,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(
@@ -1448,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,8 +415,17 @@ 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,
+    testResult: r.testResult ? {
+      passed: r.testResult.passed,
+      exitCode: r.testResult.exitCode,
+      summary: r.testResult.summary,
+      durationMs: r.testResult.durationMs,
+    } : null,
   }))
 }

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({
@@ -74,11 +76,30 @@ export const PresetSchema = z.object({
   allow_candidate_override: z.boolean().default(false),
   max_tokens: z.number().default(4096),
   judge_criteria: z.string().default(''),
+  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([
     {
@@ -335,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'
@@ -394,3 +433,5 @@ export function apply(ctx, config) {
     })
   }, 'dsh-moa: llm stream interceptor')
 }
+
+export { executeTestGateForCandidates, runCandidateTestGate } from './moa-test-gate.js'

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)}).`,
+  }
+}