@goodandready/dsh-moa 0.2.74 → 0.2.76

package/lib/pipeline/manifest-stack.js

@@ -0,0 +1,287 @@
+/**
+ * Stack-Aware Dynamic Persona Evolution from Project Manifests (#308)
+ *
+ * Scans project manifests (package.json, Cargo.toml, pyproject.toml, requirements.txt, go.mod)
+ * in the workspace root to infer primary programming languages, frameworks, ORMs,
+ * and test suites. Evolves candidate proposers into specialized domain experts
+ * (e.g. React Optimization, TypeScript Strict Safety, Accessibility, FastAPI Async)
+ * to maximize architectural hypothesis diversity.
+ */
+
+import fs from 'node:fs'
+import path from 'node:path'
+
+/**
+ * Scans workspace root manifests to detect project languages and dependencies.
+ *
+ * @param {string} cwd - Workspace root directory
+ * @returns {object} Detected stack information
+ */
+export function detectProjectStack(cwd = process.cwd()) {
+  const stack = {
+    primaryLanguage: 'unknown',
+    frameworks: [],
+    libraries: [],
+    manifestFound: false,
+    stackSummary: '',
+  }
+
+  if (!cwd || typeof cwd !== 'string') return stack
+
+  // 1. Node / JavaScript / TypeScript (package.json)
+  const pkgPath = path.join(cwd, 'package.json')
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const raw = fs.readFileSync(pkgPath, 'utf8')
+      const pkg = JSON.parse(raw)
+      stack.manifestFound = true
+      stack.primaryLanguage = 'javascript'
+
+      const allDeps = {
+        ...(pkg.dependencies || {}),
+        ...(pkg.devDependencies || {}),
+        ...(pkg.peerDependencies || {}),
+      }
+
+      if (allDeps.typescript || fs.existsSync(path.join(cwd, 'tsconfig.json'))) {
+        stack.primaryLanguage = 'typescript'
+        stack.libraries.push('typescript')
+      }
+
+      // Frameworks
+      if (allDeps.next) stack.frameworks.push('next.js')
+      else if (allDeps.react) stack.frameworks.push('react')
+
+      if (allDeps.nuxt) stack.frameworks.push('nuxt')
+      else if (allDeps.vue) stack.frameworks.push('vue')
+
+      if (allDeps['@sveltejs/kit']) stack.frameworks.push('sveltekit')
+      else if (allDeps.svelte) stack.frameworks.push('svelte')
+
+      if (allDeps['@angular/core']) stack.frameworks.push('angular')
+      if (allDeps['@nestjs/core']) stack.frameworks.push('nestjs')
+      if (allDeps.fastify) stack.frameworks.push('fastify')
+      if (allDeps.express) stack.frameworks.push('express')
+
+      // Styling & UI
+      if (allDeps.tailwindcss) stack.libraries.push('tailwindcss')
+
+      // ORM & Data
+      if (allDeps.prisma || allDeps['@prisma/client']) stack.libraries.push('prisma')
+      if (allDeps['drizzle-orm']) stack.libraries.push('drizzle')
+      if (allDeps.typeorm) stack.libraries.push('typeorm')
+      if (allDeps.mongoose) stack.libraries.push('mongoose')
+
+      // Validation
+      if (allDeps.zod) stack.libraries.push('zod')
+      if (allDeps.valibot) stack.libraries.push('valibot')
+
+      // Testing
+      if (allDeps.vitest) stack.libraries.push('vitest')
+      if (allDeps.jest) stack.libraries.push('jest')
+      if (allDeps.playwright || allDeps['@playwright/test']) stack.libraries.push('playwright')
+    } catch {
+      // safe fallback on corrupted package.json
+    }
+  }
+
+  // 2. Rust (Cargo.toml)
+  const cargoPath = path.join(cwd, 'Cargo.toml')
+  if (fs.existsSync(cargoPath)) {
+    try {
+      const content = fs.readFileSync(cargoPath, 'utf8')
+      stack.manifestFound = true
+      stack.primaryLanguage = 'rust'
+
+      if (content.includes('axum')) stack.frameworks.push('axum')
+      if (content.includes('actix-web')) stack.frameworks.push('actix-web')
+      if (content.includes('tokio')) stack.libraries.push('tokio')
+      if (content.includes('serde')) stack.libraries.push('serde')
+      if (content.includes('sqlx')) stack.libraries.push('sqlx')
+      if (content.includes('diesel')) stack.libraries.push('diesel')
+    } catch {
+      // safe fallback
+    }
+  }
+
+  // 3. Python (pyproject.toml, requirements.txt)
+  const pyprojectPath = path.join(cwd, 'pyproject.toml')
+  const reqPath = path.join(cwd, 'requirements.txt')
+  if (fs.existsSync(pyprojectPath) || fs.existsSync(reqPath)) {
+    try {
+      const pyContent = (fs.existsSync(pyprojectPath) ? fs.readFileSync(pyprojectPath, 'utf8') : '') +
+        '\n' + (fs.existsSync(reqPath) ? fs.readFileSync(reqPath, 'utf8') : '')
+      stack.manifestFound = true
+      if (stack.primaryLanguage === 'unknown') stack.primaryLanguage = 'python'
+
+      if (pyContent.includes('fastapi')) stack.frameworks.push('fastapi')
+      if (pyContent.includes('django')) stack.frameworks.push('django')
+      if (pyContent.includes('flask')) stack.frameworks.push('flask')
+      if (pyContent.includes('pydantic')) stack.libraries.push('pydantic')
+      if (pyContent.includes('sqlalchemy')) stack.libraries.push('sqlalchemy')
+      if (pyContent.includes('pytest')) stack.libraries.push('pytest')
+      if (pyContent.includes('torch')) stack.libraries.push('pytorch')
+      if (pyContent.includes('pandas')) stack.libraries.push('pandas')
+    } catch {
+      // safe fallback
+    }
+  }
+
+  // 4. Go (go.mod)
+  const goModPath = path.join(cwd, 'go.mod')
+  if (fs.existsSync(goModPath)) {
+    try {
+      const goContent = fs.readFileSync(goModPath, 'utf8')
+      stack.manifestFound = true
+      if (stack.primaryLanguage === 'unknown') stack.primaryLanguage = 'go'
+
+      if (goContent.includes('gin-gonic/gin')) stack.frameworks.push('gin')
+      if (goContent.includes('gofiber/fiber')) stack.frameworks.push('fiber')
+      if (goContent.includes('labstack/echo')) stack.frameworks.push('echo')
+      if (goContent.includes('gorm.io/gorm')) stack.libraries.push('gorm')
+      if (goContent.includes('stretchr/testify')) stack.libraries.push('testify')
+    } catch {
+      // safe fallback
+    }
+  }
+
+  // Build summary string
+  const parts = []
+  if (stack.primaryLanguage !== 'unknown') parts.push(stack.primaryLanguage)
+  if (stack.frameworks.length > 0) parts.push(`framework: ${stack.frameworks.join(', ')}`)
+  if (stack.libraries.length > 0) parts.push(`libs: ${stack.libraries.slice(0, 4).join(', ')}`)
+  stack.stackSummary = parts.join(' | ')
+
+  return stack
+}
+
+/**
+ * Returns specialized domain personas based on detected stack.
+ *
+ * @param {object} stackInfo
+ * @returns {Array<string>} Array of specialized persona role descriptions
+ */
+export function getStackPersonaSpecialties(stackInfo = {}) {
+  const lang = stackInfo.primaryLanguage || 'unknown'
+  const frameworks = Array.isArray(stackInfo.frameworks) ? stackInfo.frameworks : []
+  const libs = Array.isArray(stackInfo.libraries) ? stackInfo.libraries : []
+
+  // React / Next.js / Frontend
+  if (frameworks.includes('react') || frameworks.includes('next.js') || frameworks.includes('vue') || frameworks.includes('svelte')) {
+    return [
+      'Component Architecture, Hooks & Re-render Optimization Specialist',
+      libs.includes('typescript') || lang === 'typescript'
+        ? 'TypeScript Strict Typing, Generic Invariants & Defensive Schema Expert'
+        : 'State Management, Data Flow & Edge-Case Specialist',
+      'Accessibility (a11y), Semantic UI & Modern CSS Performance Reviewer',
+    ]
+  }
+
+  // Python / FastAPI / Django
+  if (lang === 'python') {
+    return [
+      frameworks.includes('fastapi')
+        ? 'FastAPI Async Concurrency & High-Throughput REST Architect'
+        : 'Pythonic Clean Architecture & Idiomatic Object Design Specialist',
+      libs.includes('pydantic')
+        ? 'Pydantic V2 Schema Validation & Type-Safe Domain Modeler'
+        : 'Defensive Data Integrity & Error Boundary Engineer',
+      libs.includes('pytest')
+        ? 'Pytest Fixtures, Mocking & Comprehensive Edge-Case Test Engineer'
+        : 'Performance Profiling & Memory Leak Auditor',
+    ]
+  }
+
+  // Rust
+  if (lang === 'rust') {
+    return [
+      'Rust Zero-Cost Abstractions & Concurrency Architect',
+      'Rust Memory Safety, Error Handling & Lifetime Specialist',
+      'Rust Idiomatic API & Performance Specialist',
+    ]
+  }
+
+  // Go
+  if (lang === 'go') {
+    return [
+      'Go Idiomatic Concurrency & Channel Synchronization Architect',
+      'Go Interface Design, Error Wrapping & Zero-Allocation Specialist',
+      'Go Production Reliability & Table-Driven Unit Testing Specialist',
+    ]
+  }
+
+  // General TypeScript / Node
+  if (lang === 'typescript') {
+    return [
+      'TypeScript Strict Type Safety & Clean Architecture Specialist',
+      'Async Flow, Micro-Optimization & Error Boundary Engineer',
+      'Maintainability, Modularity & Test Coverage Auditor',
+    ]
+  }
+
+  // Universal Default
+  return [
+    'System Architecture & Core Correctness Engineer',
+    'Edge-Case Analysis & Defensive Error Handling Specialist',
+    'Clean Code, Maintainability & Documentation Specialist',
+  ]
+}
+
+/**
+ * Assigns stack-aware specialized personas to candidate proposer slots.
+ *
+ * @param {Array<object>} references - Proposer slots
+ * @param {object} stackInfo - Output of detectProjectStack
+ * @param {object} [options]
+ * @param {boolean} [options.enabled=true] - Whether stack-aware personas are enabled
+ * @returns {{ references: Array<object>, isSpecialized: boolean, stackSummary: string }}
+ */
+export function assignStackAwarePersonas(references = [], stackInfo = {}, options = {}) {
+  const { enabled = true } = options
+
+  if (!enabled || !Array.isArray(references) || references.length === 0) {
+    return {
+      references: Array.isArray(references) ? references : [],
+      isSpecialized: false,
+      stackSummary: stackInfo.stackSummary || '',
+    }
+  }
+
+  const specialties = getStackPersonaSpecialties(stackInfo)
+  const evolved = references.map((slot, idx) => {
+    // If user already specified a custom non-default persona, preserve it
+    const hasCustom = slot.role_persona && slot.role_persona !== 'general' && slot.role_persona !== 'proposer'
+    if (hasCustom) {
+      return { ...slot }
+    }
+
+    const specialty = specialties[idx % specialties.length]
+    return {
+      ...slot,
+      role_persona: specialty,
+      stackSpecialization: specialty,
+    }
+  })
+
+  return {
+    references: evolved,
+    isSpecialized: Boolean(stackInfo.manifestFound),
+    stackSummary: stackInfo.stackSummary || '',
+  }
+}
+
+/**
+ * Formats a directive summarizing the project stack for injection into judge or synthesis prompts.
+ *
+ * @param {object} stackInfo
+ * @returns {string|null}
+ */
+export function formatStackAwareDirective(stackInfo = {}) {
+  if (!stackInfo || !stackInfo.manifestFound || !stackInfo.stackSummary) {
+    return null
+  }
+
+  return `### Project Stack & Architecture Context
+- Detected Environment: ${stackInfo.stackSummary}
+- Verification Requirement: All proposals must adhere to the conventions and idiomatic idioms of this technology stack.`
+}

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].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')
+}