neuralos 3.9.4 → 3.9.6

package/plugins/numbat-bridge/numbat-bridge.extreme.spec.mjs

@@ -1,148 +0,0 @@
-import { register, resolveConfig, normalizeRecord, parseNdjson, buildDeployCommand } from './index.mjs'
-
-const cases = []
-function test(n, r) { cases.push({ name: n, run: r }) }
-function assert(c, m) { if (!c) throw new Error(m ?? 'assertion failed') }
-function eq(a, b, m) { if (a !== b) throw new Error(`${m ?? 'eq'}: expected ${JSON.stringify(b)}, got ${JSON.stringify(a)}`) }
-
-function mkCtx(settings = {}, extra = {}) {
-  const tools = new Map(); const triggers = []; const panels = []; const logs = []; const emitted = []
-  const ctx = {
-    settings: { numbat: settings },
-    registerTool: (t) => tools.set(t.name, t),
-    registerTrigger: (t) => triggers.push(t),
-    registerPanel: (p) => panels.push(p),
-    log: (l) => logs.push(l),
-    emitEvent: (e) => emitted.push(e),
-    ...extra,
-  }
-  return { tools, triggers, panels, logs, emitted, ctx }
-}
-
-const CFG = { minSeverity: 'low' }
-
-// ─── config ─────────────────────────────────────────────────────────────────
-
-test('resolveConfig defaults', () => {
-  const c = resolveConfig({ settings: {} }, {})
-  eq(c.binaryPath, 'numbat', 'default binary')
-  eq(c.minSeverity, 'low', 'default minSeverity')
-  eq(c.enabled, true, 'enabled default')
-  assert(c.recordsPath.includes('.numbat'), 'records path under ~/.numbat')
-})
-
-// ─── normalizeRecord ────────────────────────────────────────────────────────
-
-test('normalizeRecord maps a finding record', () => {
-  const rec = { record_type: 'finding', severity: 'high', rule_id: 'cloud-metadata', agent: 'codex', host: 'web-01', summary: 'metadata access' }
-  const n = normalizeRecord(rec, CFG)
-  eq(n.source, 'numbat', 'source')
-  eq(n.recordType, 'finding', 'type')
-  eq(n.severity, 'high', 'severity')
-  eq(n.ruleId, 'cloud-metadata', 'ruleId')
-  eq(n.agent, 'codex', 'agent')
-  eq(n.host, 'web-01', 'host')
-})
-
-test('normalizeRecord drops low-signal raw events (noise)', () => {
-  const rec = { record_type: 'event', severity: 'info', summary: 'routine' }
-  eq(normalizeRecord(rec, CFG), null, 'info event dropped')
-})
-
-test('normalizeRecord keeps high-severity events', () => {
-  const rec = { record_type: 'event', severity: 'critical', summary: 'metadata 169.254.169.254' }
-  const n = normalizeRecord(rec, CFG)
-  assert(n, 'critical event kept')
-  eq(n.severity, 'critical', 'severity')
-})
-
-test('normalizeRecord enforces minSeverity', () => {
-  const rec = { record_type: 'finding', severity: 'low', rule_id: 'x' }
-  eq(normalizeRecord(rec, { minSeverity: 'high' }), null, 'low finding below high threshold dropped')
-  assert(normalizeRecord(rec, { minSeverity: 'low' }), 'low finding at low threshold kept')
-})
-
-// ─── parseNdjson ────────────────────────────────────────────────────────────
-
-test('parseNdjson parses multiple records, skips malformed', () => {
-  const nd = [
-    JSON.stringify({ record_type: 'finding', severity: 'high', rule_id: 'r1', agent: 'codex' }),
-    'not json',
-    JSON.stringify({ record_type: 'event', severity: 'info' }),
-    JSON.stringify({ record_type: 'indicator', severity: 'medium', rule_id: 'r2' }),
-  ].join('\n')
-  const out = parseNdjson(nd, CFG)
-  eq(out.length, 2, 'two findings (finding + indicator; info event + malformed dropped)')
-  eq(out[0].ruleId, 'r1', 'first rule')
-  eq(out[1].recordType, 'indicator', 'second type')
-})
-
-// ─── buildDeployCommand ─────────────────────────────────────────────────────
-
-test('buildDeployCommand builds correct argv per action', () => {
-  eq(JSON.stringify(buildDeployCommand('inventory')), JSON.stringify(['agents']), 'inventory')
-  eq(JSON.stringify(buildDeployCommand('scan', { agent: 'codex' })), JSON.stringify(['scan', '--agent', 'codex']), 'scan')
-  eq(JSON.stringify(buildDeployCommand('install-monitor', { agent: 'codex' })), JSON.stringify(['hook', 'install', '--agent', 'codex', '--emit', 'all']), 'install-monitor')
-  const en = buildDeployCommand('install-enforce', { agent: 'codex', rulesDir: './policy' })
-  assert(en.includes('--enforce'), 'enforce flag')
-  assert(en.includes('--rules-dir'), 'rules-dir flag')
-  eq(JSON.stringify(buildDeployCommand('status', { agent: 'codex' })), JSON.stringify(['hook', 'status', '--agent', 'codex']), 'status')
-})
-
-test('buildDeployCommand throws on unknown action', () => {
-  let threw = false
-  try { buildDeployCommand('bogus') } catch { threw = true }
-  assert(threw, 'expected throw')
-})
-
-// ─── register wiring ────────────────────────────────────────────────────────
-
-test('register wires 4 tools, 1 trigger, 1 panel', () => {
-  const { tools, triggers, panels, ctx } = mkCtx()
-  register(ctx)
-  eq(tools.size, 4, 'tool count')
-  for (const n of ['numbat_health', 'numbat_deploy', 'numbat_ingest', 'numbat_findings_summary']) assert(tools.has(n), `missing ${n}`)
-  eq(triggers.length, 1, 'trigger count')
-  eq(triggers[0].name, 'numbat_finding', 'trigger name')
-  eq(panels.length, 1, 'panel count')
-})
-
-// ─── ingest → trigger ───────────────────────────────────────────────────────
-
-test('numbat_ingest normalizes + emits a trigger event per finding', async () => {
-  const { tools, emitted, ctx } = mkCtx()
-  register(ctx)
-  const nd = [
-    JSON.stringify({ record_type: 'finding', severity: 'high', rule_id: 'cloud-metadata', agent: 'codex', host: 'web-01' }),
-    JSON.stringify({ record_type: 'finding', severity: 'medium', rule_id: 'r2', agent: 'cursor' }),
-  ].join('\n')
-  const r = await tools.get('numbat_ingest').handler({ ndjson: nd })
-  eq(r.ingested, 2, 'ingested count')
-  eq(emitted.length, 2, 'emitted events')
-  eq(emitted[0].source, 'numbat', 'event source')
-  eq(emitted[0].ruleId, 'cloud-metadata', 'event ruleId')
-})
-
-// ─── trigger match ──────────────────────────────────────────────────────────
-
-test('numbat_finding trigger matches numbat-source medium+ severity', () => {
-  const { triggers, ctx } = mkCtx()
-  register(ctx)
-  const t = triggers[0]
-  assert(t.match({ source: 'numbat', severity: 'high' }), 'matches high')
-  assert(t.match({ source: 'numbat', severity: 'medium' }), 'matches medium')
-  assert(!t.match({ source: 'numbat', severity: 'low' }), 'rejects low')
-  assert(!t.match({ source: 'other', severity: 'high' }), 'rejects other source')
-})
-
-// ─── runner ─────────────────────────────────────────────────────────────────
-async function main() {
-  let pass = 0, fail = 0
-  for (const c of cases) {
-    try { await c.run(); pass++; console.log(`PASS ${c.name}`) }
-    catch (e) { fail++; console.log(`FAIL ${c.name}: ${e?.message ?? e}`) }
-  }
-  console.log(`\n${pass}/${pass + fail} passed, ${fail} failed`)
-  if (fail > 0) process.exit(1)
-}
-main()

package/plugins/numbat-bridge/plugin.json

@@ -1,21 +0,0 @@
-{
-  "name": "numbat-bridge",
-  "version": "1.0.0",
-  "description": "Numbat bridge for RTerm — deploy Numbat (endpoint AI-agent detection/EDR) to hosts, ingest its findings (NDJSON events/findings/enforcement/indicators), and fire RTerm triggers to auto-remediate (isolate host, kill agent, open incident, run playbook). Numbat detects; RTerm responds. Config in Settings (numbat block).",
-  "entry": "index.mjs",
-  "tools": [
-    "numbat_health",
-    "numbat_deploy",
-    "numbat_ingest",
-    "numbat_findings_summary"
-  ],
-  "triggers": [
-    "numbat_finding"
-  ],
-  "panels": [
-    "numbat-findings"
-  ],
-  "permissions": [
-    "exec"
-  ]
-}

package/plugins/patch-manager/index.d.mts

@@ -1,10 +0,0 @@
-// patch-manager plugin type declarations
-export function register(ctx: any): void
-export function buildPatchStatusCommand(os: string): string
-export function buildPatchApplyCommand(os: string, opts?: { severity?: string; dryRun?: boolean }): string
-export function buildPrePatchCheckCommand(os: string): string
-export function buildPostPatchCheckCommand(os: string): string
-export function parsePatchStatus(output: string | null | undefined, os: string | null | undefined): { patches: Array<{ id: string; title: string; severity: string; os: string }>; summary: { total: number; critical: number; security: number; recommended: number } }
-export function buildPatchPlan(host: string, os: string, patchStatus: any, opts?: { severity?: string }): any
-export function buildComplianceReport(hostStatuses: Record<string, any> | null | undefined): any
-export default any

package/plugins/patch-manager/index.mjs

@@ -1,288 +0,0 @@
-/**
- * patch-manager plugin — autonomous patch management for RTerm.
- *
- * Discovers patch status across hosts (yum/apt/Windows Update), plans patch
- * deployments, executes via playbooks with MOP approval gates, and alerts on
- * completion/failure. Combines RTerm's fleet orchestration, MOP change
- * management, triggers, and audit trail into an autonomous patch pipeline.
- */
-
-// --- Pure: build the command to query patch status on a host ---
-export function buildPatchStatusCommand(os) {
-  const o = String(os).toLowerCase()
-  if (o === 'windows' || o === 'win32') {
-    return 'powershell -Command "Get-WindowsUpdate -Verbose 2>&1 | Select-Object -First 50"'
-  }
-  if (o === 'linux' || o === 'darwin') {
-    // Try yum first, then apt
-    return '(yum check-update --quiet 2>/dev/null || apt list --upgradable 2>/dev/null) | head -50'
-  }
-  return 'echo "unsupported os: ' + o + '"'
-}
-
-// --- Pure: build the command to apply patches on a host ---
-export function buildPatchApplyCommand(os, opts = {}) {
-  const o = String(os).toLowerCase()
-  const severity = opts.severity ?? 'all' // all, critical, security, recommended
-  const dryRun = opts.dryRun ?? false
-
-  if (o === 'windows' || o === 'win32') {
-    const kbFilter = severity === 'critical' ? '-KBArticleID "KB*"' : ''
-    const dryRunFlag = dryRun ? '-WhatIf' : ''
-    return `powershell -Command "Install-WindowsUpdate ${kbFilter} ${dryRunFlag} -AcceptAll -AutoReboot:$false 2>&1"`
-  }
-  if (o === 'linux') {
-    if (severity === 'security') {
-      return dryRun
-        ? '(yum update --security --assumeno 2>/dev/null || apt-get -s upgrade --with-new-pkgs 2>/dev/null | grep -i security | head -20)'
-        : '(yum update --security -y 2>/dev/null || apt-get upgrade -y --with-new-pkgs 2>/dev/null) | tail -20'
-    }
-    return dryRun
-      ? '(yum update --assumeno 2>/dev/null || apt-get -s upgrade 2>/dev/null) | tail -20'
-      : '(yum update -y 2>/dev/null || apt-get upgrade -y 2>/dev/null) | tail -20'
-  }
-  return 'echo "unsupported os: ' + o + '"'
-}
-
-// --- Pure: build the pre-patch verification command ---
-export function buildPrePatchCheckCommand(os) {
-  const o = String(os).toLowerCase()
-  if (o === 'windows' || o === 'win32') {
-    return 'powershell -Command "Get-PSDrive -Name C | Select-Object Used,Free; Get-Service -Name wuauserv | Select-Object Status"'
-  }
-  if (o === 'linux') {
-    return 'df -h / | tail -1; systemctl is-system-running 2>/dev/null || true; uptime'
-  }
-  return 'echo "unsupported os: ' + o + '"'
-}
-
-// --- Pure: build the post-patch verification command ---
-export function buildPostPatchCheckCommand(os) {
-  const o = String(os).toLowerCase()
-  if (o === 'windows' || o === 'win32') {
-    return 'powershell -Command "Get-WindowsUpdate -Verbose 2>&1 | Select-Object -First 10; Get-Service -Name wuauserv | Select-Object Status"'
-  }
-  if (o === 'linux') {
-    return 'echo "post-patch check: system running"; uptime; df -h / | tail -1'
-  }
-  return 'echo "unsupported os: ' + o + '"'
-}
-
-// --- Pure: parse patch status output into structured results ---
-export function parsePatchStatus(output, os) {
-  const o = String(os ?? '').toLowerCase()
-  const lines = String(output ?? '').split(/\r?\n/).filter((l) => l.trim().length > 0)
-  const patches = []
-  let summary = { total: 0, critical: 0, security: 0, recommended: 0 }
-
-  for (const line of lines) {
-    const l = line.trim()
-    // Windows: KB article lines
-    const kbMatch = l.match(/(KB\d{7})/i)
-    if (kbMatch) {
-      patches.push({
-        id: kbMatch[1],
-        title: l.replace(/KB\d{7}/i, '').trim().slice(0, 80),
-        severity: l.match(/critical/i) ? 'critical' : l.match(/security/i) ? 'security' : 'recommended',
-        os: 'windows',
-      })
-      summary.total++
-      if (l.match(/critical/i)) summary.critical++
-      if (l.match(/security/i)) summary.security++
-      continue
-    }
-    // Linux yum: package.arch version repo
-    const yumMatch = l.match(/^(\S+)\.(\S+)\s+(\S+)\s+(\S+)/)
-    if (yumMatch && !l.startsWith('Loaded') && !l.startsWith('Last') && !l.startsWith('No')) {
-      patches.push({
-        id: yumMatch[1],
-        title: `${yumMatch[1]}.${yumMatch[2]} ${yumMatch[3]} (${yumMatch[4]})`,
-        severity: l.match(/security/i) ? 'security' : l.match(/critical/i) ? 'critical' : 'recommended',
-        os: 'linux',
-      })
-      summary.total++
-      if (l.match(/security/i)) summary.security++
-      if (l.match(/critical/i)) summary.critical++
-      continue
-    }
-    // Linux apt: package/version
-    const aptMatch = l.match(/^(\S+)\/(\S+)\s+(\S+)\s+(\S+)/)
-    if (aptMatch && !l.startsWith('Listing')) {
-      patches.push({
-        id: aptMatch[1],
-        title: `${aptMatch[1]}/${aptMatch[2]} ${aptMatch[3]} (${aptMatch[4]})`,
-        severity: l.match(/security/i) ? 'security' : l.match(/critical/i) ? 'critical' : 'recommended',
-        os: 'linux',
-      })
-      summary.total++
-      if (l.match(/security/i)) summary.security++
-      if (l.match(/critical/i)) summary.critical++
-    }
-  }
-
-  summary.recommended = summary.total - summary.critical - summary.security
-  return { patches, summary }
-}
-
-// --- Pure: build a patch plan from patch status ---
-export function buildPatchPlan(host, os, patchStatus, opts = {}) {
-  const severity = opts.severity ?? 'all'
-  const toApply = severity === 'all'
-    ? patchStatus.patches
-    : patchStatus.patches.filter((p) => p.severity === severity)
-
-  return {
-    host,
-    os,
-    patchesToApply: toApply.length,
-    patchIds: toApply.map((p) => p.id),
-    severity,
-    estimatedDowntimeMin: toApply.length * 2, // rough estimate
-    requiresReboot: os === 'windows' || toApply.some((p) => p.severity === 'critical'),
-    plan: [
-      { step: 1, name: 'pre-check', command: buildPrePatchCheckCommand(os), description: 'Verify system health before patching' },
-      { step: 2, name: 'backup', command: 'echo "snapshot/checkpoint before patch"', description: 'Create restore point' },
-      { step: 3, name: 'apply', command: buildPatchApplyCommand(os, { severity }), description: `Apply ${toApply.length} patches (${severity})` },
-      { step: 4, name: 'post-check', command: buildPostPatchCheckCommand(os), description: 'Verify patches applied successfully' },
-      { step: 5, name: 'rollback', command: 'echo "rollback if post-check fails"', description: 'Rollback on failure', onError: 'continue' },
-    ],
-  }
-}
-
-// --- Pure: build a compliance report for a fleet ---
-export function buildComplianceReport(hostStatuses) {
-  const hosts = Object.entries(hostStatuses ?? {}).map(([host, status]) => ({
-    host,
-    os: status.os ?? 'unknown',
-    totalPatches: status.summary?.total ?? 0,
-    criticalPatches: status.summary?.critical ?? 0,
-    securityPatches: status.summary?.security ?? 0,
-    compliant: (status.summary?.critical ?? 0) === 0 && (status.summary?.security ?? 0) === 0,
-  }))
-
-  const totalHosts = hosts.length
-  const compliantHosts = hosts.filter((h) => h.compliant).length
-  const nonCompliantHosts = totalHosts - compliantHosts
-  const totalCritical = hosts.reduce((s, h) => s + h.criticalPatches, 0)
-  const totalSecurity = hosts.reduce((s, h) => s + h.securityPatches, 0)
-
-  return {
-    hosts,
-    summary: {
-      totalHosts,
-      compliantHosts,
-      nonCompliantHosts,
-      complianceRate: totalHosts > 0 ? Math.round((compliantHosts / totalHosts) * 100) : 100,
-      totalCriticalPatches: totalCritical,
-      totalSecurityPatches: totalSecurity,
-    },
-  }
-}
-
-// --- Plugin entry ---
-export function register(ctx) {
-  const { registerTool, registerTrigger, registerPanel, exec, readLedger, log } = ctx
-
-  // Tool: patch_status — query patch status of a host
-  registerTool({
-    name: 'patch_status',
-    description: 'Query the current patch status of a host (available updates). Returns patch list with severity classification.',
-    params: {
-      host: { type: 'string', description: 'Host to query' },
-      os: { type: 'string', description: 'OS type: linux, windows, darwin' },
-    },
-    handler: async (params) => {
-      const { host, os } = params ?? {}
-      if (!host || !os) return { error: 'host and os are required' }
-      const cmd = buildPatchStatusCommand(os)
-      log(`[patch-manager] querying patch status on ${host} (${os})`)
-      const output = await exec(cmd, { host })
-      const result = parsePatchStatus(output, os)
-      return { host, os, ...result }
-    },
-  })
-
-  // Tool: patch_plan — build a patch deployment plan for a host
-  registerTool({
-    name: 'patch_plan',
-    description: 'Build a patch deployment plan for a host (pre-check → backup → apply → post-check → rollback). Returns the plan for MOP approval.',
-    params: {
-      host: { type: 'string', description: 'Host to plan for' },
-      os: { type: 'string', description: 'OS type' },
-      severity: { type: 'string', description: 'Patch severity filter: all, critical, security, recommended' },
-    },
-    handler: async (params) => {
-      const { host, os, severity = 'all' } = params ?? {}
-      if (!host || !os) return { error: 'host and os are required' }
-      // First get current status
-      const statusCmd = buildPatchStatusCommand(os)
-      const statusOutput = await exec(statusCmd, { host })
-      const patchStatus = parsePatchStatus(statusOutput, os)
-      const plan = buildPatchPlan(host, os, patchStatus, { severity })
-      log(`[patch-manager] built patch plan for ${host}: ${plan.patchesToApply} patches`)
-      return plan
-    },
-  })
-
-  // Tool: patch_apply — execute a patch plan on a host (runs as MOP change)
-  registerTool({
-    name: 'patch_apply',
-    description: 'Execute a patch deployment on a host. This is a destructive operation — requires MOP approval. Returns the execution result.',
-    params: {
-      host: { type: 'string', description: 'Host to patch' },
-      os: { type: 'string', description: 'OS type' },
-      severity: { type: 'string', description: 'Patch severity filter' },
-      dryRun: { type: 'boolean', description: 'If true, simulate only (no changes)' },
-    },
-    handler: async (params) => {
-      const { host, os, severity = 'all', dryRun = false } = params ?? {}
-      if (!host || !os) return { error: 'host and os are required' }
-      const applyCmd = buildPatchApplyCommand(os, { severity, dryRun })
-      log(`[patch-manager] ${dryRun ? 'simulating' : 'applying'} patches on ${host} (${severity})`)
-      const output = await exec(applyCmd, { host })
-      const postCheck = await exec(buildPostPatchCheckCommand(os), { host })
-      return { host, os, severity, dryRun, output: output.slice(0, 2000), postCheck: postCheck.slice(0, 500) }
-    },
-  })
-
-  // Trigger: patch_failure — fires when a patch execution fails
-  registerTrigger({
-    name: 'patch_failure',
-    description: 'Fires when a patch execution output contains error/failure indicators. Use for auto-remediation or investigation.',
-    match: (event) => {
-      if (event?.source !== 'playbook') return false
-      const detail = String(event?.detail ?? '').toLowerCase()
-      return detail.includes('error') || detail.includes('failed') || detail.includes('rollback')
-    },
-    action: 'propose-change',
-  })
-
-  // Trigger: patch_completion — fires when a patch execution completes successfully
-  registerTrigger({
-    name: 'patch_completion',
-    description: 'Fires when a patch execution completes without errors. Use for compliance reporting.',
-    match: (event) => {
-      if (event?.source !== 'playbook') return false
-      const detail = String(event?.detail ?? '').toLowerCase()
-      return detail.includes('success') || detail.includes('completed') || detail.includes('no packages marked for update')
-    },
-    action: 'run-playbook',
-  })
-
-  // Panel: patch-compliance — patch compliance dashboard
-  registerPanel({
-    name: 'patch-compliance',
-    title: 'Patch Compliance',
-    render: (data) => {
-      const report = buildComplianceReport(data ?? {})
-      const rows = report.hosts.map((h) =>
-        `<tr><td>${h.host}</td><td>${h.os}</td><td>${h.totalPatches}</td><td>${h.criticalPatches}</td><td>${h.securityPatches}</td><td>${h.compliant ? '✅' : '❌'}</td></tr>`
-      ).join('')
-      return `<div class="patch-compliance"><h3>Patch Compliance</h3><p>Compliance rate: ${report.summary.complianceRate}% (${report.summary.compliantHosts}/${report.summary.totalHosts} hosts)</p><p>Critical: ${report.summary.totalCriticalPatches} | Security: ${report.summary.totalSecurityPatches}</p><table><thead><tr><th>Host</th><th>OS</th><th>Total</th><th>Critical</th><th>Security</th><th>Compliant</th></tr></thead><tbody>${rows}</tbody></table></div>`
-    },
-  })
-
-  log('[patch-manager] registered: 3 tools, 2 triggers, 1 panel')
-}
-
-export default { register, buildPatchStatusCommand, buildPatchApplyCommand, buildPrePatchCheckCommand, buildPostPatchCheckCommand, parsePatchStatus, buildPatchPlan, buildComplianceReport }

package/plugins/patch-manager/plugin.json

@@ -1,10 +0,0 @@
-{
-  "name": "patch-manager",
-  "version": "1.0.0",
-  "description": "Autonomous patch management for RTerm — discover patch status across hosts, plan patch deployments, execute via playbooks with MOP approval gates, and alert on completion/failure. Supports Linux (yum/apt) and Windows (Get-WindowsUpdate).",
-  "entry": "index.mjs",
-  "tools": ["patch_status", "patch_plan", "patch_apply"],
-  "triggers": ["patch_failure", "patch_completion"],
-  "panels": ["patch-compliance"],
-  "permissions": ["exec", "readLedger:metrics", "readLedger:incidents"]
-}

package/plugins/promptfoo-redteam/index.d.mts

@@ -1,15 +0,0 @@
-// promptfoo-redteam plugin type declarations
-export function register(ctx: any): void
-export function buildPromptfooConfig(opts: {
-  providers: Array<{ name: string; model: string; baseUrl?: string; apiKeyRef?: string }>
-  tests: Array<{ vars: { prompt: string }; assert?: any[] }>
-  description?: string
-}): { description: string; prompts: string[]; providers: any[]; tests: any[] }
-export function builtinRedteamTests(): Array<{ description: string; vars: { prompt: string }; assert: any[] }>
-export function parsePromptfooResults(raw: unknown): {
-  summary: { total: number; passed: number; failed: number; errors: number; byProvider: Record<string, { total: number; passed: number; failed: number }> }
-  findings: Array<{ severity: string; category: string; provider: string; test: string; score: number; message: string }>
-  error?: string
-}
-export function redteamVerdict(summary: { total: number; passed?: number; failed?: number; errors?: number } | null | undefined): string
-export default any