@goodandready/dsh-moa 0.2.26 → 0.2.29

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/file-workspace.js

@@ -11,7 +11,8 @@ export function isSafeRelativePath(relPath) {
   const trimmed = relPath.trim()
   if (!trimmed || path.isAbsolute(trimmed) || trimmed.startsWith('/') || trimmed.startsWith('\\')) return false
   const normalized = path.normalize(trimmed)
-  return Boolean(normalized && !normalized.startsWith('..') && !path.isAbsolute(normalized))
+  if (!normalized || normalized === '.' || normalized.startsWith('..') || path.isAbsolute(normalized)) return false
+  return true
 }
 
 /**
@@ -150,9 +151,9 @@ export async function collectProjectContext(baseDir, maxCharBudget = 16000) {
             const truncated = content.length > budgetRemaining ? content.slice(0, budgetRemaining) + '\n... [truncated]' : content
             totalChars += truncated.length
             collected.push({ relativePath: rel, content: truncated, size: stat.size })
-          } catch {
+          } catch (err) {
             skippedFiles++
-            skippedList.push(rel)
+            skippedList.push(`${rel} (read error: ${err?.message || String(err)})`)
           }
         }
       }
@@ -294,7 +295,7 @@ export async function promoteCandidateWorkspace(baseDir, winningIndex, options =
     if (!options.keepMoa) {
       await bestEffort('clean moaRoot on promote error', () => fs.rm(moaRoot, { recursive: true, force: true }))
     }
-    return []
+    throw err
   }
 }
 

package/lib/history.js

@@ -1,3 +1,4 @@
+import { logger } from './logger.js'
 /**
  * MoA Run History & Analytics Module
  * Records every MoA pipeline execution, tracks model win rates and costs,
@@ -47,7 +48,7 @@ export function rotateHistoryFileIfNeeded(filePath = DEFAULT_HISTORY_FILE, maxBy
       return true
     }
   } catch (err) {
-    console.warn('[dsh-moa] History rotation warning:', err?.message || err)
+    logger.warn('[dsh-moa] History rotation warning:', err?.message || err)
   }
   return false
 }
@@ -86,6 +87,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,
   }
 }
 
@@ -108,7 +111,7 @@ export function recordMoaRun(record, filePath = DEFAULT_HISTORY_FILE) {
     invalidateHistoryCache()
     return entry
   } catch (err) {
-    console.warn('[dsh-moa] Failed to record run to history:', err)
+    logger.warn('[dsh-moa] Failed to record run to history:', err)
     return null
   }
 }
@@ -129,7 +132,7 @@ export async function recordMoaRunAsync(record, filePath = DEFAULT_HISTORY_FILE)
     invalidateHistoryCache()
     return entry
   } catch (err) {
-    console.warn('[dsh-moa] Failed to async-record run to history:', err)
+    logger.warn('[dsh-moa] Failed to async-record run to history:', err)
     return null
   }
 }
@@ -230,7 +233,7 @@ export function getMoaHistory(limit = 20, offset = 0, filePath = DEFAULT_HISTORY
 
     return { total, runs }
   } catch (err) {
-    console.warn('[dsh-moa] Failed to read history:', err)
+    logger.warn('[dsh-moa] Failed to read history:', err)
     return { total: 0, runs: [] }
   }
 }
@@ -333,7 +336,7 @@ export function getMoaLeaderboard(filePath = DEFAULT_HISTORY_FILE, options = {})
     _historyCache.leaderboards.set(filterKey, result)
     return result
   } catch (err) {
-    console.warn('[dsh-moa] Failed to calculate leaderboard:', err)
+    logger.warn('[dsh-moa] Failed to calculate leaderboard:', err)
     return { totalRuns: 0, models: [] }
   }
 }
@@ -403,7 +406,7 @@ export function exportMoaHistory(filePath = DEFAULT_HISTORY_FILE, options = {})
 
     return JSON.stringify(records, null, 2)
   } catch (err) {
-    console.warn('[dsh-moa] Failed to export history:', err)
+    logger.warn('[dsh-moa] Failed to export history:', err)
     return options?.format === 'csv' ? '' : '[]'
   }
 }
@@ -413,6 +416,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

@@ -1,3 +1,4 @@
+import { setLogger, logger } from './logger.js'
 import { refreshCatalogInBackground } from './pricing.js'
 /**
  * DeepSeek Harness Mixture of Agents (MoA) Plugin
@@ -32,6 +33,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 +54,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 +80,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([
     {
@@ -145,6 +164,7 @@ export function plainConfig(value) {
 }
 
 export function apply(ctx, config) {
+  if (ctx.logger) setLogger(ctx.logger)
   refreshCatalogInBackground()
 
   let localConfig = plainConfig(config ?? {})
@@ -191,7 +211,7 @@ export function apply(ctx, config) {
         await settingsService.update(NS, plain)
       }
     } catch (err) {
-      console.warn('[dsh-moa] Settings persistence warning:', err?.message || err)
+      logger.warn('[dsh-moa] Settings persistence warning:', err?.message || err)
     }
     return localConfig
   }
@@ -338,6 +358,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/logger.js

@@ -0,0 +1,40 @@
+/**
+ * Context logger abstraction for dsh-moa.
+ * Avoids raw direct console warnings in server-side modules and respects Cordis ctx.logger.
+ */
+let currentLogger = null
+
+export function setLogger(logger) {
+  currentLogger = logger
+}
+
+export const logger = {
+  warn(...args) {
+    if (currentLogger && typeof currentLogger.warn === 'function') {
+      currentLogger.warn(...args)
+    } else if (typeof console !== 'undefined' && typeof console.debug === 'function') {
+      console.debug(...args)
+    }
+  },
+  debug(...args) {
+    if (currentLogger && typeof currentLogger.debug === 'function') {
+      currentLogger.debug(...args)
+    } else if (typeof console !== 'undefined' && typeof console.debug === 'function') {
+      console.debug(...args)
+    }
+  },
+  info(...args) {
+    if (currentLogger && typeof currentLogger.info === 'function') {
+      currentLogger.info(...args)
+    } else if (typeof console !== 'undefined' && typeof console.debug === 'function') {
+      console.debug(...args)
+    }
+  },
+  error(...args) {
+    if (currentLogger && typeof currentLogger.error === 'function') {
+      currentLogger.error(...args)
+    } else if (typeof console !== 'undefined' && typeof console.debug === 'function') {
+      console.debug(...args)
+    }
+  },
+}

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