@goodandready/dsh-moa 0.2.75 → 0.2.76

package/README.md

@@ -52,6 +52,8 @@ Single-model AI generation often suffers from blind spots, single-perspective bi
 9. **Run History & Win-Rate Leaderboard**: Persistent logging of every run kind (synthesis, fast mode, questionnaire) with built-in REST endpoints (`/dsh-moa/history`, `/dsh-moa/leaderboard`, `/dsh-moa/runs/<id>`).
 10. **Live Canvas 1-Click Preview (optional)**: when the `@goodandready/dsh-live-canvas` plugin is installed in the same profile, the promoted HTML is pushed to its sandbox and the MoA answer carries a one-click preview link; without it the step is skipped silently.
 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.
 
 ---
 

package/README.ru.md

@@ -52,6 +52,8 @@
 9. **История запусков и лидерборд моделей**: Персистентное логирование всех видов запусков (синтез, fast mode, опросник) и REST-эндпоинты (`/dsh-moa/history`, `/dsh-moa/leaderboard`, `/dsh-moa/runs/<id>`).
 10. **Live Canvas 1-клик предпросмотр (опционально)**: если в профиле установлен `@goodandready/dsh-live-canvas`, промоученный HTML отправляется в его песочницу, а ответ MoA содержит ссылку на предпросмотр в 1 клик; без плагина шаг тихо пропускается.
 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 библиотек.
 
 ---
 

package/README.zh.md

@@ -52,6 +52,8 @@
 9. **运行历史与胜率排行榜**：对每一类运行（综合、快速模式、问卷）进行持久化记录，并内置 REST 端点（`/dsh-moa/history`、`/dsh-moa/leaderboard`、`/dsh-moa/runs/<id>`）。
 10. **Live Canvas 一键预览（可选）**：当同一 profile 中安装了 `@goodandready/dsh-live-canvas` 时，提升到项目根目录的 HTML 会被推入其沙箱，MoA 回答附带一键预览链接；未安装时该步骤静默跳过。
 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 问题并对照标准库及项目配置清单，杜绝调用虚构不存在的幻觉方法。
 
 ---
 

package/lib/client.js

@@ -228,7 +228,11 @@ window.__ModuleLoader__.load({
       "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."
+      "aggregator.preferences_desc": "Injects learned developer preferences (strict typing, functional immutability, error boundaries) to guide Judge synthesis.",
+      "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."
     };
     const zh = {
       title: "\u667A\u80FD\u4F53\u6DF7\u5408 (MoA)",
@@ -447,7 +451,11 @@ window.__ModuleLoader__.load({
       "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"
+      "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",
+      "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"
     };
     function makeT(dict, fallback) {
       return function t(key, vars) {
@@ -2610,6 +2618,48 @@ window.__ModuleLoader__.load({
                   t("aggregator.preferences_desc") || "Injects learned developer preferences (strict typing, functional immutability, error boundaries) to guide Judge synthesis."
                 )
               ),
+              /* Adversarial White-Hat Security Fuzzing Gate (#302) */
+              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.security_gate_enabled),
+                    onChange: (e) => updateCurrentPreset((p) => ({ ...p, security_gate_enabled: e.target.checked })),
+                    style: { accentColor: "var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))", cursor: "pointer" }
+                  }),
+                  t("aggregator.security_gate_title") || "\u{1F6E1}\uFE0F Adversarial White-Hat Security Fuzzing Gate"
+                ),
+                React.createElement(
+                  "div",
+                  { style: { fontSize: 12, color: "var(--dsw-alias-label-secondary)", marginLeft: 22 } },
+                  t("aggregator.security_gate_desc") || "Red-team security auditor checks candidate proposals for SQLi, XSS, ReDoS, Command Injection and Path Traversal with blocking SECURITY_VETO."
+                )
+              ),
+              /* Chain-of-Verification (CoVe) Fact-Checking Gate (#314) */
+              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.cove_verification_enabled),
+                    onChange: (e) => updateCurrentPreset((p) => ({ ...p, cove_verification_enabled: e.target.checked })),
+                    style: { accentColor: "var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))", cursor: "pointer" }
+                  }),
+                  t("aggregator.cove_gate_title") || "\u{1F50D} Chain-of-Verification (CoVe) Fact-Checking Gate"
+                ),
+                React.createElement(
+                  "div",
+                  { style: { fontSize: 12, color: "var(--dsw-alias-label-secondary)", marginLeft: 22 } },
+                  t("aggregator.cove_gate_desc") || "Formulates API existence & method signature verification questions, disqualifying candidates that use hallucinated methods."
+                )
+              ),
               /* Fallback Judges Chain */
               React.createElement(
                 "div",

package/lib/events.js

@@ -11,6 +11,8 @@ export const MOA_EVENTS = {
   SELF_CONSISTENCY_EXPAND: 'moa/self-consistency-expand',
   STACK_DETECTED: 'moa/stack-detected',
   PREFERENCES_APPLIED: 'moa/preferences-applied',
+  SECURITY_AUDIT: 'moa/security-audit',
+  COVE_VERIFIED: 'moa/cove-verified',
   CRITIQUE_COMPLETE: 'moa/critique-complete',
   JUDGE_VERDICT: 'moa/judge-verdict',
   CONTEXT_PRUNING: 'moa/context-pruning',
@@ -36,4 +38,3 @@ export function emitEvent(ctx, eventName, payload) {
     /* best-effort event dispatch: listener exceptions must never abort pipeline */
   }
 }
-

package/lib/moa-schema.js

@@ -91,6 +91,10 @@ export const PresetSchema = z.object({
   escalation_judge: ModelSlotSchema.default({ provider: '', model: '' }),
   stack_aware_personas_enabled: z.boolean().default(false),
   developer_preferences_enabled: z.boolean().default(false),
+  security_gate_enabled: z.boolean().default(false),
+  security_gate_strict_veto: z.boolean().default(true),
+  cove_verification_enabled: z.boolean().default(false),
+  cove_max_questions: z.number().default(5),
 })
 
 export const Config = z.object({
@@ -128,6 +132,10 @@ export const Config = z.object({
   escalation_judge: ModelSlotSchema.default({ provider: '', model: '' }).volatile(),
   stack_aware_personas_enabled: z.boolean().default(false).volatile(),
   developer_preferences_enabled: z.boolean().default(false).volatile(),
+  security_gate_enabled: z.boolean().default(false).volatile(),
+  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(),
   smart_routing_model: ModelSlotSchema.default({ provider: '', model: '' }).volatile(),
   prices: z.dict(PriceRow).default({}).volatile(),
   presets: z.array(PresetSchema).default([
@@ -197,4 +205,3 @@ export function plainConfig(value) {
   }
   return value
 }
-

package/lib/pipeline/cove-verifier.js

@@ -0,0 +1,401 @@
+/**
+ * DeepSeek Harness Mixture of Agents (MoA) — Chain-of-Verification (CoVe) Fact-Checking Gate (#314)
+ *
+ * Pre-Judge verification gate that analyzes candidate proposals, formulates 3-5 factual API & syntax
+ * verification questions, audits them against standard libraries & project context, and flags
+ * hallucinated methods or nonexistent modules before arbitration.
+ */
+
+import { MOA_EVENTS, emitEvent } from '../events.js'
+
+/**
+ * Standard Node.js built-in modules.
+ */
+export const NODE_STDLIB_MODULES = new Set([
+  'assert', 'async_hooks', 'buffer', 'child_process', 'cluster', 'console',
+  'constants', 'crypto', 'dgram', 'diagnostics_channel', 'dns', 'domain',
+  'events', 'fs', 'fs/promises', 'http', 'http2', 'https', 'inspector',
+  'module', 'net', 'os', 'path', 'path/posix', 'path/win32', 'perf_hooks',
+  'process', 'punycode', 'querystring', 'readline', 'repl', 'stream',
+  'stream/promises', 'stream/web', 'string_decoder', 'test', 'timers',
+  'timers/promises', 'tls', 'trace_events', 'tty', 'url', 'util',
+  'v8', 'vm', 'wasi', 'worker_threads', 'zlib',
+])
+
+/**
+ * Common hallucinated APIs and their real replacements.
+ */
+export const KNOWN_HALLUCINATIONS = [
+  {
+    regex: /fs\.(?:readAllText|readTextFile|readText|readAsString)\s*\(/i,
+    hallucination: 'fs.readAllText / fs.readTextFile',
+    correction: 'fs.readFileSync(path, "utf8") or fs.promises.readFile(path, "utf8")',
+    reason: 'Method does not exist in Node.js fs module (often hallucinated from C# .NET or Deno).',
+  },
+  {
+    regex: /fs\.(?:writeAllText|writeTextFile|writeText|writeAsString)\s*\(/i,
+    hallucination: 'fs.writeAllText / fs.writeTextFile',
+    correction: 'fs.writeFileSync(path, data, "utf8") or fs.promises.writeFile(path, data, "utf8")',
+    reason: 'Method does not exist in Node.js fs module.',
+  },
+  {
+    regex: /fs\.readFileAsync\s*\(/i,
+    hallucination: 'fs.readFileAsync',
+    correction: 'fs.promises.readFile(...) or util.promisify(fs.readFile)',
+    reason: 'Legacy Bluebird promise naming is not a native Node.js fs method.',
+  },
+  {
+    regex: /path\.(?:normalizeUrl|combine|joinPath)\s*\(/i,
+    hallucination: 'path.combine / path.normalizeUrl',
+    correction: 'path.join(...) or new URL(...)',
+    reason: 'Method does not exist in Node.js path module.',
+  },
+  {
+    regex: /crypto\.(?:generateRandomUuidString|randomString|generateUuid)\s*\(/i,
+    hallucination: 'crypto.generateRandomUuidString',
+    correction: 'crypto.randomUUID() or crypto.randomBytes(...)',
+    reason: 'Nonexistent crypto helper hallucinated by language models.',
+  },
+  {
+    regex: /JSON\.(?:toObject|fromObject|encode|decode)\s*\(/i,
+    hallucination: 'JSON.toObject / JSON.fromObject / JSON.encode',
+    correction: 'JSON.parse(...) or JSON.stringify(...)',
+    reason: 'Invalid JSON global methods hallucinated from other ecosystems.',
+  },
+  {
+    regex: /Promise\.(?:wait|sleep|delay)\s*\(/i,
+    hallucination: 'Promise.sleep / Promise.wait / Promise.delay',
+    correction: 'new Promise(resolve => setTimeout(resolve, ms)) or timers/promises setTimeout',
+    reason: 'Native JavaScript Promise does not feature sleep/delay directly on Promise constructor.',
+  },
+]
+
+/**
+ * Extracts candidate imports, requires, and method calls to formulate verification questions.
+ *
+ * @param {string} code
+ * @param {object} [options]
+ * @returns {Array<object>} Up to maxQuestions questions
+ */
+export function generateCoveQuestions(code, options = {}) {
+  const maxQuestions = Math.min(10, Math.max(1, options.maxQuestions || 5))
+  const questions = []
+  if (!code || typeof code !== 'string') return questions
+
+  // 1. Check imports/requires
+  const importRegex = /(?:import\s+(?:\{[^}]+\}|\*\s+as\s+\w+|\w+)\s+from\s+['"]([^'"]+)['"]|require\s*\(\s*['"]([^'"]+)['"]\s*\))/g
+  let match
+  const seenModules = new Set()
+  while ((match = importRegex.exec(code)) !== null) {
+    const mod = match[1] || match[2]
+    if (mod && !seenModules.has(mod) && !mod.startsWith('.') && !mod.startsWith('/')) {
+      seenModules.add(mod)
+      const cleanMod = mod.replace(/^node:/, '')
+      questions.push({
+        id: questions.length + 1,
+        type: 'module_resolution',
+        subject: mod,
+        cleanSubject: cleanMod,
+        question: `Is module '${mod}' available in standard library or project dependencies?`,
+      })
+      if (questions.length >= maxQuestions) return questions
+    }
+  }
+
+  // 2. Check for known hallucination method calls
+  for (const h of KNOWN_HALLUCINATIONS) {
+    if (h.regex.test(code)) {
+      questions.push({
+        id: questions.length + 1,
+        type: 'api_existence',
+        subject: h.hallucination,
+        hallucinationDef: h,
+        question: `Does API '${h.hallucination}' exist and is it valid in the target runtime?`,
+      })
+      if (questions.length >= maxQuestions) return questions
+    }
+  }
+
+  // 3. Check general API calls (fs, path, crypto, child_process)
+  const apiCallRegex = /\b(fs|path|crypto|os|child_process|JSON|Promise)\.([a-zA-Z0-9_]+)\s*\(/g
+  const seenApis = new Set()
+  while ((match = apiCallRegex.exec(code)) !== null) {
+    const obj = match[1]
+    const method = match[2]
+    const full = `${obj}.${method}`
+    if (!seenApis.has(full)) {
+      seenApis.add(full)
+      questions.push({
+        id: questions.length + 1,
+        type: 'method_signature',
+        subject: full,
+        object: obj,
+        method,
+        question: `Does method '${method}' natively exist on standard global '${obj}'?`,
+      })
+      if (questions.length >= maxQuestions) return questions
+    }
+  }
+
+  // Fallback question if code has no special calls
+  if (questions.length === 0) {
+    questions.push({
+      id: 1,
+      type: 'syntax_coherence',
+      subject: 'code_structure',
+      question: 'Are all functions and return types syntactically aligned and verifiable?',
+    })
+  }
+
+  return questions.slice(0, maxQuestions)
+}
+
+/**
+ * Verifies a single CoVe factual question against stdlib and project dependencies.
+ *
+ * @param {object} q - Question object from generateCoveQuestions
+ * @param {object} [projectContext]
+ * @returns {object} Verification result
+ */
+export function verifyCoveQuestion(q, projectContext = {}) {
+  const deps = {
+    ...(projectContext.dependencies || {}),
+    ...(projectContext.devDependencies || {}),
+    ...(projectContext.stackInfo?.manifestDependencies || {}),
+  }
+
+  if (q.type === 'module_resolution') {
+    const isNode = NODE_STDLIB_MODULES.has(q.cleanSubject)
+    const isDep = Boolean(deps[q.cleanSubject] || deps[q.subject])
+    if (isNode || isDep) {
+      return {
+        verified: true,
+        confidence: 1.0,
+        rationale: isNode
+          ? `Module '${q.subject}' is a verified Node.js standard library module.`
+          : `Module '${q.subject}' is defined in project manifest dependencies.`,
+        hallucination: null,
+      }
+    }
+    return {
+      verified: false,
+      confidence: 0.85,
+      rationale: `Module '${q.subject}' is not found in Node.js stdlib or declared project dependencies.`,
+      hallucination: {
+        api: q.subject,
+        reason: `Module '${q.subject}' was referenced without declaration in package.json or stdlib.`,
+      },
+    }
+  }
+
+  if (q.type === 'api_existence') {
+    // Matched a known hallucination pattern
+    const h = q.hallucinationDef
+    return {
+      verified: false,
+      confidence: 0.95,
+      rationale: `Invalid API detected: ${h.reason} Suggested fix: ${h.correction}`,
+      hallucination: {
+        api: h.hallucination,
+        reason: h.reason,
+        correction: h.correction,
+      },
+    }
+  }
+
+  if (q.type === 'method_signature') {
+    // Verify common valid methods on known objects
+    const validFs = new Set(['readFile', 'readFileSync', 'writeFile', 'writeFileSync', 'existsSync', 'statSync', 'stat', 'mkdirSync', 'mkdir', 'unlinkSync', 'unlink', 'readdirSync', 'readdir', 'createReadStream', 'createWriteStream', 'promises'])
+    const validPath = new Set(['join', 'resolve', 'basename', 'dirname', 'extname', 'relative', 'normalize', 'isAbsolute', 'parse', 'format', 'sep', 'posix', 'win32'])
+    const validCrypto = new Set(['randomUUID', 'randomBytes', 'createHash', 'createHmac', 'createCipheriv', 'createDecipheriv', 'timingSafeEqual', 'scryptSync', 'pbkdf2Sync'])
+    const validJson = new Set(['parse', 'stringify'])
+    const validPromise = new Set(['all', 'allSettled', 'race', 'any', 'resolve', 'reject'])
+
+    let isValid = true
+    if (q.object === 'fs') isValid = validFs.has(q.method)
+    else if (q.object === 'path') isValid = validPath.has(q.method)
+    else if (q.object === 'crypto') isValid = validCrypto.has(q.method)
+    else if (q.object === 'JSON') isValid = validJson.has(q.method)
+    else if (q.object === 'Promise') isValid = validPromise.has(q.method)
+
+    if (isValid) {
+      return {
+        verified: true,
+        confidence: 0.95,
+        rationale: `'${q.subject}' is a verified standard method.`,
+        hallucination: null,
+      }
+    }
+    return {
+      verified: false,
+      confidence: 0.9,
+      rationale: `'${q.method}' does not exist on global '${q.object}'.`,
+      hallucination: {
+        api: q.subject,
+        reason: `Method '${q.method}' does not exist on '${q.object}'.`,
+      },
+    }
+  }
+
+  return {
+    verified: true,
+    confidence: 0.9,
+    rationale: 'Verified general syntax structure.',
+    hallucination: null,
+  }
+}
+
+/**
+ * Audits a single candidate solution using Chain-of-Verification (CoVe).
+ *
+ * @param {string} code
+ * @param {object} [projectContext]
+ * @param {object} [options]
+ * @returns {object}
+ */
+export function auditCandidateCove(code, projectContext = {}, options = {}) {
+  const questions = generateCoveQuestions(code, options)
+  const verifications = []
+  const hallucinations = []
+
+  for (const q of questions) {
+    const v = verifyCoveQuestion(q, projectContext)
+    verifications.push({
+      ...q,
+      verified: v.verified,
+      confidence: v.confidence,
+      rationale: v.rationale,
+    })
+    if (!v.verified && v.hallucination) {
+      hallucinations.push(v.hallucination)
+    }
+  }
+
+  const penalty = hallucinations.length * 35
+  const coveScore = Math.max(0, 100 - penalty)
+  const passed = hallucinations.length === 0
+
+  let summary = ''
+  if (passed) {
+    summary = `🔍 CoVe Fact-Checking: PASSED (Score 100/100). Verified ${questions.length} factual API/module question(s).`
+  } else {
+    summary = `⚠️ CoVe Hallucination Detected (Score ${coveScore}/100): ${hallucinations.length} non-existent or unverified API(s) found.`
+  }
+
+  return {
+    passed,
+    coveScore,
+    questions: verifications,
+    hallucinations,
+    summary,
+  }
+}
+
+/**
+ * Runs the Chain-of-Verification Gate across all candidates.
+ *
+ * @param {Array<object>} candidates
+ * @param {object} [projectContext]
+ * @param {object} [options]
+ * @returns {object}
+ */
+export function runCoveVerificationGate(candidates, projectContext = {}, options = {}) {
+  const { ctx, runId, onProgress } = options
+  const results = []
+  let totalHallucinations = 0
+
+  if (!Array.isArray(candidates) || candidates.length === 0) {
+    return {
+      results: [],
+      passedCount: 0,
+      hallucinationCount: 0,
+      coveDirective: 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 = auditCandidateCove(text, projectContext, options)
+
+    if (typeof cand === 'object' && cand !== null) {
+      cand.coveReport = report
+      cand.coveScore = report.coveScore
+      cand.coveHallucinations = report.hallucinations
+    }
+
+    totalHallucinations += report.hallucinations.length
+    results.push({
+      candidateIndex: i,
+      model: cand?.model || `Candidate ${i + 1}`,
+      report,
+    })
+
+    if (ctx) {
+      emitEvent(ctx, MOA_EVENTS.COVE_VERIFIED, {
+        runId,
+        candidateIndex: i,
+        coveScore: report.coveScore,
+        passed: report.passed,
+        questionsCount: report.questions.length,
+        hallucinationsCount: report.hallucinations.length,
+      })
+    }
+  }
+
+  const passedCount = results.filter((r) => r.report.passed).length
+
+  if (typeof onProgress === 'function') {
+    if (totalHallucinations === 0) {
+      onProgress(`🔍 *CoVe Fact-Check Passed*: All APIs and modules verified against project context.\n`)
+    } else {
+      onProgress(`⚠️ *CoVe Fact-Check Alert*: Found ${totalHallucinations} unverified or hallucinated API(s) across candidate solutions.\n`)
+    }
+  }
+
+  const coveDirective = formatCoveDirective(results)
+
+  return {
+    results,
+    passedCount,
+    hallucinationCount: totalHallucinations,
+    coveDirective,
+  }
+}
+
+/**
+ * Formats CoVe fact-checking verification findings into a prompt directive for Judge/Synthesis.
+ *
+ * @param {Array<object>} results
+ * @returns {string|null}
+ */
+export function formatCoveDirective(results) {
+  if (!Array.isArray(results) || results.length === 0) return null
+
+  const hasAnyHallucinations = results.some((r) => r.report && r.report.hallucinations.length > 0)
+  if (!hasAnyHallucinations) {
+    return '### 🔍 CHAIN-OF-VERIFICATION (CoVe): ALL CANDIDATE APIS VERIFIED FACTUAL\nNo hallucinated APIs, phantom modules, or broken native signatures detected.'
+  }
+
+  const lines = [
+    '### 🔍 CHAIN-OF-VERIFICATION (CoVe) FACT-CHECK DIRECTIVE',
+    'Independent factual audit of API calls and module imports has been completed:',
+  ]
+
+  for (const r of results) {
+    const label = `Candidate ${r.candidateIndex + 1}`
+    const rep = r.report || {}
+    if (!rep.passed && rep.hallucinations.length > 0) {
+      lines.push(`- **${label}**: ❌ **FACT-CHECK FAILURE** (Score ${rep.coveScore}/100) — Hallucinated APIs detected:`)
+      for (const h of rep.hallucinations) {
+        lines.push(`  * \`${h.api}\`: ${h.reason}${h.correction ? ` (Correction: ${h.correction})` : ''}`)
+      }
+    } else {
+      lines.push(`- **${label}**: ✅ VERIFIED (Score 100/100) — All ${rep.questions?.length || 0} API checks confirmed valid.`)
+    }
+  }
+
+  lines.push('\n**Judge Fact-Checking Rule**: Do not award winning status to solutions that rely on hallucinated methods or nonexistent packages. Prefer solutions with 100/100 verified API accuracy.')
+
+  return lines.join('\n')
+}

package/lib/pipeline/runner.js

@@ -18,6 +18,8 @@ import { stageSynthesis } from './synthesis.js'
 import { stagePromotion } from './promotion.js'
 import { applySyntaxFilter, formatSyntaxDirective } from './syntax-filter.js'
 import { stageEarlyConsensus } from './early-consensus.js'
+import { runSecurityAuditGate } from './security-fuzzer.js'
+import { runCoveVerificationGate } from './cove-verifier.js'
 import { emitEvent, MOA_EVENTS } from '../events.js'
 
 export async function runMoAPipeline({
@@ -199,6 +201,39 @@ export async function runMoAPipeline({
     return { error: new Error('Turn aborted') }
   }
 
+  // Pre-Stage 5.8: Chain-of-Verification (CoVe) Fact-Checking Gate (#314)
+  let coveDirective = null
+  let coveGateResult = null
+  if (preset?.cove_verification_enabled) {
+    coveGateResult = runCoveVerificationGate(
+      syntaxResult.validCandidates.length > 0 ? syntaxResult.validCandidates : successfulRefs,
+      ctxStage,
+      {
+        ctx,
+        runId,
+        onProgress,
+        maxQuestions: preset.cove_max_questions || 5,
+      }
+    )
+    coveDirective = coveGateResult.coveDirective
+  }
+
+  // Pre-Stage 5.9: Adversarial White-Hat Security Fuzzing Gate (#302)
+  let securityDirective = null
+  let securityGateResult = null
+  if (preset?.security_gate_enabled) {
+    securityGateResult = runSecurityAuditGate(
+      syntaxResult.validCandidates.length > 0 ? syntaxResult.validCandidates : successfulRefs,
+      {
+        ctx,
+        runId,
+        onProgress,
+        strictVeto: preset.security_gate_strict_veto !== false,
+      }
+    )
+    securityDirective = securityGateResult.securityDirective
+  }
+
   // Pre-Stage 6: Dynamic Consensus Threshold & Multi-Judge Escalation (#300)
   const escalationResult = evaluateJudgeEscalation({
     candidateOutputs: syntaxResult.validCandidates.length > 0 ? syntaxResult.validCandidates : successfulRefs,
@@ -249,7 +284,7 @@ export async function runMoAPipeline({
     preset: effectivePreset,
     successfulRefs: syntaxResult.validCandidates.length > 0 ? syntaxResult.validCandidates : successfulRefs,
     referenceOutputs, primaryJudge: effectivePrimaryJudge,
-    userPrompt, judgeCriteria: ctxStage.judgeCriteria, prices, maxTokens: ctxStage.maxTokens,
+    userPrompt, judgeCriteria: [ctxStage.judgeCriteria, coveDirective, securityDirective].filter(Boolean).join('\n\n'), prices, maxTokens: ctxStage.maxTokens,
     callLlm, signal, onProgress, cwd, runId, isRefinement: ctxStage.isRefinement,
     isFastMode: ctxStage.isFastMode, collectedCtx: ctxStage.collectedCtx, startTime,
   })
@@ -307,7 +342,7 @@ export async function runMoAPipeline({
     }
   }
 
-  const fileScoringDirective = [rawFileDirective, visualResult?.directive, adversarialTddResult?.directive, syntaxDirective, pruningDirective, ctxStage.stackAwareDirective, ctxStage.developerPreferencesDirective].filter(Boolean).join("\n\n") || null
+  const fileScoringDirective = [rawFileDirective, visualResult?.directive, adversarialTddResult?.directive, syntaxDirective, coveDirective, securityDirective, pruningDirective, ctxStage.stackAwareDirective, ctxStage.developerPreferencesDirective].filter(Boolean).join("\n\n") || null
 
   // Stage 7: Synthesis Phase
   const synthRes = await stageSynthesis({

package/lib/pipeline/security-fuzzer.js

@@ -0,0 +1,290 @@
+/**
+ * DeepSeek Harness Mixture of Agents (MoA) — Adversarial Security Fuzzing Gate (#302)
+ *
+ * White-Hat Red Team security gate that audits candidate code proposals for critical
+ * vulnerabilities, injection vectors, memory exhaustion, prototype pollution, and CWE patterns
+ * before final Judge arbitration.
+ */
+
+import { MOA_EVENTS, emitEvent } from '../events.js'
+
+/**
+ * Known vulnerability rule signatures with CWE classifications.
+ */
+export const SECURITY_RULES = [
+  {
+    cwe: 'CWE-89',
+    title: 'SQL Injection Risk',
+    severity: 'critical',
+    regex: /(?:SELECT|INSERT|UPDATE|DELETE|DROP|ALTER|CREATE|EXEC)\s+[^;`'"]*?(\$\{[^}]+\}|['"`]\s*\+\s*[a-zA-Z0-9_]+)/i,
+    detail: 'Unsanitized query construction using string interpolation or concatenation instead of parameterized bindings.',
+  },
+  {
+    cwe: 'CWE-78',
+    title: 'OS Command Injection',
+    severity: 'critical',
+    regex: /(?:child_process\.)?(?:exec|execSync)\s*\(\s*(?:`[^`]*\$\{[^}]+\}[^`]*`|['"][^'"]*['"]\s*\+)/i,
+    detail: 'Executing shell commands with interpolated or concatenated untrusted input.',
+  },
+  {
+    cwe: 'CWE-78',
+    title: 'Shell Invocation with Dynamic Arguments',
+    severity: 'critical',
+    regex: /spawn\s*\([^,]+,\s*\{[^}]*shell\s*:\s*true/i,
+    detail: 'Invoking child_process.spawn with shell: true exposes process to command injection.',
+  },
+  {
+    cwe: 'CWE-22',
+    title: 'Path Traversal Vulnerability',
+    severity: 'high',
+    regex: /(?:readFile|writeFile|createReadStream|createWriteStream|unlink|stat)\s*\([^)]*?(?:\.\.\/|\.\.\\)/i,
+    detail: 'File system operation contains unconstrained relative path traversal sequences (../).',
+  },
+  {
+    cwe: 'CWE-79',
+    title: 'Cross-Site Scripting (DOM XSS)',
+    severity: 'high',
+    regex: /(?:\.innerHTML\s*=|document\.write\s*\(|dangerouslySetInnerHTML\s*=\s*\{\s*\{\s*__html\s*:\s*(?!DOMPurify|sanitize))/i,
+    detail: 'Unescaped HTML or DOM insertion allows arbitrary script execution in browser contexts.',
+  },
+  {
+    cwe: 'CWE-1321',
+    title: 'Prototype Pollution',
+    severity: 'critical',
+    regex: /(?:__proto__|constructor\s*\[\s*['"`]prototype['"`]\s*\]|prototype\s*\[\s*['"`]\w+['"`]\s*\]\s*=)/i,
+    detail: 'Direct modification of object prototype chain may lead to remote code execution or privilege escalation.',
+  },
+  {
+    cwe: 'CWE-400',
+    title: 'Regular Expression Denial of Service (ReDoS)',
+    severity: 'high',
+    regex: /\/(?:[^\/\\]|\\.)*(?:\([^\)]*[\+\*]\)[^\)]*[\+\*]|\([^\)]*\|[^\)]*\)[\+\*])(?:[^\/\\]|\\.)*\//,
+    detail: 'Regular expression pattern contains nested quantifiers with catastrophic polynomial/exponential backtracking.',
+  },
+  {
+    cwe: 'CWE-798',
+    title: 'Hardcoded Cryptographic Secret / Credential',
+    severity: 'high',
+    regex: /(?:api_?key|auth_?token|secret_?key|private_?key|bearer_?token)\s*[:=]\s*['"`](?:sk_live_[0-9a-zA-Z]{16,}|ghp_[0-9a-zA-Z]{20,}|ey[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,})['"`]/i,
+    detail: 'Production-like API token, private key, or credential embedded directly in source code.',
+  },
+  {
+    cwe: 'CWE-362',
+    title: 'TOCTOU Concurrency Race Condition',
+    severity: 'medium',
+    regex: /fs\.existsSync\s*\([^)]+\)[\s\S]{1,80}?fs\.(?:writeFileSync|appendFileSync)\s*\(/i,
+    detail: 'Non-atomic check-then-act pattern creates file race condition under concurrent operations.',
+  },
+]
+
+/**
+ * Audits a code snippet or model response for security vulnerabilities.
+ *
+ * @param {string} code - Candidate response text or extracted code
+ * @param {object} [options]
+ * @returns {object} Audit report with score, findings, and veto flag
+ */
+export function auditCodeSecurity(code, options = {}) {
+  if (!code || typeof code !== 'string') {
+    return {
+      veto: false,
+      score: 100,
+      findings: [],
+      summary: 'Clean: No executable code provided for security audit.',
+    }
+  }
+
+  const findings = []
+  const lines = code.split('\n')
+
+  for (const rule of SECURITY_RULES) {
+    if (rule.regex.test(code)) {
+      // Pinpoint line number if possible
+      let matchedLine = null
+      let matchedSnippet = ''
+      for (let i = 0; i < lines.length; i++) {
+        if (rule.regex.test(lines[i])) {
+          matchedLine = i + 1
+          matchedSnippet = lines[i].trim().slice(0, 120)
+          break
+        }
+      }
+
+      findings.push({
+        cwe: rule.cwe,
+        title: rule.title,
+        severity: rule.severity,
+        detail: rule.detail,
+        line: matchedLine,
+        snippet: matchedSnippet || null,
+      })
+    }
+  }
+
+  let penalty = 0
+  let hasCriticalOrHigh = false
+  for (const f of findings) {
+    if (f.severity === 'critical') {
+      penalty += 45
+      hasCriticalOrHigh = true
+    } else if (f.severity === 'high') {
+      penalty += 25
+      hasCriticalOrHigh = true
+    } else if (f.severity === 'medium') {
+      penalty += 15
+    } else {
+      penalty += 5
+    }
+  }
+
+  const score = Math.max(0, Math.min(100, 100 - penalty))
+  const strictVeto = options.strictVeto !== false
+  const veto = strictVeto ? hasCriticalOrHigh || score < 60 : score < 40
+
+  let summary = ''
+  if (findings.length === 0) {
+    summary = '🛡️ Red Team Security Audit: PASSED (Score 100/100). No known CWE vulnerabilities detected.'
+  } else if (veto) {
+    summary = `⛔ SECURITY_VETO (Score ${score}/100): Found ${findings.length} security violation(s) (${findings.map((f) => f.cwe).join(', ')}).`
+  } else {
+    summary = `⚠️ Security Warning (Score ${score}/100): ${findings.length} minor/medium issue(s) identified.`
+  }
+
+  return {
+    veto,
+    score,
+    findings,
+    summary,
+  }
+}
+
+/**
+ * Executes the Adversarial Security Fuzzing Gate across all candidate outputs.
+ *
+ * @param {Array<object>} candidates - List of candidate references with output/text
+ * @param {object} [options]
+ * @returns {object} Gate execution results with directive and veto counters
+ */
+export function runSecurityAuditGate(candidates, options = {}) {
+  const { ctx, runId, onProgress, strictVeto = true } = options
+  const results = []
+  let vetoCount = 0
+
+  if (!Array.isArray(candidates) || candidates.length === 0) {
+    return {
+      results: [],
+      vetoCount: 0,
+      cleanCount: 0,
+      allPassed: true,
+      securityDirective: 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 audit = auditCodeSecurity(text, { strictVeto })
+
+    if (typeof cand === 'object' && cand !== null) {
+      cand.securityAudit = audit
+      cand.securityVeto = audit.veto
+    }
+
+    if (audit.veto) {
+      vetoCount++
+    }
+
+    results.push({
+      candidateIndex: i,
+      model: cand?.model || `Candidate ${i + 1}`,
+      audit,
+      veto: audit.veto,
+    })
+
+    if (ctx) {
+      emitEvent(ctx, MOA_EVENTS.SECURITY_AUDIT, {
+        runId,
+        candidateIndex: i,
+        score: audit.score,
+        veto: audit.veto,
+        findingsCount: audit.findings.length,
+        cwes: audit.findings.map((f) => f.cwe),
+      })
+    }
+  }
+
+  const cleanCount = candidates.length - vetoCount
+  const allPassed = vetoCount === 0
+
+  if (typeof onProgress === 'function') {
+    if (allPassed) {
+      onProgress(`🛡️ *Security Gate Passed*: All ${candidates.length} candidate solutions cleared Red Team audit.\n`)
+    } else {
+      onProgress(
+        `🚨 *Security Gate Alert*: ${vetoCount}/${candidates.length} candidates triggered SECURITY_VETO (${results
+          .filter((r) => r.veto)
+          .map((r) => `Ref ${r.candidateIndex + 1}`)
+          .join(', ')}).\n`
+      )
+    }
+  }
+
+  const securityDirective = formatSecurityAuditDirective(results, { strictVeto })
+
+  return {
+    results,
+    vetoCount,
+    cleanCount,
+    allPassed,
+    securityDirective,
+  }
+}
+
+/**
+ * Formats Red Team audit findings into a high-priority prompt directive for Stage 6/7.
+ *
+ * @param {Array<object>} results
+ * @param {object} [options]
+ * @returns {string|null} Directive text
+ */
+export function formatSecurityAuditDirective(results, options = {}) {
+  if (!Array.isArray(results) || results.length === 0) return null
+
+  const hasAnyFindings = results.some((r) => r.audit && r.audit.findings.length > 0)
+  if (!hasAnyFindings) {
+    return '### 🛡️ RED TEAM SECURITY AUDIT: ALL CANDIDATES VERIFIED SECURE\nNo injection, XSS, ReDoS, path traversal, or credential exposure detected.'
+  }
+
+  const lines = [
+    '### 🛡️ ADVERSARIAL RED TEAM SECURITY AUDIT DIRECTIVE',
+    'Strict security evaluation of candidate proposals has been completed:',
+  ]
+
+  for (const r of results) {
+    const label = `Candidate ${r.candidateIndex + 1}`
+    const a = r.audit || {}
+    if (a.veto) {
+      lines.push(
+        `- **${label}**: ⛔ **SECURITY_VETO** (Score ${a.score}/100) — DO NOT adopt this solution without removing critical flaws:`
+      )
+      for (const f of a.findings || []) {
+        lines.push(
+          `  * [${f.cwe}] ${f.title} (${f.severity.toUpperCase()}): ${f.detail}${f.line ? ` (at line ${f.line})` : ''}`
+        )
+      }
+    } else if (a.findings && a.findings.length > 0) {
+      lines.push(`- **${label}**: ⚠️ Warning (Score ${a.score}/100):`)
+      for (const f of a.findings) {
+        lines.push(`  * [${f.cwe}] ${f.title}: ${f.detail}`)
+      }
+    } else {
+      lines.push(`- **${label}**: ✅ PASSED (Score 100/100) — Free of detectable vulnerabilities.`)
+    }
+  }
+
+  lines.push(
+    '\n**Judge Mandate**: Solutions marked with SECURITY_VETO must be heavily penalized or rejected. The final synthesized code MUST NOT contain any of the flagged CWE patterns.'
+  )
+
+  return lines.join('\n')
+}

package/package.json

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