@goodandready/dsh-moa 0.2.73 → 0.2.75

package/README.md

@@ -186,6 +186,21 @@ 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]`.
+
+### 23. Stack-Aware Dynamic Persona Evolution
+Scans project manifests (`package.json`, `Cargo.toml`, `pyproject.toml`, `requirements.txt`, `go.mod`) to detect languages, frameworks, and libraries. Automatically specializes candidate proposers into domain-specific roles (e.g. React Optimization, TypeScript Safety, Accessibility, FastAPI Async) to maximize hypothesis diversity. Emits `moa/stack-detected` Cordis events. Configured via `stack_aware_personas_enabled: true`.
+
+### 24. Self-Learning Developer Preferences Metaprompt
+Maintains a persistent profile of developer coding principles and architectural preferences in `~/.dsh/moa/preferences.json`. Injects active principles into the Judge prompt to bias consensus toward team standards (strict typing, functional immutability, error boundaries). Manageable via `GET/POST/DELETE /dsh-moa/preferences` REST endpoints and preset toggle `developer_preferences_enabled: true`.
+
 ### 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,21 @@ 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`.
+
+### 23. Динамическая адаптация персон по манифестам проекта (Stack-Aware Personas)
+Автоматически сканирует манифесты проекта (`package.json`, `Cargo.toml`, `pyproject.toml`, `requirements.txt`, `go.mod`) для определения стека технологий и библиотек. Специализирует роли кандидатов под конкретный стек (оптимизация рендера, строгая типизация, доступность, асинхронные интерфейсы), обеспечивая многоаспектный анализ задачи. Генерирует событие `moa/stack-detected`. Включается через `stack_aware_personas_enabled: true`.
+
+### 24. Метапромпт предпочтений разработчика (Developer Preferences)
+Хранит профиль архитектурных стандартов и стилевых предпочтений разработчика в `~/.dsh/moa/preferences.json`. Инжектирует активные принципы в контекст судьи, гарантируя соответствие выбранного решения вкусам команды (строгая типизация, иммутабельность, обработка ошибок). Доступен REST API (`GET/POST/DELETE /dsh-moa/preferences`) и опция пресета `developer_preferences_enabled: true`.
+
 ### 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,21 @@ 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` 事件。
+
+### 23. 基于项目清单的感知角色演化 (Stack-Aware Personas)
+自动扫描工作区清单 (`package.json`, `Cargo.toml`, `pyproject.toml`, `go.mod`) 识别编程语言、框架与核心依赖，动态为各候选槽位分派互补的领域专家角色（如 React 渲染优化、TypeScript 严格类型安全、可访问性审查、FastAPI 异步架构），触发 `moa/stack-detected` 事件。通过 `stack_aware_personas_enabled: true` 配置。
+
+### 24. 自学习开发者代码偏好元提示词 (Developer Preferences)
+在本地 `~/.dsh/moa/preferences.json` 持久化存储团队编码规范与架构偏好，将启用的规则动态注入裁判评审阶段，使综合方案贴合开发者个人习惯（严格类型、函数不可变性、防御性错误边界）。提供 `GET/POST/DELETE /dsh-moa/preferences` REST 端点，通过 `developer_preferences_enabled: true` 开启。
+
 ### 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,22 @@ 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:",
+      "aggregator.stack_personas_title": "\u{1F4E6} Stack-Aware Dynamic Persona Evolution (Project Manifests)",
+      "aggregator.stack_personas_desc": "Scans project manifests (package.json, Cargo.toml, pyproject.toml, go.mod) and assigns specialized engineering roles to candidate slots.",
+      "aggregator.preferences_title": "\u{1F9E0} Developer Coding Principles & Preferences Metaprompt",
+      "aggregator.preferences_desc": "Injects learned developer preferences (strict typing, functional immutability, error boundaries) to guide Judge synthesis."
     };
     const zh = {
       title: "\u667A\u80FD\u4F53\u6DF7\u5408 (MoA)",
@@ -417,7 +432,22 @@ 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:",
+      "aggregator.stack_personas_title": "\u{1F4E6} \u57FA\u4E8E\u9879\u76EE\u914D\u7F6E\u6E05\u5355\u7684\u611F\u77E5\u89D2\u8272\u6F14\u5316 (Stack-Aware Personas)",
+      "aggregator.stack_personas_desc": "\u81EA\u52A8\u626B\u63CF\u9879\u76EE\u6E05\u5355 (package.json, Cargo.toml, pyproject.toml, go.mod) \u5E76\u4E3A\u5404\u5019\u9009\u69FD\u4F4D\u6307\u6D3E\u4E13\u5C5E\u4E13\u4E1A\u89D2\u8272\u3002",
+      "aggregator.preferences_title": "\u{1F9E0} \u81EA\u5B66\u4E60\u5F00\u53D1\u8005\u4EE3\u7801\u504F\u597D\u5143\u63D0\u793A\u8BCD (Developer Preferences)",
+      "aggregator.preferences_desc": "\u5C06\u5F00\u53D1\u8005\u504F\u597D\uFF08\u4E25\u683C\u7C7B\u578B\u3001\u51FD\u6570\u4E0D\u53EF\u53D8\u6027\u3001\u9632\u5FA1\u6027\u9519\u8BEF\u5904\u7406\u7B49\uFF09\u6CE8\u5165\u88C1\u5224\u7EFC\u5408\u8BC4\u5BA1\u9636\u6BB5\u3002"
     };
     function makeT(dict, fallback) {
       return function t(key, vars) {
@@ -2332,6 +2362,7 @@ window.__ModuleLoader__.load({
                   )
                 )
               ),
+              // --- src/client/86-card-aggregator-ext2.js ---
               /* Pre-Judge Local Syntax Gate (#303) & Early Semantic Consensus (#299) */
               React.createElement(
                 "div",
@@ -2427,6 +2458,158 @@ 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
+                      })
+                    )
+                  )
+                )
+              ),
+              /* Stack-Aware Dynamic Persona Evolution (#308) */
+              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.stack_aware_personas_enabled),
+                    onChange: (e) => updateCurrentPreset((p) => ({ ...p, stack_aware_personas_enabled: e.target.checked })),
+                    style: { accentColor: "var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))", cursor: "pointer" }
+                  }),
+                  t("aggregator.stack_personas_title") || "\u{1F4E6} Stack-Aware Dynamic Persona Evolution (Project Manifests)"
+                ),
+                React.createElement(
+                  "div",
+                  { style: { fontSize: 12, color: "var(--dsw-alias-label-secondary)", marginLeft: 22 } },
+                  t("aggregator.stack_personas_desc") || "Scans project manifests (package.json, Cargo.toml, pyproject.toml, go.mod) and assigns specialized engineering roles to candidate slots."
+                )
+              ),
+              /* Self-Learning Developer Preferences Metaprompt (#309) */
+              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.developer_preferences_enabled),
+                    onChange: (e) => updateCurrentPreset((p) => ({ ...p, developer_preferences_enabled: e.target.checked })),
+                    style: { accentColor: "var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))", cursor: "pointer" }
+                  }),
+                  t("aggregator.preferences_title") || "\u{1F9E0} Developer Coding Principles & Preferences Metaprompt"
+                ),
+                React.createElement(
+                  "div",
+                  { style: { fontSize: 12, color: "var(--dsw-alias-label-secondary)", marginLeft: 22 } },
+                  t("aggregator.preferences_desc") || "Injects learned developer preferences (strict typing, functional immutability, error boundaries) to guide Judge synthesis."
+                )
+              ),
               /* Fallback Judges Chain */
               React.createElement(
                 "div",

package/lib/events.js

@@ -7,6 +7,10 @@ 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',
+  STACK_DETECTED: 'moa/stack-detected',
+  PREFERENCES_APPLIED: 'moa/preferences-applied',
   CRITIQUE_COMPLETE: 'moa/critique-complete',
   JUDGE_VERDICT: 'moa/judge-verdict',
   CONTEXT_PRUNING: 'moa/context-pruning',

package/lib/moa-schema.js

@@ -83,6 +83,14 @@ 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: '' }),
+  stack_aware_personas_enabled: z.boolean().default(false),
+  developer_preferences_enabled: z.boolean().default(false),
 })
 
 export const Config = z.object({
@@ -112,6 +120,14 @@ 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(),
+  stack_aware_personas_enabled: z.boolean().default(false).volatile(),
+  developer_preferences_enabled: z.boolean().default(false).volatile(),
   smart_routing_model: ModelSlotSchema.default({ provider: '', model: '' }).volatile(),
   prices: z.dict(PriceRow).default({}).volatile(),
   presets: z.array(PresetSchema).default([

package/lib/pipeline/context.js

@@ -1,3 +1,7 @@
+import { detectProjectStack, assignStackAwarePersonas, formatStackAwareDirective } from './manifest-stack.js'
+import { formatPreferencesDirective } from './developer-preferences.js'
+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 +31,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)
@@ -46,6 +83,34 @@ export async function stageProjectContext({
   const semanticCacheEnabled = Boolean(preset?.semantic_cache_enabled)
   const semanticCacheTtlHours = typeof preset?.semantic_cache_ttl_hours === 'number' ? preset.semantic_cache_ttl_hours : 168
 
+  const stackInfo = detectProjectStack(cwd)
+  if (stackInfo.manifestFound) {
+    emitEvent(ctx, MOA_EVENTS.STACK_DETECTED, {
+      primaryLanguage: stackInfo.primaryLanguage,
+      frameworks: stackInfo.frameworks,
+      libraries: stackInfo.libraries,
+      stackSummary: stackInfo.stackSummary,
+    })
+    if (typeof onProgress === 'function' && stackInfo.stackSummary) {
+      onProgress(`📦 *Project Stack: Detected ${stackInfo.stackSummary}*\n`)
+    }
+  }
+
+  const stackAwarePersonasEnabled = Boolean(preset?.stack_aware_personas_enabled)
+  if (stackAwarePersonasEnabled && !selfConsistencyExpanded) {
+    const stackRes = assignStackAwarePersonas(effectiveReferenceModels, stackInfo, { enabled: true })
+    if (stackRes.isSpecialized) {
+      effectiveReferenceModels = stackRes.references
+    }
+  }
+
+  const developerPreferencesEnabled = Boolean(preset?.developer_preferences_enabled)
+  const developerPreferencesDirective = formatPreferencesDirective(null, { enabled: developerPreferencesEnabled })
+  if (developerPreferencesDirective) {
+    emitEvent(ctx, MOA_EVENTS.PREFERENCES_APPLIED, { enabled: true })
+  }
+  const stackAwareDirective = formatStackAwareDirective(stackInfo)
+
   const collectedCtx = await collectProjectContext(cwd, 16000)
   const isRefinement = Boolean(collectedCtx?.files?.length > 0 && isRefinementTask(userPrompt, collectedCtx.files))
   let projectContext = ''
@@ -65,7 +130,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 +198,9 @@ export async function stageProjectContext({
     localPreflightCheck, earlyExitConsensusEnabled, earlyExitThreshold,
     contextPruningEnabled, contextPruningDiffLines,
     semanticCacheEnabled, semanticCacheTtlHours,
+    selfConsistencyEnabled, selfConsistencyExpanded, selfConsistencySamples, selfConsistencyTemperatures,
+    escalationPolicy, escalationDisagreementThreshold, escalationJudge,
+    stackInfo, stackAwareDirective, developerPreferencesDirective,
   }
 }
 

package/lib/pipeline/developer-preferences.js

@@ -0,0 +1,196 @@
+/**
+ * Self-Learning Developer Preferences Metaprompt (#309)
+ *
+ * Tracks developer coding principles, architectural standards, and preferred idioms
+ * in a persistent local store (~/.dsh/moa/preferences.json).
+ * Injects a concise "Developer Coding Principles" directive into the Judge
+ * synthesis phase (and candidate prompts) to bias consensus toward the engineer's tastes.
+ */
+
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+
+export const DEFAULT_PREFERENCES = Object.freeze([
+  {
+    id: 'strict-typing',
+    title: 'Strict Types & Explicit Contracts',
+    rule: "Never use loose 'any' types or unchecked type casts. Explicitly define interfaces, return types, and input validation schemas.",
+    category: 'typing',
+    enabled: true,
+  },
+  {
+    id: 'functional-purity',
+    title: 'Functional Immutability',
+    rule: 'Prefer pure functions, immutable data transforms, and explicit return values over hidden global state mutations.',
+    category: 'architecture',
+    enabled: true,
+  },
+  {
+    id: 'defensive-errors',
+    title: 'Defensive Error Handling',
+    rule: 'Never swallow exceptions silently. Use structured error types, descriptive messages, and clean fallback strategies.',
+    category: 'reliability',
+    enabled: true,
+  },
+])
+
+/**
+ * Resolves the persistent preferences file path.
+ *
+ * @param {string} [customPath]
+ * @returns {string}
+ */
+export function getPreferencesFilePath(customPath = null) {
+  if (customPath && typeof customPath === 'string' && customPath.trim()) {
+    return path.resolve(customPath.trim())
+  }
+  return path.join(os.homedir(), '.dsh', 'moa', 'preferences.json')
+}
+
+/**
+ * Loads developer preferences from disk with default fallback.
+ *
+ * @param {string} [customPath]
+ * @returns {Array<object>}
+ */
+export function loadDeveloperPreferences(customPath = null) {
+  const filePath = getPreferencesFilePath(customPath)
+  if (!fs.existsSync(filePath)) {
+    // Seed default preferences file
+    try {
+      const dir = path.dirname(filePath)
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
+      fs.writeFileSync(filePath, JSON.stringify(DEFAULT_PREFERENCES, null, 2), 'utf8')
+    } catch {
+      // safe fallback if filesystem is read-only
+    }
+    return [...DEFAULT_PREFERENCES]
+  }
+
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8')
+    const parsed = JSON.parse(raw)
+    if (Array.isArray(parsed)) {
+      return parsed.filter((p) => p && typeof p === 'object' && p.id && p.rule)
+    }
+  } catch {
+    // safe fallback
+  }
+
+  return [...DEFAULT_PREFERENCES]
+}
+
+/**
+ * Atomically saves developer preferences to disk.
+ *
+ * @param {Array<object>} preferences
+ * @param {string} [customPath]
+ * @returns {boolean}
+ */
+export function saveDeveloperPreferences(preferences, customPath = null) {
+  if (!Array.isArray(preferences)) return false
+  const filePath = getPreferencesFilePath(customPath)
+
+  try {
+    const dir = path.dirname(filePath)
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
+    const tmp = `${filePath}.tmp.${Date.now()}`
+    fs.writeFileSync(tmp, JSON.stringify(preferences, null, 2), 'utf8')
+    fs.renameSync(tmp, filePath)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Adds a new developer preference rule.
+ *
+ * @param {object} item - { title, rule, category, enabled }
+ * @param {string} [customPath]
+ * @returns {object|null}
+ */
+export function addDeveloperPreference(item = {}, customPath = null) {
+  if (!item || !item.rule || typeof item.rule !== 'string') return null
+  const current = loadDeveloperPreferences(customPath)
+
+  const id = item.id || `pref-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`
+  const newPref = {
+    id,
+    title: (item.title && String(item.title).trim()) || 'Custom Coding Standard',
+    rule: String(item.rule).trim(),
+    category: (item.category && String(item.category).trim()) || 'general',
+    enabled: item.enabled !== false,
+    createdAt: new Date().toISOString(),
+  }
+
+  current.push(newPref)
+  saveDeveloperPreferences(current, customPath)
+  return newPref
+}
+
+/**
+ * Updates an existing developer preference.
+ *
+ * @param {string} id
+ * @param {object} updates
+ * @param {string} [customPath]
+ * @returns {object|null}
+ */
+export function updateDeveloperPreference(id, updates = {}, customPath = null) {
+  if (!id) return null
+  const current = loadDeveloperPreferences(customPath)
+  const idx = current.findIndex((p) => p.id === id)
+  if (idx === -1) return null
+
+  const target = current[idx]
+  if (typeof updates.title === 'string') target.title = updates.title.trim()
+  if (typeof updates.rule === 'string') target.rule = updates.rule.trim()
+  if (typeof updates.category === 'string') target.category = updates.category.trim()
+  if (typeof updates.enabled === 'boolean') target.enabled = updates.enabled
+
+  saveDeveloperPreferences(current, customPath)
+  return target
+}
+
+/**
+ * Deletes a developer preference by ID.
+ *
+ * @param {string} id
+ * @param {string} [customPath]
+ * @returns {boolean}
+ */
+export function deleteDeveloperPreference(id, customPath = null) {
+  if (!id) return false
+  const current = loadDeveloperPreferences(customPath)
+  const filtered = current.filter((p) => p.id !== id)
+  if (filtered.length === current.length) return false
+
+  return saveDeveloperPreferences(filtered, customPath)
+}
+
+/**
+ * Formats active developer preferences into an injected prompt directive.
+ *
+ * @param {Array<object>} [preferences] - Array of preferences (loads from disk if omitted)
+ * @param {object} [options]
+ * @param {boolean} [options.enabled=true]
+ * @returns {string|null}
+ */
+export function formatPreferencesDirective(preferences = null, options = {}) {
+  const { enabled = true, customPath = null } = options
+  if (!enabled) return null
+
+  const list = Array.isArray(preferences) ? preferences : loadDeveloperPreferences(customPath)
+  const active = list.filter((p) => p && p.enabled !== false && p.rule)
+
+  if (active.length === 0) return null
+
+  const lines = active.map((p) => `- [${p.title}]: ${p.rule}`)
+
+  return `### Developer Coding Principles & Preferred Conventions
+The developer has established the following coding standards for this project:
+${lines.join('\n')}
+Evaluate all proposals against these principles and favor implementations adhering to them.`
+}