@goodandready/dsh-moa 0.2.73 → 0.2.74

package/README.md

@@ -186,6 +186,15 @@ Validates markdown code blocks across all candidate outputs locally using JavaSc
 ### 20. Early Exit upon Semantic Consensus
 Compares normalized candidate proposals using token-level Sørensen-Dice similarity. When models arrive at identical or near-identical solutions (meeting or exceeding `early_exit_threshold`, default: `0.95`), the expensive Judge synthesis phase is automatically bypassed. The consensus solution is promoted directly to the workspace, saving up to 100% of judge token costs while accelerating pipeline latency. Configured via `early_exit_consensus_enabled: true` and `early_exit_threshold: 0.95`.
 
+### 21. Dynamic Consensus Threshold & Multi-Judge Escalation
+Evaluates pairwise candidate solution divergence (Disagreement Metric, 0.0–1.0) using normalized Sørensen-Dice similarity. When candidate consensus is weak (disagreement meets or exceeds `escalation_disagreement_threshold`, default: `0.40`), the pipeline automatically escalates:
+- `auto_upgrade`: Upgrades from a lightweight or fast aggregator to a designated flagship senior judge (`escalation_judge` or first senior fallback judge).
+- `council_majority`: Convenes a 3-judge panel with majority consensus voting.
+Dispatches `moa/judge-escalation` Cordis events and displays escalation decisions in live stream telemetry. Configured via `escalation_policy: 'single' | 'auto_upgrade' | 'council_majority'`, `escalation_disagreement_threshold: 0.40`, and `escalation_judge`.
+
+### 22. Self-Consistency Temperature Sampling for Single Models
+Allows single-model configurations (such as a local Ollama/vLLM instance or a single API key) to leverage Mixture-of-Agents diversity. When enabled on a preset with 1 model slot, the runner expands it into $N$ parallel candidate streams with distinct temperatures (e.g. 0.2, 0.6, 0.9) and complementary personas (`proposer`, `challenger`, `minimalist`), calculates agreement ratio, and performs full MoA consensus synthesis. Dispatches `moa/self-consistency-expand` Cordis events. Configured via `self_consistency_enabled: true`, `self_consistency_samples: 3`, and `self_consistency_temperatures: [0.2, 0.6, 0.9]`.
+
 ### 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

@@ -186,6 +186,15 @@ graph TD
 ### 20. Ранний выход по семантическому консенсусу
 Сравнивает нормализованные решения кандидатов по токенному сходству Сёренсена-Дайса. Если решения моделей совпадают или практически идентичны (достигнут порог `early_exit_threshold`, по умолчанию 0.95), стадия вызова судьи (Judge) пропускается. Согласованный вариант немедленно продвигается в проект, экономя до 100% токенов судейской коллегии и сокращая задержку ответа. Управляется параметрами `early_exit_consensus_enabled: true` и `early_exit_threshold: 0.95`.
 
+### 21. Динамический порог консенсуса и эскалация судейства (Judge Escalation)
+Оценивает степень расхождения между решениями моделей-кандидатов (метрика Disagreement Metric, 0.0–1.0) на основе попарного расстояния Сёренсена-Дайса. Если расхождение превышает порог (`escalation_disagreement_threshold`, по умолчанию 0.40), пайплайн выполняет адаптивную эскалацию:
+- `auto_upgrade`: автоматический переход с базового/быстрого судьи на флагманскую старшую модель (`escalation_judge` или первый доступный резервный судья).
+- `council_majority`: созыв коллегии из 3 судей с голосованием большинством голосов.
+Генерирует событие `moa/judge-escalation` и выводит статус эскалации в телеметрию стрима.
+
+### 22. Самосогласованное температурное сэмплирование для одиночных моделей (Self-Consistency)
+Позволяет пользователям с единственной моделью (локальная Ollama, vLLM или единственный API-ключ) получать преимущества ансамблевой валидации MoA. Автоматически разворачивает одиночный слот на $N$ параллельных запусков с различными температурами (`0.2, 0.6, 0.9`) и дополняющими друг друга инженерными персонами (`proposer`, `challenger`, `minimalist`), вычисляет коэффициент согласия (Self-Consistency Agreement) и синтезирует итоговый результат. Генерирует событие `moa/self-consistency-expand`.
+
 ### 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/README.zh.md

@@ -163,6 +163,15 @@ graph TD
 ### 20. 语义共识提前退出机制 (Early Exit upon Semantic Consensus)
 基于 Token 级 Sørensen-Dice 相似度算法比对归一化后的候选方案。当多个候选模型给出高度一致的代码方案（达到或超过 `early_exit_threshold` 阈值，默认 0.95）时，自动跳过高耗费的裁判综合评审阶段，直接将共识方案提升至项目，在大幅缩短响应延迟的同时节省多达 100% 的裁判 Token 支出。通过 `early_exit_consensus_enabled: true` 与 `early_exit_threshold: 0.95` 配置。
 
+### 21. 动态共识阈值与裁判自适应升级 (Dynamic Consensus & Judge Escalation)
+基于归一化 Sørensen-Dice 计算候选方案间的分歧度 (Disagreement Metric 0.0–1.0)。当候选分歧超过设定阈值 (`escalation_disagreement_threshold`，默认 0.40) 时，流水线自动触发升级策略：
+- `auto_upgrade`: 自动将普通/快速裁判升级为指定的高阶旗舰裁判 (`escalation_judge` 或首选候补裁判)。
+- `council_majority`: 组建 3 裁判多数席裁决团。
+触发 `moa/judge-escalation` 事件并在实时流中呈现决策依据。
+
+### 22. 单模型自洽性温度采样 (Self-Consistency Temperature Sampling)
+专为仅配置单模型（如本地 Ollama/vLLM 或单一 API Key）的场景设计。开启后自动将单槽位扩展为 $N$ 个并行采样（分别采用 0.2、0.6、0.9 等递增温度与 `proposer`、`challenger`、`minimalist` 互补提示词），评估自洽一致性比率并进行全流程 MoA 综合聚合，触发 `moa/self-consistency-expand` 事件。
+
 ### 6. Live Canvas 一键预览（可选）
 若同一 profile 中安装了 `@goodandready/dsh-live-canvas`，`dsh-moa` 会将提升后的 HTML 文件推送到 Live Canvas 的 REST 契约（`POST /dsh-live-canvas/api/preview`，由同一 harness webServer 提供服务），并在回答中附上一键预览链接（`/dsh-live-canvas/sandbox/<id>`）。未安装该插件时此步骤静默跳过——日志无报错，也不会出现死链接。
 

package/lib/client.js

@@ -213,7 +213,18 @@ window.__ModuleLoader__.load({
       "workbench.promote_btn": "Promote Harmonized Files to Workspace",
       "workbench.promoted_ok": "\u2705 Harmonized deliverable promoted to workspace root!",
       "workbench.pros": "Pros:",
-      "workbench.cons": "Cons:"
+      "workbench.cons": "Cons:",
+      "aggregator.self_consistency_title": "\u{1F3B2} Self-Consistency Temperature Sampling (Single-Model Diversity)",
+      "aggregator.self_consistency_desc": "Expands a single reference model into multiple parallel samples with varied temperatures and personas, bringing MoA benefits to single-model setups.",
+      "aggregator.self_consistency_samples": "Samples:",
+      "aggregator.escalation_title": "\u2696\uFE0F Dynamic Consensus Threshold & Judge Escalation",
+      "aggregator.escalation_desc": "Detects divergence across candidates. When consensus is weak, automatically upgrades to a senior flagship judge or convenes a 3-judge panel.",
+      "aggregator.escalation_policy": "Escalation Policy:",
+      "aggregator.escalation_policy_single": "Standard Single Judge (No Escalation)",
+      "aggregator.escalation_policy_upgrade": "Auto-Upgrade to Senior Judge on Divergence",
+      "aggregator.escalation_policy_council": "Convene 3-Judge Majority Council on Divergence",
+      "aggregator.escalation_threshold": "Divergence Threshold:",
+      "aggregator.escalation_judge_label": "Senior Judge:"
     };
     const zh = {
       title: "\u667A\u80FD\u4F53\u6DF7\u5408 (MoA)",
@@ -417,7 +428,18 @@ window.__ModuleLoader__.load({
       "workbench.promote_btn": "\u63D0\u5347\u7C98\u5408\u7ED3\u679C\u81F3\u9879\u76EE\u6839\u76EE\u5F55",
       "workbench.promoted_ok": "\u2705 \u7C98\u5408\u65B9\u6848\u5DF2\u6210\u529F\u63D0\u5347\u81F3\u9879\u76EE\u5DE5\u4F5C\u533A\uFF01",
       "workbench.pros": "\u4F18\u52BF\uFF1A",
-      "workbench.cons": "\u4E0D\u8DB3\uFF1A"
+      "workbench.cons": "\u4E0D\u8DB3\uFF1A",
+      "aggregator.self_consistency_title": "\u{1F3B2} \u5355\u6A21\u578B\u81EA\u6D3D\u6027\u6E29\u5EA6\u91C7\u6837 (Self-Consistency)",
+      "aggregator.self_consistency_desc": "\u5728\u4EC5\u914D\u7F6E\u5355\u6A21\u578B\u65F6\uFF0C\u751F\u6210\u4E0D\u540C\u6E29\u5EA6\u4E0E\u89D2\u8272\u7684\u591A\u4E2A\u5E76\u884C\u5019\u9009\u65B9\u6848\uFF0C\u8BA9\u672C\u5730 Ollama \u6216\u5355 Key \u4E5F\u4EAB\u6709 MoA \u805A\u5408\u4F18\u52BF\u3002",
+      "aggregator.self_consistency_samples": "\u91C7\u6837\u6570:",
+      "aggregator.escalation_title": "\u2696\uFE0F \u52A8\u6001\u5171\u8BC6\u9608\u503C\u4E0E\u88C1\u5224\u5347\u7EA7 (Judge Escalation)",
+      "aggregator.escalation_desc": "\u68C0\u6D4B\u5019\u9009\u65B9\u6848\u95F4\u7684\u5206\u6B67\u5EA6\u3002\u5F53\u5171\u8BC6\u8F83\u5F31\u65F6\uFF0C\u81EA\u52A8\u5347\u7EA7\u81F3\u9AD8\u9636\u65D7\u8230\u88C1\u5224\u6216\u7EC4\u5EFA 3 \u88C1\u5224\u591A\u6570\u5E2D\u3002",
+      "aggregator.escalation_policy": "\u5347\u7EA7\u7B56\u7565:",
+      "aggregator.escalation_policy_single": "\u6807\u51C6\u5355\u88C1\u5224 (\u4E0D\u5347\u7EA7)",
+      "aggregator.escalation_policy_upgrade": "\u5206\u6B67\u65F6\u81EA\u52A8\u5347\u7EA7\u81F3\u9AD8\u9636\u88C1\u5224",
+      "aggregator.escalation_policy_council": "\u5206\u6B67\u65F6\u7EC4\u5EFA 3 \u88C1\u5224\u591A\u6570\u51B3\u7B56\u5E2D",
+      "aggregator.escalation_threshold": "\u5206\u6B67\u9608\u503C:",
+      "aggregator.escalation_judge_label": "\u9AD8\u9636\u88C1\u5224\u6A21\u578B:"
     };
     function makeT(dict, fallback) {
       return function t(key, vars) {
@@ -2427,6 +2449,116 @@ window.__ModuleLoader__.load({
                   t("aggregator.semantic_cache_desc") || "Persists intermediate candidate outputs locally by deterministic SHA-256 fingerprint, eliminating duplicate API costs on retry or repeat requests."
                 )
               ),
+              /* Self-Consistency Temperature Sampling (#301) */
+              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.self_consistency_enabled),
+                    onChange: (e) => updateCurrentPreset((p) => ({ ...p, self_consistency_enabled: e.target.checked })),
+                    style: { accentColor: "var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))", cursor: "pointer" }
+                  }),
+                  t("aggregator.self_consistency_title") || "\u{1F3B2} Self-Consistency Temperature Sampling (Single-Model Diversity)"
+                ),
+                React.createElement(
+                  "div",
+                  { style: { fontSize: 12, color: "var(--dsw-alias-label-secondary)", marginLeft: 22 } },
+                  t("aggregator.self_consistency_desc") || "Expands a single reference model into multiple parallel samples with varied temperatures and personas, bringing MoA benefits to single-model setups."
+                ),
+                currentPreset.self_consistency_enabled && React.createElement(
+                  "div",
+                  { style: { marginLeft: 22, marginTop: 4, display: "flex", alignItems: "center", gap: 12 } },
+                  React.createElement("span", { style: { fontSize: 12, color: "var(--dsw-alias-label-secondary)" } }, (t("aggregator.self_consistency_samples") || "Samples:") + " " + (currentPreset.self_consistency_samples || 3)),
+                  React.createElement("input", {
+                    type: "range",
+                    min: 2,
+                    max: 5,
+                    value: currentPreset.self_consistency_samples || 3,
+                    onChange: (e) => updateCurrentPreset((p) => ({ ...p, self_consistency_samples: Number(e.target.value) })),
+                    style: { width: 100, accentColor: "var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))" }
+                  })
+                )
+              ),
+              /* Dynamic Consensus Threshold & Multi-Judge Escalation (#300) */
+              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(
+                  "div",
+                  { style: { fontSize: 13, fontWeight: 600, color: "var(--dsw-alias-label-primary)" } },
+                  t("aggregator.escalation_title") || "\u2696\uFE0F Dynamic Consensus Threshold & Judge Escalation"
+                ),
+                React.createElement(
+                  "div",
+                  { style: { fontSize: 12, color: "var(--dsw-alias-label-secondary)" } },
+                  t("aggregator.escalation_desc") || "Detects divergence across candidates. When consensus is weak, automatically upgrades to a senior flagship judge or convenes a 3-judge panel."
+                ),
+                React.createElement(
+                  "div",
+                  { style: { display: "flex", alignItems: "center", gap: 8, marginTop: 4 } },
+                  React.createElement("span", { style: { fontSize: 12, color: "var(--dsw-alias-label-secondary)" } }, t("aggregator.escalation_policy") || "Escalation Policy:"),
+                  React.createElement(
+                    "select",
+                    {
+                      value: currentPreset.escalation_policy || "single",
+                      onChange: (e) => updateCurrentPreset((p) => ({ ...p, escalation_policy: e.target.value })),
+                      style: {
+                        padding: "4px 8px",
+                        fontSize: 12,
+                        borderRadius: 6,
+                        border: "1px solid var(--dsw-alias-border-l2)",
+                        background: "var(--dsw-alias-bg-layer-1)",
+                        color: "var(--dsw-alias-label-primary)"
+                      }
+                    },
+                    React.createElement("option", { value: "single" }, t("aggregator.escalation_policy_single") || "Standard Single Judge (No Escalation)"),
+                    React.createElement("option", { value: "auto_upgrade" }, t("aggregator.escalation_policy_upgrade") || "Auto-Upgrade to Senior Judge on Divergence"),
+                    React.createElement("option", { value: "council_majority" }, t("aggregator.escalation_policy_council") || "Convene 3-Judge Majority Council on Divergence")
+                  )
+                ),
+                currentPreset.escalation_policy && currentPreset.escalation_policy !== "single" && React.createElement(
+                  "div",
+                  { style: { display: "flex", flexDirection: "column", gap: 6, marginTop: 4 } },
+                  React.createElement(
+                    "div",
+                    { style: { display: "flex", alignItems: "center", gap: 12 } },
+                    React.createElement("span", { style: { fontSize: 12, color: "var(--dsw-alias-label-secondary)" } }, (t("aggregator.escalation_threshold") || "Divergence Threshold:") + " " + Math.round((currentPreset.escalation_disagreement_threshold ?? 0.4) * 100) + "%"),
+                    React.createElement("input", {
+                      type: "range",
+                      min: 10,
+                      max: 90,
+                      value: Math.round((currentPreset.escalation_disagreement_threshold ?? 0.4) * 100),
+                      onChange: (e) => updateCurrentPreset((p) => ({ ...p, escalation_disagreement_threshold: Number(e.target.value) / 100 })),
+                      style: { width: 120, accentColor: "var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))" }
+                    })
+                  ),
+                  currentPreset.escalation_policy === "auto_upgrade" && React.createElement(
+                    "div",
+                    { style: { display: "flex", alignItems: "center", gap: 8 } },
+                    React.createElement("span", { style: { fontSize: 12, color: "var(--dsw-alias-label-secondary)" } }, t("aggregator.escalation_judge_label") || "Senior Judge:"),
+                    React.createElement(
+                      "div",
+                      { style: { flex: 1, maxWidth: 300 } },
+                      React.createElement(SearchableModelPicker, {
+                        provider: currentPreset.escalation_judge?.provider || "",
+                        model: currentPreset.escalation_judge?.model || "",
+                        onChange: (prov, mod) => {
+                          updateCurrentPreset((p) => ({
+                            ...p,
+                            escalation_judge: { provider: prov, model: mod }
+                          }));
+                        },
+                        availableModels,
+                        t
+                      })
+                    )
+                  )
+                )
+              ),
               /* Fallback Judges Chain */
               React.createElement(
                 "div",

package/lib/events.js

@@ -7,6 +7,8 @@ export const MOA_EVENTS = {
   CANDIDATE_COMPLETE: 'moa/candidate-complete',
   SYNTAX_VALIDATION: 'moa/syntax-validation',
   EARLY_CONSENSUS: 'moa/early-consensus',
+  JUDGE_ESCALATION: 'moa/judge-escalation',
+  SELF_CONSISTENCY_EXPAND: 'moa/self-consistency-expand',
   CRITIQUE_COMPLETE: 'moa/critique-complete',
   JUDGE_VERDICT: 'moa/judge-verdict',
   CONTEXT_PRUNING: 'moa/context-pruning',

package/lib/moa-schema.js

@@ -83,6 +83,12 @@ export const PresetSchema = z.object({
   context_pruning_diff_lines: z.number().default(5),
   semantic_cache_enabled: z.boolean().default(false),
   semantic_cache_ttl_hours: z.number().default(168),
+  self_consistency_enabled: z.boolean().default(false),
+  self_consistency_samples: z.number().default(3),
+  self_consistency_temperatures: z.array(z.number()).default([0.2, 0.6, 0.9]),
+  escalation_policy: z.string().default('single'),
+  escalation_disagreement_threshold: z.number().default(0.40),
+  escalation_judge: ModelSlotSchema.default({ provider: '', model: '' }),
 })
 
 export const Config = z.object({
@@ -112,6 +118,12 @@ export const Config = z.object({
   context_pruning_diff_lines: z.number().default(5).volatile(),
   semantic_cache_enabled: z.boolean().default(false).volatile(),
   semantic_cache_ttl_hours: z.number().default(168).volatile(),
+  self_consistency_enabled: z.boolean().default(false).volatile(),
+  self_consistency_samples: z.number().default(3).volatile(),
+  self_consistency_temperatures: z.array(z.number()).default([0.2, 0.6, 0.9]).volatile(),
+  escalation_policy: z.string().default('single').volatile(),
+  escalation_disagreement_threshold: z.number().default(0.40).volatile(),
+  escalation_judge: ModelSlotSchema.default({ provider: '', model: '' }).volatile(),
   smart_routing_model: ModelSlotSchema.default({ provider: '', model: '' }).volatile(),
   prices: z.dict(PriceRow).default({}).volatile(),
   presets: z.array(PresetSchema).default([

package/lib/pipeline/context.js

@@ -1,3 +1,5 @@
+import { expandSelfConsistencySlots } from './self-consistency.js'
+import { emitEvent, MOA_EVENTS } from '../events.js'
 import { balanceCandidateQuotas } from '../moa-quota-balancer.js'
 import { collectProjectContext, formatProjectContext, isRefinementTask } from '../workspace/scanner.js'
 import { applyBudgetGuardrails, createBudgetAbortPayload } from '../moa-budget.js'
@@ -27,7 +29,40 @@ export async function stageProjectContext({
   const refTemp = typeof preset?.reference_temperature === 'number' ? preset.reference_temperature : 0.6
   const aggTemp = typeof preset?.aggregator_temperature === 'number' ? preset.aggregator_temperature : 0.4
   const judgeCriteria = preset?.judge_criteria || ''
-  let isFastMode = referenceModels.length === 1 && !preset?.curator_synthesis
+  const selfConsistencyEnabled = Boolean(preset?.self_consistency_enabled)
+  const selfConsistencySamples = typeof preset?.self_consistency_samples === 'number' ? preset.self_consistency_samples : 3
+  const selfConsistencyTemperatures = Array.isArray(preset?.self_consistency_temperatures)
+    ? preset.self_consistency_temperatures
+    : [0.2, 0.6, 0.9]
+  const escalationPolicy = preset?.escalation_policy || 'single'
+  const escalationDisagreementThreshold = typeof preset?.escalation_disagreement_threshold === 'number'
+    ? preset.escalation_disagreement_threshold
+    : 0.40
+  const escalationJudge = (preset?.escalation_judge?.model) ? preset.escalation_judge : null
+
+  let effectiveReferenceModels = referenceModels
+  let selfConsistencyExpanded = false
+  if (selfConsistencyEnabled) {
+    const scRes = expandSelfConsistencySlots(referenceModels, {
+      enabled: true,
+      samples: selfConsistencySamples,
+      temperatures: selfConsistencyTemperatures,
+    })
+    if (scRes.isExpanded) {
+      effectiveReferenceModels = scRes.references
+      selfConsistencyExpanded = true
+      emitEvent(ctx, MOA_EVENTS.SELF_CONSISTENCY_EXPAND, {
+        originalModel: referenceModels[0]?.model,
+        sampleCount: scRes.sampleCount,
+        temperatures: selfConsistencyTemperatures.slice(0, scRes.sampleCount),
+      })
+      if (typeof onProgress === 'function') {
+        onProgress(`🎲 *Self-Consistency: Expanded single model into ${scRes.sampleCount} diverse temperature samples (${selfConsistencyTemperatures.slice(0, scRes.sampleCount).join(', ')})*\n`)
+      }
+    }
+  }
+
+  let isFastMode = effectiveReferenceModels.length === 1 && !preset?.curator_synthesis
   const isCuratorSynthesis = Boolean(preset?.curator_synthesis)
   const isStreamAggregator = preset?.stream_aggregator !== false
   const isQuorumEnabled = Boolean(preset?.quorum_enabled)
@@ -65,7 +100,7 @@ export async function stageProjectContext({
   }
 
   const budgetCheck = applyBudgetGuardrails({
-    references: referenceModels,
+    references: effectiveReferenceModels,
     enabled: preset?.budget_guard_enabled,
     maxBudgetUsd: preset?.max_budget_usd,
     action: preset?.budget_action || 'trim',
@@ -133,6 +168,8 @@ export async function stageProjectContext({
     localPreflightCheck, earlyExitConsensusEnabled, earlyExitThreshold,
     contextPruningEnabled, contextPruningDiffLines,
     semanticCacheEnabled, semanticCacheTtlHours,
+    selfConsistencyEnabled, selfConsistencyExpanded, selfConsistencySamples, selfConsistencyTemperatures,
+    escalationPolicy, escalationDisagreementThreshold, escalationJudge,
   }
 }
 

package/lib/pipeline/escalation.js

@@ -0,0 +1,160 @@
+/**
+ * Dynamic Consensus Threshold & Multi-Judge Escalation (#300)
+ *
+ * Detects divergence among candidate outputs (Disagreement Metric).
+ * When candidate consensus is weak or contradictory, automatically escalates:
+ * - auto_upgrade: upgrades from lightweight/fast judge to flagship/senior judge
+ * - council_majority: convenes a 3-judge panel with majority voting
+ */
+
+import { calculateSimilarity } from './early-consensus.js'
+
+/**
+ * Calculates the Disagreement Metric (0.0 to 1.0) across candidate outputs.
+ * 0.0 means perfect consensus (identical solutions).
+ * 1.0 means total divergence (completely distinct solutions).
+ *
+ * @param {Array<object>} candidateOutputs
+ * @returns {number} Disagreement metric between 0.0 and 1.0
+ */
+export function calculateDisagreementMetric(candidateOutputs = []) {
+  if (!Array.isArray(candidateOutputs) || candidateOutputs.length < 2) {
+    return 0.0
+  }
+
+  const validTexts = candidateOutputs
+    .filter((c) => c && typeof c.text === 'string' && c.text.trim())
+    .map((c) => c.text)
+
+  if (validTexts.length < 2) return 0.0
+
+  let totalSim = 0
+  let pairs = 0
+
+  for (let i = 0; i < validTexts.length; i++) {
+    for (let j = i + 1; j < validTexts.length; j++) {
+      totalSim += calculateSimilarity(validTexts[i], validTexts[j])
+      pairs++
+    }
+  }
+
+  if (pairs === 0) return 0.0
+  const avgSim = totalSim / pairs
+  const disagreement = Math.max(0.0, Math.min(1.0, 1.0 - avgSim))
+  return Number(disagreement.toFixed(4))
+}
+
+/**
+ * Evaluates whether candidate divergence warrants judge escalation.
+ *
+ * @param {object} params
+ * @param {Array<object>} params.candidateOutputs - Array of successful candidate results
+ * @param {object} params.primaryJudge - Primary configured judge slot
+ * @param {Array<object>} [params.fallbackJudges=[]] - Chain of backup judges
+ * @param {object} [params.escalationJudge] - Explicit flagship upgrade judge
+ * @param {string} [params.policy='single'] - 'single' | 'auto_upgrade' | 'council_majority'
+ * @param {number} [params.threshold=0.40] - Disagreement threshold to trigger escalation
+ * @returns {object} Escalation decision and effective judge(s)
+ */
+export function evaluateJudgeEscalation({
+  candidateOutputs = [],
+  primaryJudge = { provider: '', model: '' },
+  fallbackJudges = [],
+  escalationJudge = null,
+  policy = 'single',
+  threshold = 0.40,
+} = {}) {
+  const normPolicy = String(policy || 'single').toLowerCase()
+
+  if (normPolicy === 'single' || !Array.isArray(candidateOutputs) || candidateOutputs.length < 2) {
+    return {
+      escalated: false,
+      escalatedType: 'none',
+      judge: primaryJudge,
+      councilJudges: [primaryJudge],
+      disagreement: 0.0,
+      threshold,
+      reason: 'Standard single judge evaluation',
+    }
+  }
+
+  const disagreement = calculateDisagreementMetric(candidateOutputs)
+  const isTriggered = disagreement >= threshold
+
+  if (!isTriggered) {
+    return {
+      escalated: false,
+      escalatedType: 'none',
+      judge: primaryJudge,
+      councilJudges: [primaryJudge],
+      disagreement,
+      threshold,
+      reason: `Consensus adequate: disagreement ${(disagreement * 100).toFixed(1)}% < threshold ${(threshold * 100).toFixed(1)}%`,
+    }
+  }
+
+  if (normPolicy === 'auto_upgrade') {
+    // Pick designated escalationJudge, or the first available fallbackJudge
+    let targetJudge = null
+    if (escalationJudge && escalationJudge.model) {
+      targetJudge = escalationJudge
+    } else if (Array.isArray(fallbackJudges) && fallbackJudges.length > 0 && fallbackJudges[0]?.model) {
+      targetJudge = fallbackJudges[0]
+    } else {
+      targetJudge = primaryJudge
+    }
+
+    const upgraded = targetJudge.model !== primaryJudge.model || targetJudge.provider !== primaryJudge.provider
+    return {
+      escalated: upgraded,
+      escalatedType: upgraded ? 'auto_upgrade' : 'none',
+      judge: targetJudge,
+      originalJudge: primaryJudge,
+      councilJudges: [targetJudge],
+      disagreement,
+      threshold,
+      reason: upgraded
+        ? `High candidate divergence (${(disagreement * 100).toFixed(1)}% >= ${(threshold * 100).toFixed(1)}%): upgraded judge to ${targetJudge.provider ? targetJudge.provider + ':' : ''}${targetJudge.model}`
+        : `High divergence detected (${(disagreement * 100).toFixed(1)}%), but no senior fallback judge configured`,
+    }
+  }
+
+  if (normPolicy === 'council_majority') {
+    const council = [primaryJudge]
+    if (escalationJudge && escalationJudge.model && escalationJudge.model !== primaryJudge.model) {
+      council.push(escalationJudge)
+    }
+    if (Array.isArray(fallbackJudges)) {
+      for (const fb of fallbackJudges) {
+        if (council.length >= 3) break
+        if (fb && fb.model && !council.some((c) => c.model === fb.model && c.provider === fb.provider)) {
+          council.push(fb)
+        }
+      }
+    }
+
+    const hasMulti = council.length > 1
+    return {
+      escalated: hasMulti,
+      escalatedType: hasMulti ? 'council_majority' : 'none',
+      judge: council[0],
+      originalJudge: primaryJudge,
+      councilJudges: council,
+      disagreement,
+      threshold,
+      reason: hasMulti
+        ? `High candidate divergence (${(disagreement * 100).toFixed(1)}% >= ${(threshold * 100).toFixed(1)}%): assembled ${council.length}-judge council`
+        : `High divergence detected, but fewer than 2 judges available for council`,
+    }
+  }
+
+  return {
+    escalated: false,
+    escalatedType: 'none',
+    judge: primaryJudge,
+    councilJudges: [primaryJudge],
+    disagreement,
+    threshold,
+    reason: 'Standard single judge',
+  }
+}

package/lib/pipeline/runner.js

@@ -1,3 +1,5 @@
+import { evaluateJudgeEscalation } from './escalation.js'
+import { calculateSelfConsistencyAgreement } from './self-consistency.js'
 import { pruneCandidateEnsemble, formatPruningDirective } from './context-pruner.js'
 import { buildAstCompositeMergeDirective } from '../moa-ast-merge.js'
 import { runVisualMoaConsensus } from '../moa-visual-consensus.js'
@@ -106,6 +108,13 @@ export async function runMoAPipeline({
   })
   const syntaxDirective = syntaxResult.filterApplied ? formatSyntaxDirective(referenceOutputs, { blind: ctxStage.isBlindEvaluation }) : null
 
+  if (ctxStage.selfConsistencyExpanded && successfulRefs.length > 1) {
+    const scAgreement = calculateSelfConsistencyAgreement(successfulRefs)
+    if (typeof onProgress === 'function') {
+      onProgress(`🎯 *Self-Consistency Agreement: ${(scAgreement.agreementRatio * 100).toFixed(0)}% (${scAgreement.isStrongConsensus ? 'Strong consensus' : 'Divergent sampling'}) across ${scAgreement.sampleCount} samples*\n`)
+    }
+  }
+
   // Stage 3: Clarifying Questions Branch
   if (ctxStage.needsQuestions) {
     return await stageClarifyingQuestions({
@@ -190,11 +199,56 @@ export async function runMoAPipeline({
     return { error: new Error('Turn aborted') }
   }
 
+  // Pre-Stage 6: Dynamic Consensus Threshold & Multi-Judge Escalation (#300)
+  const escalationResult = evaluateJudgeEscalation({
+    candidateOutputs: syntaxResult.validCandidates.length > 0 ? syntaxResult.validCandidates : successfulRefs,
+    primaryJudge: ctxStage.primaryJudge,
+    fallbackJudges: ctxStage.fallbackJudges,
+    escalationJudge: ctxStage.escalationJudge,
+    policy: ctxStage.escalationPolicy,
+    threshold: ctxStage.escalationDisagreementThreshold,
+  })
+
+  let effectivePrimaryJudge = ctxStage.primaryJudge
+  let effectiveFallbackJudges = ctxStage.fallbackJudges
+  let effectiveJudgesChain = ctxStage.judgesChain
+  let effectivePreset = preset
+
+  if (escalationResult.escalated) {
+    emitEvent(ctx, MOA_EVENTS.JUDGE_ESCALATION, {
+      runId,
+      policy: ctxStage.escalationPolicy,
+      disagreement: escalationResult.disagreement,
+      threshold: escalationResult.threshold,
+      escalatedType: escalationResult.escalatedType,
+      originalJudge: escalationResult.originalJudge,
+      escalatedJudge: escalationResult.judge,
+      councilJudges: escalationResult.councilJudges,
+    })
+    if (typeof onProgress === 'function') {
+      onProgress(`⚖️ *Judge Escalation (${escalationResult.escalatedType}): ${escalationResult.reason}*\n`)
+    }
+
+    if (escalationResult.escalatedType === 'auto_upgrade') {
+      effectivePrimaryJudge = escalationResult.judge
+      effectiveFallbackJudges = ctxStage.fallbackJudges.filter(
+        (j) => !(j.provider === escalationResult.judge.provider && j.model === escalationResult.judge.model)
+      )
+      effectiveJudgesChain = [effectivePrimaryJudge, ...effectiveFallbackJudges]
+    } else if (escalationResult.escalatedType === 'council_majority') {
+      effectivePreset = {
+        ...preset,
+        multi_judge_enabled: true,
+        judge_models: escalationResult.councilJudges,
+      }
+    }
+  }
+
   // Stage 6: Multi-Judge Panel
   const mjRes = await stageMultiJudge({
-    preset,
+    preset: effectivePreset,
     successfulRefs: syntaxResult.validCandidates.length > 0 ? syntaxResult.validCandidates : successfulRefs,
-    referenceOutputs, primaryJudge: ctxStage.primaryJudge,
+    referenceOutputs, primaryJudge: effectivePrimaryJudge,
     userPrompt, judgeCriteria: ctxStage.judgeCriteria, prices, maxTokens: ctxStage.maxTokens,
     callLlm, signal, onProgress, cwd, runId, isRefinement: ctxStage.isRefinement,
     isFastMode: ctxStage.isFastMode, collectedCtx: ctxStage.collectedCtx, startTime,
@@ -263,9 +317,9 @@ export async function runMoAPipeline({
     judgeCriteria: ctxStage.judgeCriteria,
     isCuratorSynthesis: ctxStage.isCuratorSynthesis, isBlindEvaluation: ctxStage.isBlindEvaluation,
     priorTurnBaseline: ctxStage.priorTurnBaseline, compositeMergeDirective, fileScoringDirective,
-    multiJudgeResult, preset, prices, maxTokens: ctxStage.maxTokens, isFastMode: ctxStage.isFastMode,
-    primaryJudge: ctxStage.primaryJudge, fallbackJudges: ctxStage.fallbackJudges,
-    judgesChain: ctxStage.judgesChain, aggTemp: ctxStage.aggTemp,
+    multiJudgeResult, preset: effectivePreset, prices, maxTokens: ctxStage.maxTokens, isFastMode: ctxStage.isFastMode,
+    primaryJudge: effectivePrimaryJudge, fallbackJudges: effectiveFallbackJudges,
+    judgesChain: effectiveJudgesChain, aggTemp: ctxStage.aggTemp,
     aggTimeoutSec: ctxStage.aggTimeoutSec, isStreamAggregator: ctxStage.isStreamAggregator,
     onStreamDelta, signal, callLlm, onProgress, cwd, runId, isRefinement: ctxStage.isRefinement,
     collectedCtx: ctxStage.collectedCtx, startTime,

package/lib/pipeline/self-consistency.js

@@ -0,0 +1,135 @@
+/**
+ * Self-Consistency Temperature Sampling for Single Models (#301)
+ *
+ * Allows users with a single model slot (e.g., local Ollama/vLLM or a single API key)
+ * to benefit from Mixture of Agents ensemble diversity by generating parallel samples
+ * at varying temperatures and complementary system personas, followed by consistency voting.
+ */
+
+import { ROLE_PERSONA_PROMPTS } from '../moa-prompts.js'
+
+export const DEFAULT_SELF_CONSISTENCY_TEMPERATURES = Object.freeze([0.2, 0.6, 0.9])
+export const DEFAULT_SELF_CONSISTENCY_PERSONAS = Object.freeze(['proposer', 'challenger', 'minimalist'])
+
+/**
+ * Expands a single reference model into multiple parallel proposer slots
+ * with distinct temperatures and complementary reasoning personas.
+ *
+ * @param {Array<object>} referenceModels - Original reference model slots
+ * @param {object} [options]
+ * @param {boolean} [options.enabled=false] - Whether self-consistency expansion is enabled
+ * @param {number} [options.samples=3] - Number of candidate samples to generate (2-10)
+ * @param {Array<number>} [options.temperatures] - Array of temperatures for samples
+ * @param {Array<string>} [options.personas] - Array of persona role names
+ * @returns {{ references: Array<object>, isExpanded: boolean, sampleCount: number }}
+ */
+export function expandSelfConsistencySlots(referenceModels = [], options = {}) {
+  const {
+    enabled = false,
+    samples = 3,
+    temperatures = DEFAULT_SELF_CONSISTENCY_TEMPERATURES,
+    personas = DEFAULT_SELF_CONSISTENCY_PERSONAS,
+  } = options
+
+  // Expansion applies only when explicitly enabled or requested
+  if (!enabled) {
+    return {
+      references: Array.isArray(referenceModels) ? referenceModels : [],
+      isExpanded: false,
+      sampleCount: Array.isArray(referenceModels) ? referenceModels.length : 0,
+    }
+  }
+
+  const rawList = Array.isArray(referenceModels) && referenceModels.length > 0
+    ? referenceModels
+    : [{ provider: '', model: '' }]
+
+  // Only expand when a single model slot is configured
+  if (rawList.length !== 1) {
+    return {
+      references: rawList,
+      isExpanded: false,
+      sampleCount: rawList.length,
+    }
+  }
+
+  const baseSlot = rawList[0] || {}
+  const count = Math.min(10, Math.max(2, Number(samples) || 3))
+  const expandedList = []
+
+  for (let i = 0; i < count; i++) {
+    const temp = Array.isArray(temperatures) && typeof temperatures[i] === 'number'
+      ? temperatures[i]
+      : (DEFAULT_SELF_CONSISTENCY_TEMPERATURES[i % DEFAULT_SELF_CONSISTENCY_TEMPERATURES.length] || 0.6)
+
+    const role = Array.isArray(personas) && personas[i]
+      ? personas[i]
+      : (DEFAULT_SELF_CONSISTENCY_PERSONAS[i % DEFAULT_SELF_CONSISTENCY_PERSONAS.length] || 'proposer')
+
+    expandedList.push({
+      ...baseSlot,
+      label: baseSlot.label
+        ? `${baseSlot.label} [T=${temp}, ${role}]`
+        : `Sample ${i + 1} (${baseSlot.model || 'model'}, T=${temp})`,
+      temperature: temp,
+      role_persona: role,
+      sampleIndex: i + 1,
+      isSelfConsistencySample: true,
+    })
+  }
+
+  return {
+    references: expandedList,
+    isExpanded: true,
+    sampleCount: expandedList.length,
+  }
+}
+
+/**
+ * Calculates majority agreement and self-consistency metrics across candidate outputs.
+ *
+ * @param {Array<object>} candidateOutputs - Array of successful candidate results
+ * @returns {{ agreementRatio: number, isStrongConsensus: boolean, sampleCount: number }}
+ */
+export function calculateSelfConsistencyAgreement(candidateOutputs = []) {
+  if (!Array.isArray(candidateOutputs) || candidateOutputs.length < 2) {
+    return {
+      agreementRatio: 1.0,
+      isStrongConsensus: true,
+      sampleCount: Array.isArray(candidateOutputs) ? candidateOutputs.length : 0,
+    }
+  }
+
+  const texts = candidateOutputs
+    .filter((c) => c && typeof c.text === 'string' && c.text.trim())
+    .map((c) => c.text.trim().toLowerCase().replace(/\s+/g, ' '))
+
+  if (texts.length < 2) {
+    return {
+      agreementRatio: 1.0,
+      isStrongConsensus: true,
+      sampleCount: texts.length,
+    }
+  }
+
+  // Count exact and near-match clusters
+  let maxClusterSize = 1
+  for (let i = 0; i < texts.length; i++) {
+    let clusterSize = 1
+    for (let j = 0; j < texts.length; j++) {
+      if (i === j) continue
+      // If texts are very similar (> 85% overlap)
+      if (texts[i] === texts[j] || (texts[i].length > 20 && texts[j].includes(texts[i].slice(0, 40)))) {
+        clusterSize++
+      }
+    }
+    if (clusterSize > maxClusterSize) maxClusterSize = clusterSize
+  }
+
+  const agreementRatio = Number((maxClusterSize / texts.length).toFixed(2))
+  return {
+    agreementRatio,
+    isStrongConsensus: agreementRatio >= 0.66,
+    sampleCount: texts.length,
+  }
+}

package/package.json

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