feat: Hermes Zero-Day Research Engine - 9 new modules + UI tab

hermes_orchestrator, fuzzing_engine, symbolic_engine, taint_analyzer, cve_intel, commit_watcher, exploit_primitives, bounty_gateway, vuln_classifier + adversarial_reviewer upgraded to R1/Llama3.3/Gemma3 + Hermes tab in app.py

adversarial_reviewer.py

@@ -22,10 +22,10 @@ OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
 
 ADVERSARY_MODEL_PRIMARY = os.getenv(
     "RHODAWK_ADVERSARY_MODEL",
-    "openrouter/qwen/qwen-2.5-7b-instruct:free"
+    "deepseek/deepseek-r1:free"
 )
-ADVERSARY_MODEL_SECONDARY = "openrouter/google/gemma-2-9b-it:free"
-ADVERSARY_MODEL_TERTIARY  = "openrouter/mistralai/mistral-7b-instruct:free"
+ADVERSARY_MODEL_SECONDARY = "meta-llama/llama-3.3-70b-instruct:free"
+ADVERSARY_MODEL_TERTIARY  = "google/gemma-3-27b-it:free"
 
 _MODEL_CHAIN = [
     ADVERSARY_MODEL_PRIMARY,

app.py

@@ -35,6 +35,15 @@ from git import Repo
 from tenacity import retry, stop_after_attempt, wait_exponential
 
 from adversarial_reviewer import run_adversarial_review
+from hermes_orchestrator import (
+    run_hermes_research, get_hermes_logs, get_session_summary,
+    compute_ves, build_tvg,
+)
+from bounty_gateway import (
+    get_pipeline, get_pipeline_summary, human_approve, human_reject,
+    submit_to_hackerone, submit_github_advisory, add_to_pipeline,
+)
+from vuln_classifier import classify_vulnerability, get_all_cwes
 from audit_logger import export_compliance_report, log_audit_event, read_audit_trail, verify_chain_integrity
 from conviction_engine import evaluate_conviction, auto_merge_pr
 from formal_verifier import run_formal_verification
@@ -1374,6 +1383,151 @@ def reject_disclosure_fn(disclosure_id: str) -> str:
         return f"Error: {e}"
 
 
+# ──────────────────────────────────────────────────────────────
+# HERMES ORCHESTRATOR HELPERS
+# ──────────────────────────────────────────────────────────────
+
+_hermes_sessions: dict = {}
+_hermes_active_session_id: str = ""
+_hermes_running = threading.Event()
+
+
+def _hermes_run_background(
+    target_repo: str,
+    repo_dir: str,
+    focus_area: str,
+    max_iterations: int,
+) -> None:
+    global _hermes_active_session_id
+    _hermes_running.set()
+    try:
+        session = run_hermes_research(
+            target_repo=target_repo,
+            repo_dir=repo_dir,
+            focus_area=focus_area,
+            max_iterations=int(max_iterations),
+        )
+        _hermes_sessions[session.session_id] = session
+        _hermes_active_session_id = session.session_id
+
+        for finding in session.findings:
+            add_to_pipeline(
+                finding_id=finding.finding_id,
+                title=finding.title,
+                description=finding.description,
+                proof_of_concept=finding.proof_of_concept,
+                target_repo=target_repo,
+                cwe_id=finding.cwe_id,
+                severity=finding.severity,
+                estimated_cvss=round(finding.ves_score, 1),
+                bounty_tier="P1" if finding.ves_score >= 8 else "P2" if finding.ves_score >= 5 else "P3",
+                exploit_class=finding.exploit_primitive,
+            )
+    finally:
+        _hermes_running.clear()
+
+
+def hermes_start_research(
+    target_repo: str, local_path: str, focus_area: str, max_iter: str
+) -> str:
+    if _hermes_running.is_set():
+        return "⚠️ Hermes is already running a research session. Wait for it to complete."
+    if not target_repo.strip():
+        return "❌ Target repository is required (e.g. owner/repo)"
+
+    repo_dir = local_path.strip() or f"/data/repo/{target_repo.split('/')[-1]}"
+    if not os.path.isdir(repo_dir):
+        return f"❌ Local path not found: {repo_dir}\nClone the repo first using the main Audit tab."
+
+    t = threading.Thread(
+        target=_hermes_run_background,
+        args=(target_repo.strip(), repo_dir, focus_area.strip(), max_iter or 15),
+        daemon=True, name="hermes-research",
+    )
+    t.start()
+    return (
+        f"🧠 Hermes started on {target_repo}\n"
+        f"Focus: {focus_area or 'Full autonomous scan'}\n"
+        f"Max iterations: {max_iter}\n\n"
+        "Watch the live logs below. Findings will appear in the Disclosure Pipeline tab."
+    )
+
+
+def hermes_get_live_logs() -> str:
+    logs = get_hermes_logs()
+    status = "🔄 RUNNING" if _hermes_running.is_set() else "⏸ IDLE"
+    header = f"[HERMES STATUS: {status}]\n{'─' * 50}\n"
+    return header + "\n".join(logs[-80:]) if logs else header + "No logs yet."
+
+
+def hermes_get_session_summary() -> str:
+    if not _hermes_active_session_id:
+        return "No session completed yet."
+    session = _hermes_sessions.get(_hermes_active_session_id)
+    if not session:
+        return "Session not found."
+    summary = get_session_summary(session)
+    lines = [
+        f"Session: {summary['session_id']}",
+        f"Target: {summary['target']}",
+        f"Phase: {summary['phase']}",
+        f"Started: {summary['started_at']}",
+        f"Completed: {summary.get('completed_at', 'in progress')}",
+        f"Total findings: {summary['total_findings']}",
+        f"By severity: {summary['by_severity']}",
+        f"Tool calls: {summary['tool_calls']}",
+        f"Attack surface sinks: {summary['attack_surface_size']}",
+        "",
+        "TOP FINDINGS (by VES score):",
+    ]
+    for f in summary["top_findings"]:
+        lines.append(
+            f"  [{f['severity']}] {f['title'][:60]}\n"
+            f"    CWE: {f['cwe']} | VES: {f['ves']} | ACTS: {f['acts']}\n"
+            f"    File: {f['file']} | Status: {f['status']}"
+        )
+    return "\n".join(lines)
+
+
+def hermes_get_pipeline_display() -> str:
+    return get_pipeline_summary()
+
+
+def hermes_approve_finding(record_id: str, notes: str) -> str:
+    if not record_id.strip():
+        return "❌ Record ID required"
+    result = human_approve(record_id.strip(), notes.strip())
+    return f"✅ Finding {record_id} approved.\n{result}"
+
+
+def hermes_reject_finding(record_id: str, notes: str) -> str:
+    if not record_id.strip():
+        return "❌ Record ID required"
+    result = human_reject(record_id.strip(), notes.strip())
+    return f"❌ Finding {record_id} rejected.\n{result}"
+
+
+def hermes_submit_hackerone(record_id: str) -> str:
+    if not record_id.strip():
+        return "❌ Record ID required"
+    result = submit_to_hackerone(record_id.strip())
+    if result.get("success"):
+        return f"✅ Submitted to HackerOne: {result.get('url')}"
+    return f"❌ Submission failed: {result.get('error')}"
+
+
+def hermes_submit_github(record_id: str, owner_repo: str) -> str:
+    if not record_id.strip() or not owner_repo.strip():
+        return "❌ Record ID and owner/repo required"
+    parts = owner_repo.strip().split("/")
+    if len(parts) != 2:
+        return "❌ Format must be owner/repo"
+    result = submit_github_advisory(record_id.strip(), parts[0], parts[1])
+    if result.get("success"):
+        return f"✅ GitHub Advisory created: {result.get('url')}"
+    return f"❌ Submission failed: {result.get('error')}"
+
+
 # ──────────────────────────────────────────────────────────────
 # GRADIO ENTERPRISE DASHBOARD
 # ──────────────────────────────────────────────────────────────
@@ -1802,13 +1956,134 @@ Approved disclosures generate a message you send manually via the maintainer's s
                     )
                     sr_reject_btn.click(reject_disclosure_fn, inputs=sr_did, outputs=sr_approval_out)
 
+        # ── HERMES AI SECURITY RESEARCHER TAB ──────────────────────
+        with gr.Tab("🧠 Hermes Zero-Day"):
+            gr.Markdown("""
+# Hermes — Autonomous Zero-Day Research Engine
+
+Hermes is your AI security researcher. Point it at any open source project and it will:
+- **Map the attack surface** (entry points, dangerous sinks, security-critical files)
+- **Run taint analysis** to trace untrusted input to dangerous sinks
+- **Perform symbolic execution** to find unchecked code paths
+- **Generate and run fuzz campaigns** to find crashes
+- **Reason about exploitability** (CVSS, PoC generation)
+- **Score findings** with VES (Vulnerability Entropy Score) + ACTS (Adversarial Consensus)
+
+**ALL findings require human approval before any disclosure is sent.**
+""")
+            with gr.Tabs():
+                with gr.Tab("🚀 Launch Research"):
+                    gr.Markdown("### Start an autonomous security research session")
+                    with gr.Row():
+                        hermes_repo     = gr.Textbox(label="Target Repository (owner/repo)", placeholder="torvalds/linux", scale=2)
+                        hermes_path     = gr.Textbox(label="Local Clone Path", placeholder="/data/repo/linux", scale=2)
+                    hermes_focus    = gr.Textbox(
+                        label="Focus Area (optional)",
+                        placeholder="memory management subsystem, authentication middleware, crypto primitives...",
+                    )
+                    with gr.Row():
+                        hermes_max_iter = gr.Slider(minimum=5, maximum=30, value=15, step=1, label="Max Research Iterations")
+                        hermes_launch   = gr.Button("🧠 Launch Hermes", variant="primary", scale=1)
+                    hermes_launch_out = gr.Textbox(label="Status", interactive=False, lines=5)
+                    hermes_launch.click(
+                        hermes_start_research,
+                        inputs=[hermes_repo, hermes_path, hermes_focus, hermes_max_iter],
+                        outputs=hermes_launch_out,
+                    )
+
+                with gr.Tab("📡 Live Research Logs"):
+                    hermes_live_logs = gr.TextArea(
+                        label="Hermes Research Log (auto-refreshes)",
+                        lines=30, interactive=False,
+                    )
+                    gr.Button("🔄 Refresh Logs", variant="secondary").click(
+                        hermes_get_live_logs, outputs=hermes_live_logs
+                    )
+
+                with gr.Tab("📊 Session Summary"):
+                    hermes_summary_out = gr.TextArea(label="Last Session Summary", lines=25, interactive=False)
+                    gr.Button("📊 Get Summary", variant="secondary").click(
+                        hermes_get_session_summary, outputs=hermes_summary_out
+                    )
+
+                with gr.Tab("🔒 Disclosure Pipeline"):
+                    gr.Markdown("""
+### Human-Approval Gate
+
+All findings sit here as **PENDING_HUMAN_APPROVAL** until you explicitly approve them.
+Hermes never auto-submits. You review, then approve or reject each finding individually.
+After approval, you can submit to HackerOne or create a GitHub Security Advisory.
+
+**90-day disclosure countdown starts on approval.**
+""")
+                    hermes_pipeline_out = gr.TextArea(label="Pipeline Status", lines=12, interactive=False)
+                    gr.Button("🔄 Refresh Pipeline", variant="secondary").click(
+                        hermes_get_pipeline_display, outputs=hermes_pipeline_out
+                    )
+
+                    gr.HTML("<hr/>")
+                    gr.Markdown("#### Review & Approve/Reject a Finding")
+                    with gr.Row():
+                        hermes_record_id = gr.Textbox(label="Record ID", scale=2)
+                        hermes_notes     = gr.Textbox(label="Analyst Notes", scale=3)
+                    with gr.Row():
+                        hermes_approve_btn = gr.Button("✅ Approve Finding", variant="primary")
+                        hermes_reject_btn  = gr.Button("❌ Reject Finding", variant="secondary")
+                    hermes_approval_out = gr.Textbox(label="Result", interactive=False)
+                    hermes_approve_btn.click(
+                        hermes_approve_finding,
+                        inputs=[hermes_record_id, hermes_notes],
+                        outputs=hermes_approval_out,
+                    )
+                    hermes_reject_btn.click(
+                        hermes_reject_finding,
+                        inputs=[hermes_record_id, hermes_notes],
+                        outputs=hermes_approval_out,
+                    )
+
+                    gr.HTML("<hr/>")
+                    gr.Markdown("#### Submit Approved Finding (requires credentials in env vars)")
+                    with gr.Row():
+                        hermes_submit_record = gr.Textbox(label="Approved Record ID", scale=2)
+                        hermes_gh_repo       = gr.Textbox(label="GitHub owner/repo (for GHSA)", placeholder="torvalds/linux", scale=2)
+                    with gr.Row():
+                        hermes_h1_btn  = gr.Button("🎯 Submit to HackerOne", variant="primary")
+                        hermes_gh_btn  = gr.Button("🐙 Create GitHub Advisory", variant="secondary")
+                    hermes_submit_out = gr.Textbox(label="Submission Result", interactive=False)
+                    hermes_h1_btn.click(
+                        hermes_submit_hackerone,
+                        inputs=[hermes_submit_record],
+                        outputs=hermes_submit_out,
+                    )
+                    hermes_gh_btn.click(
+                        hermes_submit_github,
+                        inputs=[hermes_submit_record, hermes_gh_repo],
+                        outputs=hermes_submit_out,
+                    )
+
+                with gr.Tab("📚 CWE Reference"):
+                    gr.Markdown("### CWE Taxonomy — Coverage Map")
+                    cwe_table_data = [
+                        [c["cwe_id"], c["name"], c["category"], c["severity"],
+                         str(c["cvss_base"]), c.get("owasp", "")]
+                        for c in get_all_cwes()
+                    ]
+                    gr.Dataframe(
+                        value=cwe_table_data,
+                        headers=["CWE ID", "Name", "Category", "Severity", "CVSS", "OWASP"],
+                        interactive=False,
+                    )
+
     # ── AUTO-REFRESH ────────────────────────────────────────────
     timer = gr.Timer(3)
-    timer.tick(get_live_logs,   outputs=live_logs)
-    timer.tick(get_metrics_row, outputs=[stat_status, stat_total, stat_done, stat_prs, stat_failed, stat_sast])
+    timer.tick(get_live_logs,       outputs=live_logs)
+    timer.tick(get_metrics_row,     outputs=[stat_status, stat_total, stat_done, stat_prs, stat_failed, stat_sast])
+    timer.tick(hermes_get_live_logs, outputs=hermes_live_logs)
 
     demo.load(get_live_logs,            outputs=live_logs)
     demo.load(get_metrics_row,          outputs=[stat_status, stat_total, stat_done, stat_prs, stat_failed, stat_sast])
+    demo.load(hermes_get_live_logs,     outputs=hermes_live_logs)
+    demo.load(hermes_get_pipeline_display, outputs=hermes_pipeline_out)
     demo.load(get_job_table,            outputs=job_table)
     demo.load(get_audit_display,        outputs=audit_log)
     demo.load(get_chain_integrity_display, outputs=chain_status)

bounty_gateway.py

@@ -0,0 +1,398 @@
+"""
+Rhodawk AI — Bug Bounty Gateway (Human-Approval Required)
+==========================================================
+Manages the responsible disclosure pipeline to:
+  - HackerOne (REST API v1)
+  - Bugcrowd (JSON API)
+  - GitHub Security Advisories (GHSA)
+  - Direct maintainer email (coordinated disclosure)
+
+CRITICAL DESIGN PRINCIPLE:
+  NOTHING is submitted without explicit human approval.
+  All findings sit in PENDING_HUMAN_APPROVAL state until a human clicks
+  the "Approve & Submit" button in the Gradio UI. The approval gate is
+  enforced at the API call level, not just the UI level.
+
+Disclosure timeline follows Google Project Zero standard (90 days).
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sqlite3
+import time
+from dataclasses import dataclass, field, asdict
+from enum import Enum
+from typing import Optional
+
+import requests
+
+HACKERONE_API_KEY     = os.getenv("HACKERONE_API_KEY", "")
+HACKERONE_USERNAME    = os.getenv("HACKERONE_USERNAME", "")
+HACKERONE_PROGRAM     = os.getenv("HACKERONE_PROGRAM", "")
+BUGCROWD_API_KEY      = os.getenv("BUGCROWD_API_KEY", "")
+BUGCROWD_PROGRAM_URL  = os.getenv("BUGCROWD_PROGRAM_URL", "")
+GITHUB_TOKEN          = os.getenv("GITHUB_TOKEN", "")
+
+DISCLOSURE_DB = os.getenv("RHODAWK_DISCLOSURE_DB", "/data/disclosure_pipeline.db")
+DISCLOSURE_WINDOW_DAYS = int(os.getenv("RHODAWK_DISCLOSURE_DAYS", "90"))
+
+
+class DisclosureStatus(str, Enum):
+    PENDING_HUMAN_APPROVAL = "PENDING_HUMAN_APPROVAL"
+    HUMAN_APPROVED         = "HUMAN_APPROVED"
+    HUMAN_REJECTED         = "HUMAN_REJECTED"
+    SUBMITTED_HACKERONE    = "SUBMITTED_HACKERONE"
+    SUBMITTED_BUGCROWD     = "SUBMITTED_BUGCROWD"
+    SUBMITTED_GITHUB_GHSA  = "SUBMITTED_GITHUB_GHSA"
+    SUBMITTED_DIRECT       = "SUBMITTED_DIRECT"
+    DUPLICATE              = "DUPLICATE"
+    NOT_A_BUG              = "NOT_A_BUG"
+    FIXED_BY_VENDOR        = "FIXED_BY_VENDOR"
+
+
+@dataclass
+class DisclosureRecord:
+    record_id: str
+    finding_id: str
+    title: str
+    description: str
+    proof_of_concept: str
+    target_repo: str
+    cwe_id: str
+    severity: str
+    estimated_cvss: float
+    bounty_tier: str
+    exploit_class: str
+    status: DisclosureStatus = DisclosureStatus.PENDING_HUMAN_APPROVAL
+    platform: str = "none"
+    submission_url: str = ""
+    bounty_received: float = 0.0
+    created_at: str = field(default_factory=lambda: time.strftime("%Y-%m-%dT%H:%M:%SZ"))
+    approved_at: str = ""
+    submitted_at: str = ""
+    deadline: str = ""
+    human_notes: str = ""
+    cve_draft: dict = field(default_factory=dict)
+
+
+def _init_db():
+    os.makedirs(os.path.dirname(DISCLOSURE_DB), exist_ok=True)
+    conn = sqlite3.connect(DISCLOSURE_DB)
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS disclosure_records (
+            record_id TEXT PRIMARY KEY,
+            finding_id TEXT,
+            title TEXT,
+            description TEXT,
+            proof_of_concept TEXT,
+            target_repo TEXT,
+            cwe_id TEXT,
+            severity TEXT,
+            estimated_cvss REAL,
+            bounty_tier TEXT,
+            exploit_class TEXT,
+            status TEXT,
+            platform TEXT,
+            submission_url TEXT,
+            bounty_received REAL,
+            created_at TEXT,
+            approved_at TEXT,
+            submitted_at TEXT,
+            deadline TEXT,
+            human_notes TEXT,
+            cve_draft TEXT
+        )
+    """)
+    conn.commit()
+    conn.close()
+
+
+_init_db()
+
+
+def add_to_pipeline(
+    finding_id: str,
+    title: str,
+    description: str,
+    proof_of_concept: str,
+    target_repo: str,
+    cwe_id: str,
+    severity: str,
+    estimated_cvss: float,
+    bounty_tier: str,
+    exploit_class: str,
+    cve_draft: dict = None,
+) -> DisclosureRecord:
+    """Add a new finding to the disclosure pipeline. Status = PENDING_HUMAN_APPROVAL."""
+    record_id = hashlib.sha256(f"{finding_id}{time.time()}".encode()).hexdigest()[:16]
+    deadline = time.strftime(
+        "%Y-%m-%dT%H:%M:%SZ",
+        time.gmtime(time.time() + DISCLOSURE_WINDOW_DAYS * 86400)
+    )
+    record = DisclosureRecord(
+        record_id=record_id,
+        finding_id=finding_id,
+        title=title,
+        description=description,
+        proof_of_concept=proof_of_concept,
+        target_repo=target_repo,
+        cwe_id=cwe_id,
+        severity=severity,
+        estimated_cvss=estimated_cvss,
+        bounty_tier=bounty_tier,
+        exploit_class=exploit_class,
+        deadline=deadline,
+        cve_draft=cve_draft or {},
+    )
+    _save_record(record)
+    print(f"[DISCLOSURE] Added to pipeline: {record_id} — Status: PENDING_HUMAN_APPROVAL")
+    return record
+
+
+def _save_record(record: DisclosureRecord):
+    conn = sqlite3.connect(DISCLOSURE_DB)
+    conn.execute("""
+        INSERT OR REPLACE INTO disclosure_records VALUES (
+            ?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?
+        )
+    """, (
+        record.record_id, record.finding_id, record.title, record.description,
+        record.proof_of_concept, record.target_repo, record.cwe_id, record.severity,
+        record.estimated_cvss, record.bounty_tier, record.exploit_class,
+        record.status.value, record.platform, record.submission_url,
+        record.bounty_received, record.created_at, record.approved_at,
+        record.submitted_at, record.deadline, record.human_notes,
+        json.dumps(record.cve_draft),
+    ))
+    conn.commit()
+    conn.close()
+
+
+def get_pipeline(status_filter: str = None) -> list[dict]:
+    """Get all records in the pipeline, optionally filtered by status."""
+    conn = sqlite3.connect(DISCLOSURE_DB)
+    if status_filter:
+        rows = conn.execute(
+            "SELECT * FROM disclosure_records WHERE status=? ORDER BY created_at DESC",
+            (status_filter,)
+        ).fetchall()
+    else:
+        rows = conn.execute(
+            "SELECT * FROM disclosure_records ORDER BY created_at DESC"
+        ).fetchall()
+    conn.close()
+
+    columns = [
+        "record_id", "finding_id", "title", "description", "proof_of_concept",
+        "target_repo", "cwe_id", "severity", "estimated_cvss", "bounty_tier",
+        "exploit_class", "status", "platform", "submission_url", "bounty_received",
+        "created_at", "approved_at", "submitted_at", "deadline", "human_notes", "cve_draft",
+    ]
+    return [dict(zip(columns, row)) for row in rows]
+
+
+def human_approve(record_id: str, notes: str = "") -> dict:
+    """
+    Human approval gate — must be called before any submission attempt.
+    Updates status to HUMAN_APPROVED. Still does not submit.
+    """
+    conn = sqlite3.connect(DISCLOSURE_DB)
+    conn.execute(
+        "UPDATE disclosure_records SET status=?, approved_at=?, human_notes=? WHERE record_id=?",
+        (DisclosureStatus.HUMAN_APPROVED.value,
+         time.strftime("%Y-%m-%dT%H:%M:%SZ"), notes, record_id)
+    )
+    conn.commit()
+    conn.close()
+    print(f"[DISCLOSURE] HUMAN APPROVED: {record_id}")
+    return {"status": "approved", "record_id": record_id, "notes": notes}
+
+
+def human_reject(record_id: str, notes: str = "") -> dict:
+    """Human rejection — finding is closed without disclosure."""
+    conn = sqlite3.connect(DISCLOSURE_DB)
+    conn.execute(
+        "UPDATE disclosure_records SET status=?, human_notes=? WHERE record_id=?",
+        (DisclosureStatus.HUMAN_REJECTED.value, notes, record_id)
+    )
+    conn.commit()
+    conn.close()
+    print(f"[DISCLOSURE] HUMAN REJECTED: {record_id} — {notes}")
+    return {"status": "rejected", "record_id": record_id}
+
+
+def submit_to_hackerone(record_id: str) -> dict:
+    """
+    Submit an APPROVED finding to HackerOne.
+    REQUIRES human_approve() to have been called first.
+    """
+    records = get_pipeline()
+    record = next((r for r in records if r["record_id"] == record_id), None)
+    if not record:
+        return {"error": f"Record {record_id} not found"}
+
+    if record["status"] != DisclosureStatus.HUMAN_APPROVED.value:
+        return {
+            "error": f"BLOCKED: Record status is '{record['status']}'. "
+                     f"Human approval required before submission. "
+                     f"Call human_approve('{record_id}') first."
+        }
+
+    if not HACKERONE_API_KEY or not HACKERONE_USERNAME or not HACKERONE_PROGRAM:
+        return {
+            "error": "HackerOne credentials not configured. "
+                     "Set HACKERONE_API_KEY, HACKERONE_USERNAME, HACKERONE_PROGRAM env vars."
+        }
+
+    payload = {
+        "data": {
+            "type": "report",
+            "attributes": {
+                "title": record["title"],
+                "vulnerability_information": (
+                    f"## Description\n{record['description']}\n\n"
+                    f"## Proof of Concept\n```\n{record['proof_of_concept']}\n```\n\n"
+                    f"## CWE\n{record['cwe_id']}\n\n"
+                    f"## Severity\n{record['severity']} (CVSS: {record['estimated_cvss']})\n\n"
+                    f"*Generated by Rhodawk AI Security Research Engine — "
+                    f"human-verified before submission*"
+                ),
+                "impact": (
+                    f"Estimated severity: {record['severity']}\n"
+                    f"Exploit class: {record['exploit_class']}\n"
+                    f"Bounty tier estimate: {record['bounty_tier']}"
+                ),
+                "severity_rating": {
+                    "CRITICAL": "critical", "HIGH": "high",
+                    "MEDIUM": "medium", "LOW": "low",
+                }.get(record["severity"], "medium"),
+            },
+            "relationships": {
+                "program": {"data": {"type": "program", "attributes": {"handle": HACKERONE_PROGRAM}}}
+            }
+        }
+    }
+
+    try:
+        resp = requests.post(
+            "https://api.hackerone.com/v1/hackers/reports",
+            auth=(HACKERONE_USERNAME, HACKERONE_API_KEY),
+            json=payload,
+            timeout=30,
+        )
+        if resp.status_code in (200, 201):
+            data = resp.json()
+            report_url = f"https://hackerone.com/reports/{data['data']['id']}"
+            conn = sqlite3.connect(DISCLOSURE_DB)
+            conn.execute(
+                "UPDATE disclosure_records SET status=?, platform=?, submission_url=?, submitted_at=? WHERE record_id=?",
+                (DisclosureStatus.SUBMITTED_HACKERONE.value, "hackerone", report_url,
+                 time.strftime("%Y-%m-%dT%H:%M:%SZ"), record_id)
+            )
+            conn.commit()
+            conn.close()
+            return {"success": True, "platform": "hackerone", "url": report_url}
+        else:
+            return {"error": f"HackerOne API error {resp.status_code}: {resp.text[:500]}"}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def submit_github_advisory(record_id: str, repo_owner: str, repo_name: str) -> dict:
+    """
+    Submit an APPROVED finding as a GitHub Security Advisory (GHSA).
+    Requires GitHub token with security_events scope.
+    """
+    records = get_pipeline()
+    record = next((r for r in records if r["record_id"] == record_id), None)
+    if not record:
+        return {"error": f"Record {record_id} not found"}
+
+    if record["status"] != DisclosureStatus.HUMAN_APPROVED.value:
+        return {"error": f"BLOCKED: Human approval required. Status: {record['status']}"}
+
+    if not GITHUB_TOKEN:
+        return {"error": "GITHUB_TOKEN not set"}
+
+    severity_map = {"CRITICAL": "critical", "HIGH": "high", "MEDIUM": "medium", "LOW": "low"}
+
+    payload = {
+        "summary": record["title"],
+        "description": (
+            f"{record['description']}\n\n"
+            f"**Proof of Concept:**\n```\n{record['proof_of_concept']}\n```\n\n"
+            f"*Discovered by Rhodawk AI Security Research Engine — human-verified*"
+        ),
+        "severity": severity_map.get(record["severity"], "medium"),
+        "cwe_ids": [record["cwe_id"]] if record["cwe_id"] != "CWE-UNKNOWN" else [],
+        "vulnerabilities": [
+            {"package": {"ecosystem": "other", "name": repo_name},
+             "vulnerable_version_range": "*"}
+        ],
+    }
+
+    try:
+        resp = requests.post(
+            f"https://api.github.com/repos/{repo_owner}/{repo_name}/security-advisories",
+            headers={
+                "Authorization": f"Bearer {GITHUB_TOKEN}",
+                "Accept": "application/vnd.github+json",
+                "X-GitHub-API-Version": "2022-11-28",
+            },
+            json=payload,
+            timeout=30,
+        )
+        if resp.status_code in (200, 201):
+            data = resp.json()
+            advisory_url = data.get("html_url", "")
+            conn = sqlite3.connect(DISCLOSURE_DB)
+            conn.execute(
+                "UPDATE disclosure_records SET status=?, platform=?, submission_url=?, submitted_at=? WHERE record_id=?",
+                (DisclosureStatus.SUBMITTED_GITHUB_GHSA.value, "github_ghsa", advisory_url,
+                 time.strftime("%Y-%m-%dT%H:%M:%SZ"), record_id)
+            )
+            conn.commit()
+            conn.close()
+            return {"success": True, "platform": "github_ghsa", "url": advisory_url}
+        else:
+            return {"error": f"GitHub API error {resp.status_code}: {resp.text[:500]}"}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def get_pipeline_summary() -> str:
+    """Human-readable pipeline summary for the Gradio dashboard."""
+    records = get_pipeline()
+    if not records:
+        return "No findings in disclosure pipeline yet."
+
+    pending = [r for r in records if r["status"] == "PENDING_HUMAN_APPROVAL"]
+    approved = [r for r in records if r["status"] == "HUMAN_APPROVED"]
+    submitted = [r for r in records if "SUBMITTED" in r["status"]]
+    rejected = [r for r in records if r["status"] == "HUMAN_REJECTED"]
+
+    lines = [
+        f"Disclosure Pipeline — {len(records)} total finding(s)\n",
+        f"  ⏳ Pending human approval : {len(pending)}",
+        f"  ✅ Human approved         : {len(approved)}",
+        f"  📤 Submitted              : {len(submitted)}",
+        f"  ❌ Rejected               : {len(rejected)}",
+        "",
+    ]
+    for r in sorted(records, key=lambda x: x["estimated_cvss"], reverse=True)[:5]:
+        days_left = ""
+        if r.get("deadline"):
+            try:
+                deadline_ts = time.mktime(time.strptime(r["deadline"][:19], "%Y-%m-%dT%H:%M:%S"))
+                days = int((deadline_ts - time.time()) / 86400)
+                days_left = f" ({days}d left)"
+            except Exception:
+                pass
+        lines.append(
+            f"  [{r['bounty_tier']}] {r['title'][:60]} | "
+            f"CVSS:{r['estimated_cvss']} | {r['status']}{days_left}"
+        )
+    return "\n".join(lines)

commit_watcher.py

@@ -0,0 +1,339 @@
+"""
+Rhodawk AI — Commit Watcher + CAD Algorithm
+============================================
+Monitors GitHub repository commit streams for:
+  1. Silent security patches (fixes without CVE mention)
+  2. Regression introductions (commits that break previously safe invariants)
+  3. Dependency bumps that change security-relevant code
+
+Custom Algorithm: CAD (Commit Anomaly Detection)
+  Uses statistical analysis of commit metadata + diff content to score
+  how "suspicious" a commit is from a security perspective.
+  High CAD score = likely silent security fix = potential unpatched vuln in older versions.
+
+CAD Score Components:
+  - keyword_score: security-related words in commit message (without CVE/advisory mention)
+  - diff_complexity: unusual churn patterns (small message + large diff = suspicious)
+  - sink_delta: did the commit add/remove dangerous sinks?
+  - author_entropy: is this from an unusual author for this file?
+  - timing: late-night commits, weekend commits (higher anomaly weight)
+"""
+
+from __future__ import annotations
+
+import hashlib
+import math
+import os
+import re
+import subprocess
+import time
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class CommitAnalysis:
+    sha: str
+    message: str
+    author: str
+    date: str
+    files_changed: int
+    insertions: int
+    deletions: int
+    cad_score: float           # 0.0–10.0 (higher = more suspicious)
+    security_keywords: list[str]
+    sink_changes: list[str]
+    has_cve_mention: bool
+    has_advisory_mention: bool
+    is_suspicious: bool        # cad_score > threshold
+    diff_snippet: str
+
+
+_SECURITY_KEYWORDS = {
+    "overflow", "injection", "traversal", "escape", "sanitize", "sanitise",
+    "validate", "validation", "bypass", "privilege", "escalation", "disclosure",
+    "arbitrary", "execute", "remote", "code", "memory", "corruption", "buffer",
+    "heap", "stack", "uaf", "use-after-free", "null", "deref", "dereference",
+    "race", "condition", "toctou", "deserialization", "serialize", "pickle",
+    "auth", "authentication", "authorization", "permission", "access control",
+    "sql", "query", "xss", "csrf", "ssrf", "xxe", "open redirect", "clickjack",
+    "timing", "side channel", "cryptographic", "weak", "hardcoded", "credential",
+    "secret", "password", "token", "key", "certificate", "tls", "ssl",
+    "fix", "patch", "security", "vulnerability", "vuln", "issue", "bug",
+    "denial", "dos", "crash", "abort", "segfault", "exception", "error handling",
+}
+
+_CVE_PATTERN    = re.compile(r"\bCVE-\d{4}-\d+\b", re.IGNORECASE)
+_ADVISORY_PATTERN = re.compile(r"\bGHSA-[A-Z0-9-]+\b|\bSA-\d+\b|\bVU#\d+\b", re.IGNORECASE)
+
+_DANGEROUS_SINK_PATTERNS = re.compile(
+    r"\beval\b|\bexec\b|\bos\.system\b|\bsubprocess\b|\bpickle\b|\byaml\.load\b"
+    r"|\bchild_process\b|\binnerHTML\b|\bdocument\.write\b|\bSQLQuery\b|\bcursor\.execute\b",
+    re.IGNORECASE,
+)
+
+CAD_THRESHOLD = float(os.getenv("RHODAWK_CAD_THRESHOLD", "5.0"))
+
+
+def _git_log(repo_dir: str, n: int = 50) -> list[dict]:
+    """Get recent commits with stats."""
+    try:
+        result = subprocess.run(
+            ["git", "log", f"-{n}", "--format=%H|%s|%an|%ae|%ai", "--shortstat"],
+            cwd=repo_dir, capture_output=True, text=True, timeout=30,
+        )
+        entries = []
+        lines = result.stdout.strip().splitlines()
+        i = 0
+        while i < len(lines):
+            line = lines[i].strip()
+            if "|" in line and len(line.split("|")) >= 5:
+                parts = line.split("|", 4)
+                sha, msg, author, email, date = parts[0], parts[1], parts[2], parts[3], parts[4]
+                insertions = 0
+                deletions = 0
+                files_changed = 0
+                if i + 1 < len(lines) and ("changed" in lines[i + 1] or "insertion" in lines[i + 1]):
+                    stat_line = lines[i + 1]
+                    m = re.search(r"(\d+)\s+file", stat_line)
+                    if m:
+                        files_changed = int(m.group(1))
+                    m = re.search(r"(\d+)\s+insertion", stat_line)
+                    if m:
+                        insertions = int(m.group(1))
+                    m = re.search(r"(\d+)\s+deletion", stat_line)
+                    if m:
+                        deletions = int(m.group(1))
+                    i += 1
+                entries.append({
+                    "sha": sha.strip(),
+                    "message": msg.strip(),
+                    "author": author.strip(),
+                    "email": email.strip(),
+                    "date": date.strip(),
+                    "files_changed": files_changed,
+                    "insertions": insertions,
+                    "deletions": deletions,
+                })
+            i += 1
+        return entries
+    except Exception as e:
+        print(f"[CAD] git log failed: {e}")
+        return []
+
+
+def _get_commit_diff(repo_dir: str, sha: str) -> str:
+    """Get the diff for a specific commit."""
+    try:
+        result = subprocess.run(
+            ["git", "show", "--unified=3", "--no-color", sha],
+            cwd=repo_dir, capture_output=True, text=True, timeout=15,
+        )
+        return result.stdout[:5000]
+    except Exception:
+        return ""
+
+
+def _compute_cad_score(commit: dict, diff: str) -> tuple[float, list[str], list[str]]:
+    """
+    CAD (Commit Anomaly Detection) algorithm.
+
+    Returns (cad_score, matched_security_keywords, sink_changes)
+    """
+    msg = commit["message"].lower()
+    score = 0.0
+    matched_keywords = []
+    sink_changes = []
+
+    # --- Keyword scoring ---
+    for kw in _SECURITY_KEYWORDS:
+        if kw in msg:
+            matched_keywords.append(kw)
+            score += 0.4
+
+    has_cve = bool(_CVE_PATTERN.search(commit["message"]))
+    has_advisory = bool(_ADVISORY_PATTERN.search(commit["message"]))
+
+    # If it mentions CVE/advisory it's already disclosed — less interesting for us
+    if has_cve or has_advisory:
+        score -= 2.0
+    # If it has security keywords WITHOUT CVE → silent fix (most interesting)
+    elif matched_keywords:
+        score += 1.5
+
+    # --- Diff complexity scoring ---
+    ins = commit["insertions"]
+    dels = commit["deletions"]
+    total_churn = ins + dels
+
+    if total_churn > 0:
+        # Short commit message + large diff = suspicious
+        msg_length_penalty = 1.0 if len(commit["message"]) < 30 else 0.5
+        churn_score = math.log10(max(total_churn, 1)) * msg_length_penalty * 0.8
+        score += min(churn_score, 3.0)
+
+    # High deletions relative to insertions = removing dangerous code
+    if dels > 0 and ins > 0:
+        del_ratio = dels / (ins + dels)
+        if del_ratio > 0.6:
+            score += 0.8
+
+    # --- Sink delta scoring ---
+    added_lines = [l for l in diff.splitlines() if l.startswith("+") and not l.startswith("+++")]
+    removed_lines = [l for l in diff.splitlines() if l.startswith("-") and not l.startswith("---")]
+
+    for line in added_lines:
+        if _DANGEROUS_SINK_PATTERNS.search(line):
+            sink_changes.append(f"ADDED: {line[1:].strip()[:80]}")
+            score += 0.5
+
+    for line in removed_lines:
+        if _DANGEROUS_SINK_PATTERNS.search(line):
+            sink_changes.append(f"REMOVED: {line[1:].strip()[:80]}")
+            score += 0.3  # Removing dangerous code = possible silent fix
+
+    # --- Timing scoring ---
+    try:
+        date_str = commit["date"][:19]
+        import datetime
+        dt = datetime.datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S")
+        hour = dt.hour
+        weekday = dt.weekday()
+        if hour < 6 or hour > 22:
+            score += 0.5
+        if weekday >= 5:
+            score += 0.3
+    except Exception:
+        pass
+
+    return round(min(score, 10.0), 3), matched_keywords, sink_changes
+
+
+def analyze_recent_commits(repo_dir: str, lookback: int = 50) -> dict:
+    """
+    Main entry point. Analyze recent commits using CAD algorithm.
+    Returns suspicious commits sorted by CAD score.
+    """
+    print(f"[CAD] Analyzing last {lookback} commits in {repo_dir}")
+    commits = _git_log(repo_dir, n=lookback)
+
+    if not commits:
+        return {"error": "No commits found or git log failed", "suspicious_commits": [], "total": 0}
+
+    analyses = []
+    for commit in commits[:lookback]:
+        diff = _get_commit_diff(repo_dir, commit["sha"])
+        cad_score, keywords, sinks = _compute_cad_score(commit, diff)
+
+        has_cve = bool(_CVE_PATTERN.search(commit["message"]))
+        has_advisory = bool(_ADVISORY_PATTERN.search(commit["message"]))
+
+        analysis = CommitAnalysis(
+            sha=commit["sha"][:12],
+            message=commit["message"][:200],
+            author=commit["author"],
+            date=commit["date"][:19],
+            files_changed=commit["files_changed"],
+            insertions=commit["insertions"],
+            deletions=commit["deletions"],
+            cad_score=cad_score,
+            security_keywords=keywords,
+            sink_changes=sinks,
+            has_cve_mention=has_cve,
+            has_advisory_mention=has_advisory,
+            is_suspicious=cad_score >= CAD_THRESHOLD,
+            diff_snippet=diff[:500],
+        )
+        analyses.append(analysis)
+
+    analyses.sort(key=lambda a: a.cad_score, reverse=True)
+    suspicious = [a for a in analyses if a.is_suspicious]
+
+    print(f"[CAD] Found {len(suspicious)} suspicious commit(s) out of {len(analyses)}")
+
+    return {
+        "total_analyzed": len(analyses),
+        "suspicious_count": len(suspicious),
+        "threshold": CAD_THRESHOLD,
+        "algorithm": "CAD_v1",
+        "suspicious_commits": [
+            {
+                "sha": a.sha, "message": a.message, "author": a.author,
+                "date": a.date, "cad_score": a.cad_score,
+                "security_keywords": a.security_keywords,
+                "sink_changes": a.sink_changes[:3],
+                "files_changed": a.files_changed,
+                "insertions": a.insertions, "deletions": a.deletions,
+                "has_cve": a.has_cve_mention,
+                "diff_snippet": a.diff_snippet[:300],
+            }
+            for a in suspicious[:10]
+        ],
+        "all_scores": [{"sha": a.sha[:8], "score": a.cad_score, "msg": a.message[:60]}
+                       for a in analyses[:20]],
+    }
+
+
+def watch_repo_stream(
+    owner: str,
+    repo: str,
+    github_token: str,
+    callback,
+    poll_interval_s: int = 300,
+) -> None:
+    """
+    Continuously poll a GitHub repo for new commits and run CAD on each batch.
+    callback(analysis_result) is called when suspicious commits are found.
+    Runs in a background thread.
+    """
+    import threading
+    import requests
+
+    seen_shas = set()
+
+    def _poll():
+        while True:
+            try:
+                headers = {
+                    "Authorization": f"Bearer {github_token}",
+                    "Accept": "application/vnd.github+json",
+                }
+                resp = requests.get(
+                    f"https://api.github.com/repos/{owner}/{repo}/commits",
+                    headers=headers, params={"per_page": 20}, timeout=15,
+                )
+                if resp.status_code != 200:
+                    time.sleep(poll_interval_s)
+                    continue
+
+                commits = resp.json()
+                new_commits = [c for c in commits if c["sha"] not in seen_shas]
+
+                if new_commits:
+                    for c in new_commits:
+                        seen_shas.add(c["sha"])
+
+                    print(f"[CAD WATCH] {len(new_commits)} new commit(s) on {owner}/{repo}")
+                    result = {
+                        "repo": f"{owner}/{repo}",
+                        "new_commits": len(new_commits),
+                        "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
+                        "commits": [
+                            {
+                                "sha": c["sha"][:12],
+                                "message": c["commit"]["message"][:100],
+                                "author": c["commit"]["author"]["name"],
+                            }
+                            for c in new_commits
+                        ],
+                    }
+                    callback(result)
+
+            except Exception as e:
+                print(f"[CAD WATCH] Error: {e}")
+
+            time.sleep(poll_interval_s)
+
+    t = threading.Thread(target=_poll, daemon=True, name=f"cad-watch-{owner}-{repo}")
+    t.start()
+    return t

cve_intel.py

@@ -0,0 +1,333 @@
+"""
+Rhodawk AI — CVE Intelligence Layer
+=====================================
+Queries NVD/CVE databases and implements SSEC (Semantic Similarity Exploit Chain)
+to find code patterns similar to historically exploited vulnerabilities.
+
+Custom Algorithms:
+  SSEC — Semantic Similarity Exploit Chain
+    Embeds known exploit patterns and compares them to repo code using cosine
+    similarity. Finds "looks like CWE-X" candidates even without a test failure.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+import os
+import re
+import time
+import glob
+import hashlib
+import requests
+from dataclasses import dataclass, field
+from typing import Optional
+
+NVD_API_KEY   = os.getenv("NVD_API_KEY", "")
+NVD_BASE      = "https://services.nvd.nist.gov/rest/json/cves/2.0"
+CACHE_DIR     = "/data/cve_cache"
+
+os.makedirs(CACHE_DIR, exist_ok=True)
+
+
+@dataclass
+class CVERecord:
+    cve_id: str
+    description: str
+    severity: str
+    cvss_score: float
+    cwe_ids: list[str]
+    affected_products: list[str]
+    published: str
+    references: list[str]
+
+
+# ──────────────────────────────────────────────────────────────
+# KNOWN EXPLOIT PATTERNS — SSEC seed corpus
+# Each entry: (pattern_name, CWE, regex_or_keywords, severity)
+# ──────────────────────────────────────────────────────────────
+
+_EXPLOIT_PATTERNS = [
+    # Memory corruption
+    ("buffer_overflow_c",      "CWE-119", r"strcpy|strcat|sprintf|gets\s*\(|scanf\s*\(", "CRITICAL"),
+    ("integer_overflow",       "CWE-190", r"(\w+)\s*\*\s*(\w+)\s*(?:>|<|==)\s*\d+|malloc\s*\(\s*\w+\s*\*", "HIGH"),
+    ("use_after_free",         "CWE-416", r"free\s*\(\s*(\w+)\s*\).*\1\s*->|\1\[", "CRITICAL"),
+    ("format_string",          "CWE-134", r'printf\s*\(\s*(?!")[^,)]+\)|fprintf\s*\(\s*\w+\s*,\s*(?!")[^,)]+\)', "HIGH"),
+    ("null_deref",             "CWE-476", r"(\w+)\s*=\s*malloc\(.*(?<!if\s*\()(?<!\w\s*==\s*NULL)\s*\1->|\1\[", "HIGH"),
+    # Injection
+    ("sql_injection_py",       "CWE-89",  r'execute\s*\(\s*["\'].*%s|cursor\.execute\s*\(.*format\s*\(|\.query\s*\(.*\+', "CRITICAL"),
+    ("sql_injection_js",       "CWE-89",  r'query\s*\(`[^`]*\$\{|\.query\s*\(\s*["\'][^"\']*"\s*\+', "CRITICAL"),
+    ("cmd_injection_py",       "CWE-78",  r'os\.system\s*\(.*\+|subprocess\.call\s*\(.*shell\s*=\s*True', "CRITICAL"),
+    ("path_traversal",         "CWE-22",  r'open\s*\(.*\+.*\.\.|os\.path\.join.*request|send_file.*request', "HIGH"),
+    ("xss_reflected",          "CWE-79",  r'innerHTML\s*=.*req\.|document\.write.*req\.|render.*template.*request', "HIGH"),
+    ("xxe",                    "CWE-611", r'ElementTree\.parse|lxml\.etree\.parse|minidom\.parseString.*(?!defusedxml)', "HIGH"),
+    ("ssrf",                   "CWE-918", r'requests\.get\s*\(.*request\.|urllib.*urlopen.*request\.|httpx.*get.*request', "HIGH"),
+    # Crypto
+    ("weak_hash",              "CWE-328", r'hashlib\.md5\s*\(|hashlib\.sha1\s*\(|MD5\s*\(|SHA1\s*\(', "MEDIUM"),
+    ("hardcoded_secret",       "CWE-798", r'password\s*=\s*["\'][^"\']{4,}["\']|secret\s*=\s*["\'][^"\']{4,}["\']|api_key\s*=\s*["\'][^"\']{8,}["\']', "HIGH"),
+    ("weak_random",            "CWE-338", r'random\.random\s*\(|Math\.random\s*\(|rand\s*\(\)', "MEDIUM"),
+    ("insecure_tls",           "CWE-295", r'verify\s*=\s*False|ssl\._create_unverified_context|rejectUnauthorized\s*:\s*false', "HIGH"),
+    # Deserialization
+    ("pickle_deserial",        "CWE-502", r'pickle\.loads\s*\(.*request|pickle\.load\s*\(.*request', "CRITICAL"),
+    ("yaml_deserial",          "CWE-502", r'yaml\.load\s*\((?!.*Loader\s*=\s*yaml\.SafeLoader)', "HIGH"),
+    ("json_deserial_uncheck",  "CWE-502", r'eval\s*\(.*JSON|eval\s*\(.*json', "HIGH"),
+    # Auth/AuthZ
+    ("missing_auth",           "CWE-306", r'@app\.route.*(?!@login_required|@require_auth|@authenticated)', "MEDIUM"),
+    ("jwt_none_alg",           "CWE-347", r'algorithms\s*=\s*\[\s*["\']none["\']|decode.*options.*verify_signature.*False', "CRITICAL"),
+    ("debug_mode_prod",        "CWE-489", r'DEBUG\s*=\s*True|app\.run.*debug\s*=\s*True', "MEDIUM"),
+    # Race conditions
+    ("toctou",                 "CWE-367", r'os\.path\.exists.*open\s*\(|access.*open\s*\(', "MEDIUM"),
+    ("race_condition_thread",  "CWE-362", r'threading\.Thread.*shared_var|global\s+\w+.*thread', "MEDIUM"),
+]
+
+
+def _scan_file_for_patterns(file_path: str, source: str) -> list[dict]:
+    """Scan a single file against all SSEC exploit patterns."""
+    findings = []
+    lines = source.splitlines()
+
+    for pattern_name, cwe, regex, severity in _EXPLOIT_PATTERNS:
+        try:
+            for i, line in enumerate(lines, 1):
+                if re.search(regex, line, re.IGNORECASE):
+                    if line.strip().startswith("#") or line.strip().startswith("//"):
+                        continue
+                    findings.append({
+                        "pattern": pattern_name,
+                        "cwe": cwe,
+                        "severity": severity,
+                        "file": file_path,
+                        "line": i,
+                        "snippet": line.strip()[:120],
+                        "ssec_confidence": _compute_ssec_confidence(line, cwe),
+                    })
+        except re.error:
+            pass
+
+    return findings
+
+
+def _compute_ssec_confidence(line: str, cwe: str) -> float:
+    """
+    SSEC confidence scoring — custom algorithm.
+    Higher confidence when multiple indicators co-occur on the same line.
+    """
+    score = 0.5
+    line_lower = line.lower()
+
+    dangerous_keywords = ["request", "input", "user", "external", "upload", "argv", "environ", "param"]
+    if any(kw in line_lower for kw in dangerous_keywords):
+        score += 0.2
+
+    validation_keywords = ["sanitize", "escape", "validate", "encode", "filter", "check", "verify"]
+    if any(kw in line_lower for kw in validation_keywords):
+        score -= 0.15
+
+    if line.strip().startswith(("#", "//", "*")):
+        score = 0.1
+
+    test_indicators = ["test_", "mock_", "fake_", "stub_", "assert", "unittest"]
+    if any(t in line_lower for t in test_indicators):
+        score -= 0.2
+
+    return round(max(0.1, min(1.0, score)), 3)
+
+
+def run_ssec_scan(repo_dir: str, focus_files: list[str] = None) -> dict:
+    """
+    SSEC (Semantic Similarity Exploit Chain) scan.
+    Scans all source files against known exploit patterns.
+    Returns ranked findings by confidence × severity.
+    """
+    all_findings = []
+
+    extensions = ["*.py", "*.js", "*.ts", "*.go", "*.java", "*.rb", "*.c", "*.cpp", "*.h"]
+    search_files = []
+
+    if focus_files:
+        for f in focus_files:
+            fpath = os.path.join(repo_dir, f)
+            if os.path.exists(fpath):
+                search_files.append(fpath)
+    else:
+        for ext in extensions:
+            found = glob.glob(f"{repo_dir}/**/{ext}", recursive=True)
+            search_files.extend(found)
+
+    search_files = [
+        f for f in search_files
+        if "node_modules" not in f
+        and "site-packages" not in f
+        and ".tox" not in f
+        and ".git" not in f
+        and "vendor/" not in f
+    ]
+
+    for fpath in search_files[:200]:
+        rel = os.path.relpath(fpath, repo_dir)
+        try:
+            source = open(fpath, encoding="utf-8", errors="replace").read()
+        except Exception:
+            continue
+
+        findings = _scan_file_for_patterns(rel, source)
+        all_findings.extend(findings)
+
+    sev_rank = {"CRITICAL": 4, "HIGH": 3, "MEDIUM": 2, "LOW": 1}
+    all_findings.sort(
+        key=lambda x: (sev_rank.get(x["severity"], 0), x["ssec_confidence"]),
+        reverse=True,
+    )
+
+    unique_cwes = list(set(f["cwe"] for f in all_findings))
+    critical_count = sum(1 for f in all_findings if f["severity"] == "CRITICAL")
+    high_count = sum(1 for f in all_findings if f["severity"] == "HIGH")
+
+    return {
+        "total_findings": len(all_findings),
+        "critical": critical_count,
+        "high": high_count,
+        "unique_cwes": unique_cwes,
+        "top_findings": all_findings[:20],
+        "files_scanned": len(search_files),
+        "algorithm": "SSEC_v1",
+    }
+
+
+def query_cve_intel(description: str, cwe_hint: str = None) -> dict:
+    """
+    Query NVD for CVEs similar to the given description.
+    Falls back to local pattern matching if NVD API is unavailable.
+    """
+    cache_key = hashlib.sha256(f"{description}{cwe_hint}".encode()).hexdigest()[:16]
+    cache_file = os.path.join(CACHE_DIR, f"{cache_key}.json")
+
+    if os.path.exists(cache_file):
+        try:
+            age = time.time() - os.path.getmtime(cache_file)
+            if age < 86400 * 7:
+                return json.load(open(cache_file))
+        except Exception:
+            pass
+
+    result = _query_nvd_api(description, cwe_hint)
+    if not result.get("error"):
+        try:
+            json.dump(result, open(cache_file, "w"), indent=2)
+        except Exception:
+            pass
+
+    if result.get("error") or not result.get("cves"):
+        result = _local_cve_lookup(description, cwe_hint)
+
+    return result
+
+
+def _query_nvd_api(description: str, cwe_hint: str = None) -> dict:
+    """Query NVD 2.0 API."""
+    params = {
+        "keywordSearch": description[:100],
+        "resultsPerPage": 5,
+        "startIndex": 0,
+    }
+    if cwe_hint:
+        params["cweId"] = cwe_hint
+
+    headers = {}
+    if NVD_API_KEY:
+        headers["apiKey"] = NVD_API_KEY
+
+    try:
+        resp = requests.get(NVD_BASE, params=params, headers=headers, timeout=10)
+        if resp.status_code == 200:
+            data = resp.json()
+            cves = []
+            for item in data.get("vulnerabilities", [])[:5]:
+                cve = item.get("cve", {})
+                metrics = cve.get("metrics", {})
+                cvss_data = (
+                    metrics.get("cvssMetricV31", [{}])[0].get("cvssData", {})
+                    if metrics.get("cvssMetricV31")
+                    else metrics.get("cvssMetricV30", [{}])[0].get("cvssData", {})
+                    if metrics.get("cvssMetricV30")
+                    else {}
+                )
+                descs = cve.get("descriptions", [])
+                desc_text = next((d["value"] for d in descs if d.get("lang") == "en"), "")
+                cwes = [
+                    w.get("description", [{}])[0].get("value", "")
+                    for w in cve.get("weaknesses", [])
+                    if w.get("description")
+                ]
+                cves.append({
+                    "id": cve.get("id", ""),
+                    "description": desc_text[:300],
+                    "severity": cvss_data.get("baseSeverity", "UNKNOWN"),
+                    "cvss_score": cvss_data.get("baseScore", 0.0),
+                    "cwes": cwes,
+                    "published": cve.get("published", ""),
+                })
+            return {"cves": cves, "source": "nvd_api", "total": data.get("totalResults", 0)}
+        return {"error": f"NVD API returned {resp.status_code}", "cves": []}
+    except Exception as e:
+        return {"error": str(e), "cves": []}
+
+
+def _local_cve_lookup(description: str, cwe_hint: str = None) -> dict:
+    """
+    Local CVE pattern database — offline fallback.
+    Returns well-known CVE examples for common vulnerability classes.
+    """
+    LOCAL_CVE_DB = {
+        "CWE-89": [
+            {"id": "CVE-2021-44228-analog", "description": "SQL injection via unsanitized user input in ORM query", "severity": "CRITICAL", "cvss_score": 9.8},
+        ],
+        "CWE-502": [
+            {"id": "CVE-2019-20107-analog", "description": "Unsafe deserialization of user-controlled pickle data", "severity": "CRITICAL", "cvss_score": 9.8},
+        ],
+        "CWE-78": [
+            {"id": "CVE-2021-3129-analog", "description": "OS command injection via unsanitized shell argument", "severity": "CRITICAL", "cvss_score": 9.8},
+        ],
+        "CWE-22": [
+            {"id": "CVE-2018-1000116-analog", "description": "Path traversal via ../ in user-supplied file path", "severity": "HIGH", "cvss_score": 7.5},
+        ],
+        "CWE-79": [
+            {"id": "CVE-2022-XXXX-xss", "description": "Reflected XSS via unescaped user input in HTML response", "severity": "HIGH", "cvss_score": 6.1},
+        ],
+        "CWE-798": [
+            {"id": "CVE-2021-hardcoded", "description": "Hardcoded credentials in source code", "severity": "HIGH", "cvss_score": 7.5},
+        ],
+        "CWE-295": [
+            {"id": "CVE-2021-tls-verify", "description": "TLS certificate verification disabled allowing MITM", "severity": "HIGH", "cvss_score": 7.4},
+        ],
+        "CWE-347": [
+            {"id": "CVE-2020-jwt-none", "description": "JWT 'none' algorithm accepted allowing token forgery", "severity": "CRITICAL", "cvss_score": 9.8},
+        ],
+    }
+    cve_matches = []
+    desc_lower = description.lower()
+
+    keywords_to_cwe = {
+        "sql": "CWE-89", "pickle": "CWE-502", "deserializ": "CWE-502",
+        "command": "CWE-78", "shell": "CWE-78", "path traversal": "CWE-22",
+        "directory traversal": "CWE-22", "xss": "CWE-79", "cross-site": "CWE-79",
+        "hardcoded": "CWE-798", "tls": "CWE-295", "ssl": "CWE-295",
+        "jwt": "CWE-347", "token": "CWE-347",
+    }
+
+    matched_cwe = cwe_hint
+    if not matched_cwe:
+        for kw, cwe in keywords_to_cwe.items():
+            if kw in desc_lower:
+                matched_cwe = cwe
+                break
+
+    if matched_cwe and matched_cwe in LOCAL_CVE_DB:
+        cve_matches = LOCAL_CVE_DB[matched_cwe]
+
+    return {
+        "cves": cve_matches,
+        "source": "local_db",
+        "matched_cwe": matched_cwe,
+        "total": len(cve_matches),
+    }

exploit_primitives.py

@@ -0,0 +1,310 @@
+"""
+Rhodawk AI — Exploit Primitive Reasoner
+=========================================
+Given a crash or vulnerability candidate, reasons about:
+  1. Exploitability class (overflow, UAF, injection, race, crypto, logic)
+  2. Control flow impact (can attacker redirect execution?)
+  3. Data flow impact (can attacker read/write arbitrary memory?)
+  4. Proof-of-Concept generation (minimal triggerable input)
+  5. Severity and bounty tier estimate
+
+Uses DeepSeek-R1 (reasoning model) for deep exploit chain analysis.
+Never auto-submits — all output goes to the disclosure pipeline for human review.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import time
+import requests
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY", "")
+EXPLOIT_MODEL      = os.getenv("HERMES_MODEL", "deepseek/deepseek-r1:free")
+OPENROUTER_BASE    = "https://openrouter.ai/api/v1"
+
+
+@dataclass
+class ExploitAnalysis:
+    vulnerability_id: str
+    exploit_class: str          # memory_corruption | injection | logic | crypto | race | info_disclosure
+    control_flow_impact: str    # full_control | partial_control | none
+    data_impact: str            # arbitrary_read_write | arbitrary_read | arbitrary_write | none
+    auth_bypass_possible: bool
+    remote_exploitable: bool
+    exploit_complexity: str     # LOW | MEDIUM | HIGH
+    estimated_cvss: float
+    bounty_tier: str            # P1 ($10k+) | P2 ($5k) | P3 ($2k) | P4 (<$1k)
+    proof_of_concept: str
+    attack_scenario: str
+    mitigations_present: list[str]
+    confidence: float
+    reasoning: str
+
+
+_EXPLOIT_SYSTEM = """You are a world-class exploit developer and vulnerability researcher.
+Given a crash, vulnerability description, or suspicious code pattern, analyze its exploitability
+with extreme precision. Think like an attacker trying to maximize impact.
+
+Consider:
+- Can the attacker control the input that triggers this?
+- Does this give code execution, information disclosure, or denial of service?
+- What mitigations are in place (ASLR, stack canaries, bounds checking, authentication)?
+- What is the minimal proof-of-concept that demonstrates the issue?
+- What is the realistic attack scenario (network, local, authenticated, unauthenticated)?
+
+Be honest about uncertainty. If you cannot determine exploitability, say so clearly.
+A false positive wastes a researcher's time and damages credibility.
+
+Respond in this exact JSON format:
+{
+  "exploit_class": "memory_corruption|injection|logic|crypto|race|info_disclosure|denial_of_service",
+  "control_flow_impact": "full_control|partial_control|none",
+  "data_impact": "arbitrary_read_write|arbitrary_read|arbitrary_write|none",
+  "auth_bypass_possible": true/false,
+  "remote_exploitable": true/false,
+  "exploit_complexity": "LOW|MEDIUM|HIGH",
+  "estimated_cvss": 0.0-10.0,
+  "bounty_tier": "P1|P2|P3|P4",
+  "proof_of_concept": "minimal code or input that triggers the issue",
+  "attack_scenario": "step by step how an attacker would exploit this",
+  "mitigations_present": ["mitigation1", "mitigation2"],
+  "confidence": 0.0-1.0,
+  "reasoning": "your full chain of reasoning about exploitability"
+}
+"""
+
+_CVSS_TO_TIER = {
+    (9.0, 10.0): "P1",
+    (7.0, 8.9):  "P2",
+    (4.0, 6.9):  "P3",
+    (0.0, 3.9):  "P4",
+}
+
+
+def _estimate_bounty_tier(cvss: float) -> str:
+    for (lo, hi), tier in _CVSS_TO_TIER.items():
+        if lo <= cvss <= hi:
+            return tier
+    return "P4"
+
+
+def _call_exploit_reasoner(prompt: str) -> dict:
+    if not OPENROUTER_API_KEY:
+        return {
+            "exploit_class": "unknown",
+            "control_flow_impact": "unknown",
+            "data_impact": "unknown",
+            "auth_bypass_possible": False,
+            "remote_exploitable": False,
+            "exploit_complexity": "HIGH",
+            "estimated_cvss": 0.0,
+            "bounty_tier": "P4",
+            "proof_of_concept": "OPENROUTER_API_KEY not set — manual analysis required",
+            "attack_scenario": "",
+            "mitigations_present": [],
+            "confidence": 0.0,
+            "reasoning": "API key not available",
+        }
+
+    headers = {
+        "Authorization": f"Bearer {OPENROUTER_API_KEY}",
+        "Content-Type": "application/json",
+        "HTTP-Referer": "https://rhodawk.ai",
+        "X-Title": "Rhodawk Exploit Reasoner",
+    }
+    payload = {
+        "model": EXPLOIT_MODEL,
+        "messages": [
+            {"role": "system", "content": _EXPLOIT_SYSTEM},
+            {"role": "user", "content": prompt},
+        ],
+        "temperature": 0.1,
+        "max_tokens": 2000,
+        "response_format": {"type": "json_object"},
+    }
+    try:
+        resp = requests.post(
+            f"{OPENROUTER_BASE}/chat/completions",
+            headers=headers, json=payload, timeout=120,
+        )
+        resp.raise_for_status()
+        content = resp.json()["choices"][0]["message"]["content"]
+        return json.loads(content)
+    except Exception as e:
+        return {
+            "exploit_class": "analysis_failed",
+            "control_flow_impact": "unknown",
+            "data_impact": "unknown",
+            "auth_bypass_possible": False,
+            "remote_exploitable": False,
+            "exploit_complexity": "HIGH",
+            "estimated_cvss": 0.0,
+            "bounty_tier": "P4",
+            "proof_of_concept": f"Analysis failed: {e}",
+            "attack_scenario": "",
+            "mitigations_present": [],
+            "confidence": 0.0,
+            "reasoning": str(e),
+        }
+
+
+def reason_exploitability(
+    crash_input: str,
+    crash_output: str,
+    file_path: str,
+    vuln_type: str,
+    source_context: str = "",
+) -> dict:
+    """
+    Main entry point for exploit primitive reasoning.
+    Returns a detailed exploitability analysis.
+    """
+    vuln_id = hashlib.sha256(f"{file_path}{crash_input}{time.time()}".encode()).hexdigest()[:12]
+
+    prompt = (
+        f"VULNERABILITY TYPE: {vuln_type}\n"
+        f"FILE: {file_path}\n\n"
+        f"CRASH INPUT / TRIGGER:\n```\n{crash_input[:1000]}\n```\n\n"
+        f"CRASH OUTPUT / STACK TRACE:\n```\n{crash_output[:2000]}\n```\n\n"
+    )
+    if source_context:
+        prompt += f"SOURCE CONTEXT:\n```\n{source_context[:1500]}\n```\n\n"
+
+    prompt += "Analyze this vulnerability's exploitability in full detail."
+
+    print(f"[EXPLOIT] Reasoning about {vuln_type} in {file_path} (ID: {vuln_id})")
+    raw = _call_exploit_reasoner(prompt)
+
+    cvss = float(raw.get("estimated_cvss", 0.0))
+    tier = raw.get("bounty_tier") or _estimate_bounty_tier(cvss)
+
+    analysis = ExploitAnalysis(
+        vulnerability_id=vuln_id,
+        exploit_class=raw.get("exploit_class", "unknown"),
+        control_flow_impact=raw.get("control_flow_impact", "none"),
+        data_impact=raw.get("data_impact", "none"),
+        auth_bypass_possible=bool(raw.get("auth_bypass_possible", False)),
+        remote_exploitable=bool(raw.get("remote_exploitable", False)),
+        exploit_complexity=raw.get("exploit_complexity", "HIGH"),
+        estimated_cvss=round(cvss, 1),
+        bounty_tier=tier,
+        proof_of_concept=raw.get("proof_of_concept", ""),
+        attack_scenario=raw.get("attack_scenario", ""),
+        mitigations_present=raw.get("mitigations_present", []),
+        confidence=float(raw.get("confidence", 0.0)),
+        reasoning=raw.get("reasoning", "")[:1000],
+    )
+
+    print(f"[EXPLOIT] {vuln_id}: CVSS={analysis.estimated_cvss}, Tier={analysis.bounty_tier}, "
+          f"Confidence={analysis.confidence}")
+
+    return {
+        "vulnerability_id": analysis.vulnerability_id,
+        "exploit_class": analysis.exploit_class,
+        "control_flow_impact": analysis.control_flow_impact,
+        "data_impact": analysis.data_impact,
+        "auth_bypass_possible": analysis.auth_bypass_possible,
+        "remote_exploitable": analysis.remote_exploitable,
+        "exploit_complexity": analysis.exploit_complexity,
+        "estimated_cvss": analysis.estimated_cvss,
+        "bounty_tier": analysis.bounty_tier,
+        "proof_of_concept": analysis.proof_of_concept,
+        "attack_scenario": analysis.attack_scenario,
+        "mitigations_present": analysis.mitigations_present,
+        "confidence": analysis.confidence,
+        "reasoning": analysis.reasoning,
+        "disclosure_ready": analysis.confidence >= 0.7 and analysis.estimated_cvss >= 4.0,
+        "requires_human_review": True,
+    }
+
+
+def generate_cve_draft(
+    finding_title: str,
+    finding_description: str,
+    exploit_analysis: dict,
+    affected_repo: str,
+    affected_versions: str = "unspecified",
+) -> dict:
+    """
+    Generate a CVE draft report ready for human review and submission.
+    Output format follows CVE JSON 5.0 schema.
+    """
+    cvss = exploit_analysis.get("estimated_cvss", 0.0)
+    tier = exploit_analysis.get("bounty_tier", "P4")
+    exploit_class = exploit_analysis.get("exploit_class", "unknown")
+
+    cwe_map = {
+        "memory_corruption": "CWE-119",
+        "injection": "CWE-74",
+        "logic": "CWE-840",
+        "crypto": "CWE-310",
+        "race": "CWE-362",
+        "info_disclosure": "CWE-200",
+        "denial_of_service": "CWE-400",
+    }
+    cwe = cwe_map.get(exploit_class, "CWE-UNKNOWN")
+
+    severity = "CRITICAL" if cvss >= 9.0 else "HIGH" if cvss >= 7.0 else "MEDIUM" if cvss >= 4.0 else "LOW"
+
+    draft = {
+        "dataType": "CVE_RECORD",
+        "dataVersion": "5.0",
+        "cveMetadata": {
+            "state": "DRAFT",
+            "assignerOrgId": "rhodawk-ai",
+            "dateReserved": time.strftime("%Y-%m-%dT%H:%M:%S.000Z"),
+        },
+        "containers": {
+            "cna": {
+                "title": finding_title,
+                "descriptions": [
+                    {
+                        "lang": "en",
+                        "value": finding_description,
+                    }
+                ],
+                "affected": [
+                    {
+                        "repo": f"https://github.com/{affected_repo}",
+                        "versions": [{"version": affected_versions, "status": "affected"}],
+                    }
+                ],
+                "problemTypes": [
+                    {"descriptions": [{"type": "CWE", "cweId": cwe, "lang": "en"}]}
+                ],
+                "metrics": [
+                    {
+                        "cvssV3_1": {
+                            "version": "3.1",
+                            "baseScore": cvss,
+                            "baseSeverity": severity,
+                        }
+                    }
+                ],
+                "references": [
+                    {"url": f"https://github.com/{affected_repo}", "name": "Repository"}
+                ],
+                "x_rhodawk_metadata": {
+                    "bounty_tier": tier,
+                    "exploit_class": exploit_class,
+                    "disclosure_status": "PENDING_HUMAN_APPROVAL",
+                    "generated_by": "Rhodawk AI Security Research Engine",
+                    "requires_human_verification": True,
+                    "analyst_notes": exploit_analysis.get("reasoning", "")[:500],
+                },
+            }
+        },
+    }
+    return {
+        "cve_draft": draft,
+        "severity": severity,
+        "cvss": cvss,
+        "bounty_tier": tier,
+        "ready_for_human_review": True,
+        "auto_submit": False,
+    }

fuzzing_engine.py

@@ -0,0 +1,375 @@
+"""
+Rhodawk AI — Autonomous Fuzzing Engine
+=======================================
+Generates language-aware fuzzing harnesses using LLM then executes them.
+Integrates with AFL++, libFuzzer (via atheris for Python), and Hypothesis.
+
+Pipeline per target:
+  1. LLM generates a harness tailored to the target function/API
+  2. Harness is written to /tmp and compiled/instrumented
+  3. Fuzzer runs for duration_s seconds with coverage feedback
+  4. Crashes are triaged: unique crashes extracted, deduped by stack hash
+  5. Results returned for exploit_primitives reasoning
+
+Supported modes:
+  - Python   → atheris (libFuzzer bindings for Python)
+  - C/C++    → AFL++ subprocess (if installed)
+  - JS/TS    → jsfuzz / fast-check property testing
+  - Generic  → Hypothesis with AI-generated strategies
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import subprocess
+import tempfile
+import time
+from dataclasses import dataclass, field
+from typing import Optional
+
+import requests
+
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY", "")
+FUZZ_MODEL         = os.getenv("HERMES_FAST_MODEL", "deepseek/deepseek-v3:free")
+OPENROUTER_BASE    = "https://openrouter.ai/api/v1"
+
+MAX_FUZZ_DURATION  = int(os.getenv("RHODAWK_MAX_FUZZ_DURATION", "120"))
+FUZZ_CORPUS_DIR    = os.getenv("RHODAWK_FUZZ_CORPUS", "/data/fuzz_corpus")
+
+
+@dataclass
+class CrashRecord:
+    crash_id: str
+    target: str
+    crash_input: str
+    crash_output: str
+    stack_hash: str
+    crash_type: str      # segfault | assertion | exception | timeout | oom
+    is_unique: bool
+    reproducer_path: str
+    timestamp: str = field(default_factory=lambda: time.strftime("%Y-%m-%dT%H:%M:%SZ"))
+
+
+@dataclass
+class FuzzResult:
+    target: str
+    language: str
+    duration_s: int
+    total_executions: int
+    unique_crashes: list[CrashRecord]
+    coverage_percent: float
+    harness_code: str
+    error: Optional[str] = None
+
+
+def _llm_generate_harness(
+    target: str,
+    language: str,
+    repo_dir: str,
+    source_context: str,
+) -> str:
+    """Use LLM to generate a fuzzing harness for the target function."""
+    if not OPENROUTER_API_KEY:
+        return _fallback_harness(target, language)
+
+    system = (
+        "You are an expert fuzzing engineer. Generate a minimal, correct fuzzing harness "
+        "for the given target. The harness must: "
+        "1) Accept raw bytes as input, 2) Parse them into valid arguments, "
+        "3) Call the target without crashing on invalid input (catch exceptions), "
+        "4) Be as fast as possible (no I/O, no sleep). "
+        "Return ONLY the harness code, no explanation."
+    )
+
+    if language == "python":
+        prompt = (
+            f"TARGET FUNCTION: {target}\n"
+            f"LANGUAGE: Python (atheris/libFuzzer)\n"
+            f"SOURCE CONTEXT:\n```python\n{source_context[:2000]}\n```\n\n"
+            "Generate an atheris fuzzing harness. Import atheris and the target module. "
+            "The TestOneInput function must accept bytes. Use FuzzedDataProvider to extract typed values."
+        )
+    elif language in ("javascript", "typescript"):
+        prompt = (
+            f"TARGET FUNCTION: {target}\n"
+            f"LANGUAGE: {language} (jsfuzz)\n"
+            f"SOURCE CONTEXT:\n```javascript\n{source_context[:2000]}\n```\n\n"
+            "Generate a jsfuzz harness. Export a default async function that accepts Buffer."
+        )
+    elif language in ("go",):
+        prompt = (
+            f"TARGET FUNCTION: {target}\n"
+            f"LANGUAGE: Go (native fuzzing)\n"
+            f"SOURCE CONTEXT:\n```go\n{source_context[:2000]}\n```\n\n"
+            "Generate a Go fuzz test using testing.F and f.Fuzz()."
+        )
+    else:
+        prompt = (
+            f"TARGET: {target}\n"
+            f"LANGUAGE: {language}\n"
+            f"SOURCE:\n```\n{source_context[:2000]}\n```\n\n"
+            "Generate a Hypothesis property-based test that explores the target's input space."
+        )
+
+    headers = {
+        "Authorization": f"Bearer {OPENROUTER_API_KEY}",
+        "Content-Type": "application/json",
+    }
+    payload = {
+        "model": FUZZ_MODEL,
+        "messages": [
+            {"role": "system", "content": system},
+            {"role": "user", "content": prompt},
+        ],
+        "temperature": 0.1,
+        "max_tokens": 1500,
+    }
+    try:
+        resp = requests.post(
+            f"{OPENROUTER_BASE}/chat/completions",
+            headers=headers, json=payload, timeout=60,
+        )
+        resp.raise_for_status()
+        content = resp.json()["choices"][0]["message"]["content"]
+        code = _extract_code_block(content)
+        return code or _fallback_harness(target, language)
+    except Exception:
+        return _fallback_harness(target, language)
+
+
+def _extract_code_block(text: str) -> str:
+    """Extract first code block from markdown."""
+    import re
+    m = re.search(r"```(?:python|javascript|go|typescript|rust)?\n(.*?)```", text, re.DOTALL)
+    if m:
+        return m.group(1).strip()
+    lines = [l for l in text.splitlines() if not l.startswith("```")]
+    return "\n".join(lines).strip()
+
+
+def _fallback_harness(target: str, language: str) -> str:
+    """Generic fallback harness when LLM is unavailable."""
+    if language == "python":
+        return f"""
+import atheris
+import sys
+
+@atheris.instrument_func
+def fuzz_target(data):
+    fdp = atheris.FuzzedDataProvider(data)
+    try:
+        val = fdp.ConsumeUnicodeNoSurrogates(128)
+        # TODO: call {target}(val)
+    except Exception:
+        pass
+
+atheris.Setup(sys.argv, fuzz_target)
+atheris.Fuzz()
+"""
+    return f"# Fallback harness for {target} ({language})\n# Manual harness required\n"
+
+
+def _get_source_context(repo_dir: str, target: str, language: str) -> str:
+    """Extract relevant source code context around the target function."""
+    import glob as _glob
+
+    ext_map = {
+        "python": ["*.py"], "javascript": ["*.js"], "typescript": ["*.ts"],
+        "go": ["*.go"], "rust": ["*.rs"], "java": ["*.java"], "ruby": ["*.rb"],
+    }
+    extensions = ext_map.get(language, ["*.*"])
+
+    for ext in extensions:
+        for fpath in _glob.glob(f"{repo_dir}/**/{ext}", recursive=True):
+            if "test" in fpath.lower() or "node_modules" in fpath:
+                continue
+            try:
+                content = open(fpath).read()
+                if target.split(".")[-1] in content or target.split("::")[-1] in content:
+                    rel = os.path.relpath(fpath, repo_dir)
+                    return f"# File: {rel}\n{content[:3000]}"
+            except Exception:
+                pass
+    return f"# Could not find source for {target}"
+
+
+def _run_python_atheris(harness_code: str, duration_s: int) -> list[CrashRecord]:
+    """Run atheris fuzzer on a Python harness."""
+    crashes = []
+    harness_path = None
+    corpus_dir = None
+
+    try:
+        fd, harness_path = tempfile.mkstemp(suffix="_fuzz.py")
+        with os.fdopen(fd, "w") as f:
+            f.write(harness_code)
+
+        corpus_dir = tempfile.mkdtemp(prefix="fuzz_corpus_")
+        seed_file = os.path.join(corpus_dir, "seed")
+        with open(seed_file, "wb") as f:
+            f.write(b"hello world\x00\xff")
+
+        crash_dir = tempfile.mkdtemp(prefix="fuzz_crashes_")
+
+        cmd = [
+            "python", harness_path,
+            f"-max_total_time={duration_s}",
+            f"-artifact_prefix={crash_dir}/",
+            corpus_dir,
+        ]
+
+        proc = subprocess.Popen(
+            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+            text=True, timeout=duration_s + 30,
+        )
+        try:
+            stdout, stderr = proc.communicate(timeout=duration_s + 30)
+        except subprocess.TimeoutExpired:
+            proc.kill()
+            stdout, stderr = proc.communicate()
+
+        combined = stdout + stderr
+        for crash_file in os.listdir(crash_dir):
+            if crash_file.startswith("crash-") or crash_file.startswith("oom-"):
+                crash_path = os.path.join(crash_dir, crash_file)
+                try:
+                    with open(crash_path, "rb") as f:
+                        crash_bytes = f.read()
+                    crash_input = crash_bytes.hex()[:500]
+                    stack_hash = hashlib.sha256(crash_bytes[:64]).hexdigest()[:16]
+                    crashes.append(CrashRecord(
+                        crash_id=hashlib.sha256(crash_bytes).hexdigest()[:12],
+                        target="python_harness",
+                        crash_input=crash_input,
+                        crash_output=combined[-1000:],
+                        stack_hash=stack_hash,
+                        crash_type="exception" if "crash-" in crash_file else "oom",
+                        is_unique=True,
+                        reproducer_path=crash_path,
+                    ))
+                except Exception:
+                    pass
+
+    except Exception as e:
+        crashes.append(CrashRecord(
+            crash_id="setup_error",
+            target="python_harness",
+            crash_input="",
+            crash_output=str(e),
+            stack_hash="error",
+            crash_type="setup_error",
+            is_unique=False,
+            reproducer_path="",
+        ))
+    finally:
+        if harness_path and os.path.exists(harness_path):
+            os.unlink(harness_path)
+
+    return crashes
+
+
+def _run_hypothesis(repo_dir: str, target: str, harness_code: str, duration_s: int) -> list[CrashRecord]:
+    """Run Hypothesis property-based testing as a fuzzing fallback."""
+    crashes = []
+    fd, test_path = tempfile.mkstemp(suffix="_hyp_test.py", dir="/tmp")
+    try:
+        with os.fdopen(fd, "w") as f:
+            f.write(harness_code)
+
+        proc = subprocess.Popen(
+            ["python", "-m", "pytest", test_path, "-x", "--tb=short",
+             f"--hypothesis-seed=0", "-q"],
+            cwd=repo_dir, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+            text=True,
+        )
+        try:
+            stdout, stderr = proc.communicate(timeout=min(duration_s, 60))
+        except subprocess.TimeoutExpired:
+            proc.kill()
+            stdout, stderr = proc.communicate()
+
+        combined = (stdout or "") + (stderr or "")
+        if "FAILED" in combined or "AssertionError" in combined or "Falsifying" in combined:
+            stack_hash = hashlib.sha256(combined[:200].encode()).hexdigest()[:16]
+            crashes.append(CrashRecord(
+                crash_id=stack_hash,
+                target=target,
+                crash_input="see Hypothesis output",
+                crash_output=combined[:2000],
+                stack_hash=stack_hash,
+                crash_type="assertion",
+                is_unique=True,
+                reproducer_path=test_path,
+            ))
+    except Exception as e:
+        pass
+    finally:
+        try:
+            os.unlink(test_path)
+        except OSError:
+            pass
+
+    return crashes
+
+
+def run_fuzzing_campaign(
+    repo_dir: str,
+    target: str,
+    language: str = "python",
+    duration_s: int = 60,
+) -> dict:
+    """
+    Main entry point. Generate harness + run fuzzer + return triage results.
+    """
+    duration_s = min(duration_s, MAX_FUZZ_DURATION)
+    print(f"[FUZZ] Starting campaign: {target} ({language}, {duration_s}s)")
+
+    source_context = _get_source_context(repo_dir, target, language)
+    harness_code = _llm_generate_harness(target, language, repo_dir, source_context)
+
+    start = time.time()
+    if language == "python" and "atheris" in harness_code:
+        crashes = _run_python_atheris(harness_code, duration_s)
+    else:
+        crashes = _run_hypothesis(repo_dir, target, harness_code, duration_s)
+
+    elapsed = time.time() - start
+
+    unique_hashes = set()
+    unique_crashes = []
+    for c in crashes:
+        if c.stack_hash not in unique_hashes:
+            unique_hashes.add(c.stack_hash)
+            unique_crashes.append(c)
+
+    result = FuzzResult(
+        target=target,
+        language=language,
+        duration_s=int(elapsed),
+        total_executions=len(crashes),
+        unique_crashes=unique_crashes,
+        coverage_percent=0.0,
+        harness_code=harness_code,
+    )
+
+    print(f"[FUZZ] Done: {len(unique_crashes)} unique crash(es) in {elapsed:.1f}s")
+
+    return {
+        "target": result.target,
+        "language": result.language,
+        "duration_s": result.duration_s,
+        "unique_crashes": len(result.unique_crashes),
+        "harness_code": result.harness_code[:500],
+        "crashes": [
+            {
+                "id": c.crash_id, "type": c.crash_type,
+                "input_hex": c.crash_input[:100],
+                "output_snippet": c.crash_output[:500],
+                "stack_hash": c.stack_hash,
+            }
+            for c in result.unique_crashes
+        ],
+        "has_crashes": len(result.unique_crashes) > 0,
+    }

hermes_orchestrator.py

@@ -0,0 +1,632 @@
+"""
+Rhodawk AI — Hermes Master Orchestrator
+========================================
+Hermes is the intelligent agent that coordinates all security research components.
+It acts as the "brain" — deciding which tools to deploy, in what order, and how
+to synthesize findings into a coherent vulnerability report.
+
+Architecture:
+  Hermes receives a target (repo + optional focus area) and executes a dynamic
+  multi-phase research plan using tool calls. It maintains state across phases,
+  routes findings between components, and escalates confidence incrementally.
+
+Phases:
+  1. RECON       — clone, fingerprint, map attack surface
+  2. STATIC      — taint analysis, symbolic execution planning, CWE pattern match
+  3. DYNAMIC     — fuzzing harness generation + execution
+  4. EXPLOIT     — exploit primitive reasoning on confirmed crashes
+  5. CONSENSUS   — multi-model adversarial verdict on findings
+  6. DISCLOSURE  — package report, hold for human approval
+
+Custom Algorithms:
+  VES  — Vulnerability Entropy Score: how surprising/dangerous a code path is
+  TVG  — Temporal Vulnerability Graph: how bugs propagate across commits
+  ACTS — Adversarial Consensus Trust Score: Bayesian multi-model confidence
+  CAD  — Commit Anomaly Detection: statistical detection of silent security patches
+  SSEC — Semantic Similarity Exploit Chain: embedding distance to known exploit patterns
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import threading
+import time
+from dataclasses import dataclass, field, asdict
+from enum import Enum
+from typing import Any, Callable, Optional
+
+import requests
+
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY", "")
+HERMES_MODEL       = os.getenv("HERMES_MODEL", "deepseek/deepseek-r1:free")
+HERMES_FAST_MODEL  = os.getenv("HERMES_FAST_MODEL", "deepseek/deepseek-v3:free")
+OPENROUTER_BASE    = "https://openrouter.ai/api/v1"
+
+_log_lock = threading.Lock()
+_hermes_logs: list[str] = []
+
+
+def hermes_log(msg: str, level: str = "HERMES"):
+    ts = time.strftime("%H:%M:%S")
+    icons = {
+        "HERMES": "🧠", "RECON": "🔭", "STATIC": "🔬", "DYNAMIC": "💥",
+        "EXPLOIT": "⚔️", "CONSENSUS": "🗳", "DISCLOSURE": "📋",
+        "TOOL": "🔧", "FIND": "🎯", "WARN": "⚠️", "OK": "✅", "FAIL": "❌",
+        "VES": "📊", "TVG": "🕸", "ACTS": "🧮", "CAD": "👁", "SSEC": "🔗",
+    }
+    line = f"[{ts}] {icons.get(level, '🧠')} [HERMES] {msg}"
+    print(line)
+    with _log_lock:
+        _hermes_logs.append(line)
+        if len(_hermes_logs) > 500:
+            _hermes_logs.pop(0)
+
+
+def get_hermes_logs() -> list[str]:
+    with _log_lock:
+        return list(_hermes_logs)
+
+
+# ──────────────────────────────────────────────────────────────
+# DATA STRUCTURES
+# ──────────────────────────────────────────────────────────────
+
+class ResearchPhase(str, Enum):
+    RECON      = "RECON"
+    STATIC     = "STATIC"
+    DYNAMIC    = "DYNAMIC"
+    EXPLOIT    = "EXPLOIT"
+    CONSENSUS  = "CONSENSUS"
+    DISCLOSURE = "DISCLOSURE"
+    COMPLETE   = "COMPLETE"
+
+
+@dataclass
+class VulnerabilityFinding:
+    finding_id: str
+    title: str
+    cwe_id: str
+    severity: str            # CRITICAL | HIGH | MEDIUM | LOW
+    confidence: float        # 0.0 - 1.0
+    file_path: str
+    line_number: int
+    description: str
+    proof_of_concept: str
+    exploit_primitive: str   # overflow | uaf | race | injection | crypto | logic
+    ves_score: float         # Vulnerability Entropy Score
+    acts_score: float        # Adversarial Consensus Trust Score
+    phase_found: str
+    raw_evidence: dict = field(default_factory=dict)
+    disclosure_status: str = "PENDING_HUMAN_APPROVAL"
+    timestamp: str = field(default_factory=lambda: time.strftime("%Y-%m-%dT%H:%M:%SZ"))
+
+
+@dataclass
+class HermesSession:
+    session_id: str
+    target_repo: str
+    repo_dir: str
+    phase: ResearchPhase = ResearchPhase.RECON
+    findings: list[VulnerabilityFinding] = field(default_factory=list)
+    tool_call_log: list[dict] = field(default_factory=list)
+    attack_surface: dict = field(default_factory=dict)
+    tvg_graph: dict = field(default_factory=dict)
+    started_at: str = field(default_factory=lambda: time.strftime("%Y-%m-%dT%H:%M:%SZ"))
+    completed_at: Optional[str] = None
+
+
+# ──────────────────────────────────────────────────────────────
+# TOOL REGISTRY — Hermes dispatches these
+# ──────────────────────────────────────────────────────────────
+
+class HermesTool:
+    """Base class for all Hermes-dispatchable tools."""
+    name: str = "base_tool"
+    description: str = ""
+
+    def run(self, **kwargs) -> dict:
+        raise NotImplementedError
+
+
+class ReconTool(HermesTool):
+    name = "recon"
+    description = "Map attack surface of a cloned repository. Returns language, entry points, dangerous sinks, security-critical files."
+
+    def run(self, repo_dir: str, **kwargs) -> dict:
+        hermes_log(f"Recon scan → {repo_dir}", "RECON")
+        from taint_analyzer import map_attack_surface
+        return map_attack_surface(repo_dir)
+
+
+class TaintTool(HermesTool):
+    name = "taint_analysis"
+    description = "Run taint/data-flow analysis to trace untrusted input to dangerous sinks."
+
+    def run(self, repo_dir: str, focus_files: list[str] = None, **kwargs) -> dict:
+        hermes_log(f"Taint analysis → {len(focus_files or [])} focus files", "STATIC")
+        from taint_analyzer import run_taint_analysis
+        return run_taint_analysis(repo_dir, focus_files=focus_files)
+
+
+class SymbolicTool(HermesTool):
+    name = "symbolic_execution"
+    description = "Run symbolic execution to explore all code paths and find unsatisfied constraints."
+
+    def run(self, repo_dir: str, target_function: str = None, **kwargs) -> dict:
+        hermes_log(f"Symbolic execution → {target_function or 'auto-select'}", "STATIC")
+        from symbolic_engine import run_symbolic_analysis
+        return run_symbolic_analysis(repo_dir, target_function=target_function)
+
+
+class FuzzTool(HermesTool):
+    name = "fuzz"
+    description = "Generate a fuzzing harness and execute it against a target function or binary."
+
+    def run(self, repo_dir: str, target: str, language: str = "python", duration_s: int = 60, **kwargs) -> dict:
+        hermes_log(f"Fuzzing → {target} ({duration_s}s)", "DYNAMIC")
+        from fuzzing_engine import run_fuzzing_campaign
+        return run_fuzzing_campaign(repo_dir, target, language=language, duration_s=duration_s)
+
+
+class ExploitTool(HermesTool):
+    name = "exploit_reasoning"
+    description = "Reason about exploitability of a crash or vulnerability candidate. Generate PoC."
+
+    def run(self, crash_input: str, crash_output: str, file_path: str, vuln_type: str, **kwargs) -> dict:
+        hermes_log(f"Exploit reasoning → {vuln_type} in {file_path}", "EXPLOIT")
+        from exploit_primitives import reason_exploitability
+        return reason_exploitability(crash_input, crash_output, file_path, vuln_type)
+
+
+class CVETool(HermesTool):
+    name = "cve_intel"
+    description = "Query CVE/NVD/CWE knowledge base for similar historical vulnerabilities."
+
+    def run(self, description: str, cwe_hint: str = None, **kwargs) -> dict:
+        hermes_log(f"CVE intel → {cwe_hint or 'auto'}", "STATIC")
+        from cve_intel import query_cve_intel
+        return query_cve_intel(description, cwe_hint=cwe_hint)
+
+
+class CommitWatchTool(HermesTool):
+    name = "commit_watch"
+    description = "Analyze recent commits for silent security patches using CAD algorithm."
+
+    def run(self, repo_dir: str, lookback_commits: int = 50, **kwargs) -> dict:
+        hermes_log(f"Commit watch → last {lookback_commits} commits", "CAD")
+        from commit_watcher import analyze_recent_commits
+        return analyze_recent_commits(repo_dir, lookback=lookback_commits)
+
+
+class SSECTool(HermesTool):
+    name = "ssec_scan"
+    description = "Semantic Similarity Exploit Chain: find code patterns similar to known exploits."
+
+    def run(self, repo_dir: str, focus_files: list[str] = None, **kwargs) -> dict:
+        hermes_log("SSEC scan — embedding similarity to known exploit patterns", "SSEC")
+        from cve_intel import run_ssec_scan
+        return run_ssec_scan(repo_dir, focus_files=focus_files)
+
+
+_TOOL_REGISTRY: dict[str, HermesTool] = {
+    t.name: t() for t in [
+        ReconTool, TaintTool, SymbolicTool, FuzzTool,
+        ExploitTool, CVETool, CommitWatchTool, SSECTool,
+    ]
+}
+
+
+def _dispatch_tool(tool_name: str, args: dict, session: HermesSession) -> dict:
+    tool = _TOOL_REGISTRY.get(tool_name)
+    if not tool:
+        return {"error": f"Unknown tool: {tool_name}"}
+    start = time.time()
+    try:
+        result = tool.run(**args)
+    except Exception as e:
+        result = {"error": str(e)}
+    elapsed = round(time.time() - start, 2)
+    session.tool_call_log.append({
+        "tool": tool_name, "args": args,
+        "result_keys": list(result.keys()) if isinstance(result, dict) else "non-dict",
+        "elapsed_s": elapsed, "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
+    })
+    return result
+
+
+# ──────────────────────────────────────────────────────────────
+# VES — VULNERABILITY ENTROPY SCORE (Custom Algorithm)
+# ──────────────────────────────────────────────────────────────
+
+def compute_ves(
+    reachability: float,     # 0-1: how reachable is this from untrusted input
+    severity_class: str,     # CRITICAL | HIGH | MEDIUM | LOW
+    novelty: float,          # 0-1: how different from known CVEs (higher = more novel/interesting)
+    exploit_complexity: str, # LOW | MEDIUM | HIGH
+    auth_required: bool,
+) -> float:
+    """
+    VES (Vulnerability Entropy Score) — custom algorithm.
+
+    Measures the "information surprise" of a vulnerability weighted by its
+    danger. High VES = high-value finding (novel + dangerous + reachable).
+
+    Formula inspired by Shannon entropy: VES = -log2(P) × W
+    Where P is the probability an auditor would find this naturally,
+    and W is a danger weight. Higher VES = better bug bounty target.
+    """
+    import math
+
+    severity_weight = {"CRITICAL": 1.0, "HIGH": 0.75, "MEDIUM": 0.5, "LOW": 0.25}.get(severity_class, 0.5)
+    complexity_factor = {"LOW": 0.9, "MEDIUM": 0.6, "HIGH": 0.3}.get(exploit_complexity, 0.6)
+    auth_penalty = 0.7 if auth_required else 1.0
+
+    # P(naturally found) = (1 - novelty) × (1 - reachability × 0.5)
+    p_found_naturally = max(0.001, (1.0 - novelty) * (1.0 - reachability * 0.5))
+    entropy = -math.log2(p_found_naturally)
+
+    ves = entropy * severity_weight * complexity_factor * auth_penalty * reachability
+    return round(min(ves, 10.0), 4)
+
+
+# ──────────────────────────────────────────────────────────────
+# ACTS — ADVERSARIAL CONSENSUS TRUST SCORE (Custom Algorithm)
+# ──────────────────────────────────────────────────────────────
+
+def compute_acts(model_verdicts: list[dict]) -> float:
+    """
+    ACTS (Adversarial Consensus Trust Score) — Bayesian multi-model confidence.
+
+    Each model contributes a vote weighted by its stated confidence.
+    Agreement amplifies confidence. Disagreement deflates it.
+    Returns 0.0–1.0 where >0.7 = high trust finding.
+    """
+    if not model_verdicts:
+        return 0.0
+
+    confirm_weight = 0.0
+    total_weight = 0.0
+    agreements = 0
+    first_verdict = model_verdicts[0].get("verdict", "UNCERTAIN")
+
+    for verdict in model_verdicts:
+        v = verdict.get("verdict", "UNCERTAIN")
+        c = float(verdict.get("confidence", 0.5))
+        total_weight += c
+        if v in ("CONFIRM", "APPROVE", "VULNERABLE"):
+            confirm_weight += c
+        if v == first_verdict:
+            agreements += 1
+
+    if total_weight == 0:
+        return 0.0
+
+    raw_score = confirm_weight / total_weight
+    agreement_factor = agreements / len(model_verdicts)
+    acts = raw_score * (0.6 + 0.4 * agreement_factor)
+    return round(acts, 4)
+
+
+# ──────────────────────────────────────────────────────────────
+# LLM CALLS — Hermes reasoning engine
+# ──────────────────────────────────────────────────────────────
+
+_HERMES_SYSTEM = """You are Hermes, a world-class autonomous security research agent.
+Your goal is to find real, exploitable vulnerabilities in open source projects.
+You are methodical, adversarial, and thorough. You think like an attacker.
+
+You have access to these tools:
+- recon: Map attack surface (entry points, dangerous sinks, security-critical files)
+- taint_analysis: Trace untrusted input to dangerous sinks
+- symbolic_execution: Explore all code paths mathematically
+- fuzz: Generate and run fuzzing campaigns to find crashes
+- exploit_reasoning: Reason about exploitability, generate PoC
+- cve_intel: Query historical CVEs for similar patterns
+- commit_watch: Find silent security patches in commit history
+- ssec_scan: Semantic similarity to known exploit patterns
+
+For each target, produce a research plan and execute it step by step.
+When you find something, rate its severity honestly. Never hallucinate findings.
+A false positive wastes a maintainer's time. Be certain before escalating.
+
+Respond with JSON tool calls in this format:
+{
+  "thought": "your reasoning about what to do next",
+  "tool": "tool_name",
+  "args": {"key": "value"},
+  "phase": "RECON|STATIC|DYNAMIC|EXPLOIT|CONSENSUS|DISCLOSURE"
+}
+Or to report a final finding:
+{
+  "thought": "summary reasoning",
+  "finding": {
+    "title": "...", "cwe_id": "CWE-XXX", "severity": "HIGH",
+    "confidence": 0.85, "file_path": "...", "line_number": 0,
+    "description": "...", "proof_of_concept": "...", "exploit_primitive": "..."
+  }
+}
+Or to signal completion:
+{"done": true, "summary": "..."}
+"""
+
+
+def _hermes_llm_call(messages: list[dict], model: str = None, timeout: int = 120) -> dict:
+    if not OPENROUTER_API_KEY:
+        return {"done": True, "summary": "OPENROUTER_API_KEY not set"}
+
+    model = model or HERMES_MODEL
+    headers = {
+        "Authorization": f"Bearer {OPENROUTER_API_KEY}",
+        "Content-Type": "application/json",
+        "HTTP-Referer": "https://rhodawk.ai",
+        "X-Title": "Rhodawk Hermes Orchestrator",
+    }
+    payload = {
+        "model": model,
+        "messages": messages,
+        "temperature": 0.2,
+        "max_tokens": 2048,
+        "response_format": {"type": "json_object"},
+    }
+    try:
+        resp = requests.post(
+            f"{OPENROUTER_BASE}/chat/completions",
+            headers=headers, json=payload, timeout=timeout,
+        )
+        resp.raise_for_status()
+        content = resp.json()["choices"][0]["message"]["content"]
+        return json.loads(content)
+    except Exception as e:
+        hermes_log(f"LLM call failed: {e}", "WARN")
+        return {"done": True, "summary": f"LLM error: {e}"}
+
+
+# ──────────────────────────────────────────────────────────────
+# MAIN HERMES RESEARCH LOOP
+# ──────────────────────────────────────────────────────────────
+
+def run_hermes_research(
+    target_repo: str,
+    repo_dir: str,
+    focus_area: str = "",
+    max_iterations: int = 20,
+    progress_callback: Optional[Callable[[str], None]] = None,
+) -> HermesSession:
+    """
+    Main Hermes research loop. Runs until max_iterations or completion.
+    Returns a HermesSession with all findings.
+    """
+    session_id = hashlib.sha256(f"{target_repo}{time.time()}".encode()).hexdigest()[:12]
+    session = HermesSession(
+        session_id=session_id,
+        target_repo=target_repo,
+        repo_dir=repo_dir,
+    )
+
+    def log(msg, level="HERMES"):
+        hermes_log(msg, level)
+        if progress_callback:
+            progress_callback(f"[{level}] {msg}")
+
+    log(f"Session {session_id} started → {target_repo}")
+    log(f"Model: {HERMES_MODEL} | Max iterations: {max_iterations}")
+
+    messages = [
+        {"role": "system", "content": _HERMES_SYSTEM},
+        {"role": "user", "content": (
+            f"TARGET REPOSITORY: {target_repo}\n"
+            f"LOCAL PATH: {repo_dir}\n"
+            f"FOCUS AREA: {focus_area or 'Full autonomous scan — prioritize attack surface'}\n\n"
+            "Begin your security research. Start with reconnaissance to map the attack surface, "
+            "then systematically probe for vulnerabilities. Remember: only report findings you "
+            "are confident are real and exploitable."
+        )},
+    ]
+
+    for iteration in range(max_iterations):
+        log(f"Iteration {iteration + 1}/{max_iterations}", "HERMES")
+
+        response = _hermes_llm_call(messages)
+
+        if response.get("done"):
+            log(f"Research complete: {response.get('summary', 'No summary')}", "OK")
+            session.phase = ResearchPhase.COMPLETE
+            break
+
+        if "finding" in response:
+            finding_data = response["finding"]
+            log(f"FINDING: {finding_data.get('title', '?')} [{finding_data.get('severity', '?')}]", "FIND")
+
+            # Compute VES
+            ves = compute_ves(
+                reachability=finding_data.get("confidence", 0.5),
+                severity_class=finding_data.get("severity", "MEDIUM"),
+                novelty=0.6,
+                exploit_complexity="MEDIUM",
+                auth_required=False,
+            )
+            log(f"VES Score: {ves}", "VES")
+
+            finding = VulnerabilityFinding(
+                finding_id=hashlib.sha256(
+                    f"{finding_data.get('file_path', '')}{finding_data.get('line_number', 0)}{time.time()}".encode()
+                ).hexdigest()[:12],
+                title=finding_data.get("title", "Unnamed Finding"),
+                cwe_id=finding_data.get("cwe_id", "CWE-UNKNOWN"),
+                severity=finding_data.get("severity", "MEDIUM"),
+                confidence=float(finding_data.get("confidence", 0.5)),
+                file_path=finding_data.get("file_path", ""),
+                line_number=int(finding_data.get("line_number", 0)),
+                description=finding_data.get("description", ""),
+                proof_of_concept=finding_data.get("proof_of_concept", ""),
+                exploit_primitive=finding_data.get("exploit_primitive", "unknown"),
+                ves_score=ves,
+                acts_score=0.0,
+                phase_found=session.phase.value,
+                disclosure_status="PENDING_HUMAN_APPROVAL",
+            )
+            session.findings.append(finding)
+
+            messages.append({"role": "assistant", "content": json.dumps(response)})
+            messages.append({"role": "user", "content": (
+                f"Finding recorded (ID: {finding.finding_id}, VES: {ves}). "
+                "Continue research ��� there may be more vulnerabilities. "
+                "If you believe the surface is exhausted, signal done."
+            )})
+            continue
+
+        if "tool" not in response:
+            log("No tool call in response — signaling done", "WARN")
+            break
+
+        tool_name = response.get("tool", "")
+        tool_args = response.get("args", {})
+        phase_str = response.get("phase", session.phase.value)
+        thought = response.get("thought", "")
+
+        try:
+            session.phase = ResearchPhase(phase_str)
+        except ValueError:
+            pass
+
+        log(f"Phase: {session.phase.value} | Tool: {tool_name}", session.phase.value)
+        if thought:
+            log(f"Reasoning: {thought[:200]}", "HERMES")
+
+        tool_args["repo_dir"] = repo_dir
+        tool_result = _dispatch_tool(tool_name, tool_args, session)
+
+        if tool_name == "recon" and isinstance(tool_result, dict):
+            session.attack_surface = tool_result
+            log(f"Attack surface: {len(tool_result.get('dangerous_sinks', []))} sinks, "
+                f"{len(tool_result.get('entry_points', []))} entry points", "RECON")
+
+        messages.append({"role": "assistant", "content": json.dumps(response)})
+        messages.append({
+            "role": "user",
+            "content": (
+                f"Tool '{tool_name}' result:\n```json\n"
+                f"{json.dumps(tool_result, indent=2)[:3000]}\n```\n\n"
+                "Based on these results, what is your next action?"
+            ),
+        })
+
+        time.sleep(1)
+
+    # Run ACTS consensus on all findings
+    if session.findings:
+        log(f"Running ACTS consensus on {len(session.findings)} finding(s)...", "CONSENSUS")
+        session.phase = ResearchPhase.CONSENSUS
+        _run_acts_consensus(session)
+
+    session.phase = ResearchPhase.DISCLOSURE
+    session.completed_at = time.strftime("%Y-%m-%dT%H:%M:%SZ")
+    log(f"Session complete — {len(session.findings)} finding(s) pending human approval", "DISCLOSURE")
+    return session
+
+
+def _run_acts_consensus(session: HermesSession):
+    """Run multi-model adversarial consensus on each finding to compute ACTS score."""
+    from adversarial_reviewer import _call_concurrent_consensus
+
+    CONSENSUS_MODELS = [
+        "deepseek/deepseek-r1:free",
+        "meta-llama/llama-3.3-70b-instruct:free",
+        "google/gemma-3-27b-it:free",
+    ]
+
+    for finding in session.findings:
+        hermes_log(f"ACTS consensus: {finding.finding_id}", "ACTS")
+        prompt = (
+            f"VULNERABILITY FINDING FOR CONSENSUS REVIEW\n\n"
+            f"Title: {finding.title}\n"
+            f"CWE: {finding.cwe_id}\n"
+            f"Severity claimed: {finding.severity}\n"
+            f"File: {finding.file_path}:{finding.line_number}\n"
+            f"Description: {finding.description}\n"
+            f"PoC: {finding.proof_of_concept}\n"
+            f"Exploit primitive: {finding.exploit_primitive}\n\n"
+            "Is this a real, exploitable vulnerability? Respond as a hostile security reviewer."
+        )
+        try:
+            result, _ = _call_concurrent_consensus(prompt)
+            verdicts = [
+                {"verdict": result.get("verdict", "UNCERTAIN"), "confidence": result.get("confidence", 0.5)}
+            ]
+            finding.acts_score = compute_acts(verdicts)
+            hermes_log(f"ACTS score for {finding.finding_id}: {finding.acts_score}", "ACTS")
+        except Exception as e:
+            hermes_log(f"ACTS consensus failed for {finding.finding_id}: {e}", "WARN")
+            finding.acts_score = finding.confidence
+
+
+# ──────────────────────────────────────────────────────────────
+# TVG — TEMPORAL VULNERABILITY GRAPH (Custom Algorithm)
+# ──────────────────────────────────────────────────────────────
+
+def build_tvg(repo_dir: str, findings: list[VulnerabilityFinding]) -> dict:
+    """
+    TVG (Temporal Vulnerability Graph) — tracks how vulnerability patterns
+    propagate across commits over time.
+
+    Builds a directed graph: commit → file → vulnerable_function → severity
+    Allows answering: "was this bug always here, or introduced recently?"
+    """
+    import subprocess
+    graph = {"nodes": [], "edges": [], "hotspots": []}
+
+    for finding in findings:
+        if not finding.file_path:
+            continue
+        try:
+            result = subprocess.run(
+                ["git", "log", "--follow", "--oneline", "-20", "--", finding.file_path],
+                cwd=repo_dir, capture_output=True, text=True, timeout=10,
+            )
+            commits = [line.split(" ", 1) for line in result.stdout.strip().splitlines() if line]
+            for sha, msg in commits[:5]:
+                node = {"id": sha[:8], "file": finding.file_path, "msg": msg[:80]}
+                if node not in graph["nodes"]:
+                    graph["nodes"].append(node)
+                graph["edges"].append({
+                    "from": sha[:8], "to": finding.finding_id,
+                    "label": finding.cwe_id,
+                })
+            if len(commits) > 10:
+                graph["hotspots"].append({
+                    "file": finding.file_path, "commit_count": len(commits),
+                    "finding": finding.finding_id,
+                })
+        except Exception:
+            pass
+
+    return graph
+
+
+def get_session_summary(session: HermesSession) -> dict:
+    """Produce a human-readable summary of a research session."""
+    findings_by_sev: dict[str, list] = {}
+    for f in session.findings:
+        findings_by_sev.setdefault(f.severity, []).append(f)
+
+    return {
+        "session_id": session.session_id,
+        "target": session.target_repo,
+        "started_at": session.started_at,
+        "completed_at": session.completed_at,
+        "phase": session.phase.value,
+        "total_findings": len(session.findings),
+        "by_severity": {k: len(v) for k, v in findings_by_sev.items()},
+        "top_findings": [
+            {
+                "id": f.finding_id, "title": f.title, "cwe": f.cwe_id,
+                "severity": f.severity, "ves": f.ves_score, "acts": f.acts_score,
+                "file": f.file_path, "status": f.disclosure_status,
+            }
+            for f in sorted(session.findings, key=lambda x: x.ves_score, reverse=True)[:5]
+        ],
+        "tool_calls": len(session.tool_call_log),
+        "attack_surface_size": len(session.attack_surface.get("dangerous_sinks", [])),
+    }

mcp_config.json

@@ -3,17 +3,14 @@
     "TEMPLATE ONLY — contains NO secrets.",
     "Actual runtime config is written to /tmp/mcp_runtime.json at startup.",
     "FETCH_ALLOWED_DOMAINS prevents SSRF against internal services.",
-    "GITHUB_PERSONAL_ACCESS_TOKEN is injected from env at runtime — never committed.",
-    "NOTE: @modelcontextprotocol/server-fetch does not exist on npm.",
-    "      The fetch MCP server is a Python package (mcp-server-fetch on PyPI).",
-    "      It is installed via uv in the Dockerfile and invoked with `uvx mcp-server-fetch`."
+    "Secrets injected from env at runtime — never committed."
   ],
   "mcpServers": {
     "fetch-docs": {
       "command": "uvx",
       "args": ["mcp-server-fetch"],
       "env": {
-        "FETCH_ALLOWED_DOMAINS": "docs.python.org,pypi.org,docs.github.com,packaging.python.org,peps.python.org"
+        "FETCH_ALLOWED_DOMAINS": "docs.python.org,pypi.org,docs.github.com,packaging.python.org,peps.python.org,cwe.mitre.org,nvd.nist.gov,owasp.org,portswigger.net,hackerone.com,bugcrowd.com,cve.org,exploit-db.com,docs.rs,go.dev,nodejs.org,developer.mozilla.org"
       }
     },
     "github-manager": {
@@ -22,6 +19,29 @@
       "env": {
         "GITHUB_PERSONAL_ACCESS_TOKEN": "__INJECTED_BY_APP_AT_RUNTIME__"
       }
+    },
+    "filesystem-research": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/data/repo", "/tmp/research"],
+      "description": "Read-only access to cloned repos and research scratch space"
+    },
+    "memory-store": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-memory"],
+      "description": "Persistent knowledge graph for cross-session vulnerability memory"
+    },
+    "sequential-thinking": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"],
+      "description": "Structured chain-of-thought for complex vulnerability analysis"
+    },
+    "web-search": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
+      "env": {
+        "BRAVE_API_KEY": "__INJECTED_BY_APP_AT_RUNTIME__"
+      },
+      "description": "Search for CVEs, exploit PoCs, vendor advisories, and security research"
     }
   }
 }

requirements.txt

@@ -24,3 +24,7 @@ z3-solver>=4.12.0
 qdrant-client>=1.9.0
 transformers>=4.40.0
 torch>=2.2.0
+atheris>=2.3.0
+angr>=9.2.0
+networkx>=3.0
+defusedxml>=0.7.1

symbolic_engine.py

@@ -0,0 +1,350 @@
+"""
+Rhodawk AI — Symbolic Execution Engine
+========================================
+Uses angr (Python binary analysis framework) to perform symbolic execution
+on compiled binaries, and AST-based path analysis for interpreted languages.
+
+For Python/JS repos where angr isn't applicable, performs:
+  - Control flow graph analysis
+  - Constraint collection on input-touching branches
+  - Path condition enumeration to find unreachable/unchecked branches
+
+Findings fed back to Hermes for exploit_primitives reasoning.
+"""
+
+from __future__ import annotations
+
+import ast
+import os
+import json
+import tempfile
+import subprocess
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class SymbolicPath:
+    function_name: str
+    file_path: str
+    line_start: int
+    line_end: int
+    constraint_summary: str
+    is_vulnerable: bool
+    vulnerability_type: str     # unchecked_input | integer_overflow | null_deref | format_string
+    confidence: float
+    angr_available: bool = False
+
+
+@dataclass
+class SymbolicResult:
+    target_function: str
+    paths_explored: int
+    vulnerable_paths: list[SymbolicPath]
+    overflow_candidates: list[dict]
+    null_deref_candidates: list[dict]
+    unchecked_inputs: list[dict]
+    tool_used: str             # angr | ast_analysis | semgrep_symbolic
+
+
+def _try_import_angr():
+    try:
+        import angr
+        return angr
+    except ImportError:
+        return None
+
+
+def _find_binary(repo_dir: str) -> Optional[str]:
+    """Find a compiled binary in the repo."""
+    for root, dirs, files in os.walk(repo_dir):
+        dirs[:] = [d for d in dirs if d not in [".git", "node_modules", "__pycache__"]]
+        for f in files:
+            fpath = os.path.join(root, f)
+            try:
+                if os.access(fpath, os.X_OK) and not f.endswith((".py", ".js", ".ts", ".sh")):
+                    result = subprocess.run(
+                        ["file", fpath], capture_output=True, text=True, timeout=3,
+                    )
+                    if "ELF" in result.stdout or "Mach-O" in result.stdout:
+                        return fpath
+            except Exception:
+                pass
+    return None
+
+
+def _angr_analysis(binary_path: str, target_function: str) -> SymbolicResult:
+    """Run angr symbolic execution on a compiled binary."""
+    angr = _try_import_angr()
+    if not angr:
+        return SymbolicResult(
+            target_function=target_function,
+            paths_explored=0,
+            vulnerable_paths=[],
+            overflow_candidates=[],
+            null_deref_candidates=[],
+            unchecked_inputs=[],
+            tool_used="angr_unavailable",
+        )
+
+    vulnerable_paths = []
+    overflow_candidates = []
+
+    try:
+        proj = angr.Project(binary_path, auto_load_libs=False)
+        cfg = proj.analyses.CFGFast()
+
+        func = None
+        for addr, f in proj.kb.functions.items():
+            if target_function in (f.name or ""):
+                func = f
+                break
+
+        if func is None:
+            func = list(proj.kb.functions.values())[0] if proj.kb.functions else None
+
+        if func:
+            state = proj.factory.blank_state(addr=func.addr)
+            simgr = proj.factory.simulation_manager(state)
+            simgr.explore(find=lambda s: s.solver.satisfiable(), n=50)
+
+            paths_explored = len(simgr.active) + len(simgr.deadended)
+
+            for state in simgr.active[:10]:
+                constraints = str(state.solver.constraints)[:200]
+                if any(kw in constraints for kw in ["__add__", "__mul__", "SignExt"]):
+                    overflow_candidates.append({
+                        "address": hex(state.addr),
+                        "constraint_hint": constraints[:100],
+                        "type": "potential_integer_overflow",
+                    })
+
+            return SymbolicResult(
+                target_function=target_function or func.name or "unknown",
+                paths_explored=paths_explored,
+                vulnerable_paths=vulnerable_paths,
+                overflow_candidates=overflow_candidates,
+                null_deref_candidates=[],
+                unchecked_inputs=[],
+                tool_used="angr",
+            )
+    except Exception as e:
+        return SymbolicResult(
+            target_function=target_function,
+            paths_explored=0,
+            vulnerable_paths=[],
+            overflow_candidates=[{"error": str(e)}],
+            null_deref_candidates=[],
+            unchecked_inputs=[],
+            tool_used="angr_error",
+        )
+
+
+def _ast_analysis(repo_dir: str, target_function: str) -> SymbolicResult:
+    """
+    AST-based symbolic path analysis for Python code.
+    Finds:
+    - Functions that accept user input without validation
+    - Integer arithmetic without bounds checks before dangerous operations
+    - Format string interpolation of external data
+    - Null/None returns used without checks
+    """
+    import glob
+
+    vulnerable_paths = []
+    unchecked_inputs = []
+    overflow_candidates = []
+    null_deref_candidates = []
+    paths_explored = 0
+
+    DANGEROUS_CALLS = {
+        "eval", "exec", "compile", "subprocess.call", "subprocess.run",
+        "os.system", "os.popen", "open", "pickle.loads", "yaml.load",
+        "__import__", "getattr", "setattr",
+    }
+    INPUT_SOURCES = {
+        "input", "request.args", "request.form", "request.json",
+        "request.data", "sys.argv", "os.environ", "socket.recv",
+        "read", "readline", "readlines",
+    }
+    INT_OPS = {"__add__", "__mul__", "__lshift__", "<<", "+", "*"}
+
+    for py_file in glob.glob(f"{repo_dir}/**/*.py", recursive=True):
+        if "test_" in py_file or "site-packages" in py_file or ".tox" in py_file:
+            continue
+        try:
+            source = open(py_file).read()
+            tree = ast.parse(source)
+        except Exception:
+            continue
+
+        rel_path = os.path.relpath(py_file, repo_dir)
+
+        class InputFlowVisitor(ast.NodeVisitor):
+            def __init__(self):
+                self.tainted_vars = set()
+                self.findings = []
+
+            def visit_Assign(self, node):
+                if isinstance(node.value, ast.Call):
+                    func_name = _get_call_name(node.value)
+                    if any(src in func_name for src in INPUT_SOURCES):
+                        for target in node.targets:
+                            if isinstance(target, ast.Name):
+                                self.tainted_vars.add(target.id)
+                self.generic_visit(node)
+
+            def visit_Call(self, node):
+                func_name = _get_call_name(node)
+                if any(danger in func_name for danger in DANGEROUS_CALLS):
+                    for arg in node.args:
+                        if isinstance(arg, ast.Name) and arg.id in self.tainted_vars:
+                            self.findings.append({
+                                "type": "tainted_input_to_dangerous_sink",
+                                "sink": func_name,
+                                "variable": arg.id,
+                                "line": node.lineno,
+                            })
+                self.generic_visit(node)
+
+        def _get_call_name(node):
+            if isinstance(node.func, ast.Name):
+                return node.func.id
+            if isinstance(node.func, ast.Attribute):
+                return f"{_get_attr_chain(node.func)}"
+            return ""
+
+        def _get_attr_chain(node):
+            if isinstance(node, ast.Attribute):
+                return f"{_get_attr_chain(node.value)}.{node.attr}"
+            if isinstance(node, ast.Name):
+                return node.id
+            return ""
+
+        for node in ast.walk(tree):
+            paths_explored += 1
+
+            if isinstance(node, ast.FunctionDef):
+                if target_function and target_function not in node.name:
+                    continue
+
+                has_validation = False
+                has_int_op = False
+                accepts_external = False
+
+                for arg in node.args.args:
+                    if arg.arg in ("data", "input", "user_input", "buf", "content", "payload", "request"):
+                        accepts_external = True
+
+                for child in ast.walk(node):
+                    if isinstance(child, ast.If):
+                        has_validation = True
+                    if isinstance(child, ast.BinOp) and isinstance(child.op, (ast.Add, ast.Mult, ast.LShift)):
+                        has_int_op = True
+
+                if accepts_external and not has_validation:
+                    unchecked_inputs.append({
+                        "function": node.name,
+                        "file": rel_path,
+                        "line": node.lineno,
+                        "reason": "accepts external input without apparent validation branch",
+                    })
+
+                if has_int_op and accepts_external:
+                    overflow_candidates.append({
+                        "function": node.name,
+                        "file": rel_path,
+                        "line": node.lineno,
+                        "reason": "integer arithmetic on externally-supplied values without bounds check",
+                    })
+
+            if isinstance(node, (ast.BinOp, ast.AugAssign)):
+                if isinstance(getattr(node, "op", None), (ast.Add, ast.Mult, ast.LShift)):
+                    pass
+
+        visitor = InputFlowVisitor()
+        visitor.visit(tree)
+        for f in visitor.findings:
+            vulnerable_paths.append(SymbolicPath(
+                function_name=f.get("sink", "unknown"),
+                file_path=rel_path,
+                line_start=f.get("line", 0),
+                line_end=f.get("line", 0),
+                constraint_summary=f.get("type", ""),
+                is_vulnerable=True,
+                vulnerability_type="unchecked_input",
+                confidence=0.7,
+            ))
+
+    return SymbolicResult(
+        target_function=target_function or "all",
+        paths_explored=paths_explored,
+        vulnerable_paths=vulnerable_paths,
+        overflow_candidates=overflow_candidates,
+        null_deref_candidates=null_deref_candidates,
+        unchecked_inputs=unchecked_inputs,
+        tool_used="ast_analysis",
+    )
+
+
+def _semgrep_symbolic(repo_dir: str) -> dict:
+    """Run semgrep with security-focused rules for additional coverage."""
+    try:
+        result = subprocess.run(
+            ["semgrep", "--config", "p/security-audit", "--json",
+             "--timeout", "60", "--max-memory", "512", repo_dir],
+            capture_output=True, text=True, timeout=90,
+        )
+        if result.returncode in (0, 1):
+            data = json.loads(result.stdout or "{}")
+            return {
+                "findings": len(data.get("results", [])),
+                "results": data.get("results", [])[:10],
+                "tool": "semgrep_security_audit",
+            }
+    except Exception as e:
+        pass
+    return {"findings": 0, "results": [], "tool": "semgrep_unavailable"}
+
+
+def run_symbolic_analysis(repo_dir: str, target_function: str = None) -> dict:
+    """
+    Main entry point. Chooses the best available analysis method.
+    """
+    binary = _find_binary(repo_dir)
+    angr = _try_import_angr()
+
+    if binary and angr:
+        print(f"[SYMBOLIC] Using angr on binary: {binary}")
+        result = _angr_analysis(binary, target_function or "main")
+        tool_used = "angr"
+    else:
+        print(f"[SYMBOLIC] Using AST analysis (angr not available or no binary found)")
+        result = _ast_analysis(repo_dir, target_function or "")
+        tool_used = "ast_analysis"
+
+    semgrep = _semgrep_symbolic(repo_dir)
+
+    return {
+        "tool_used": tool_used,
+        "paths_explored": result.paths_explored,
+        "vulnerable_paths": [
+            {
+                "function": p.function_name, "file": p.file_path,
+                "line": p.line_start, "type": p.vulnerability_type,
+                "confidence": p.confidence, "summary": p.constraint_summary,
+            }
+            for p in result.vulnerable_paths[:10]
+        ],
+        "overflow_candidates": result.overflow_candidates[:5],
+        "unchecked_inputs": result.unchecked_inputs[:10],
+        "null_deref_candidates": result.null_deref_candidates[:5],
+        "semgrep_findings": semgrep.get("findings", 0),
+        "semgrep_results": semgrep.get("results", [])[:5],
+        "total_issues": (
+            len(result.vulnerable_paths)
+            + len(result.overflow_candidates)
+            + len(result.unchecked_inputs)
+            + semgrep.get("findings", 0)
+        ),
+    }

taint_analyzer.py

@@ -0,0 +1,304 @@
+"""
+Rhodawk AI — Taint Analysis Engine
+=====================================
+Tracks untrusted input as it flows through source code to dangerous sinks.
+Language-agnostic: Python (AST), JS/TS (regex+AST heuristics), Go (grep patterns).
+
+Also exposes map_attack_surface() used by Hermes recon phase.
+"""
+
+from __future__ import annotations
+
+import ast
+import glob
+import json
+import os
+import re
+import subprocess
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class TaintFlow:
+    source: str          # where untrusted input enters
+    sink: str            # dangerous function it reaches
+    path: list[str]      # chain of variable names/calls
+    file_path: str
+    source_line: int
+    sink_line: int
+    cwe_candidates: list[str]
+    confidence: float
+
+
+@dataclass
+class AttackSurface:
+    entry_points: list[dict]        # functions reachable from network/user
+    dangerous_sinks: list[dict]     # calls to exec/eval/open/format etc
+    security_critical_files: list[str]
+    external_dependencies: list[str]
+    crypto_operations: list[dict]
+    authentication_flows: list[dict]
+    deserialization_points: list[dict]
+    language: str
+
+
+_PYTHON_SOURCES = {
+    "input", "sys.argv", "os.environ.get", "os.getenv",
+    "request.args.get", "request.form.get", "request.json",
+    "request.data", "request.body", "request.POST", "request.GET",
+    "socket.recv", "socket.recvfrom", "read", "readline",
+    "json.loads", "urllib.parse.parse_qs", "flask.request",
+    "django.request", "fastapi.Body", "fastapi.Query",
+}
+
+_PYTHON_SINKS = {
+    "eval": "CWE-95",
+    "exec": "CWE-95",
+    "compile": "CWE-95",
+    "os.system": "CWE-78",
+    "os.popen": "CWE-78",
+    "subprocess.call": "CWE-78",
+    "subprocess.run": "CWE-78",
+    "subprocess.Popen": "CWE-78",
+    "open": "CWE-73",
+    "pickle.loads": "CWE-502",
+    "pickle.load": "CWE-502",
+    "yaml.load": "CWE-502",
+    "marshal.loads": "CWE-502",
+    "shelve.open": "CWE-502",
+    "__import__": "CWE-95",
+    "getattr": "CWE-913",
+    "setattr": "CWE-913",
+    "format": "CWE-134",
+    "% s": "CWE-134",
+    "cursor.execute": "CWE-89",
+    "raw_input": "CWE-20",
+    "render_template_string": "CWE-94",
+    "send_file": "CWE-73",
+    "redirect": "CWE-601",
+}
+
+_JS_SINKS = {
+    r"eval\s*\(": "CWE-95",
+    r"new\s+Function\s*\(": "CWE-95",
+    r"child_process\.exec\s*\(": "CWE-78",
+    r"execSync\s*\(": "CWE-78",
+    r"innerHTML\s*=": "CWE-79",
+    r"document\.write\s*\(": "CWE-79",
+    r"dangerouslySetInnerHTML": "CWE-79",
+    r"__proto__": "CWE-1321",
+    r"res\.redirect\s*\(": "CWE-601",
+    r"require\s*\(\s*req\b": "CWE-706",
+    r"fs\.readFile\s*\(": "CWE-73",
+    r"path\.join\s*\(": "CWE-22",
+    r"serialize\s*\(": "CWE-502",
+    r"deserialize\s*\(": "CWE-502",
+    r"\.query\s*\(": "CWE-89",
+}
+
+_SECURITY_FILE_PATTERNS = [
+    "auth", "login", "password", "token", "session", "crypto",
+    "cipher", "ssl", "tls", "secret", "key", "permission", "acl",
+    "admin", "sudo", "privilege", "sql", "query", "database",
+    "upload", "download", "file", "path", "directory",
+]
+
+
+def map_attack_surface(repo_dir: str) -> dict:
+    """
+    Comprehensive attack surface mapping — used by Hermes recon phase.
+    Returns structured data about entry points, sinks, and security-critical areas.
+    """
+    entry_points = []
+    dangerous_sinks = []
+    security_files = []
+    crypto_ops = []
+    auth_flows = []
+    deser_points = []
+    ext_deps = []
+
+    # --- Python files ---
+    for py_file in glob.glob(f"{repo_dir}/**/*.py", recursive=True):
+        if "site-packages" in py_file or ".tox" in py_file or "node_modules" in py_file:
+            continue
+        rel = os.path.relpath(py_file, repo_dir)
+
+        if any(p in rel.lower() for p in _SECURITY_FILE_PATTERNS):
+            security_files.append(rel)
+
+        try:
+            source = open(py_file).read()
+            lines = source.splitlines()
+        except Exception:
+            continue
+
+        for i, line in enumerate(lines, 1):
+            stripped = line.strip()
+
+            for sink, cwe in _PYTHON_SINKS.items():
+                if sink in stripped and not stripped.startswith("#"):
+                    dangerous_sinks.append({
+                        "file": rel, "line": i,
+                        "sink": sink, "cwe": cwe,
+                        "snippet": stripped[:120],
+                    })
+
+            if any(src in stripped for src in ["@app.route", "@router.", "def get(", "def post(", "def put(", "def delete(", "async def "]):
+                entry_points.append({"file": rel, "line": i, "snippet": stripped[:100]})
+
+            if any(kw in stripped.lower() for kw in ["hashlib", "hmac", "aes", "rsa", "des", "md5", "sha1", "random.random()"]):
+                crypto_ops.append({"file": rel, "line": i, "snippet": stripped[:100]})
+                if "md5" in stripped.lower() or "sha1" in stripped.lower() or "random.random" in stripped.lower():
+                    crypto_ops[-1]["warning"] = "weak_crypto"
+
+            if any(kw in stripped.lower() for kw in ["pickle.load", "yaml.load(", "marshal.load", "jsonpickle"]):
+                deser_points.append({"file": rel, "line": i, "snippet": stripped[:100]})
+
+    # --- JS/TS files ---
+    for js_file in glob.glob(f"{repo_dir}/**/*.js", recursive=True):
+        if "node_modules" in js_file or ".min." in js_file:
+            continue
+        rel = os.path.relpath(js_file, repo_dir)
+        if any(p in rel.lower() for p in _SECURITY_FILE_PATTERNS):
+            security_files.append(rel)
+        try:
+            source = open(js_file).read()
+            lines = source.splitlines()
+        except Exception:
+            continue
+
+        for i, line in enumerate(lines, 1):
+            for pattern, cwe in _JS_SINKS.items():
+                if re.search(pattern, line):
+                    dangerous_sinks.append({
+                        "file": rel, "line": i,
+                        "sink": pattern[:30], "cwe": cwe,
+                        "snippet": line.strip()[:120],
+                    })
+
+    # --- Dependencies ---
+    for req_file in ["requirements.txt", "package.json", "go.mod", "Gemfile", "Cargo.toml"]:
+        fpath = os.path.join(repo_dir, req_file)
+        if os.path.exists(fpath):
+            try:
+                content = open(fpath).read()
+                if req_file == "package.json":
+                    data = json.loads(content)
+                    deps = {**data.get("dependencies", {}), **data.get("devDependencies", {})}
+                    ext_deps.extend(list(deps.keys())[:30])
+                else:
+                    ext_deps.extend([l.strip().split("==")[0].split(">=")[0]
+                                     for l in content.splitlines() if l.strip() and not l.startswith("#")][:30])
+            except Exception:
+                pass
+
+    return {
+        "entry_points": entry_points[:30],
+        "dangerous_sinks": dangerous_sinks[:50],
+        "security_critical_files": list(set(security_files))[:20],
+        "external_dependencies": ext_deps[:30],
+        "crypto_operations": crypto_ops[:15],
+        "authentication_flows": auth_flows[:10],
+        "deserialization_points": deser_points[:10],
+        "summary": {
+            "entry_points": len(entry_points),
+            "dangerous_sinks": len(dangerous_sinks),
+            "security_files": len(set(security_files)),
+            "deser_risks": len(deser_points),
+            "crypto_issues": sum(1 for c in crypto_ops if c.get("warning")),
+        },
+    }
+
+
+def run_taint_analysis(repo_dir: str, focus_files: list[str] = None) -> dict:
+    """
+    Full taint analysis: find flows from sources to sinks.
+    Returns a list of confirmed taint flows with CWE classification.
+    """
+    flows = []
+
+    search_files = []
+    if focus_files:
+        search_files = [os.path.join(repo_dir, f) for f in focus_files if f.endswith(".py")]
+    else:
+        search_files = glob.glob(f"{repo_dir}/**/*.py", recursive=True)
+        search_files = [f for f in search_files
+                        if "site-packages" not in f and ".tox" not in f and "test_" not in f]
+
+    for py_file in search_files[:50]:
+        rel = os.path.relpath(py_file, repo_dir)
+        try:
+            source = open(py_file).read()
+            tree = ast.parse(source)
+        except Exception:
+            continue
+
+        tainted_vars: dict[str, int] = {}
+        lines = source.splitlines()
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Assign) and isinstance(node.value, ast.Call):
+                func_str = _node_to_str(node.value.func)
+                if any(src in func_str for src in _PYTHON_SOURCES):
+                    for target in node.targets:
+                        if isinstance(target, ast.Name):
+                            tainted_vars[target.id] = node.lineno
+
+            if isinstance(node, ast.Call):
+                func_str = _node_to_str(node.func)
+                matched_sink = next((s for s in _PYTHON_SINKS if s in func_str), None)
+                if matched_sink:
+                    for arg in node.args:
+                        arg_str = _node_to_str(arg)
+                        if isinstance(arg, ast.Name) and arg.id in tainted_vars:
+                            flows.append(TaintFlow(
+                                source=f"tainted_var:{arg.id}",
+                                sink=matched_sink,
+                                path=[arg.id, matched_sink],
+                                file_path=rel,
+                                source_line=tainted_vars[arg.id],
+                                sink_line=node.lineno,
+                                cwe_candidates=[_PYTHON_SINKS[matched_sink]],
+                                confidence=0.8,
+                            ))
+                        elif isinstance(arg, ast.JoinedStr):
+                            for val in ast.walk(arg):
+                                if isinstance(val, ast.Name) and val.id in tainted_vars:
+                                    flows.append(TaintFlow(
+                                        source=f"fstring:{val.id}",
+                                        sink=matched_sink,
+                                        path=[val.id, "f-string", matched_sink],
+                                        file_path=rel,
+                                        source_line=tainted_vars[val.id],
+                                        sink_line=node.lineno,
+                                        cwe_candidates=[_PYTHON_SINKS[matched_sink], "CWE-134"],
+                                        confidence=0.7,
+                                    ))
+
+    return {
+        "flows_found": len(flows),
+        "flows": [
+            {
+                "source": f.source, "sink": f.sink,
+                "file": f.file_path,
+                "source_line": f.source_line, "sink_line": f.sink_line,
+                "cwes": f.cwe_candidates, "confidence": f.confidence,
+                "path": " → ".join(f.path),
+            }
+            for f in sorted(flows, key=lambda x: x.confidence, reverse=True)[:20]
+        ],
+        "high_confidence_flows": sum(1 for f in flows if f.confidence >= 0.75),
+        "unique_cwes": list(set(cwe for f in flows for cwe in f.cwe_candidates)),
+    }
+
+
+def _node_to_str(node) -> str:
+    try:
+        if isinstance(node, ast.Name):
+            return node.id
+        if isinstance(node, ast.Attribute):
+            return f"{_node_to_str(node.value)}.{node.attr}"
+        return ""
+    except Exception:
+        return ""

vuln_classifier.py

@@ -0,0 +1,360 @@
+"""
+Rhodawk AI — Vulnerability Classifier
+========================================
+CWE taxonomy-based classification of raw findings.
+Maps evidence → CWE → CVSS vector → severity tier.
+
+Also computes the final composite security score used in dashboards.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class ClassificationResult:
+    cwe_id: str
+    cwe_name: str
+    cwe_category: str
+    owasp_top10: Optional[str]
+    severity: str
+    cvss_base_score: float
+    cvss_vector: str
+    exploitation_likelihood: str   # LIKELY | POSSIBLE | UNLIKELY
+    remediation_guidance: str
+
+
+_CWE_DATABASE = {
+    "CWE-89": {
+        "name": "SQL Injection",
+        "category": "Injection",
+        "owasp": "A03:2021-Injection",
+        "severity": "CRITICAL",
+        "cvss_base": 9.8,
+        "cvss_vector": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H",
+        "likelihood": "LIKELY",
+        "remediation": "Use parameterized queries/prepared statements. Never concatenate user input into SQL strings.",
+    },
+    "CWE-79": {
+        "name": "Cross-Site Scripting (XSS)",
+        "category": "Injection",
+        "owasp": "A03:2021-Injection",
+        "severity": "HIGH",
+        "cvss_base": 6.1,
+        "cvss_vector": "CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N",
+        "likelihood": "LIKELY",
+        "remediation": "Escape all output. Use Content Security Policy. Validate and sanitize inputs.",
+    },
+    "CWE-78": {
+        "name": "OS Command Injection",
+        "category": "Injection",
+        "owasp": "A03:2021-Injection",
+        "severity": "CRITICAL",
+        "cvss_base": 9.8,
+        "cvss_vector": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H",
+        "likelihood": "LIKELY",
+        "remediation": "Never pass user input to shell commands. Use subprocess with list arguments (shell=False).",
+    },
+    "CWE-22": {
+        "name": "Path Traversal",
+        "category": "File Handling",
+        "owasp": "A01:2021-Broken Access Control",
+        "severity": "HIGH",
+        "cvss_base": 7.5,
+        "cvss_vector": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N",
+        "likelihood": "LIKELY",
+        "remediation": "Canonicalize paths. Validate against allowed directory. Use os.path.realpath and check prefix.",
+    },
+    "CWE-502": {
+        "name": "Deserialization of Untrusted Data",
+        "category": "Deserialization",
+        "owasp": "A08:2021-Software and Data Integrity Failures",
+        "severity": "CRITICAL",
+        "cvss_base": 9.8,
+        "cvss_vector": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H",
+        "likelihood": "LIKELY",
+        "remediation": "Never deserialize user-controlled data with pickle/yaml.load/marshal. Use JSON with strict schema validation.",
+    },
+    "CWE-798": {
+        "name": "Hardcoded Credentials",
+        "category": "Authentication",
+        "owasp": "A07:2021-Identification and Authentication Failures",
+        "severity": "HIGH",
+        "cvss_base": 7.5,
+        "cvss_vector": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N",
+        "likelihood": "LIKELY",
+        "remediation": "Move credentials to environment variables or secrets managers. Rotate immediately if exposed.",
+    },
+    "CWE-918": {
+        "name": "Server-Side Request Forgery (SSRF)",
+        "category": "Injection",
+        "owasp": "A10:2021-SSRF",
+        "severity": "HIGH",
+        "cvss_base": 7.5,
+        "cvss_vector": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N",
+        "likelihood": "POSSIBLE",
+        "remediation": "Validate and allowlist URLs. Block requests to internal networks. Use a URL parser, not string matching.",
+    },
+    "CWE-611": {
+        "name": "XML External Entity (XXE)",
+        "category": "Injection",
+        "owasp": "A05:2021-Security Misconfiguration",
+        "severity": "HIGH",
+        "cvss_base": 7.5,
+        "cvss_vector": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N",
+        "likelihood": "POSSIBLE",
+        "remediation": "Use defusedxml. Disable external entity processing in XML parsers.",
+    },
+    "CWE-295": {
+        "name": "Improper Certificate Validation",
+        "category": "Cryptography",
+        "owasp": "A02:2021-Cryptographic Failures",
+        "severity": "HIGH",
+        "cvss_base": 7.4,
+        "cvss_vector": "CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N",
+        "likelihood": "POSSIBLE",
+        "remediation": "Never set verify=False. Use proper CA bundles. Enable certificate pinning for critical connections.",
+    },
+    "CWE-347": {
+        "name": "Improper Verification of Cryptographic Signature",
+        "category": "Cryptography",
+        "owasp": "A02:2021-Cryptographic Failures",
+        "severity": "CRITICAL",
+        "cvss_base": 9.8,
+        "cvss_vector": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H",
+        "likelihood": "LIKELY",
+        "remediation": "Always verify JWT signatures. Never accept 'none' algorithm. Use explicit algorithm allowlists.",
+    },
+    "CWE-362": {
+        "name": "Race Condition",
+        "category": "Concurrency",
+        "owasp": None,
+        "severity": "MEDIUM",
+        "cvss_base": 5.9,
+        "cvss_vector": "CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:H/A:N",
+        "likelihood": "POSSIBLE",
+        "remediation": "Use locks/mutexes for shared state. Prefer atomic operations. Use thread-safe data structures.",
+    },
+    "CWE-190": {
+        "name": "Integer Overflow",
+        "category": "Memory",
+        "owasp": None,
+        "severity": "HIGH",
+        "cvss_base": 7.5,
+        "cvss_vector": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:H",
+        "likelihood": "POSSIBLE",
+        "remediation": "Validate numeric ranges before arithmetic. Use checked arithmetic libraries.",
+    },
+    "CWE-119": {
+        "name": "Buffer Overflow",
+        "category": "Memory",
+        "owasp": None,
+        "severity": "CRITICAL",
+        "cvss_base": 9.8,
+        "cvss_vector": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H",
+        "likelihood": "POSSIBLE",
+        "remediation": "Use bounds-checked functions. Enable stack canaries and ASLR. Use memory-safe languages.",
+    },
+    "CWE-416": {
+        "name": "Use After Free",
+        "category": "Memory",
+        "owasp": None,
+        "severity": "CRITICAL",
+        "cvss_base": 9.8,
+        "cvss_vector": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H",
+        "likelihood": "POSSIBLE",
+        "remediation": "Set pointers to NULL after free. Use smart pointers (Rust/C++). Enable AddressSanitizer in CI.",
+    },
+    "CWE-134": {
+        "name": "Format String Vulnerability",
+        "category": "Injection",
+        "owasp": "A03:2021-Injection",
+        "severity": "HIGH",
+        "cvss_base": 8.1,
+        "cvss_vector": "CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N",
+        "likelihood": "POSSIBLE",
+        "remediation": "Never pass user input as printf format string. Use explicit format specifiers.",
+    },
+    "CWE-95": {
+        "name": "Code Injection (eval/exec)",
+        "category": "Injection",
+        "owasp": "A03:2021-Injection",
+        "severity": "CRITICAL",
+        "cvss_base": 9.8,
+        "cvss_vector": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H",
+        "likelihood": "LIKELY",
+        "remediation": "Never use eval/exec on user-controlled data. Use AST parsing or safe expression evaluators.",
+    },
+    "CWE-200": {
+        "name": "Information Exposure",
+        "category": "Information Disclosure",
+        "owasp": "A01:2021-Broken Access Control",
+        "severity": "MEDIUM",
+        "cvss_base": 5.3,
+        "cvss_vector": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N",
+        "likelihood": "LIKELY",
+        "remediation": "Strip sensitive data from error messages. Log minimally. Use generic error responses.",
+    },
+    "CWE-338": {
+        "name": "Weak PRNG for Security",
+        "category": "Cryptography",
+        "owasp": "A02:2021-Cryptographic Failures",
+        "severity": "MEDIUM",
+        "cvss_base": 5.9,
+        "cvss_vector": "CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:N/A:N",
+        "likelihood": "POSSIBLE",
+        "remediation": "Use secrets.token_hex() or os.urandom() for security contexts. Never use random.random() for tokens.",
+    },
+    "CWE-328": {
+        "name": "Weak Cryptographic Hash",
+        "category": "Cryptography",
+        "owasp": "A02:2021-Cryptographic Failures",
+        "severity": "MEDIUM",
+        "cvss_base": 5.9,
+        "cvss_vector": "CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:N/A:N",
+        "likelihood": "POSSIBLE",
+        "remediation": "Replace MD5/SHA1 with SHA-256 or better. For passwords use bcrypt/argon2/scrypt.",
+    },
+    "CWE-400": {
+        "name": "Uncontrolled Resource Consumption (DoS)",
+        "category": "Availability",
+        "owasp": None,
+        "severity": "HIGH",
+        "cvss_base": 7.5,
+        "cvss_vector": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H",
+        "likelihood": "LIKELY",
+        "remediation": "Implement rate limiting. Set resource limits (memory, CPU, time). Validate input sizes.",
+    },
+    "CWE-1321": {
+        "name": "Prototype Pollution",
+        "category": "Injection",
+        "owasp": "A03:2021-Injection",
+        "severity": "HIGH",
+        "cvss_base": 7.5,
+        "cvss_vector": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:H/A:L",
+        "likelihood": "POSSIBLE",
+        "remediation": "Use Object.create(null) for object maps. Validate object keys. Use Map instead of plain objects.",
+    },
+    "CWE-601": {
+        "name": "Open Redirect",
+        "category": "URL Handling",
+        "owasp": "A01:2021-Broken Access Control",
+        "severity": "MEDIUM",
+        "cvss_base": 6.1,
+        "cvss_vector": "CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N",
+        "likelihood": "LIKELY",
+        "remediation": "Validate redirect URLs against an allowlist. Never redirect to user-supplied arbitrary URLs.",
+    },
+    "CWE-306": {
+        "name": "Missing Authentication",
+        "category": "Authentication",
+        "owasp": "A07:2021-Identification and Authentication Failures",
+        "severity": "CRITICAL",
+        "cvss_base": 9.1,
+        "cvss_vector": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N",
+        "likelihood": "LIKELY",
+        "remediation": "Require authentication on all sensitive endpoints. Use middleware to enforce auth globally.",
+    },
+    "CWE-74": {
+        "name": "Injection (generic)",
+        "category": "Injection",
+        "owasp": "A03:2021-Injection",
+        "severity": "HIGH",
+        "cvss_base": 7.5,
+        "cvss_vector": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N",
+        "likelihood": "POSSIBLE",
+        "remediation": "Validate, escape, and parameterize all user input that reaches interpreters.",
+    },
+}
+
+
+def classify_vulnerability(
+    cwe_hint: str,
+    description: str = "",
+    exploit_class: str = "",
+) -> ClassificationResult:
+    """
+    Classify a vulnerability by CWE ID, returning full taxonomy information.
+    Falls back to heuristic matching from description if CWE is unknown.
+    """
+    cwe_data = _CWE_DATABASE.get(cwe_hint)
+
+    if not cwe_data:
+        cwe_hint, cwe_data = _infer_cwe(description, exploit_class)
+
+    if not cwe_data:
+        cwe_hint = "CWE-UNKNOWN"
+        cwe_data = {
+            "name": "Unknown Vulnerability", "category": "Unclassified",
+            "owasp": None, "severity": "MEDIUM", "cvss_base": 5.0,
+            "cvss_vector": "CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:L/A:N",
+            "likelihood": "POSSIBLE",
+            "remediation": "Manual security review required.",
+        }
+
+    return ClassificationResult(
+        cwe_id=cwe_hint,
+        cwe_name=cwe_data["name"],
+        cwe_category=cwe_data["category"],
+        owasp_top10=cwe_data.get("owasp"),
+        severity=cwe_data["severity"],
+        cvss_base_score=cwe_data["cvss_base"],
+        cvss_vector=cwe_data["cvss_vector"],
+        exploitation_likelihood=cwe_data["likelihood"],
+        remediation_guidance=cwe_data["remediation"],
+    )
+
+
+def _infer_cwe(description: str, exploit_class: str) -> tuple[str, Optional[dict]]:
+    """Infer CWE from description keywords when CWE ID is not provided."""
+    desc_lower = (description + " " + exploit_class).lower()
+
+    inference_rules = [
+        (["sql", "query injection", "database injection"], "CWE-89"),
+        (["xss", "cross-site scripting", "innerhtml"], "CWE-79"),
+        (["command injection", "os.system", "shell injection"], "CWE-78"),
+        (["path traversal", "directory traversal", "../"], "CWE-22"),
+        (["pickle", "deserializ", "yaml.load"], "CWE-502"),
+        (["hardcoded", "hardcoded credential", "hardcoded password"], "CWE-798"),
+        (["ssrf", "server-side request forgery"], "CWE-918"),
+        (["xxe", "xml external entity"], "CWE-611"),
+        (["tls", "ssl", "certificate verification"], "CWE-295"),
+        (["jwt", "token forgery", "signature bypass"], "CWE-347"),
+        (["race condition", "toctou"], "CWE-362"),
+        (["integer overflow", "arithmetic overflow"], "CWE-190"),
+        (["buffer overflow", "stack overflow", "heap overflow"], "CWE-119"),
+        (["use after free", "uaf"], "CWE-416"),
+        (["format string"], "CWE-134"),
+        (["eval", "exec", "code injection"], "CWE-95"),
+        (["prototype pollution", "__proto__"], "CWE-1321"),
+        (["open redirect", "redirect"], "CWE-601"),
+        (["missing auth", "unauthenticated"], "CWE-306"),
+        (["weak hash", "md5", "sha1"], "CWE-328"),
+        (["weak random", "math.random", "random.random"], "CWE-338"),
+        (["denial of service", "dos", "resource exhaustion"], "CWE-400"),
+        (["information disclosure", "data leak", "sensitive data"], "CWE-200"),
+    ]
+
+    for keywords, cwe in inference_rules:
+        if any(kw in desc_lower for kw in keywords):
+            return cwe, _CWE_DATABASE.get(cwe)
+
+    return "CWE-UNKNOWN", None
+
+
+def get_all_cwes() -> list[dict]:
+    """Return the full CWE database as a list for the UI."""
+    return [
+        {
+            "cwe_id": cwe_id,
+            "name": data["name"],
+            "category": data["category"],
+            "severity": data["severity"],
+            "cvss_base": data["cvss_base"],
+            "owasp": data.get("owasp", ""),
+        }
+        for cwe_id, data in _CWE_DATABASE.items()
+    ]