@goodandready/dsh-moa 0.2.76 → 0.2.78

package/README.md

@@ -54,6 +54,10 @@ Single-model AI generation often suffers from blind spots, single-perspective bi
 11. **Interactive Workbench (File Scoring 1–10, User Pick & Mix, Top-Model Glue & Judge Re-Check)**: Judge scores each candidate file (1–10) with pros and cons. Users can mix and match files across proposals in the WebUI. The turn's top-performing reference model harmonizes cross-file imports and contracts, followed by a final judge re-audit before promotion. Companion integration with [`dsh-time-machine`](https://github.com/goodandready/dsh-time-machine) for safe pre-promotion rollback checkpoints.
 12. **Adversarial White-Hat Security Fuzzing Gate (#302)**: Red Team security audit scanning candidate code for SQLi, XSS, Command Injection, Path Traversal, ReDoS, and Prototype Pollution with blocking `SECURITY_VETO`.
 13. **Chain-of-Verification (CoVe) Fact-Checking Gate for Code (#314)**: Independent pre-judge verification formulating factual API questions, validating modules and functions against standard library and project manifests to eliminate hallucinated methods.
+14. **Runtime CPU & Memory Profiler Gate (#315)**: Sandboxed micro-benchmarking of candidate execution duration, ops/sec throughput, and heap usage with hard timeout protection to select algorithmically optimal code.
+15. **Mutation Testing Gate for Candidate Tests (#316)**: Injects AST-level fault mutations to compute Mutation Score (killed vs survived mutants), weeding out tautological assertions and fake test suites.
+16. **Hybrid Private Edge MoA & Cloud Judge Sanitizer (#306)**: Preserves confidentiality with local edge proposers on MiniPC while scrubbing absolute paths, internal IPs, and API secrets before external Cloud Judge arbitration.
+17. **Heterogeneous Speculative Decoding (#317)**: High-throughput local edge draft coupled with single-pass cloud model verification, slashing response latency by 2-3x.
 
 ---
 

package/README.ru.md

@@ -54,6 +54,10 @@
 11. **Интерактивный воркбенч (Оценка файлов 1–10, выбор в UI, склейка лучшей моделью и повторный аудит)**: Судья оценивает каждый сгенерированный файл каждого кандидата (1–10) с указанием ключевых плюсов и минусов. Пользователь комбинирует желаемый набор файлов в WebUI; лучшая модель раунда вызывается для гармонизации импортов и контрактов, после чего судья выполняет финальную валидацию перед промоушеном. Совместимо с [`dsh-time-machine`](https://github.com/goodandready/dsh-time-machine) для безопасных теневых снимков Git.
 12. **Состязательный White-Hat фильтр безопасности (#302)**: Red Team аудит безопасности перед арбитражем судьи, выявляющий SQLi, XSS, инъекции команд, Path Traversal, ReDoS и Prototype Pollution с блокирующим вердиктом `SECURITY_VETO`.
 13. **Фильтр верификации фактов и API (CoVe) (#314)**: Автономная цепочка верификации (Chain-of-Verification), формулирующая проверочные вопросы по вызовам методов и пакетам, исключающая галлюцинированные и несуществующие API библиотек.
+14. **Профайлер производительности CPU и памяти (#315)**: Изолированный бенчмаркинг времени выполнения кандидатов, пропускной способности (ops/sec) и потребления heap-памяти с защитой от зависаний для выбора алгоритмически оптимального кода.
+15. **Мутационное тестирование тестов кандидатов (#316)**: Внедрение AST-мутаций кода для расчёта Mutation Score (убитые vs выжившие мутанты), устраняющее ложноположительные и тавтологические тесты.
+16. **Гибридный приватный Edge MoA (#306)**: Локальные генераторы на MiniPC сохраняют секреты и кодовую базу в контуре, маскируя пути, IP и токены перед отправкой судье в облако.
+17. **Гетерогенное спекулятивное декодирование (#317)**: Быстрый черновик от локальной edge-модели с пакетной валидацией и доработкой флагманом в облаке с ускорением в 2-3 раза.
 
 ---
 

package/README.zh.md

@@ -54,6 +54,10 @@
 11. **交互式工作台 (1-10分文件打分、自由混搭、最优模型粘合与裁判复审)**：裁判对每个候选模型生成的每个文件进行 1–10 分打分并列出优缺点。用户可在 WebUI 中自由勾选组合所需文件；当轮最高分模型被调用以粘合协同跨文件导入与类型接口，随后由裁判进行最终复审。支持配套插件 [`dsh-time-machine`](https://github.com/goodandready/dsh-time-machine) 在文件提升前创建影子 Git 回滚快照。
 12. **对抗性白帽安全模糊测试关卡 (#302)**：红队安全审计器在裁判前检查 SQLi、XSS、命令注入、路径穿越、ReDoS 和原型污染漏洞，发现严重漏洞时触发 `SECURITY_VETO` 否决。
 13. **代码事实与 API 验证链关卡 (CoVe) (#314)**：独立的裁判前事实核验，生成针对性 API 问题并对照标准库及项目配置清单，杜绝调用虚构不存在的幻觉方法。
+14. **运行期 CPU 与内存性能分析关卡 (#315)**：在隔离沙箱中微基准测试候选方案执行延迟、吞吐量（ops/sec）与堆内存占用，带有硬超时保护，指引裁判挑选算法最优代码。
+15. **候选测试套件变异测试关卡 (#316)**：注入 AST 级别故障变异以计算变异得分（消灭 vs 存活变异体），剔除恒真废测试与虚假测试套件。
+16. **混合隐私边缘 MoA 与云端裁判脱敏 (#306)**：本地 MiniPC 边缘模型在内网读取代码生成方案，在提交给外部云端裁判前自动脱敏绝对路径、内网 IP 与 API 密钥。
+17. **异构投机解码加速 (#317)**：本地小模型快速生成投机代码草稿块，云端旗舰模型单次批处理验证与完善，首包延迟降低 2-3 倍。
 
 ---
 

package/lib/client.js

@@ -232,7 +232,15 @@ window.__ModuleLoader__.load({
       "aggregator.security_gate_title": "\u{1F6E1}\uFE0F Adversarial White-Hat Security Fuzzing Gate",
       "aggregator.security_gate_desc": "Red-team security auditor checks candidate proposals for SQLi, XSS, ReDoS, Command Injection and Path Traversal with blocking SECURITY_VETO.",
       "aggregator.cove_gate_title": "\u{1F50D} Chain-of-Verification (CoVe) Fact-Checking Gate",
-      "aggregator.cove_gate_desc": "Formulates API existence & method signature verification questions, disqualifying candidates that use hallucinated methods."
+      "aggregator.cove_gate_desc": "Formulates API existence & method signature verification questions, disqualifying candidates that use hallucinated methods.",
+      "aggregator.profiler_gate_title": "\u26A1 Automated Runtime Memory & CPU Profiler Gate",
+      "aggregator.profiler_gate_desc": "Runs isolated micro-benchmarks measuring execution latency, throughput (ops/sec), and heap memory usage.",
+      "aggregator.mutation_gate_title": "\u{1F9EC} Runtime Mutation Testing Gate for Candidate Tests",
+      "aggregator.mutation_gate_desc": "Injects synthetic faults into candidate code to test test-suite robustness, eliminating tautological and weak tests.",
+      "aggregator.privacy_gate_title": "\u{1F6E1}\uFE0F Hybrid Private Edge MoA (Local Edge Proposers + Cloud Judge)",
+      "aggregator.privacy_gate_desc": "Scans and redacts proprietary secrets, local paths, and private network IPs before forwarding proposals to external cloud judges.",
+      "aggregator.speculative_gate_title": "\u26A1 Heterogeneous Speculative Decoding (Local Draft + Cloud Verifier)",
+      "aggregator.speculative_gate_desc": "Lightweight local edge model generates high-speed token drafts verified and completed in one fast pass by the cloud model."
     };
     const zh = {
       title: "\u667A\u80FD\u4F53\u6DF7\u5408 (MoA)",
@@ -455,7 +463,15 @@ window.__ModuleLoader__.load({
       "aggregator.security_gate_title": "\u{1F6E1}\uFE0F \u5BF9\u6297\u6027\u767D\u5E3D\u5B89\u5168\u6A21\u7CCA\u6D4B\u8BD5\u5173\u5361",
       "aggregator.security_gate_desc": "\u7EA2\u961F\u5B89\u5168\u5BA1\u8BA1\u5668\u68C0\u67E5\u5019\u9009\u65B9\u6848\u4E2D\u7684 SQLi\u3001XSS\u3001ReDoS\u3001\u547D\u4EE4\u6CE8\u5165\u548C\u8DEF\u5F84\u7A7F\u8D8A\u6F0F\u6D1E\uFF0C\u5E76\u5728\u53D1\u73B0\u4E25\u91CD\u6F0F\u6D1E\u65F6\u89E6\u53D1 SECURITY_VETO \u5426\u51B3\u3002",
       "aggregator.cove_gate_title": "\u{1F50D} \u9A8C\u8BC1\u94FE (CoVe) \u4EE3\u7801\u4E8B\u5B9E\u4E0E API \u6838\u67E5\u5173\u5361",
-      "aggregator.cove_gate_desc": "\u751F\u6210 API \u5B58\u5728\u6027\u4E0E\u65B9\u6CD5\u7B7E\u540D\u6838\u9A8C\u95EE\u9898\uFF0C\u81EA\u52A8\u60E9\u7F5A\u6216\u53D6\u6D88\u4F7F\u7528\u865A\u6784\u5E7B\u89C9\u65B9\u6CD5\u7684\u5019\u9009\u65B9\u6848\u3002"
+      "aggregator.cove_gate_desc": "\u751F\u6210 API \u5B58\u5728\u6027\u4E0E\u65B9\u6CD5\u7B7E\u540D\u6838\u9A8C\u95EE\u9898\uFF0C\u81EA\u52A8\u60E9\u7F5A\u6216\u53D6\u6D88\u4F7F\u7528\u865A\u6784\u5E7B\u89C9\u65B9\u6CD5\u7684\u5019\u9009\u65B9\u6848\u3002",
+      "aggregator.profiler_gate_title": "\u26A1 \u81EA\u52A8\u8FD0\u884C\u65F6 CPU \u4E0E\u5185\u5B58\u6027\u80FD\u5206\u6790\u5173\u5361",
+      "aggregator.profiler_gate_desc": "\u5728\u9694\u79BB\u6C99\u7BB1\u4E2D\u8FD0\u884C\u5FAE\u57FA\u51C6\u6D4B\u8BD5\uFF0C\u7CBE\u786E\u5EA6\u91CF\u6267\u884C\u5EF6\u8FDF\u3001\u541E\u5410\u91CF (ops/sec) \u548C\u5806\u5185\u5B58\u5206\u914D\u3002",
+      "aggregator.mutation_gate_title": "\u{1F9EC} \u5019\u9009\u6D4B\u8BD5\u5957\u4EF6\u8FD0\u884C\u65F6\u53D8\u5F02\u6D4B\u8BD5\u5173\u5361",
+      "aggregator.mutation_gate_desc": "\u5411\u4EE3\u7801\u6CE8\u5165\u5408\u6210\u6545\u969C\u5E76\u9A8C\u8BC1\u6D4B\u8BD5\u7684\u6355\u83B7\u80FD\u529B\uFF0C\u5254\u9664\u540C\u4E49\u53CD\u590D\u4E0E\u65E0\u6548\u7684\u865A\u5047\u6D4B\u8BD5\u3002",
+      "aggregator.privacy_gate_title": "\u{1F6E1}\uFE0F \u6DF7\u5408\u9690\u79C1\u8FB9\u7F18 MoA (\u672C\u5730\u751F\u6210 + \u4E91\u7AEF\u88C1\u5224)",
+      "aggregator.privacy_gate_desc": "\u5728\u5C06\u5019\u9009\u63D0\u6848\u53D1\u9001\u7ED9\u5916\u90E8\u4E91\u7AEF\u88C1\u5224\u4E4B\u524D\uFF0C\u626B\u63CF\u5E76\u8131\u654F\u4E13\u6709\u5BC6\u94A5\u3001\u672C\u5730\u7EDD\u5BF9\u8DEF\u5F84\u4E0E\u79C1\u6709\u7F51\u7EDC IP\u3002",
+      "aggregator.speculative_gate_title": "\u26A1 \u5F02\u6784\u6295\u673A\u89E3\u7801 (\u672C\u5730\u8349\u7A3F + \u4E91\u7AEF\u9A8C\u8BC1)",
+      "aggregator.speculative_gate_desc": "\u8F7B\u91CF\u7EA7\u672C\u5730\u8FB9\u7F18\u6A21\u578B\u751F\u6210\u9AD8\u901F\u8349\u7A3F\uFF0C\u7531\u5F3A\u5927\u7684\u4E91\u7AEF\u6A21\u578B\u4E00\u6B21\u6027\u5FEB\u901F\u9A8C\u8BC1\u5E76\u5B8C\u5584\u3002"
     };
     function makeT(dict, fallback) {
       return function t(key, vars) {
@@ -2660,6 +2676,90 @@ window.__ModuleLoader__.load({
                   t("aggregator.cove_gate_desc") || "Formulates API existence & method signature verification questions, disqualifying candidates that use hallucinated methods."
                 )
               ),
+              /* Automated Runtime Memory & CPU Profiler Gate (#315) */
+              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.profiler_gate_enabled),
+                    onChange: (e) => updateCurrentPreset((p) => ({ ...p, profiler_gate_enabled: e.target.checked })),
+                    style: { accentColor: "var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))", cursor: "pointer" }
+                  }),
+                  t("aggregator.profiler_gate_title") || "\u26A1 Automated Runtime Memory & CPU Profiler Gate"
+                ),
+                React.createElement(
+                  "div",
+                  { style: { fontSize: 12, color: "var(--dsw-alias-label-secondary)", marginLeft: 22 } },
+                  t("aggregator.profiler_gate_desc") || "Runs isolated micro-benchmarks measuring execution latency, throughput (ops/sec), and heap memory usage."
+                )
+              ),
+              /* Runtime Mutation Testing Gate (#316) */
+              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.mutation_testing_enabled),
+                    onChange: (e) => updateCurrentPreset((p) => ({ ...p, mutation_testing_enabled: e.target.checked })),
+                    style: { accentColor: "var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))", cursor: "pointer" }
+                  }),
+                  t("aggregator.mutation_gate_title") || "\u{1F9EC} Runtime Mutation Testing Gate for Candidate Tests"
+                ),
+                React.createElement(
+                  "div",
+                  { style: { fontSize: 12, color: "var(--dsw-alias-label-secondary)", marginLeft: 22 } },
+                  t("aggregator.mutation_gate_desc") || "Injects synthetic faults into candidate code to test test-suite robustness, eliminating tautological and weak tests."
+                )
+              ),
+              /* Hybrid Edge Privacy Gate (#306) */
+              React.createElement(
+                "div",
+                { style: { display: "flex", flexDirection: "column", gap: 4 } },
+                React.createElement(
+                  "label",
+                  { style: { display: "flex", alignItems: "center", gap: 8, fontSize: 13, fontWeight: 600, color: "var(--dsw-alias-label-primary)", cursor: "pointer" } },
+                  React.createElement("input", {
+                    type: "checkbox",
+                    checked: Boolean(currentPreset.hybrid_edge_privacy_enabled),
+                    onChange: (e) => updateCurrentPreset((p) => ({ ...p, hybrid_edge_privacy_enabled: e.target.checked })),
+                    style: { accentColor: "var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))", cursor: "pointer" }
+                  }),
+                  t("aggregator.privacy_gate_title") || "\u{1F6E1}\uFE0F Hybrid Private Edge MoA (Local Edge Proposers + Cloud Judge)"
+                ),
+                React.createElement(
+                  "div",
+                  { style: { fontSize: 12, color: "var(--dsw-alias-label-secondary)", marginLeft: 22 } },
+                  t("aggregator.privacy_gate_desc") || "Scans and redacts proprietary secrets, local paths, and private network IPs before forwarding proposals to external cloud judges."
+                )
+              ),
+              /* Heterogeneous Speculative Decoding (#317) */
+              React.createElement(
+                "div",
+                { style: { display: "flex", flexDirection: "column", gap: 4 } },
+                React.createElement(
+                  "label",
+                  { style: { display: "flex", alignItems: "center", gap: 8, fontSize: 13, fontWeight: 600, color: "var(--dsw-alias-label-primary)", cursor: "pointer" } },
+                  React.createElement("input", {
+                    type: "checkbox",
+                    checked: Boolean(currentPreset.speculative_draft_enabled),
+                    onChange: (e) => updateCurrentPreset((p) => ({ ...p, speculative_draft_enabled: e.target.checked })),
+                    style: { accentColor: "var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))", cursor: "pointer" }
+                  }),
+                  t("aggregator.speculative_gate_title") || "\u26A1 Heterogeneous Speculative Decoding (Local Draft + Cloud Verifier)"
+                ),
+                React.createElement(
+                  "div",
+                  { style: { fontSize: 12, color: "var(--dsw-alias-label-secondary)", marginLeft: 22 } },
+                  t("aggregator.speculative_gate_desc") || "Lightweight local edge model generates high-speed token drafts verified and completed in one fast pass by the cloud model."
+                )
+              ),
               /* Fallback Judges Chain */
               React.createElement(
                 "div",

package/lib/events.js

@@ -13,6 +13,10 @@ export const MOA_EVENTS = {
   PREFERENCES_APPLIED: 'moa/preferences-applied',
   SECURITY_AUDIT: 'moa/security-audit',
   COVE_VERIFIED: 'moa/cove-verified',
+  PROFILER_COMPLETE: 'moa/profiler-complete',
+  MUTATION_COMPLETE: 'moa/mutation-complete',
+  PRIVACY_SANITIZED: 'moa/privacy-sanitized',
+  SPECULATIVE_DRAFT: 'moa/speculative-draft',
   CRITIQUE_COMPLETE: 'moa/critique-complete',
   JUDGE_VERDICT: 'moa/judge-verdict',
   CONTEXT_PRUNING: 'moa/context-pruning',

package/lib/moa-schema.js

@@ -95,6 +95,18 @@ export const PresetSchema = z.object({
   security_gate_strict_veto: z.boolean().default(true),
   cove_verification_enabled: z.boolean().default(false),
   cove_max_questions: z.number().default(5),
+  profiler_gate_enabled: z.boolean().default(false),
+  profiler_iterations: z.number().default(100),
+  profiler_timeout_ms: z.number().default(2000),
+  mutation_testing_enabled: z.boolean().default(false),
+  min_mutation_score: z.number().default(0.70),
+  hybrid_edge_privacy_enabled: z.boolean().default(false),
+  cloud_judge_sanitization_enabled: z.boolean().default(true),
+  redact_paths: z.boolean().default(true),
+  redact_secrets: z.boolean().default(true),
+  redact_ips: z.boolean().default(true),
+  speculative_draft_enabled: z.boolean().default(false),
+  speculative_block_size: z.number().default(256),
 })
 
 export const Config = z.object({
@@ -136,6 +148,18 @@ export const Config = z.object({
   security_gate_strict_veto: z.boolean().default(true).volatile(),
   cove_verification_enabled: z.boolean().default(false).volatile(),
   cove_max_questions: z.number().default(5).volatile(),
+  profiler_gate_enabled: z.boolean().default(false).volatile(),
+  profiler_iterations: z.number().default(100).volatile(),
+  profiler_timeout_ms: z.number().default(2000).volatile(),
+  mutation_testing_enabled: z.boolean().default(false).volatile(),
+  min_mutation_score: z.number().default(0.70).volatile(),
+  hybrid_edge_privacy_enabled: z.boolean().default(false).volatile(),
+  cloud_judge_sanitization_enabled: z.boolean().default(true).volatile(),
+  redact_paths: z.boolean().default(true).volatile(),
+  redact_secrets: z.boolean().default(true).volatile(),
+  redact_ips: z.boolean().default(true).volatile(),
+  speculative_draft_enabled: z.boolean().default(false).volatile(),
+  speculative_block_size: z.number().default(256).volatile(),
   smart_routing_model: ModelSlotSchema.default({ provider: '', model: '' }).volatile(),
   prices: z.dict(PriceRow).default({}).volatile(),
   presets: z.array(PresetSchema).default([

package/lib/pipeline/candidates.js

@@ -1,3 +1,4 @@
+import { createSpeculativeCallLlm } from './speculative-verifier.js'
 import { createCachingCallLlm } from './semantic-cache.js'
 import { runSpeculativeMoa } from '../moa-speculative.js'
 import { runAdversarialTddLoop } from '../moa-adversarial-tdd.js'
@@ -47,6 +48,23 @@ export async function stageCandidateRound1({
         ctx,
       })
     : callLlm
+  let candidateCallLlm = effectiveCallLlm
+  const draftModelSlot = typeof preset?.speculative_draft_model === 'object' && preset?.speculative_draft_model?.model
+    ? preset.speculative_draft_model
+    : typeof preset?.speculative_draft_model === 'string' && preset?.speculative_draft_model
+      ? { provider: 'ollama', model: preset.speculative_draft_model }
+      : null
+
+  if (preset?.speculative_draft_enabled && draftModelSlot) {
+    candidateCallLlm = createSpeculativeCallLlm(effectiveCallLlm, {
+      draftSlot: draftModelSlot,
+      blockSize: preset.speculative_block_size || 256,
+      ctx,
+      runId,
+      onProgress,
+    })
+  }
+
   const lastMsgText = enrichedMessages[enrichedMessages.length - 1]?.content || ''
   const adaptiveRefs = preset?.adaptive_personas_enabled
     ? assignAdaptivePersonas(effectiveReferences, typeof lastMsgText === 'string' ? lastMsgText : '').references
@@ -75,7 +93,7 @@ export async function stageCandidateRound1({
 
   if (!referenceOutputs) {
     referenceOutputs = preset?.subagent_swarm_enabled
-    ? await runSubagentSwarm(adaptiveRefs, enrichedMessages, { temperature: refTemp, maxTokens, signal, cwd, runId }, effectiveCallLlm, onProgress)
+    ? await runSubagentSwarm(adaptiveRefs, enrichedMessages, { temperature: refTemp, maxTokens, signal, cwd, runId }, candidateCallLlm, onProgress)
     : await runReferencesParallel(
     adaptiveRefs,
     enrichedMessages,
@@ -93,7 +111,7 @@ export async function stageCandidateRound1({
       maxRetries: candidateRetries,
       signal,
     },
-    effectiveCallLlm,
+    candidateCallLlm,
     onProgress
   )
   }

package/lib/pipeline/mutation-tester.js

@@ -0,0 +1,323 @@
+/**
+ * DeepSeek Harness Mixture of Agents (MoA) — Mutation Testing Gate for Candidate Tests (#316)
+ *
+ * Injects deterministic AST-level fault mutations into candidate implementations and evaluates
+ * candidate test suites against mutants to calculate Mutation Score (killed vs survived mutants),
+ * eliminating false-positive and tautological tests before Judge arbitration.
+ */
+
+import vm from 'node:vm'
+import { MOA_EVENTS, emitEvent } from '../events.js'
+import { extractExecutableCode } from './runtime-profiler.js'
+
+/**
+ * Mutation operator patterns.
+ */
+export const MUTATION_OPERATORS = [
+  {
+    name: 'invert_strict_equality',
+    regex: /===/g,
+    replacement: '!==',
+    description: 'Replaced strict equality (===) with inequality (!==)',
+  },
+  {
+    name: 'invert_relational_lt',
+    regex: /<(?!=)/g,
+    replacement: '>=',
+    description: 'Replaced less-than (<) with greater-or-equal (>=)',
+  },
+  {
+    name: 'invert_relational_gt',
+    regex: />(?!=)/g,
+    replacement: '<=',
+    description: 'Replaced greater-than (>) with less-or-equal (<=)',
+  },
+  {
+    name: 'invert_logical_and',
+    regex: /&&/g,
+    replacement: '||',
+    description: 'Replaced logical AND (&&) with logical OR (||)',
+  },
+  {
+    name: 'invert_arithmetic_plus',
+    regex: /(?<=\w\s*)\+(?=\s*\w)/g,
+    replacement: '-',
+    description: 'Replaced addition (+) with subtraction (-)',
+  },
+  {
+    name: 'invert_boolean_true',
+    regex: /\btrue\b/g,
+    replacement: 'false',
+    description: 'Replaced literal true with false',
+  },
+  {
+    name: 'mutate_return_zero',
+    regex: /return\s+0;/g,
+    replacement: 'return 1;',
+    description: 'Mutated return 0 to return 1',
+  },
+]
+
+/**
+ * Generates an array of mutant variations from a single source code string.
+ *
+ * @param {string} sourceCode
+ * @param {object} [options]
+ * @returns {Array<object>} Up to maxMutants mutant objects
+ */
+export function generateMutants(sourceCode, options = {}) {
+  const maxMutants = Math.min(10, Math.max(1, options.maxMutants || 5))
+  const mutants = []
+  if (!sourceCode || typeof sourceCode !== 'string') return mutants
+
+  for (const op of MUTATION_OPERATORS) {
+    let match
+    const re = new RegExp(op.regex.source, op.regex.flags)
+    while ((match = re.exec(sourceCode)) !== null) {
+      const idx = match.index
+      const len = match[0].length
+      const mutantCode = sourceCode.slice(0, idx) + op.replacement + sourceCode.slice(idx + len)
+
+      mutants.push({
+        id: mutants.length + 1,
+        operator: op.name,
+        description: op.description,
+        originalSnippet: match[0],
+        replacementSnippet: op.replacement,
+        mutantCode,
+      })
+
+      if (mutants.length >= maxMutants) return mutants
+    }
+  }
+
+  return mutants
+}
+
+/**
+ * Runs a test script against an implementation in an isolated VM context.
+ *
+ * @param {string} codeToExecute
+ * @param {number} [timeoutMs=1000]
+ * @returns {{ ok: boolean, error: string | null }}
+ */
+function executeScript(codeToExecute, timeoutMs = 1000) {
+  const sandbox = {
+    console: { log: () => {}, warn: () => {}, error: () => {} },
+    assert: (cond, msg) => { if (!cond) throw new Error(msg || 'Assertion failed'); },
+    Math, Date, Array, Object, String, Number, Boolean, Set, Map, JSON,
+  }
+  sandbox.assert.equal = (a, b) => { if (a !== b) throw new Error(`Assertion failed: ${a} !== ${b}`); }
+  sandbox.assert.strictEqual = (a, b) => { if (a !== b) throw new Error(`Assertion failed: ${a} !== ${b}`); }
+  sandbox.assert.ok = (v) => { if (!v) throw new Error('Assertion failed: falsy value'); }
+
+  try {
+    const context = vm.createContext(sandbox)
+    const script = new vm.Script(codeToExecute)
+    script.runInContext(context, { timeout: timeoutMs })
+    return { ok: true, error: null }
+  } catch (err) {
+    return { ok: false, error: err.message }
+  }
+}
+
+/**
+ * Evaluates a candidate's implementation against generated mutants.
+ *
+ * @param {string} rawText - Candidate text containing code or tests
+ * @param {object} [options]
+ * @returns {object} Mutation testing report
+ */
+export function auditCandidateMutations(rawText, options = {}) {
+  const { minMutationScore = 0.7, maxMutants = 5, timeoutMs = 1000 } = options
+  const code = extractExecutableCode(rawText)
+
+  if (!code || !code.trim()) {
+    return {
+      passed: true,
+      mutationScore: 100,
+      totalMutants: 0,
+      killedCount: 0,
+      survivedCount: 0,
+      mutants: [],
+      summary: 'Mutation Testing: No code to mutate.',
+    }
+  }
+
+  // 1. Verify baseline executes cleanly
+  const baseline = executeScript(code, timeoutMs)
+  if (!baseline.ok) {
+    return {
+      passed: false,
+      mutationScore: 0,
+      totalMutants: 0,
+      killedCount: 0,
+      survivedCount: 0,
+      mutants: [],
+      error: `Baseline test execution failed: ${baseline.error}`,
+      summary: `Baseline execution failed (${baseline.error}).`,
+    }
+  }
+
+  // 2. Generate mutations on the code
+  const mutants = generateMutants(code, { maxMutants })
+  if (mutants.length === 0) {
+    return {
+      passed: true,
+      mutationScore: 100,
+      totalMutants: 0,
+      killedCount: 0,
+      survivedCount: 0,
+      mutants: [],
+      summary: 'Mutation Testing: Code contains no mutable operators.',
+    }
+  }
+
+  // 3. Test each mutant
+  let killedCount = 0
+  let survivedCount = 0
+  const evaluatedMutants = []
+
+  for (const m of mutants) {
+    const res = executeScript(m.mutantCode, timeoutMs)
+    if (!res.ok) {
+      // Mutant was killed (good! The test broke as expected)
+      killedCount++
+      evaluatedMutants.push({
+        ...m,
+        status: 'KILLED',
+        reason: res.error,
+      })
+    } else {
+      // Mutant survived (bad! Code was broken but test passed anyway)
+      survivedCount++
+      evaluatedMutants.push({
+        ...m,
+        status: 'SURVIVED',
+        reason: 'Test suite passed despite injected fault.',
+      })
+    }
+  }
+
+  const mutationRatio = Number((killedCount / mutants.length).toFixed(2))
+  const mutationScore = Math.round(mutationRatio * 100)
+  const passed = mutationRatio >= minMutationScore
+
+  const summary = passed
+    ? `🧬 Mutation Testing: PASSED (Score ${mutationScore}%). Killed ${killedCount}/${mutants.length} mutant(s).`
+    : `⚠️ Mutation Testing: WEAK TESTS (Score ${mutationScore}% < ${Math.round(minMutationScore * 100)}%). ${survivedCount} mutant(s) survived undetected.`
+
+  return {
+    passed,
+    mutationScore,
+    mutationRatio,
+    totalMutants: mutants.length,
+    killedCount,
+    survivedCount,
+    mutants: evaluatedMutants,
+    summary,
+  }
+}
+
+/**
+ * Runs the Mutation Testing Gate across all candidate solutions.
+ *
+ * @param {Array<object>} candidates
+ * @param {object} [options]
+ * @returns {object} Mutation gate report
+ */
+export function runMutationGate(candidates, options = {}) {
+  const { ctx, runId, onProgress, minMutationScore = 0.70 } = options
+  const results = []
+
+  if (!Array.isArray(candidates) || candidates.length === 0) {
+    return {
+      results: [],
+      passedCount: 0,
+      mutationDirective: null,
+    }
+  }
+
+  for (let i = 0; i < candidates.length; i++) {
+    const cand = candidates[i]
+    const text = typeof cand === 'string' ? cand : cand.output || cand.text || cand.code || ''
+    const report = auditCandidateMutations(text, { minMutationScore, ...options })
+
+    if (typeof cand === 'object' && cand !== null) {
+      cand.mutationReport = report
+      cand.mutationScore = report.mutationScore
+    }
+
+    results.push({
+      candidateIndex: i,
+      model: cand?.model || `Candidate ${i + 1}`,
+      report,
+    })
+
+    if (ctx) {
+      emitEvent(ctx, MOA_EVENTS.MUTATION_COMPLETE, {
+        runId,
+        candidateIndex: i,
+        mutationScore: report.mutationScore,
+        killedCount: report.killedCount,
+        totalMutants: report.totalMutants,
+        passed: report.passed,
+      })
+    }
+  }
+
+  const passedCount = results.filter((r) => r.report.passed).length
+
+  if (typeof onProgress === 'function' && results.length > 0) {
+    const summaryList = results.map((r) => `Ref ${r.candidateIndex + 1}: ${r.report.mutationScore}%`).join(', ')
+    onProgress(`🧬 *Mutation Testing Gate*: ${summaryList}\n`)
+  }
+
+  const mutationDirective = formatMutationDirective(results)
+
+  return {
+    results,
+    passedCount,
+    mutationDirective,
+  }
+}
+
+/**
+ * Formats mutation testing results into a prompt directive for the Judge.
+ *
+ * @param {Array<object>} results
+ * @returns {string|null}
+ */
+export function formatMutationDirective(results) {
+  if (!Array.isArray(results) || results.length === 0) return null
+
+  const lines = [
+    '### 🧬 RUNTIME MUTATION TESTING & FAULT INJECTION REPORT',
+    'Evaluation of test robustness against synthetic fault injection (killing code mutants):',
+  ]
+
+  for (const r of results) {
+    const label = `Candidate ${r.candidateIndex + 1}`
+    const rep = r.report
+    if (rep.totalMutants === 0) {
+      lines.push(`- **${label}**: ℹ️ No mutable operators found in test suite.`)
+    } else if (rep.passed) {
+      lines.push(
+        `- **${label}**: ✅ **RESILIENT TESTS** (Score ${rep.mutationScore}%) — Killed ${rep.killedCount}/${rep.totalMutants} fault mutants.`
+      )
+    } else {
+      lines.push(
+        `- **${label}**: ⚠️ **WEAK/TAUTOLOGICAL TESTS** (Score ${rep.mutationScore}%) — ${rep.survivedCount}/${rep.totalMutants} mutant(s) survived! The tests pass even when logic is inverted.`
+      )
+      for (const m of (rep.mutants || []).filter((m) => m.status === 'SURVIVED')) {
+        lines.push(`  * ${m.description} [Survived]`)
+      }
+    }
+  }
+
+  lines.push(
+    '\n**Judge Quality Mandate**: Prefer solutions whose test suites have a high Mutation Score. Solutions with surviving mutants have weak or tautological tests that do not genuinely verify behavior.'
+  )
+
+  return lines.join('\n')
+}