Saved progress at the end of the loop

Replit-Commit-Author: Agent
Replit-Commit-Session-Id: c29cee77-62e9-4c59-8869-90c93983f51f
Replit-Commit-Checkpoint-Type: full_checkpoint
Replit-Commit-Event-Id: e7ee9f19-8382-4992-89c8-79b4e20447cb
Replit-Helium-Checkpoint-Created: true

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,62 @@
+FROM python:3.12-slim AS builder
+
+ENV DEBIAN_FRONTEND=noninteractive \
+    PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends git curl ca-certificates build-essential && \
+    rm -rf /var/lib/apt/lists/* && \
+    curl -LsSf https://astral.sh/uv/install.sh | sh && \
+    ln -s $HOME/.local/bin/uv /usr/local/bin/uv
+
+WORKDIR /build
+COPY requirements.txt .
+RUN pip wheel --no-cache-dir --wheel-dir /wheels -r requirements.txt mcp-server-fetch
+
+FROM python:3.12-slim AS runtime
+
+LABEL org.opencontainers.image.title="Rhodawk AI DevSecOps Engine v4.0"
+LABEL org.opencontainers.image.description="Autonomous CI/CD healing, red-team CEGIS, SAST, supply-chain gate, SWE-bench, and data flywheel"
+LABEL org.opencontainers.image.version="4.0.0"
+
+ENV DEBIAN_FRONTEND=noninteractive \
+    PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    GRADIO_SERVER_NAME=0.0.0.0 \
+    GRADIO_SERVER_PORT=7860
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        git curl ca-certificates build-essential && \
+    curl -fsSL https://deb.nodesource.com/setup_20.x | bash - && \
+    apt-get install -y --no-install-recommends nodejs && \
+    rm -rf /var/lib/apt/lists/* && \
+    curl -LsSf https://astral.sh/uv/install.sh | env HOME=/root sh && \
+    ln -s /root/.local/bin/uv /usr/local/bin/uv
+
+RUN npm install -g --quiet @modelcontextprotocol/server-github
+
+RUN userdel -r node 2>/dev/null || true && \
+    useradd -m -u 1000 -s /bin/bash rhodawk
+
+RUN mkdir -p /data /app && chown -R rhodawk:rhodawk /data /app
+
+WORKDIR /app
+
+COPY --from=builder /wheels /wheels
+RUN pip install --no-cache-dir /wheels/* && rm -rf /wheels
+
+ENV HOME=/home/rhodawk
+ENV PATH=$HOME/.local/bin:/usr/local/bin:$PATH
+
+USER rhodawk
+
+COPY --chown=rhodawk:rhodawk *.py mcp_config.json ./
+
+EXPOSE 7860 7861
+
+HEALTHCHECK --interval=30s --timeout=10s --start-period=120s --retries=3 \
+    CMD curl -f http://localhost:7860/ || exit 1
+
+CMD ["python", "-u", "app.py"]

README.md

@@ -0,0 +1,130 @@
+---
+title: Rhodawk AI DevSecOps Engine
+emoji: 🦅
+colorFrom: purple
+colorTo: indigo
+sdk: docker
+pinned: true
+license: apache-2.0
+---
+
+# 🦅 Rhodawk AI — Autonomous DevSecOps Control Plane v4.0
+
+> **Autonomous CI/CD healing + Zero-Day Discovery. The only DevSecOps engine that attacks its own green repos.**
+
+Rhodawk AI v4.0 is an enterprise-grade autonomous DevSecOps control plane with two modes:
+- **Blue Team**: detects failing tests, deploys AI (Aider + Qwen via OpenRouter) to generate a fix, gates through SAST + supply chain + adversarial LLM review, opens a PR.
+- **Red Team / CEGIS**: when all tests pass (repo is GREEN), autonomously attacks the codebase — discovering mathematical invariants, synthesizing Property-Based Tests via Hypothesis, fuzzing to exhaustion, and handing the minimal crashing counter-example to the Blue Team for patching.
+
+---
+
+## Architecture
+
+```
+GitHub Repo
+    │
+    ▼
+pytest discovery & execution
+    │
+    ├── FAIL ──► Blue Team Healing Loop
+    │               │
+    │               ├── Memory Engine (TF-IDF — similar past fixes)
+    │               ├── Aider Agent (Qwen 2.5 Coder 32B via OpenRouter + MCP)
+    │               ├── SAST Gate (bandit + secret scanner)
+    │               ├── Supply Chain Gate (pip-audit + typosquatting)
+    │               ├── Adversarial LLM Review (hostile red-team model)
+    │               └── Open PR → Immutable Audit Trail (SHA-256 JSONL)
+    │
+    └── ALL PASS ──► 🆕 Red Team CEGIS Engine
+                        │
+                        ├── AST Universal Analyzer
+                        │     rank functions by complexity, overflow risk, recursion, mutations
+                        ├── Red Team LLM (Attacker)
+                        │     synthesize Hypothesis property-based test (invariant attack)
+                        ├── Deterministic Fuzzing Loop (50,000 examples, aggressive boundaries)
+                        │
+                        ├── CRASH ──► Package minimal counter-example (zero-day)
+                        │              └── CEGIS Handoff → Blue Team patches it → PR
+                        │
+                        └── NO CRASH ──► Inject survived inputs → harder invariant → retry
+                                          (up to 4 CEGIS rounds, escalates to Claude for final round)
+```
+
+---
+
+## Required Secrets
+
+Set these in **Settings → Secrets** of your HuggingFace Space:
+
+| Secret | Description |
+|--------|-------------|
+| `GITHUB_TOKEN` | GitHub PAT with `repo` + `pull_request` scope |
+| `GITHUB_REPO` | Target repository in `owner/repo` format |
+| `OPENROUTER_API_KEY` | OpenRouter API key (Qwen 2.5 Coder 32B) |
+
+## Optional Secrets
+
+| Secret | Description |
+|--------|-------------|
+| `TELEGRAM_BOT_TOKEN` | Telegram bot token for notifications |
+| `TELEGRAM_CHAT_ID` | Telegram chat ID |
+| `SLACK_WEBHOOK_URL` | Slack incoming webhook URL |
+| `RHODAWK_TENANT_ID` | Namespace for multi-tenant deployments (default: `default`) |
+| `RHODAWK_MODEL` | Override AI model (default: `openrouter/qwen/qwen-2.5-coder-32b-instruct:free`) |
+| `RHODAWK_RED_TEAM_ENABLED` | Enable/disable Red Team CEGIS engine (default: `true`) |
+| `RHODAWK_RED_TEAM_MODEL` | Red Team attacker model (default: Qwen 2.5 Coder 32B) |
+| `RHODAWK_RED_TEAM_MODEL_STRONG` | Escalation model for final CEGIS rounds (default: Claude 3.5 Sonnet) |
+| `RHODAWK_CEGIS_ROUNDS` | Max CEGIS re-attack rounds per target (default: `4`) |
+| `RHODAWK_FUZZ_EXAMPLES` | Hypothesis max_examples per PBT run (default: `50000`) |
+| `RHODAWK_FUZZ_TIMEOUT` | Fuzzing subprocess timeout in seconds (default: `180`) |
+| `RHODAWK_MAX_TARGETS` | Max AST attack targets per audit (default: `8`) |
+
+---
+
+## Enterprise Features
+
+### SAST Gate (Pre-PR Security Scanning)
+Every AI-generated diff is scanned for:
+- Hardcoded secrets, API keys, and tokens
+- Dangerous Python patterns (`os.system`, `eval`, `pickle.loads`, `subprocess` with `shell=True`)
+- Bandit SAST findings (HIGH+ severity blocks the PR)
+
+**If the SAST gate blocks a PR, it is never opened.** The AI agent cannot bypass this gate.
+
+### Immutable Audit Trail
+Every AI action is appended to a SHA-256 chained JSONL file:
+- AI model version and prompt hash are logged per job
+- Each entry references the previous entry's hash (tamper-evident chain)
+- Chain integrity can be verified on-demand from the dashboard
+- Suitable as SOC 2 / ISO 27001 evidence
+
+### Namespaced Job Queue
+Jobs are keyed by `(tenant_id, repo, test_path)` — the foundation for multi-tenant SaaS. Backed by atomic JSON writes today, designed to swap to PostgreSQL with zero application changes.
+
+### 🆕 Red Team CEGIS Engine (v4.0)
+The industry's first autonomous zero-day discovery loop integrated directly into a CI/CD healing platform:
+
+- **AST Universal Analyzer** — scores every Python function by cyclomatic complexity, arithmetic operations, recursion depth, and mutable argument mutation. Ranks targets by attack priority with composite scoring.
+- **Red Team LLM (The Attacker)** — dispatches an adversarial LLM with the function's full AST profile. The LLM synthesizes a Hypothesis property-based test targeting: integer overflow, commutativity, associativity, idempotency, roundtrip encoding, monotonicity, aliasing, and exception-swallowing.
+- **Deterministic Fuzzing Loop** — executes the generated PBT via subprocess (`shell=False` enforced, secrets stripped) with up to 50,000 randomized examples. Captures the minimal falsifying counter-example with exact input values.
+- **CEGIS Re-attack Loop** — if no crash is found, the survived inputs are injected back into the LLM prompt ("these inputs didn't work, try harder") and a new invariant is synthesized. Up to 4 rounds, escalating to a stronger model on the final round.
+- **CEGIS Handoff (Red → Blue)** — the crash is packaged as a deterministic pytest with the exact failing input baked in. The Blue Team processes it identically to a human-written failing test: SAST → supply chain → adversarial review → PR.
+
+**Result:** Zero-day vulnerabilities are discovered, reproduced, patched, and PRed autonomously — without any human writing a test.
+
+---
+
+## Roadmap
+
+1. **Firecracker microVMs** — per-job execution isolation replacing subprocess
+2. **GitHub App** — fine-grained per-repo OAuth replacing Personal Access Tokens
+3. **PostgreSQL job store** — horizontal scaling for concurrent audits
+4. **Webhook event triggers** — event-driven audits on push/PR events
+5. **Fine-tuned model** — trained on proprietary `(test_failure, fix)` dataset
+6. **Data flywheel** — every PR approval/rejection becomes training signal
+7. **Concurrency fuzzer** — Hypothesis stateful testing + threading to find race conditions
+8. **Multi-language AST** — extend Red Team to JavaScript (Babel AST), Go (go/ast), Rust (syn)
+
+---
+
+*Built by Rhodawk AI — the autonomous DevSecOps control plane.*

adversarial_reviewer.py

@@ -0,0 +1,191 @@
+import hashlib
+import json
+import os
+import time
+import requests
+from requests.exceptions import HTTPError
+
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
+
+# Three-model rotation chain — each is a different provider/size to avoid
+# hitting the same rate limit bucket twice in a row.
+# Override the primary with RHODAWK_ADVERSARY_MODEL env var if needed.
+ADVERSARY_MODEL_PRIMARY = os.getenv(
+    "RHODAWK_ADVERSARY_MODEL",
+    "openrouter/qwen/qwen-2.5-7b-instruct:free"
+)
+ADVERSARY_MODEL_SECONDARY = "openrouter/google/gemma-2-9b-it:free"
+ADVERSARY_MODEL_TERTIARY  = "openrouter/mistralai/mistral-7b-instruct:free"
+
+# Ordered list — tried left to right, skipping on 429 or 404
+_MODEL_CHAIN = [
+    ADVERSARY_MODEL_PRIMARY,
+    ADVERSARY_MODEL_SECONDARY,
+    ADVERSARY_MODEL_TERTIARY,
+]
+
+# Seconds to wait after a 429 before trying the next model in the chain
+_RATE_LIMIT_WAIT = 20
+
+ADVERSARY_SYSTEM_PROMPT = """You are a hostile senior security engineer and code quality enforcer.
+Your ONLY job is to find problems in AI-generated code fixes. Be adversarial. Be thorough. Be brutal.
+
+You are reviewing a diff produced by an AI to fix a failing test. Your job is to find:
+1. SECURITY ISSUES: hardcoded credentials, injection risks, path traversal, insecure deserialization,
+   dangerous imports (os.system, eval, exec), secrets in code, SSRF vectors
+2. CORRECTNESS ISSUES: does the fix actually solve the root cause or just suppress the symptom?
+   Does it handle edge cases? Will it break on different inputs?
+3. REGRESSION RISKS: does this change break other functionality? Does it change public API signatures?
+   Does it modify behavior for the passing cases?
+4. CODE QUALITY: does this fix increase cyclomatic complexity significantly? Does it introduce
+   dead code, duplicate logic, or anti-patterns?
+5. SUPPLY CHAIN: does it add new dependencies? Are they trustworthy? Do they have known CVEs?
+
+Respond ONLY in this exact JSON format:
+{
+  "verdict": "APPROVE" | "CONDITIONAL" | "REJECT",
+  "confidence": 0.0-1.0,
+  "critical_issues": ["issue1", "issue2"],
+  "warnings": ["warning1", "warning2"],
+  "summary": "one sentence verdict summary",
+  "retry_guidance": "if REJECT: specific guidance for what the primary AI should do differently"
+}
+
+verdict rules:
+- REJECT if ANY critical_issues exist (security vulnerabilities, correctness failures that will cause runtime errors, regressions)
+- CONDITIONAL if only warnings exist (code quality, minor style, non-critical concerns)
+- APPROVE if no issues found
+"""
+
+
+def _call_openrouter(model: str, system: str, user: str, timeout: int = 60) -> dict:
+    headers = {
+        "Authorization": f"Bearer {OPENROUTER_API_KEY}",
+        "Content-Type": "application/json",
+        "HTTP-Referer": "https://rhodawk.ai",
+        "X-Title": "Rhodawk AI Adversarial Reviewer",
+    }
+    payload = {
+        "model": model.replace("openrouter/", ""),
+        "messages": [
+            {"role": "system", "content": system},
+            {"role": "user", "content": user},
+        ],
+        "temperature": 0.1,
+        "max_tokens": 1024,
+        "response_format": {"type": "json_object"},
+    }
+    resp = requests.post(
+        "https://openrouter.ai/api/v1/chat/completions",
+        headers=headers,
+        json=payload,
+        timeout=timeout,
+    )
+    resp.raise_for_status()
+    data = resp.json()
+    content = data["choices"][0]["message"]["content"]
+    return json.loads(content)
+
+
+def _call_with_model_chain(user_prompt: str) -> tuple[dict, str]:
+    """
+    Try each model in the chain in order.
+    On 429 (rate limit): wait _RATE_LIMIT_WAIT seconds then try next model.
+    On 404 (model not found): immediately try next model.
+    Returns (result_dict, model_used_string).
+    Raises RuntimeError if all models fail.
+    """
+    last_error = None
+    for model in _MODEL_CHAIN:
+        try:
+            result = _call_openrouter(model, ADVERSARY_SYSTEM_PROMPT, user_prompt)
+            return result, model
+        except HTTPError as e:
+            status = e.response.status_code if e.response is not None else 0
+            if status == 429:
+                # Rate limited — wait before trying next model
+                time.sleep(_RATE_LIMIT_WAIT)
+                last_error = e
+                continue
+            elif status == 404:
+                # Model not found — skip immediately
+                last_error = e
+                continue
+            else:
+                # Other HTTP error — skip to next model
+                last_error = e
+                continue
+        except Exception as e:
+            last_error = e
+            continue
+
+    raise RuntimeError(f"All models in chain failed. Last error: {last_error}")
+
+
+def run_adversarial_review(
+    diff_text: str,
+    test_path: str,
+    original_failure: str,
+    repo: str,
+) -> dict:
+    """
+    Run the adversarial LLM review on an AI-generated diff.
+
+    Returns a dict with:
+      verdict: "APPROVE" | "CONDITIONAL" | "REJECT"
+      critical_issues: list[str]
+      warnings: list[str]
+      summary: str
+      retry_guidance: str
+      model_used: str
+      review_hash: str
+      timestamp: str
+    """
+    if not OPENROUTER_API_KEY:
+        return {
+            "verdict": "APPROVE",
+            "critical_issues": [],
+            "warnings": ["Adversarial review skipped — OPENROUTER_API_KEY not set"],
+            "summary": "Review skipped",
+            "retry_guidance": "",
+            "model_used": "none",
+            "review_hash": "skipped",
+            "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        }
+
+    user_prompt = (
+        f"REPOSITORY: {repo}\n"
+        f"FAILING TEST: {test_path}\n\n"
+        f"ORIGINAL FAILURE OUTPUT:\n```\n{original_failure[:1500]}\n```\n\n"
+        f"AI-GENERATED DIFF TO REVIEW:\n```diff\n{diff_text[:3000]}\n```\n\n"
+        f"Find every problem with this diff. Be adversarial."
+    )
+
+    try:
+        result, model_used = _call_with_model_chain(user_prompt)
+    except Exception as e:
+        return {
+            "verdict": "CONDITIONAL",
+            "critical_issues": [],
+            "warnings": [f"Adversarial review failed after trying all models: {e}"],
+            "summary": "Review unavailable — proceeding with SAST gate only",
+            "retry_guidance": "",
+            "model_used": "failed",
+            "review_hash": "failed",
+            "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        }
+
+    review_input = f"{diff_text}{original_failure}"
+    review_hash = hashlib.sha256(review_input.encode()).hexdigest()[:16]
+
+    return {
+        "verdict": result.get("verdict", "CONDITIONAL"),
+        "confidence": result.get("confidence", 0.5),
+        "critical_issues": result.get("critical_issues", []),
+        "warnings": result.get("warnings", []),
+        "summary": result.get("summary", ""),
+        "retry_guidance": result.get("retry_guidance", ""),
+        "model_used": model_used,
+        "review_hash": review_hash,
+        "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+    }

app.py

@@ -0,0 +1,1058 @@
+"""
+Rhodawk AI — Autonomous DevSecOps Control Plane v3.0
+=====================================================
+The code review monster. No competitor has this capability stack.
+
+Full loop:
+  1. Clone repo → discover tests → run pytest
+  2. FAIL → retrieve similar fixes from memory (data flywheel)
+  3. Dispatch Aider with failure + memory context via MCP tools
+  4. Re-run tests on the patched code (verification — CLOSES THE LOOP)
+  5. If still failing → retry with new failure context (up to MAX_RETRIES)
+  6. SAST gate: bandit + 16-pattern secret scanner
+  7. Supply chain gate: pip-audit + typosquatting detection
+  8. Adversarial LLM review: second model plays hostile red-team reviewer
+  9. If adversary REJECTs → loop back with critique as context
+  10. All clear → open PR, record to training store, update memory
+  11. Webhook server runs in parallel for event-driven triggers
+"""
+
+import glob
+import hashlib
+import json
+import os
+import signal
+import subprocess
+import tempfile
+import threading
+import time
+from typing import Optional
+
+import gradio as gr
+import requests
+from git import Repo
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+from adversarial_reviewer import run_adversarial_review
+from audit_logger import export_compliance_report, log_audit_event, read_audit_trail, verify_chain_integrity
+from github_app import get_github_token
+from job_queue import JobStatus, get_job_status_enum, get_metrics, list_all_jobs, upsert_job
+from memory_engine import get_memory_stats, record_fix_outcome, retrieve_similar_fixes
+from embedding_memory import retrieve_similar_fixes_v2
+from notifier import (
+    notify,
+    notify_audit_complete,
+    notify_audit_start,
+    notify_chain_integrity,
+    notify_patch_failed,
+    notify_pr_created,
+    notify_sast_blocked,
+    notify_test_failed,
+)
+from sast_gate import run_sast_gate
+from red_team_fuzzer import get_red_team_logs, get_red_team_stats, run_red_team_cegis
+from supply_chain import run_supply_chain_gate
+from training_store import export_training_data, get_statistics, record_attempt, update_test_result
+from verification_loop import (
+    MAX_RETRIES,
+    ADVERSARIAL_REJECTION_MULTIPLIER,
+    VerificationAttempt,
+    VerificationResult,
+    build_initial_prompt,
+    build_retry_prompt,
+)
+from webhook_server import set_job_dispatcher, start_webhook_server
+from worker_pool import MAX_WORKERS, run_parallel_audit
+
+# ──────────────────────────────────────────────────────────────
+# SECRETS — env only, never hardcoded
+# ──────────────────────────────────────────────────────────────
+GITHUB_TOKEN = os.getenv("GITHUB_TOKEN")
+GITHUB_REPO = os.getenv("GITHUB_REPO")
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
+TENANT_ID = os.getenv("RHODAWK_TENANT_ID", "default")
+MODEL = os.getenv("RHODAWK_MODEL", "openrouter/qwen/qwen-2.5-coder-32b-instruct:free")
+RED_TEAM_ENABLED = os.getenv("RHODAWK_RED_TEAM_ENABLED", "true").lower() != "false"
+
+for _key, _val in [("GITHUB_TOKEN", GITHUB_TOKEN), ("GITHUB_REPO", GITHUB_REPO), ("OPENROUTER_API_KEY", OPENROUTER_API_KEY)]:
+    if not _val:
+        raise EnvironmentError(f"Required secret '{_key}' is not set. Add it in HuggingFace Space Settings → Secrets.")
+
+# ──────────────────────────────────────────────────────────────
+# PATHS & CONSTANTS
+# ──────────────────────────────────────────────────────────────
+PERSISTENT_DIR = "/data"
+REPO_DIR = f"{PERSISTENT_DIR}/repo"
+VENV_DIR = f"{PERSISTENT_DIR}/target_venv"
+MCP_RUNTIME_CONFIG = "/tmp/mcp_runtime.json"
+
+# ──────────────────────────────────────────────────────────────
+# GLOBAL STATE
+# ──────────────────────────────────────────────────────────────
+dashboard_logs: list[str] = []
+_log_lock = threading.Lock()
+_audit_event = threading.Event()
+
+
+def ui_log(message: str, level: str = "INFO"):
+    ts = time.strftime("%H:%M:%S")
+    icons = {"OK": "✅", "FAIL": "❌", "WARN": "⚠", "SAST": "🛡", "ADV": "🔴", "PR": "🔁",
+             "SKIP": "⏭", "MEM": "🧠", "CHAIN": "⛓", "SUPPLY": "📦", "RETRY": "🔄", "INFO": "  ",
+             "RED": "⚔️", "ATTACK": "🗡", "CRASH": "💥", "BENCH": "🧪", "POOL": "⚡"}
+    line = f"[{ts}] {icons.get(level, '  ')} {message}"
+    print(line)
+    with _log_lock:
+        dashboard_logs.append(line)
+        if len(dashboard_logs) > 300:
+            dashboard_logs.pop(0)
+
+
+# ──────────────────────────────────────────────────────────────
+# SUBPROCESS RUNNER — shell=False enforced, secrets stripped
+# ──────────────────────────────────────────────────────────────
+def run_subprocess_safe(cmd: list, cwd: str = REPO_DIR, timeout: int = 300,
+                        env_overrides: dict = None, raise_on_error: bool = True) -> tuple[str, int]:
+    if isinstance(cmd, str):
+        raise TypeError("SECURITY: String commands forbidden. Use list.")
+    env = os.environ.copy()
+    for k in ["OPENROUTER_API_KEY", "GITHUB_TOKEN", "GITHUB_PERSONAL_ACCESS_TOKEN",
+               "TELEGRAM_BOT_TOKEN", "SLACK_WEBHOOK_URL", "RHODAWK_WEBHOOK_SECRET"]:
+        env.pop(k, None)
+    if env_overrides:
+        env.update(env_overrides)
+    proc = None
+    try:
+        proc = subprocess.Popen(cmd, shell=False, cwd=cwd, stdout=subprocess.PIPE,
+                                stderr=subprocess.PIPE, text=True, env=env, start_new_session=True)
+        stdout, stderr = proc.communicate(timeout=timeout)
+        output = (stdout or "") + "\n" + (stderr or "")
+        if raise_on_error and proc.returncode != 0:
+            raise subprocess.CalledProcessError(proc.returncode, cmd, stdout, stderr)
+        return output, proc.returncode
+    except subprocess.TimeoutExpired:
+        if proc:
+            try:
+                os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
+            except ProcessLookupError:
+                pass
+            proc.communicate()
+        raise RuntimeError(f"Command timed out after {timeout}s: {cmd[0]}")
+
+
+# ──────────────────────────────────────────────────────────────
+# GIT HELPERS
+# ──────────────────────────────────────────────────────────────
+def configure_git_credentials():
+    cred_path = "/tmp/.git-credentials"
+    with open(cred_path, "w") as f:
+        f.write(f"https://x-token:{GITHUB_TOKEN}@github.com\n")
+    os.chmod(cred_path, 0o600)
+    run_subprocess_safe(["git", "config", "--global", "credential.helper", f"store --file {cred_path}"], cwd="/tmp")
+
+
+def write_mcp_config() -> str:
+    config = {
+        "mcpServers": {
+            # @modelcontextprotocol/server-fetch does not exist on npm.
+            # The fetch MCP server is a Python package; invoke via uvx.
+            "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,semver.org"}
+            },
+            "github-manager": {
+                "command": "npx", "args": ["-y", "@modelcontextprotocol/server-github"],
+                "env": {"GITHUB_PERSONAL_ACCESS_TOKEN": GITHUB_TOKEN}
+            },
+        }
+    }
+    with open(MCP_RUNTIME_CONFIG, "w") as f:
+        json.dump(config, f, indent=2)
+    os.chmod(MCP_RUNTIME_CONFIG, 0o600)
+    return MCP_RUNTIME_CONFIG
+
+
+def safe_git_pull():
+    _, code = run_subprocess_safe(["git", "pull", "--ff-only", "origin", "main"], cwd=REPO_DIR, raise_on_error=False)
+    if code != 0:
+        run_subprocess_safe(["git", "fetch", "origin"], cwd=REPO_DIR)
+        run_subprocess_safe(["git", "reset", "--hard", "origin/main"], cwd=REPO_DIR)
+        run_subprocess_safe(["git", "clean", "-fd"], cwd=REPO_DIR)
+
+
+def cleanup_stale_branch(branch_name: str):
+    run_subprocess_safe(["git", "branch", "-D", branch_name], cwd=REPO_DIR, raise_on_error=False)
+    run_subprocess_safe(["git", "push", "origin", "--delete", branch_name], cwd=REPO_DIR, raise_on_error=False)
+
+
+def create_fix_branch(branch_name: str) -> bool:
+    run_subprocess_safe(["git", "checkout", "main"], cwd=REPO_DIR, raise_on_error=False)
+    run_subprocess_safe(["git", "pull", "--ff-only", "origin", "main"], cwd=REPO_DIR, raise_on_error=False)
+    run_subprocess_safe(["git", "branch", "-D", branch_name], cwd=REPO_DIR, raise_on_error=False)
+    _, code = run_subprocess_safe(["git", "checkout", "-b", branch_name], cwd=REPO_DIR, raise_on_error=False)
+    return code == 0
+
+
+def ensure_fix_committed(test_path: str) -> None:
+    status, _ = run_subprocess_safe(["git", "status", "--porcelain"], cwd=REPO_DIR, raise_on_error=False)
+    if not status.strip():
+        return
+    run_subprocess_safe(["git", "add", "."], cwd=REPO_DIR, raise_on_error=False)
+    message = f"[Rhodawk] Auto-heal {os.path.basename(test_path)}"
+    run_subprocess_safe(["git", "commit", "-m", message], cwd=REPO_DIR, raise_on_error=False)
+
+
+def push_fix_branch(branch_name: str) -> bool:
+    _, code = run_subprocess_safe(["git", "push", "-u", "origin", branch_name], cwd=REPO_DIR, raise_on_error=False)
+    return code == 0
+
+
+def create_github_pr(repo: str, branch: str, test_path: str, token: str) -> str:
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Accept": "application/vnd.github+json",
+        "X-GitHub-API-Version": "2022-11-28",
+    }
+    payload = {
+        "title": f"[Rhodawk] Auto-heal: {os.path.basename(test_path)}",
+        "head": branch,
+        "base": "main",
+        "body": (
+            "## Rhodawk AI Autonomous Fix\n\n"
+            "This PR was generated autonomously by Rhodawk AI v4.0.\n"
+            "- Tests verified green after fix\n"
+            "- SAST gate passed\n"
+            "- Supply chain gate passed\n"
+            "- Adversarial LLM review completed\n\n"
+            f"**Test fixed:** `{test_path}`\n"
+        ),
+        "draft": False,
+    }
+    resp = requests.post(
+        f"https://api.github.com/repos/{repo}/pulls",
+        headers=headers,
+        json=payload,
+        timeout=30,
+    )
+    resp.raise_for_status()
+    return resp.json()["html_url"]
+
+
+def get_current_diff() -> str:
+    try:
+        diff, _ = run_subprocess_safe(["git", "diff", "HEAD~1", "HEAD", "--unified=3"], cwd=REPO_DIR, raise_on_error=False)
+        return diff
+    except Exception:
+        # Try working tree diff if no commits yet
+        try:
+            diff, _ = run_subprocess_safe(["git", "diff", "--unified=3"], cwd=REPO_DIR, raise_on_error=False)
+            return diff
+        except Exception:
+            return ""
+
+
+def get_changed_files() -> list[str]:
+    try:
+        out, _ = run_subprocess_safe(["git", "diff", "--name-only", "HEAD~1", "HEAD"], cwd=REPO_DIR, raise_on_error=False)
+        return [f.strip() for f in out.splitlines() if f.strip()]
+    except Exception:
+        return []
+
+
+def setup_target_venv() -> str:
+    if not os.path.exists(VENV_DIR):
+        ui_log("Creating isolated virtualenv via uv...")
+        run_subprocess_safe(["uv", "venv", VENV_DIR], cwd="/tmp")
+    pytest_bin = os.path.join(VENV_DIR, "bin", "pytest")
+    req_path = os.path.join(REPO_DIR, "requirements.txt")
+    if os.path.exists(req_path):
+        ui_log("Installing target repo deps via uv...")
+        run_subprocess_safe(
+            ["uv", "pip", "install", "--python", VENV_DIR, "--quiet", "-r", req_path],
+            cwd=REPO_DIR, timeout=600,
+        )
+    return pytest_bin
+
+
+# ──────────────────────────────────────────────────────────────
+# AIDER RUNNER
+# ──────────────────────────────────────────────────────────────
+def run_aider(mcp_config_path: str, prompt: str, context_files: list[str]) -> tuple[str, int]:
+    fd, prompt_path = tempfile.mkstemp(prefix="aider_prompt_", suffix=".txt")
+    try:
+        with os.fdopen(fd, "w") as f:
+            f.write(prompt)
+        valid = [f for f in context_files if os.path.exists(os.path.join(REPO_DIR, f))]
+        cmd = ["aider", "--model", MODEL, "--yes", "--no-stream",
+               "--message-file", prompt_path]
+        if mcp_config_path and os.path.exists(mcp_config_path):
+            cmd += ["--mcp-config", mcp_config_path]
+        cmd += valid
+
+        return run_subprocess_safe(cmd, cwd=REPO_DIR, timeout=600,
+                                   env_overrides={"OPENROUTER_API_KEY": OPENROUTER_API_KEY},
+                                   raise_on_error=False)
+    finally:
+        try:
+            os.unlink(prompt_path)
+        except OSError:
+            pass
+
+
+# ──────────────────────────────────────────────────────────────
+# THE FULL LOOP — this is the product
+# ──────────────────────────────────────────────────────────────
+def process_failing_test(
+    test_path: str,
+    initial_failure: str,
+    pytest_bin: str,
+    mcp_config_path: str,
+    job_id: str,
+    branch_name: str,
+) -> VerificationResult:
+    """
+    The core autonomous healing loop:
+      memory retrieval → aider fix → test verification → adversarial review
+      → SAST gate → supply chain gate → PR open
+    Retries up to MAX_RETRIES with accumulating context.
+    """
+    filename = os.path.basename(test_path)
+    src_file = f"src/{filename.replace('test_', '')}"
+    context_files = [test_path]
+    
+    # E.g., 'agents/test_generator.py' -> 'agents/generator.py'
+    src_file = test_path.replace('test_', '')
+    
+    # Try finding the file in the same directory first
+    if os.path.exists(os.path.join(REPO_DIR, src_file)):
+        context_files.append(src_file)
+    else:
+        # Fallback to the src/ directory pattern
+        filename = os.path.basename(test_path)
+        fallback_src = f"src/{filename.replace('test_', '')}"
+        if os.path.exists(os.path.join(REPO_DIR, fallback_src)):
+            src_file = fallback_src
+            context_files.append(src_file)
+
+    if os.path.exists(os.path.join(REPO_DIR, "requirements.txt")):
+        context_files.append("requirements.txt")
+
+    attempt_history: list[VerificationAttempt] = []
+    current_failure = initial_failure
+
+    cleanup_stale_branch(branch_name)
+    if not create_fix_branch(branch_name):
+        return VerificationResult(
+            success=False,
+            attempts=attempt_history,
+            failure_reason=f"Unable to create fix branch {branch_name}",
+        )
+
+    max_total_attempts = MAX_RETRIES + max(0, ADVERSARIAL_REJECTION_MULTIPLIER)
+    for attempt_num in range(1, max_total_attempts + 1):
+        ui_log(f"Attempt {attempt_num}/{max_total_attempts}: {test_path}", "RETRY" if attempt_num > 1 else "INFO")
+
+        # ── Step 1: Retrieve similar fixes from memory ──────────
+        try:
+            similar_fixes = retrieve_similar_fixes_v2(current_failure, top_k=3)
+        except Exception:
+            similar_fixes = retrieve_similar_fixes(current_failure, top_k=3)
+        if similar_fixes:
+            ui_log(f"Memory: found {len(similar_fixes)} similar past fix(es) (best similarity: {similar_fixes[0]['similarity']})", "MEM")
+
+        # ── Step 2: Build prompt with memory + retry context ────
+        if attempt_num == 1:
+            prompt = build_initial_prompt(test_path, src_file, branch_name, current_failure, similar_fixes)
+        else:
+            prompt = build_retry_prompt(test_path, src_file, branch_name, initial_failure, attempt_history, similar_fixes)
+
+        prompt_hash = hashlib.sha256(prompt.encode()).hexdigest()[:16]
+
+        log_audit_event("AIDER_DISPATCH", job_id, GITHUB_REPO, MODEL, {
+            "test": test_path, "attempt": attempt_num, "prompt_hash": prompt_hash,
+            "memory_hits": len(similar_fixes),
+        }, "DISPATCHED")
+
+        # ── Step 3: Run Aider ───────────────────────────────────
+        aider_output, aider_code = run_aider(mcp_config_path, prompt, context_files)
+
+        if aider_code != 0:
+            ui_log(f"Aider non-zero exit on attempt {attempt_num}", "WARN")
+            ui_log(f"AIDER CRASH REASON: {aider_output.strip()[:800]}", "FAIL") # <--- ADD THIS LINE
+            attempt_history.append(VerificationAttempt(
+
+                attempt_number=attempt_num, prompt_hash=prompt_hash,
+                aider_exit_code=aider_code, test_exit_code=-1,
+                test_output="Aider failed to produce output", diff_produced="",
+            ))
+            record_fix_outcome(current_failure, test_path, "", success=False)
+            if attempt_num < max_total_attempts:
+                time.sleep(RETRY_BACKOFF_SECONDS := 5)
+                continue
+            return VerificationResult(success=False, attempts=attempt_history,
+                                      failure_reason=f"Aider failed on all {MAX_RETRIES} attempts")
+
+        # ── Step 4: Get the diff Aider produced ─────────────────
+        diff_text = get_current_diff()
+        changed_files = get_changed_files()
+
+        # ── Step 5: RE-RUN TESTS — close the loop ───────────────
+        ui_log(f"Verifying fix — re-running tests (attempt {attempt_num})...", "INFO")
+        test_output, test_code = run_subprocess_safe(
+            [pytest_bin, test_path, "-v", "--tb=short"], cwd=REPO_DIR, timeout=120, raise_on_error=False
+        )
+
+        attempt = VerificationAttempt(
+            attempt_number=attempt_num, prompt_hash=prompt_hash,
+            aider_exit_code=aider_code, test_exit_code=test_code,
+            test_output=test_output, diff_produced=diff_text,
+        )
+        attempt_history.append(attempt)
+
+        # ── Step 6: SAST gate ────────────────────────────────────
+        ui_log("Running SAST gate on AI diff...", "SAST")
+        sast_report = run_sast_gate(diff_text, changed_files, REPO_DIR)
+        log_audit_event("SAST_SCAN", job_id, GITHUB_REPO, MODEL, {
+            "attempt": attempt_num, "passed": sast_report.passed,
+            "findings": len(sast_report.findings), "blocked_reason": sast_report.blocked_reason,
+        }, "PASSED" if sast_report.passed else "BLOCKED")
+
+        if not sast_report.passed:
+            ui_log(f"SAST BLOCKED: {sast_report.blocked_reason}", "SAST")
+            notify_sast_blocked(test_path, sast_report.blocked_reason)
+            record_fix_outcome(current_failure, test_path, diff_text, success=False)
+            # Revert and retry with SAST failure as context
+            run_subprocess_safe(["git", "checkout", "."], cwd=REPO_DIR, raise_on_error=False)
+            current_failure = f"Previous fix was SAST-blocked: {sast_report.blocked_reason}\n\nOriginal failure:\n{initial_failure}"
+            if attempt_num < max_total_attempts:
+                continue
+            return VerificationResult(success=False, attempts=attempt_history,
+                                      failure_reason=f"SAST gate blocked all attempts")
+
+        # ── Step 7: Supply chain gate ────────────────────────────
+        ui_log("Running supply chain gate...", "SUPPLY")
+        sc_report = run_supply_chain_gate(diff_text, REPO_DIR)
+        log_audit_event("SUPPLY_CHAIN_SCAN", job_id, GITHUB_REPO, MODEL, {
+            "attempt": attempt_num, "passed": sc_report.passed,
+            "new_packages": sc_report.new_packages, "blocked_reason": sc_report.blocked_reason,
+        }, "PASSED" if sc_report.passed else "BLOCKED")
+
+        if not sc_report.passed:
+            ui_log(f"SUPPLY CHAIN BLOCKED: {sc_report.blocked_reason}", "SUPPLY")
+            run_subprocess_safe(["git", "checkout", "."], cwd=REPO_DIR, raise_on_error=False)
+            current_failure = f"Previous fix introduced supply chain risk: {sc_report.blocked_reason}\n\nOriginal:\n{initial_failure}"
+            if attempt_num < max_total_attempts:
+                continue
+            return VerificationResult(success=False, attempts=attempt_history,
+                                      failure_reason=f"Supply chain gate blocked all attempts")
+
+        # ── Step 8: ADVERSARIAL LLM REVIEW ──────────────────────
+        ui_log("Dispatching adversarial reviewer (red team)...", "ADV")
+        adv_review = run_adversarial_review(diff_text, test_path, initial_failure, GITHUB_REPO)
+        verdict = adv_review.get("verdict", "CONDITIONAL")
+
+        log_audit_event("ADVERSARIAL_REVIEW", job_id, GITHUB_REPO, MODEL, {
+            "attempt": attempt_num, "verdict": verdict,
+            "model": adv_review.get("model_used"), "review_hash": adv_review.get("review_hash"),
+            "critical_issues": adv_review.get("critical_issues", []),
+            "summary": adv_review.get("summary", ""),
+        }, verdict)
+
+        if adv_review.get("warnings"):
+            for w in adv_review["warnings"]:
+                ui_log(f"Adversary warning: {w}", "ADV")
+
+        if verdict == "REJECT":
+            ui_log(f"ADVERSARIAL REJECTED: {adv_review.get('summary', '')}", "ADV")
+            for issue in adv_review.get("critical_issues", []):
+                ui_log(f"  Critical: {issue}", "ADV")
+
+            record_fix_outcome(current_failure, test_path, diff_text, success=False)
+            run_subprocess_safe(["git", "checkout", "."], cwd=REPO_DIR, raise_on_error=False)
+
+            # Inject adversary critique into next attempt
+            critique = adv_review.get("retry_guidance", "")
+            issues = "\n".join(adv_review.get("critical_issues", []))
+            current_failure = (
+                f"Your previous fix was REJECTED by adversarial review.\n"
+                f"Critical issues found:\n{issues}\n"
+                f"Guidance: {critique}\n\n"
+                f"Original failure:\n{initial_failure}"
+            )
+            if attempt_num < max_total_attempts:
+                continue
+            return VerificationResult(success=False, attempts=attempt_history,
+                                      failure_reason="Adversarial reviewer rejected all attempts")
+
+        # ── Step 9: Check if tests pass ──────────────────────────
+        if test_code != 0:
+            ui_log(f"Tests still failing after attempt {attempt_num}. Retrying with new context...", "RETRY")
+            record_fix_outcome(current_failure, test_path, diff_text, success=False)
+            current_failure = (
+                f"Attempt {attempt_num} fix did not solve the problem.\n"
+                f"New failure:\n{test_output[:1500]}\n\n"
+                f"Original failure:\n{initial_failure}"
+            )
+            run_subprocess_safe(["git", "checkout", "."], cwd=REPO_DIR, raise_on_error=False)
+            if attempt_num < max_total_attempts:
+                continue
+            return VerificationResult(success=False, attempts=attempt_history,
+                                      failure_reason=f"Tests still failing after {MAX_RETRIES} attempts",
+                                      final_test_output=test_output)
+
+        # ── EVERYTHING PASSED ────────────────────────────────────
+        ui_log(f"VERIFIED GREEN on attempt {attempt_num}: {test_path}", "OK")
+        ensure_fix_committed(test_path)
+        diff_text = get_current_diff()
+        record_fix_outcome(current_failure, test_path, diff_text, success=True)
+
+        return VerificationResult(
+            success=True, attempts=attempt_history,
+            final_diff=diff_text, final_test_output=test_output,
+            total_attempts=attempt_num,
+        )
+
+    return VerificationResult(success=False, attempts=attempt_history,
+                              failure_reason="Max retries exceeded")
+
+
+# ──────────────────────────────────────────────────────────────
+# MAIN AUDIT ORCHESTRATOR
+# ──────────────────────────────────────────────────────────────
+def process_audit_test(
+    test_path: str,
+    pytest_bin: str,
+    mcp_config_path: str,
+    tenant_id: str,
+    target_repo: str,
+) -> dict:
+    filename = os.path.basename(test_path)
+    branch_name = f"rhodawk/auto-patch/{filename.replace('.py','').replace('_','-')}"
+
+    current_status = get_job_status_enum(tenant_id, target_repo, test_path)
+    if current_status == JobStatus.DONE:
+        ui_log(f"Skipping (DONE): {test_path}", "SKIP")
+        return {"skipped": True}
+    if current_status == JobStatus.RUNNING:
+        ui_log(f"Cleaning interrupted job: {test_path}", "WARN")
+        cleanup_stale_branch(branch_name)
+        safe_git_pull()
+
+    job_id = upsert_job(tenant_id, target_repo, test_path, JobStatus.RUNNING)
+    ui_log(f"Testing: {test_path} [job:{job_id}]")
+
+    initial_output, pytest_code = run_subprocess_safe(
+        [pytest_bin, test_path, "-v", "--tb=short"], cwd=REPO_DIR, timeout=120, raise_on_error=False
+    )
+
+    if pytest_code == 0:
+        ui_log(f"PASSED: {test_path}", "OK")
+        upsert_job(tenant_id, target_repo, test_path, JobStatus.DONE, "tests passed")
+        log_audit_event("TEST_PASS", job_id, target_repo, MODEL,
+                        {"test": test_path, "attempt": 0}, "PASSED")
+        record_attempt(tenant_id, target_repo, test_path, initial_output, MODEL,
+                       "baseline", 0, test_passed_after=True)
+        return {"success": True, "already_green": True}
+
+    ui_log(f"FAILED: {test_path} — entering healing loop...", "FAIL")
+    notify_test_failed(test_path)
+    log_audit_event("TEST_FAIL", job_id, target_repo, MODEL, {"test": test_path}, "FAILED")
+
+    result = process_failing_test(test_path, initial_output, pytest_bin, mcp_config_path, job_id, branch_name)
+
+    attempt_id = record_attempt(
+        tenant_id, target_repo, test_path, initial_output, MODEL,
+        hashlib.sha256(initial_output.encode()).hexdigest()[:16],
+        attempt_number=result.total_attempts or len(result.attempts),
+        diff_produced=result.final_diff,
+        test_passed_after=result.success,
+    )
+
+    if result.success:
+        pr_url = ""
+        try:
+            if push_fix_branch(branch_name):
+                pr_url = create_github_pr(target_repo, branch_name, test_path, get_github_token(target_repo))
+        except Exception as e:
+            ui_log(f"PR creation failed for {test_path}: {e}", "WARN")
+
+        update_test_result(attempt_id, True, pr_url)
+        upsert_job(tenant_id, target_repo, test_path, JobStatus.DONE,
+                   f"healed in {result.total_attempts} attempt(s) — PR submitted",
+                   pr_url=pr_url, model_version=MODEL)
+        if pr_url:
+            notify_pr_created(test_path, pr_url)
+        ui_log(f"PR submitted for {test_path} (healed in {result.total_attempts} attempt(s))", "PR")
+        log_audit_event("PR_SUBMITTED", job_id, target_repo, MODEL,
+                        {"test": test_path, "attempts": result.total_attempts, "branch": branch_name, "pr_url": pr_url}, "SUCCESS")
+        run_subprocess_safe(["git", "checkout", "main"], cwd=REPO_DIR, raise_on_error=False)
+        safe_git_pull()
+        return {"success": True, "pr_url": pr_url}
+
+    update_test_result(attempt_id, False)
+    upsert_job(tenant_id, target_repo, test_path, JobStatus.FAILED, result.failure_reason)
+    notify_patch_failed(test_path)
+    ui_log(f"UNRESOLVED after {MAX_RETRIES} attempts: {result.failure_reason}", "FAIL")
+    log_audit_event("HEALING_EXHAUSTED", job_id, target_repo, MODEL,
+                    {"test": test_path, "reason": result.failure_reason}, "FAILED")
+    run_subprocess_safe(["git", "checkout", "main"], cwd=REPO_DIR, raise_on_error=False)
+    safe_git_pull()
+    return {"success": False, "error": result.failure_reason}
+
+
+def enterprise_audit_loop(repo_override: str = None, branch: str = "main", specific_test: str = None):
+    target_repo = repo_override or GITHUB_REPO
+    ui_log("═" * 70)
+    ui_log(f"AUDIT START — Tenant: {TENANT_ID} | Repo: {target_repo} | Model: {MODEL}")
+    notify_audit_start(target_repo)
+    log_audit_event("AUDIT_START", "orchestrator", target_repo, MODEL,
+                    {"tenant": TENANT_ID, "branch": branch}, "STARTED")
+
+    try:
+        configure_git_credentials()
+        mcp_config_path = write_mcp_config()
+
+        if not os.path.exists(REPO_DIR):
+            ui_log("Cloning repository...")
+            Repo.clone_from(f"https://github.com/{target_repo}.git", REPO_DIR)
+            run_subprocess_safe(["git", "config", "user.name", "Rhodawk AI"], cwd=REPO_DIR)
+            run_subprocess_safe(["git", "config", "user.email", "agent@rhodawk.ai"], cwd=REPO_DIR)
+        else:
+            ui_log("Syncing to latest origin/main...")
+            safe_git_pull()
+
+        pytest_bin = setup_target_venv()
+
+        if specific_test:
+            test_files = [os.path.join(REPO_DIR, specific_test)] if os.path.exists(os.path.join(REPO_DIR, specific_test)) else []
+        else:
+            test_files = sorted(glob.glob(f"{REPO_DIR}/**/test_*.py", recursive=True))
+
+        ui_log(f"Discovered {len(test_files)} test file(s).")
+
+        relative_tests = [os.path.relpath(test_path, REPO_DIR) for test_path in test_files]
+        pool_result = run_parallel_audit(
+            relative_tests,
+            process_audit_test,
+            pytest_bin=pytest_bin,
+            mcp_config_path=mcp_config_path,
+            tenant_id=TENANT_ID,
+            target_repo=target_repo,
+        )
+        ui_log(
+            f"Worker pool complete — workers={MAX_WORKERS}, healed={pool_result['healed']}, "
+            f"failed={pool_result['failed']}, skipped={pool_result['skipped']}",
+            "POOL",
+        )
+
+        all_green = True
+        for relative_test in relative_tests:
+            status = get_job_status_enum(TENANT_ID, target_repo, relative_test)
+            if status != JobStatus.DONE:
+                all_green = False
+                break
+
+        if all_green and RED_TEAM_ENABLED and relative_tests:
+            ui_log("All tests GREEN — activating Red Team CEGIS.", "RED")
+            run_red_team_cegis(
+                repo_dir=REPO_DIR,
+                pytest_bin=pytest_bin,
+                mcp_config_path=mcp_config_path,
+                blue_team_fn=process_failing_test,
+                tenant_id=TENANT_ID,
+                log_audit_fn=log_audit_event,
+                notify_fn=notify,
+            )
+
+    except Exception as e:
+        ui_log(f"FATAL: {e}", "FAIL")
+        notify(f"🔴 *FATAL*\n`{e}`", "ERROR")
+        log_audit_event("AUDIT_CRASH", "orchestrator", target_repo, MODEL, {"error": str(e)}, "CRASHED")
+        return
+    finally:
+        _audit_event.clear()
+
+    final_metrics = get_metrics()
+    training_stats = get_statistics()
+    notify_audit_complete(final_metrics)
+
+    is_valid, integrity_msg = verify_chain_integrity()
+    notify_chain_integrity(is_valid, integrity_msg)
+
+    ui_log("═" * 70)
+    ui_log(f"AUDIT COMPLETE — Fix success rate: {training_stats['fix_success_rate']} | "
+           f"SAST blocks: {training_stats['sast_blocked']} | "
+           f"Adversarial rejects: {training_stats['adversarially_rejected']} | "
+           f"Patterns learned: {training_stats['patterns_learned']}")
+    log_audit_event("AUDIT_COMPLETE", "orchestrator", target_repo, MODEL,
+                    {**final_metrics, **training_stats}, "COMPLETE")
+
+
+def trigger_audit_fn():
+    if _audit_event.is_set():
+        return "⚠️ Audit already running."
+    if not _audit_event.is_set():
+        _audit_event.set()
+        threading.Thread(target=enterprise_audit_loop, daemon=True).start()
+        return "🚀 Audit triggered — full healing loop deployed."
+    return "⚠️ Audit already running."
+
+
+# ──────────────────────────────────────────────────────────────
+# REGISTER WEBHOOK DISPATCHER
+# ──────────────────────────────────────────────────────────────
+def _webhook_dispatch(**kwargs):
+    if not _audit_event.is_set():
+        _audit_event.set()
+        threading.Thread(target=enterprise_audit_loop, kwargs=kwargs, daemon=True).start()
+
+set_job_dispatcher(_webhook_dispatch)
+
+
+# ──────────────────────────────────────────────────────────────
+# DASHBOARD DATA GETTERS
+# ──────────────────────────────────────────────────────────────
+def get_live_logs() -> str:
+    with _log_lock:
+        return "\n".join(dashboard_logs[-100:])
+
+
+def get_metrics_row():
+    m = get_metrics()
+    status = "🟡 Running..." if _audit_event.is_set() else "🟢 Idle / Secure"
+    return (status, m["total"], m["done"], m["prs_created"], m["failed"], m["sast_blocked"])
+
+
+def get_job_table() -> list[list]:
+    jobs = list_all_jobs()[:30]
+    rows = []
+    for j in jobs:
+        icons = {"DONE": "✅", "FAILED": "❌", "SAST_BLOCKED": "🛡 Blocked",
+                 "RUNNING": "🔄", "PENDING": "⏳"}
+        rows.append([j.get("test_path", ""), icons.get(j["status"], j["status"]),
+                     j.get("pr_url", "—"), j.get("model_version", "—"), j.get("updated_at", "")])
+    return rows or [["No jobs yet", "", "", "", ""]]
+
+
+def get_audit_display() -> str:
+    events = read_audit_trail(40)
+    if not events:
+        return "No audit events yet."
+    lines = []
+    for e in reversed(events):
+        lines.append(
+            f"[{e['timestamp_utc']}] {e['event_type']:25s} | {e['outcome']:10s} | "
+            f"hash:{e['entry_hash'][:12]}..."
+        )
+    return "\n".join(lines)
+
+
+def get_chain_integrity_display() -> str:
+    valid, msg = verify_chain_integrity()
+    return f"{'🔒 VERIFIED' if valid else '🚨 COMPROMISED'} — {msg}"
+
+
+def get_training_stats_display() -> str:
+    try:
+        stats = get_statistics()
+        mem = get_memory_stats()
+        return (
+            f"Total fix attempts:        {stats['total_attempts']}\n"
+            f"Successful fixes:          {stats['successful_fixes']} ({stats['fix_success_rate']})\n"
+            f"SAST blocked:              {stats['sast_blocked']}\n"
+            f"Adversarially rejected:    {stats['adversarially_rejected']}\n"
+            f"Human-merged PRs:          {stats['human_merged']}\n"
+            f"Memory patterns stored:    {mem['patterns_stored']} ({mem['successful_patterns']} with success signal)\n\n"
+            f"Top recurring failures:\n" +
+            "\n".join(f"  {t['attempts']}x  {t['path']}" for t in stats.get("top_failing_tests", []))
+        )
+    except Exception as e:
+        return f"Stats unavailable: {e}"
+
+
+def get_training_export() -> str:
+    try:
+        data = export_training_data(limit=100)
+        if not data:
+            return "No training data yet. Run audits to accumulate (failure, fix) pairs."
+        lines = data.split("\n")
+        return f"# {len(lines)} training examples (JSONL format)\n# Copy and use for fine-tuning\n\n" + data[:8000]
+    except Exception as e:
+        return f"Export failed: {e}"
+
+
+def get_webhook_log_display() -> str:
+    from webhook_server import get_webhook_log
+    events = get_webhook_log(30)
+    if not events:
+        return f"No webhook events yet.\n\nWebhook endpoint: POST http://this-space:7861/webhook/github\nHealth check: GET http://this-space:7861/webhook/health"
+    lines = [f"[{e['timestamp']}] {e['event_type']:20s} | {e['status']:8s} | {e.get('repo','')} | {e.get('detail','')}" for e in events]
+    return "\n".join(lines)
+
+
+def get_red_team_display() -> str:
+    stats = get_red_team_stats()
+    return (
+        f"Zero-days discovered: {stats['zero_days_discovered']}\n"
+        f"Property-based tests generated: {stats['pbts_generated']}\n"
+        f"Artifacts directory: {stats['red_team_dir']}\n\n"
+        f"Recent Red Team logs:\n{stats['recent_logs']}"
+    )
+
+
+def trigger_swebench_eval(max_instances: int = 25) -> str:
+    def _run():
+        try:
+            from swebench_harness import run_swebench_eval
+            result = run_swebench_eval(max_instances=int(max_instances))
+            ui_log(
+                f"SWE-bench complete — pass@1={result['pass_at_1']:.2%}, "
+                f"resolved={result['resolved']}/{result['total']}",
+                "BENCH",
+            )
+        except Exception as e:
+            ui_log(f"SWE-bench eval failed: {e}", "BENCH")
+
+    threading.Thread(target=_run, daemon=True).start()
+    return f"🧪 SWE-bench Verified evaluation started for {int(max_instances)} instance(s)."
+
+
+def get_swebench_display() -> str:
+    path = "/data/swebench_report.md"
+    if not os.path.exists(path):
+        return "No SWE-bench report yet. Start an evaluation to generate pass@1 results."
+    with open(path, "r", encoding="utf-8") as f:
+        return f.read()[:12000]
+
+
+def export_compliance_display() -> str:
+    try:
+        return f"Compliance report exported: {export_compliance_report()}"
+    except Exception as e:
+        return f"Compliance export failed: {e}"
+
+
+def reset_queue():
+    import shutil
+    shutil.rmtree("/data/jobs", ignore_errors=True)
+    return "✅ Job queue cleared."
+
+
+# ──────────────────────────────────────────────────────────────
+# GRADIO ENTERPRISE DASHBOARD
+# ──────────────────────────────────────────────────────────────
+THEME = gr.themes.Base(
+    primary_hue="violet", secondary_hue="slate", neutral_hue="slate",
+    font=[gr.themes.GoogleFont("Inter"), "ui-sans-serif", "system-ui"],
+).set(
+    body_background_fill="#0a0a0f",
+    body_text_color="#e2e8f0",
+    block_background_fill="#12121c",
+    block_border_color="#1e1e2e",
+    block_label_text_color="#64748b",
+    input_background_fill="#0a0a0f",
+    button_primary_background_fill="#5b21b6",
+    button_primary_background_fill_hover="#6d28d9",
+    button_primary_text_color="#ffffff",
+)
+
+with gr.Blocks(theme=THEME, title="Rhodawk AI — Code Review Monster") as demo:
+
+    gr.HTML("""
+    <div style="padding:20px 0 4px 0; border-bottom:1px solid #1e1e2e; margin-bottom:16px;">
+      <div style="display:flex; align-items:center; gap:14px;">
+        <span style="font-size:2.2rem;">🦅</span>
+        <div>
+          <h1 style="margin:0; font-size:1.5rem; font-weight:800; color:#f1f5f9; letter-spacing:-0.03em;">
+            Rhodawk AI <span style="color:#7c3aed; font-size:0.9rem; font-weight:600; margin-left:8px;">v3.0</span>
+          </h1>
+          <p style="margin:2px 0 0; font-size:0.8rem; color:#475569; letter-spacing:0.02em;">
+            AUTONOMOUS DEVSECOPS CONTROL PLANE &nbsp;·&nbsp;
+            CLOSED VERIFICATION LOOP &nbsp;·&nbsp;
+            ADVERSARIAL LLM REVIEW &nbsp;·&nbsp;
+            DATA FLYWHEEL &nbsp;·&nbsp;
+            SUPPLY CHAIN GATE
+          </p>
+        </div>
+      </div>
+    </div>
+    """)
+
+    with gr.Tabs():
+
+        # ── TAB 1: LIVE OPERATIONS ──────────────────────────────
+        with gr.Tab("⚡ Live Operations"):
+            with gr.Row():
+                stat_status = gr.Textbox(label="System Status", interactive=False, scale=3)
+                stat_total = gr.Number(label="Tests Scanned", interactive=False)
+                stat_done = gr.Number(label="Verified Green", interactive=False)
+                stat_prs = gr.Number(label="PRs Generated", interactive=False)
+                stat_failed = gr.Number(label="Failed", interactive=False)
+                stat_sast = gr.Number(label="SAST Blocked", interactive=False)
+
+            with gr.Row():
+                btn_audit = gr.Button("🚀 Trigger Full Healing Audit", variant="primary", scale=3)
+                btn_reset = gr.Button("🗑 Reset Queue", variant="secondary", scale=1)
+
+            trigger_out = gr.Textbox(label="", interactive=False, show_label=False)
+            live_logs = gr.TextArea(label="Live Agent Execution Log", lines=26, interactive=False)
+
+            btn_audit.click(trigger_audit_fn, outputs=trigger_out)
+            btn_reset.click(reset_queue, outputs=trigger_out)
+
+        # ── TAB 2: JOB QUEUE ───────────────────────────────────
+        with gr.Tab("📋 Job Queue"):
+            gr.Markdown("### Namespaced job store — per (tenant, repo, test)")
+            job_table = gr.Dataframe(
+                headers=["Test Path", "Status", "PR URL", "Model", "Updated At"],
+                datatype=["str", "str", "str", "str", "str"], interactive=False, wrap=True,
+            )
+            gr.Button("🔄 Refresh", variant="secondary").click(get_job_table, outputs=job_table)
+
+        # ── TAB 3: AUDIT TRAIL ─────────────────────────────────
+        with gr.Tab("🔒 Audit Trail"):
+            gr.Markdown(
+                "### SHA-256 chained audit log — every AI action is cryptographically linked\n"
+                "Covers: dispatch → SAST scan → supply chain → adversarial review → PR submission"
+            )
+            chain_status = gr.Textbox(label="Chain Integrity Status", interactive=False)
+            audit_log = gr.TextArea(label="Events (latest first)", lines=20, interactive=False)
+            gr.Button("🔍 Verify Chain", variant="secondary").click(
+                fn=lambda: (get_chain_integrity_display(), get_audit_display()),
+                outputs=[chain_status, audit_log]
+            )
+
+        # ── TAB 4: TRAINING DATA & FLYWHEEL ───────────────────
+        with gr.Tab("🧠 Data Flywheel"):
+            gr.Markdown(
+                "### Proprietary training data pipeline\n"
+                "Every `(failure, fix, adversarial_verdict, test_result)` tuple is stored. "
+                "This is the compounding advantage — the system gets smarter with every run. "
+                "Export as HuggingFace-compatible JSONL for model fine-tuning."
+            )
+            stats_display = gr.TextArea(label="Flywheel Statistics", lines=12, interactive=False)
+            training_export = gr.TextArea(label="Training Data Export (JSONL)", lines=14, interactive=False)
+
+            with gr.Row():
+                gr.Button("📊 Refresh Stats", variant="secondary").click(get_training_stats_display, outputs=stats_display)
+                gr.Button("⬇ Export JSONL", variant="secondary").click(get_training_export, outputs=training_export)
+
+        # ── TAB 5: WEBHOOKS ────────────────────────────────────
+        with gr.Tab("🔗 Webhooks"):
+            gr.Markdown(f"""
+### Event-Driven Trigger Server (Port 7861)
+
+Rhodawk accepts real-time events from GitHub, CI systems, and any HTTP client.
+Configure your GitHub repo to send webhooks here and every push/failure triggers an autonomous healing job.
+
+**Endpoints:**
+```
+POST /webhook/github    — GitHub push/check_run events (HMAC-SHA256 validated)
+POST /webhook/ci        — Generic CI failure: {{"repo": "owner/repo", "test_path": "tests/..."}}
+POST /webhook/trigger   — Manual trigger
+GET  /webhook/health    — Liveness probe
+GET  /webhook/queue     — Current job status (JSON)
+```
+
+**GitHub Setup:**
+1. Go to your repo → Settings → Webhooks → Add webhook
+2. URL: `https://your-space.hf.space:7861/webhook/github`
+3. Secret: set `RHODAWK_WEBHOOK_SECRET` in Space secrets  
+4. Events: push, check_run, status
+            """)
+            webhook_log = gr.TextArea(label="Webhook Event Log", lines=15, interactive=False)
+            gr.Button("🔄 Refresh", variant="secondary").click(get_webhook_log_display, outputs=webhook_log)
+
+        with gr.Tab("⚔️ Red Team"):
+            gr.Markdown(
+                "### Autonomous Red Team CEGIS\n"
+                "When all tests are green, Rhodawk attacks the repo with generated property-based tests "
+                "and hands reproducible zero-days back to Blue Team for patching."
+            )
+            red_team_box = gr.TextArea(label="Red Team Stats & Logs", lines=22, interactive=False)
+            gr.Button("🔄 Refresh Red Team Stats", variant="secondary").click(get_red_team_display, outputs=red_team_box)
+
+        with gr.Tab("🧪 SWE-bench"):
+            gr.Markdown("### SWE-bench Verified Evaluation")
+            with gr.Row():
+                swebench_count = gr.Number(label="Max instances", value=25, precision=0)
+                swebench_start = gr.Button("Start Evaluation", variant="primary")
+                swebench_refresh = gr.Button("Refresh Report", variant="secondary")
+            swebench_status = gr.Textbox(label="Status", interactive=False)
+            swebench_report = gr.TextArea(label="SWE-bench Report", lines=24, interactive=False)
+            swebench_start.click(trigger_swebench_eval, inputs=swebench_count, outputs=swebench_status)
+            swebench_refresh.click(get_swebench_display, outputs=swebench_report)
+
+        # ── TAB 8: SYSTEM / ARCHITECTURE ──────────────────────
+        with gr.Tab("ℹ️ Architecture"):
+            compliance_out = gr.Textbox(label="Compliance Export", interactive=False)
+            gr.Button("Export SOC 2 Evidence Summary", variant="secondary").click(
+                export_compliance_display, outputs=compliance_out
+            )
+            gr.Markdown(f"""
+### Rhodawk AI v4.0 — Capability Stack
+
+**Tenant:** `{TENANT_ID}` | **Target:** `{GITHUB_REPO}` | **Model:** `{MODEL}`
+
+---
+
+| Layer | Technology | What it does |
+|---|---|---|
+| AI Agent | Aider + OpenRouter/Qwen | Autonomous patch generation |
+| MCP Tools | fetch-docs, github-manager | Documentation + PR creation |
+| **Verification Loop** | pytest re-run per attempt | **Closes the loop — tests the fix before PR** |
+| **Adversarial Review** | Second LLM (red team) | **Every diff reviewed by a hostile model** |
+| **Memory Engine** | Embeddings + SQLite | **Cross-repo semantic retrieval of similar fixes** |
+| **Supply Chain Gate** | pip-audit + typosquatting + PyPI metadata | **Catches malicious dependencies in AI diffs** |
+| SAST Gate | bandit + semgrep + secret/injection patterns | Pre-PR security scanning |
+| Audit Trail | SHA-256 JSONL chain | SOC 2 / ISO 27001 evidence |
+| Training Store | SQLite (failure→fix→outcome) | Fine-tuning dataset accumulation |
+| Webhook Server | HTTP on :7861 + HMAC + rate limit | Event-driven GitHub/CI triggers |
+| Worker Pool | ThreadPoolExecutor | Parallel audit execution |
+| SWE-bench Harness | SWE-bench Verified | pass@1 benchmarking reports |
+| Notifications | Telegram + Slack | Multi-channel alerting |
+| Virtualenv | uv | Blazing-fast isolated Python env |
+
+---
+
+### What no competitor has (combined)
+
+1. **Closed verification loop** — generates fix, re-runs tests, retries with new context up to {MAX_RETRIES}x
+2. **Adversarial LLM review** — autonomous red-team pass on every AI-generated diff before PR
+3. **Fix memory flywheel** — TF-IDF retrieval of similar past fixes injected as few-shot examples
+4. **Supply chain attack detection** — typosquatting + CVE scan on AI-added packages
+5. **Event-driven webhook triggers** — real-time CI/CD participant, not a manual tool
+6. **Structured training data pipeline** — every run accumulates fine-tuning signal
+7. **Red Team CEGIS** — all-green repos are attacked, fuzzed, and patched autonomously
+
+---
+
+### Roadmap
+- Firecracker microVMs for per-job execution isolation
+- GitHub App rollout across all enterprise tenants
+- Multi-model consensus (3 models, pick majority agreement)
+- Fine-tuned model trained on proprietary failure→fix dataset
+- Distributed job queue (Postgres + worker pool)
+            """)
+
+    # ── 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])
+
+    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(get_job_table, outputs=job_table)
+    demo.load(get_audit_display, outputs=audit_log)
+    demo.load(get_chain_integrity_display, outputs=chain_status)
+    demo.load(get_training_stats_display, outputs=stats_display)
+    demo.load(get_webhook_log_display, outputs=webhook_log)
+    demo.load(get_red_team_display, outputs=red_team_box)
+    demo.load(get_swebench_display, outputs=swebench_report)
+
+
+if __name__ == "__main__":
+    ui_log(f"Rhodawk AI v3.0 starting — Tenant: {TENANT_ID} | Model: {MODEL}")
+    ui_log("Starting webhook server on port 7861...")
+    start_webhook_server()
+    ui_log("Webhook server running. Launching dashboard...")
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=False, show_error=True)

audit_logger.py

@@ -0,0 +1,186 @@
+"""
+Rhodawk AI — Immutable Audit Trail Engine
+==========================================
+Every AI action is appended to an append-only JSONL file with SHA-256 chaining.
+Each entry references the hash of the previous entry, creating a tamper-evident
+chain of custody for every line of AI-generated code. Required for SOC 2 / ISO 27001.
+"""
+
+import hashlib
+import json
+import os
+import threading
+import time
+from typing import Optional
+
+AUDIT_LOG_PATH = "/data/audit_trail.jsonl"
+_audit_write_lock = threading.Lock()
+
+_last_hash: Optional[str] = None
+
+
+def _compute_hash(entry: dict) -> str:
+    canonical = json.dumps(entry, sort_keys=True, separators=(",", ":"))
+    return hashlib.sha256(canonical.encode()).hexdigest()
+
+
+def _get_last_hash() -> str:
+    global _last_hash
+    if _last_hash:
+        return _last_hash
+    if not os.path.exists(AUDIT_LOG_PATH):
+        return "GENESIS"
+    try:
+        with open(AUDIT_LOG_PATH, "rb") as f:
+            lines = f.read().splitlines()
+            if not lines:
+                return "GENESIS"
+            last_line = lines[-1].decode("utf-8").strip()
+            if not last_line:
+                return "GENESIS"
+            last_entry = json.loads(last_line)
+            _last_hash = last_entry.get("entry_hash", "GENESIS")
+            return _last_hash
+    except Exception:
+        return "GENESIS"
+
+
+def log_audit_event(
+    event_type: str,
+    job_id: str,
+    repo: str,
+    model: str,
+    details: dict,
+    outcome: str = "PENDING",
+) -> str:
+    """
+    Append an audit event to the immutable JSONL chain.
+    Returns the entry hash for cross-referencing.
+    """
+    global _last_hash
+
+    with _audit_write_lock:
+        prev_hash = _get_last_hash()
+
+        entry = {
+            "schema_version": "1.0",
+            "timestamp_utc": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+            "unix_ts": time.time(),
+            "event_type": event_type,
+            "job_id": job_id,
+            "repo": repo,
+            "model_version": model,
+            "outcome": outcome,
+            "details": details,
+            "prev_hash": prev_hash,
+        }
+
+        entry_hash = _compute_hash(entry)
+        entry["entry_hash"] = entry_hash
+
+        os.makedirs(os.path.dirname(AUDIT_LOG_PATH), exist_ok=True)
+        with open(AUDIT_LOG_PATH, "a") as f:
+            f.write(json.dumps(entry) + "\n")
+
+        _last_hash = entry_hash
+        return entry_hash
+
+
+def read_audit_trail(limit: int = 50) -> list[dict]:
+    """Return the last N audit events for dashboard display."""
+    if not os.path.exists(AUDIT_LOG_PATH):
+        return []
+    events = []
+    try:
+        with open(AUDIT_LOG_PATH, "r") as f:
+            for line in f:
+                line = line.strip()
+                if line:
+                    try:
+                        events.append(json.loads(line))
+                    except json.JSONDecodeError:
+                        pass
+    except OSError:
+        return []
+    return events[-limit:]
+
+
+def verify_chain_integrity() -> tuple[bool, str]:
+    """
+    Walk the entire audit chain and verify each entry's hash.
+    Returns (is_valid, summary_message).
+    Used for compliance attestation.
+    """
+    if not os.path.exists(AUDIT_LOG_PATH):
+        return True, "No audit log yet — chain is clean."
+
+    events = []
+    with open(AUDIT_LOG_PATH, "r") as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                events.append(json.loads(line))
+
+    if not events:
+        return True, "Empty log — chain is clean."
+
+    for i, entry in enumerate(events):
+        stored_hash = entry.pop("entry_hash", None)
+        computed = _compute_hash(entry)
+        entry["entry_hash"] = stored_hash
+
+        if computed != stored_hash:
+            return False, f"CHAIN BROKEN at entry {i} (event: {entry.get('event_type')}). Possible tampering detected."
+
+        if i > 0:
+            expected_prev = events[i - 1]["entry_hash"]
+            if entry["prev_hash"] != expected_prev:
+                return False, f"HASH CHAIN BROKEN between entries {i-1} and {i}."
+
+    return True, f"Chain VERIFIED — {len(events)} entries, all hashes valid."
+
+
+def export_compliance_report(output_path: str = "/data/rhodawk_soc2_audit_summary.md") -> str:
+    events = read_audit_trail(limit=100000)
+    valid, integrity_msg = verify_chain_integrity()
+    by_type: dict[str, int] = {}
+    by_outcome: dict[str, int] = {}
+    repos: dict[str, int] = {}
+    for event in events:
+        by_type[event.get("event_type", "UNKNOWN")] = by_type.get(event.get("event_type", "UNKNOWN"), 0) + 1
+        by_outcome[event.get("outcome", "UNKNOWN")] = by_outcome.get(event.get("outcome", "UNKNOWN"), 0) + 1
+        repos[event.get("repo", "unknown")] = repos.get(event.get("repo", "unknown"), 0) + 1
+
+    report = [
+        "# Rhodawk AI SOC 2 Audit Evidence Summary",
+        "",
+        f"Generated: {time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())}",
+        f"Chain integrity: {'VERIFIED' if valid else 'COMPROMISED'}",
+        f"Integrity detail: {integrity_msg}",
+        f"Total audit events: {len(events)}",
+        "",
+        "## Event Types",
+        "",
+        *[f"- {name}: {count}" for name, count in sorted(by_type.items())],
+        "",
+        "## Outcomes",
+        "",
+        *[f"- {name}: {count}" for name, count in sorted(by_outcome.items())],
+        "",
+        "## Repository Coverage",
+        "",
+        *[f"- {name}: {count} event(s)" for name, count in sorted(repos.items())],
+        "",
+        "## Latest Evidence Entries",
+        "",
+    ]
+    for event in events[-25:]:
+        report.append(
+            f"- `{event.get('timestamp_utc')}` `{event.get('event_type')}` "
+            f"`{event.get('outcome')}` hash `{event.get('entry_hash', '')[:16]}`"
+        )
+
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.write("\n".join(report))
+    return output_path

embedding_memory.py

@@ -0,0 +1,115 @@
+"""
+Rhodawk AI — Embedding-Based Memory Engine v2
+==============================================
+Cross-repository semantic retrieval using sentence-transformers embeddings.
+"""
+
+import os
+import re
+import sqlite3
+from typing import Optional
+
+import numpy as np
+
+from training_store import DB_PATH
+
+EMBEDDING_DB_PATH = os.getenv("RHODAWK_EMBEDDING_DB", "/data/embedding_memory.db")
+MODEL_NAME = os.getenv("RHODAWK_EMBEDDING_MODEL", "all-MiniLM-L6-v2")
+_MODEL = None
+
+
+def _get_model():
+    global _MODEL
+    if _MODEL is None:
+        from sentence_transformers import SentenceTransformer
+        _MODEL = SentenceTransformer(MODEL_NAME)
+    return _MODEL
+
+
+def _normalize_failure(failure_output: str) -> str:
+    text = re.sub(r'File "[^"]+", line \d+', "File <path>, line <n>", failure_output)
+    text = re.sub(r"/[\w./-]+", "<path>", text)
+    text = re.sub(r"\b\d+\b", "<num>", text)
+    return text[:4000]
+
+
+def embed_failure(failure_output: str) -> np.ndarray:
+    normalized = _normalize_failure(failure_output)
+    return _get_model().encode(normalized, normalize_embeddings=True)
+
+
+def _ensure_schema() -> None:
+    os.makedirs(os.path.dirname(EMBEDDING_DB_PATH), exist_ok=True)
+    with sqlite3.connect(EMBEDDING_DB_PATH) as conn:
+        conn.execute("""
+            CREATE TABLE IF NOT EXISTS fix_embeddings (
+                failure_signature TEXT PRIMARY KEY,
+                embedding BLOB NOT NULL,
+                fix_diff TEXT NOT NULL,
+                success_rate TEXT NOT NULL,
+                sample_failure TEXT NOT NULL,
+                updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+
+
+def rebuild_embedding_index(limit: int = 1000) -> int:
+    _ensure_schema()
+    with sqlite3.connect(DB_PATH) as source:
+        source.row_factory = sqlite3.Row
+        rows = source.execute("""
+            SELECT fp.failure_signature, fp.fix_diff, fp.success_count, fp.attempt_count,
+                   fa.failure_output as sample_failure
+            FROM fix_patterns fp
+            LEFT JOIN fix_attempts fa ON fa.failure_signature = fp.failure_signature
+                AND fa.success_signal = 1
+            WHERE fp.success_count > 0
+            ORDER BY fp.success_count DESC
+            LIMIT ?
+        """, (limit,)).fetchall()
+
+    with sqlite3.connect(EMBEDDING_DB_PATH) as target:
+        for row in rows:
+            sample = row["sample_failure"] or row["failure_signature"]
+            emb = embed_failure(sample).astype(np.float32).tobytes()
+            attempts = row["attempt_count"] or 1
+            success_rate = f"{(row['success_count'] / attempts * 100):.0f}%"
+            target.execute("""
+                INSERT INTO fix_embeddings (failure_signature, embedding, fix_diff, success_rate, sample_failure)
+                VALUES (?, ?, ?, ?, ?)
+                ON CONFLICT(failure_signature) DO UPDATE SET
+                    embedding=excluded.embedding,
+                    fix_diff=excluded.fix_diff,
+                    success_rate=excluded.success_rate,
+                    sample_failure=excluded.sample_failure,
+                    updated_at=CURRENT_TIMESTAMP
+            """, (row["failure_signature"], emb, row["fix_diff"], success_rate, sample))
+    return len(rows)
+
+
+def retrieve_similar_fixes_v2(
+    failure_output: str,
+    top_k: int = 5,
+    min_similarity: float = 0.75,
+) -> list[dict]:
+    _ensure_schema()
+    query_vec = embed_failure(failure_output).astype(np.float32)
+    with sqlite3.connect(EMBEDDING_DB_PATH) as conn:
+        conn.row_factory = sqlite3.Row
+        rows = conn.execute("SELECT failure_signature, embedding, fix_diff, success_rate FROM fix_embeddings").fetchall()
+
+    results = []
+    for row in rows:
+        vec = np.frombuffer(row["embedding"], dtype=np.float32)
+        if vec.size != query_vec.size:
+            continue
+        sim = float(np.dot(query_vec, vec))
+        if sim >= min_similarity:
+            results.append({
+                "failure_signature": row["failure_signature"],
+                "fix_diff": row["fix_diff"],
+                "success_rate": row["success_rate"],
+                "similarity": round(sim, 3),
+            })
+    results.sort(key=lambda item: item["similarity"], reverse=True)
+    return results[:top_k]

github_app.py

@@ -0,0 +1,53 @@
+"""
+Rhodawk AI — GitHub App Authentication
+=======================================
+Short-lived installation tokens for enterprise multi-repo access.
+"""
+
+import os
+import time
+
+import jwt
+import requests
+
+
+def get_installation_token(repo: str) -> str:
+    app_id = os.getenv("RHODAWK_APP_ID")
+    private_key = os.getenv("RHODAWK_APP_PRIVATE_KEY", "").replace("\\n", "\n")
+    if not app_id or not private_key:
+        raise EnvironmentError("RHODAWK_APP_ID and RHODAWK_APP_PRIVATE_KEY are required")
+
+    now = int(time.time())
+    payload = {"iat": now - 60, "exp": now + 600, "iss": app_id}
+    jwt_token = jwt.encode(payload, private_key, algorithm="RS256")
+    headers = {
+        "Authorization": f"Bearer {jwt_token}",
+        "Accept": "application/vnd.github+json",
+        "X-GitHub-API-Version": "2022-11-28",
+    }
+
+    owner, repo_name = repo.split("/", 1)
+    resp = requests.get(
+        f"https://api.github.com/repos/{owner}/{repo_name}/installation",
+        headers=headers,
+        timeout=15,
+    )
+    resp.raise_for_status()
+    installation_id = resp.json()["id"]
+
+    resp = requests.post(
+        f"https://api.github.com/app/installations/{installation_id}/access_tokens",
+        headers=headers,
+        timeout=15,
+    )
+    resp.raise_for_status()
+    return resp.json()["token"]
+
+
+def get_github_token(repo: str) -> str:
+    if os.getenv("RHODAWK_APP_ID") and os.getenv("RHODAWK_APP_PRIVATE_KEY"):
+        return get_installation_token(repo)
+    token = os.getenv("GITHUB_TOKEN", "")
+    if not token:
+        raise EnvironmentError("No GitHub App credentials or GITHUB_TOKEN configured")
+    return token

job_queue.py

@@ -0,0 +1,138 @@
+"""
+Rhodawk AI — Namespaced Job Queue
+===================================
+Replaces the flat single-tenant STATE_FILE with a proper namespaced job store.
+Each job is keyed by (tenant_id, repo, test_path) — ready for multi-tenant SaaS.
+State is persisted as atomic JSON writes. Future path: swap backing store to PostgreSQL.
+"""
+
+import hashlib
+import json
+import os
+import threading
+import time
+from enum import Enum
+from typing import Optional
+
+QUEUE_DIR = "/data/jobs"
+_queue_lock = threading.Lock()
+
+
+class JobStatus(Enum):
+    PENDING = "PENDING"
+    RUNNING = "RUNNING"
+    SAST_BLOCKED = "SAST_BLOCKED"
+    DONE = "DONE"
+    FAILED = "FAILED"
+
+
+def _job_id(tenant_id: str, repo: str, test_path: str) -> str:
+    raw = f"{tenant_id}::{repo}::{test_path}"
+    return hashlib.sha256(raw.encode()).hexdigest()[:16]
+
+
+def _job_path(job_id: str) -> str:
+    os.makedirs(QUEUE_DIR, exist_ok=True)
+    return os.path.join(QUEUE_DIR, f"{job_id}.json")
+
+
+def upsert_job(
+    tenant_id: str,
+    repo: str,
+    test_path: str,
+    status: JobStatus,
+    detail: str = "",
+    pr_url: Optional[str] = None,
+    sast_findings: Optional[list] = None,
+    model_version: Optional[str] = None,
+    prompt_hash: Optional[str] = None,
+) -> str:
+    job_id = _job_id(tenant_id, repo, test_path)
+    path = _job_path(job_id)
+
+    with _queue_lock:
+        existing = {}
+        if os.path.exists(path):
+            try:
+                with open(path) as f:
+                    existing = json.load(f)
+            except Exception:
+                existing = {}
+
+        job = {
+            **existing,
+            "job_id": job_id,
+            "tenant_id": tenant_id,
+            "repo": repo,
+            "test_path": test_path,
+            "status": status.value,
+            "detail": detail,
+            "updated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        }
+
+        if "created_at" not in job:
+            job["created_at"] = job["updated_at"]
+        if pr_url is not None:
+            job["pr_url"] = pr_url
+        if sast_findings is not None:
+            job["sast_findings_count"] = len(sast_findings)
+        if model_version is not None:
+            job["model_version"] = model_version
+        if prompt_hash is not None:
+            job["prompt_hash"] = prompt_hash
+
+        tmp_path = path + ".tmp"
+        with open(tmp_path, "w") as f:
+            json.dump(job, f, indent=2)
+        os.replace(tmp_path, path)
+
+    return job_id
+
+
+def get_job(tenant_id: str, repo: str, test_path: str) -> Optional[dict]:
+    job_id = _job_id(tenant_id, repo, test_path)
+    path = _job_path(job_id)
+    if not os.path.exists(path):
+        return None
+    try:
+        with open(path) as f:
+            return json.load(f)
+    except Exception:
+        return None
+
+
+def get_job_status_enum(tenant_id: str, repo: str, test_path: str) -> Optional[JobStatus]:
+    job = get_job(tenant_id, repo, test_path)
+    if not job:
+        return None
+    try:
+        return JobStatus(job["status"])
+    except ValueError:
+        return None
+
+
+def list_all_jobs() -> list[dict]:
+    if not os.path.exists(QUEUE_DIR):
+        return []
+    jobs = []
+    for fname in sorted(os.listdir(QUEUE_DIR)):
+        if not fname.endswith(".json"):
+            continue
+        try:
+            with open(os.path.join(QUEUE_DIR, fname)) as f:
+                jobs.append(json.load(f))
+        except Exception:
+            pass
+    return sorted(jobs, key=lambda j: j.get("updated_at", ""), reverse=True)
+
+
+def get_metrics() -> dict:
+    jobs = list_all_jobs()
+    return {
+        "total": len(jobs),
+        "done": sum(1 for j in jobs if j["status"] == "DONE"),
+        "failed": sum(1 for j in jobs if j["status"] == "FAILED"),
+        "running": sum(1 for j in jobs if j["status"] == "RUNNING"),
+        "sast_blocked": sum(1 for j in jobs if j["status"] == "SAST_BLOCKED"),
+        "prs_created": sum(1 for j in jobs if j.get("pr_url")),
+    }

mcp_config.json

@@ -0,0 +1,27 @@
+{
+  "_comment": [
+    "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`."
+  ],
+  "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"
+      }
+    },
+    "github-manager": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-github"],
+      "env": {
+        "GITHUB_PERSONAL_ACCESS_TOKEN": "__INJECTED_BY_APP_AT_RUNTIME__"
+      }
+    }
+  }
+}

memory_engine.py

@@ -0,0 +1,134 @@
+"""
+Rhodawk AI — Fix Memory Engine (Data Flywheel)
+===============================================
+Retrieves semantically similar past successful fixes and injects them as
+few-shot examples into the prompt for new failures.
+
+This is the compounding advantage: the more repos Rhodawk heals, the better
+it gets at healing new repos. After 500 examples, fix accuracy on similar
+failures improves measurably. After 5,000 — you fine-tune the model on it.
+
+Implementation: TF-IDF based similarity on failure signatures.
+No external embedding API required. Runs entirely on-device.
+Designed to be swapped out for a vector database (Pinecone/Qdrant) at scale.
+"""
+
+import hashlib
+import re
+import sqlite3
+from collections import Counter
+from typing import Optional
+
+from training_store import DB_PATH
+
+
+def _tokenize(text: str) -> list[str]:
+    text = text.lower()
+    text = re.sub(r"[^\w\s]", " ", text)
+    tokens = text.split()
+    stopwords = {"the", "a", "an", "is", "in", "at", "of", "and", "or", "for", "with",
+                 "line", "file", "test", "error", "assert", "none", "true", "false",
+                 "self", "return", "import", "from", "def", "class"}
+    return [t for t in tokens if len(t) > 2 and t not in stopwords]
+
+
+def _tf_idf_similarity(query_tokens: list[str], doc_tokens: list[str], corpus_df: dict, corpus_size: int) -> float:
+    import math
+
+    def tf(tokens: list[str], term: str) -> float:
+        count = tokens.count(term)
+        return count / len(tokens) if tokens else 0
+
+    def idf(term: str) -> float:
+        df = corpus_df.get(term, 0)
+        return math.log((corpus_size + 1) / (df + 1)) + 1
+
+    query_set = set(query_tokens)
+    doc_set = set(doc_tokens)
+    all_terms = query_set | doc_set
+
+    query_vec = {t: tf(query_tokens, t) * idf(t) for t in all_terms}
+    doc_vec = {t: tf(doc_tokens, t) * idf(t) for t in all_terms}
+
+    dot = sum(query_vec.get(t, 0) * doc_vec.get(t, 0) for t in all_terms)
+    q_norm = sum(v**2 for v in query_vec.values()) ** 0.5
+    d_norm = sum(v**2 for v in doc_vec.values()) ** 0.5
+
+    if q_norm == 0 or d_norm == 0:
+        return 0.0
+    return dot / (q_norm * d_norm)
+
+
+def retrieve_similar_fixes(failure_output: str, top_k: int = 3, min_similarity: float = 0.15) -> list[dict]:
+    """
+    Retrieve the most similar successful past fixes for a given failure output.
+    Returns list of dicts with keys: failure_signature, fix_diff, success_rate, similarity
+    """
+    try:
+        conn = sqlite3.connect(DB_PATH, timeout=5)
+        conn.row_factory = sqlite3.Row
+
+        # Get all successful patterns
+        rows = conn.execute("""
+            SELECT fp.failure_signature, fp.fix_diff, fp.success_count, fp.attempt_count,
+                   fa.failure_output as sample_failure
+            FROM fix_patterns fp
+            LEFT JOIN fix_attempts fa ON fa.failure_signature = fp.failure_signature
+                AND fa.success_signal = 1
+            WHERE fp.success_count > 0
+            ORDER BY fp.success_count DESC
+            LIMIT 200
+        """).fetchall()
+
+        conn.close()
+
+        if not rows:
+            return []
+
+        query_tokens = _tokenize(failure_output)
+
+        # Build corpus document frequency
+        corpus_docs = [_tokenize(r["sample_failure"] or r["failure_signature"]) for r in rows]
+        corpus_df: dict[str, int] = Counter()
+        for doc in corpus_docs:
+            for term in set(doc):
+                corpus_df[term] += 1
+
+        results = []
+        for i, row in enumerate(rows):
+            doc_tokens = corpus_docs[i]
+            sim = _tf_idf_similarity(query_tokens, doc_tokens, corpus_df, len(rows))
+
+            if sim >= min_similarity:
+                total = row["attempt_count"] or 1
+                success_rate = f"{(row['success_count'] / total * 100):.0f}%"
+                results.append({
+                    "failure_signature": row["failure_signature"],
+                    "fix_diff": row["fix_diff"],
+                    "success_rate": success_rate,
+                    "similarity": round(sim, 3),
+                })
+
+        results.sort(key=lambda x: x["similarity"], reverse=True)
+        return results[:top_k]
+
+    except Exception:
+        return []
+
+
+def record_fix_outcome(failure_output: str, context: str, fix_diff: str, success: bool):
+    """Called after each fix attempt to update the memory store."""
+    from training_store import record_pattern
+    context_hash = hashlib.sha256(context.encode()).hexdigest()[:16]
+    record_pattern(failure_output, context_hash, fix_diff, success)
+
+
+def get_memory_stats() -> dict:
+    try:
+        conn = sqlite3.connect(DB_PATH, timeout=5)
+        total = conn.execute("SELECT COUNT(*) FROM fix_patterns").fetchone()[0]
+        successful = conn.execute("SELECT COUNT(*) FROM fix_patterns WHERE success_count > 0").fetchone()[0]
+        conn.close()
+        return {"patterns_stored": total, "successful_patterns": successful}
+    except Exception:
+        return {"patterns_stored": 0, "successful_patterns": 0}

notifier.py

@@ -0,0 +1,95 @@
+"""
+Rhodawk AI — Multi-Channel Notification Engine
+================================================
+Fire-and-forget notifications across Telegram (and extensible to Slack/PagerDuty).
+All dispatches use tenacity retry logic and never block the audit loop.
+"""
+
+import os
+import threading
+import requests
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+TELEGRAM_BOT_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
+TELEGRAM_CHAT_ID = os.getenv("TELEGRAM_CHAT_ID")
+SLACK_WEBHOOK_URL = os.getenv("SLACK_WEBHOOK_URL")
+
+
+@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10))
+def _post_telegram(payload: dict):
+    url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage"
+    resp = requests.post(url, json=payload, timeout=10)
+    resp.raise_for_status()
+
+
+@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10))
+def _post_slack(payload: dict):
+    resp = requests.post(SLACK_WEBHOOK_URL, json=payload, timeout=10)
+    resp.raise_for_status()
+
+
+def _dispatch(message: str, level: str = "INFO"):
+    if TELEGRAM_BOT_TOKEN and TELEGRAM_CHAT_ID:
+        try:
+            _post_telegram({
+                "chat_id": TELEGRAM_CHAT_ID,
+                "text": message,
+                "parse_mode": "Markdown",
+                "disable_web_page_preview": True,
+            })
+        except Exception:
+            pass
+
+    if SLACK_WEBHOOK_URL:
+        color_map = {"INFO": "#36a64f", "WARN": "#ffa500", "ERROR": "#ff0000", "CRITICAL": "#8b0000"}
+        try:
+            _post_slack({
+                "attachments": [{
+                    "color": color_map.get(level, "#36a64f"),
+                    "text": message.replace("*", ""),
+                    "mrkdwn_in": ["text"],
+                }]
+            })
+        except Exception:
+            pass
+
+
+def notify(message: str, level: str = "INFO"):
+    """Non-blocking dispatch. Spawns a daemon thread — never blocks audit loop."""
+    threading.Thread(target=_dispatch, args=(message, level), daemon=True).start()
+
+
+def notify_audit_start(repo: str):
+    notify(f"🚀 *Rhodawk AI*\n\nAutonomous audit initiated on `{repo}`.", "INFO")
+
+
+def notify_test_failed(test_path: str):
+    notify(f"⚠️ *Test Failed*\n`{test_path}`\nDispatching Aider agent...", "WARN")
+
+
+def notify_sast_blocked(test_path: str, reason: str):
+    notify(f"🛡️ *SAST Gate BLOCKED PR*\n`{test_path}`\nReason: `{reason}`\nHuman review required.", "CRITICAL")
+
+
+def notify_pr_created(test_path: str, pr_url: str):
+    notify(f"✅ *Auto-Heal PR Generated*\n`{test_path}`\n[View PR]({pr_url})\nAwaiting human review.", "INFO")
+
+
+def notify_patch_failed(test_path: str):
+    notify(f"🔴 *Patch Failed*\n`{test_path}`\nAider returned non-zero exit.", "ERROR")
+
+
+def notify_audit_complete(metrics: dict):
+    notify(
+        f"🎯 *Audit Complete*\n"
+        f"Scanned: `{metrics['total']}` | Green: `{metrics['done']}` | "
+        f"PRs: `{metrics['prs_created']}` | SAST Blocked: `{metrics['sast_blocked']}`",
+        "INFO",
+    )
+
+
+def notify_chain_integrity(valid: bool, summary: str):
+    if valid:
+        notify(f"🔒 *Audit Chain Verified*\n{summary}", "INFO")
+    else:
+        notify(f"🚨 *CHAIN INTEGRITY VIOLATION*\n{summary}", "CRITICAL")

red_team_fuzzer.py

@@ -0,0 +1,1503 @@
+"""
+Rhodawk AI — Autonomous Red Team Fuzzing Engine (CEGIS)
+========================================================
+The Zero-Day Discovery Machine. No competitor has this.
+
+What this does:
+  When the Blue Team audit loop encounters a "Green" repository (all tests passing),
+  this engine takes over. It autonomously ATTACKS the codebase — discovering
+  mathematical invariants, synthesizing Property-Based Tests, and fuzzing them
+  to exhaustion to find the minimal crashing counter-example (the zero-day payload).
+  The crash is then handed to the Blue Team verification_loop.py for autonomous patching.
+
+Architecture — CEGIS (Counter-Example Guided Inductive Synthesis):
+  ┌─────────────────────────────────────────────────────────────────┐
+  │                    RED TEAM ENGINE (This File)                  │
+  │                                                                 │
+  │  1. MCP Universal Analyzer                                      │
+  │     └── Parse AST → score complexity → rank attack targets      │
+  │                                                                 │
+  │  2. Red Team LLM (The Attacker)                                 │
+  │     └── Adversarial prompt → generate Hypothesis PBT           │
+  │         targeting: overflows, race conditions, invariant breaks  │
+  │                                                                 │
+  │  3. Deterministic Fuzzing Loop                                  │
+  │     └── Execute PBT via subprocess → aggressive randomization   │
+  │         → extract minimal falsifying counter-example            │
+  │                                                                 │
+  │  4. CEGIS Re-attack (if no crash found)                        │
+  │     └── Inject "survived inputs" back to LLM → demand harder   │
+  │         invariant → repeat up to MAX_CEGIS_ROUNDS              │
+  │                                                                 │
+  │  5. Handoff to Blue Team                                        │
+  │     └── Package crash payload → inject into verification_loop   │
+  │         as a synthetic failing pytest → Blue Team patches it    │
+  └─────────────────────────────────────────────────────────────────┘
+
+Invariant classes targeted:
+  - Mathematical: commutativity, associativity, idempotency, monotonicity
+  - Boundary: integer overflow (sys.maxsize, 2^63-1, -1, 0), empty sequences
+  - Roundtrip: encode→decode, serialize→deserialize, compress→decompress
+  - Concurrency: race conditions via threading + shared state mutation
+  - Type coercion: implicit conversions that cause precision loss or exceptions
+  - State machine: functions that should be pure but carry hidden mutable state
+"""
+
+import ast
+import hashlib
+import json
+import os
+import re
+import signal
+import subprocess
+import sys
+import tempfile
+import textwrap
+import threading
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Callable, Optional
+
+import requests
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+# ──────────────────────────────────────────────────────────────
+# CONFIGURATION & SECRETS
+# ──────────────────────────────────────────────────────────────
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
+RED_TEAM_MODEL = os.getenv(
+    "RHODAWK_RED_TEAM_MODEL",
+    "openrouter/qwen/qwen-2.5-coder-32b-instruct:free",
+)
+RED_TEAM_MODEL_STRONG = os.getenv(
+    "RHODAWK_RED_TEAM_MODEL_STRONG",
+    "openrouter/anthropic/claude-3-5-sonnet",
+)
+
+PERSISTENT_DIR = "/data"
+RED_TEAM_DIR = f"{PERSISTENT_DIR}/red_team"
+FUZZ_VENV_DIR = f"{PERSISTENT_DIR}/fuzz_venv"
+
+MAX_CEGIS_ROUNDS = int(os.getenv("RHODAWK_CEGIS_ROUNDS", "4"))
+FUZZ_MAX_EXAMPLES = int(os.getenv("RHODAWK_FUZZ_EXAMPLES", "50000"))
+FUZZ_TIMEOUT_SECONDS = int(os.getenv("RHODAWK_FUZZ_TIMEOUT", "180"))
+MAX_TARGETS_PER_RUN = int(os.getenv("RHODAWK_MAX_TARGETS", "8"))
+MIN_COMPLEXITY_SCORE = float(os.getenv("RHODAWK_MIN_COMPLEXITY", "2.0"))
+
+# ──────────────────────────────────────────────────────────────
+# LOGGING — mirrors app.py ui_log pattern
+# ────────────────────────────────────────────────────────���─────
+_rt_log_lock = threading.Lock()
+_rt_logs: list[str] = []
+
+
+def rte_log(message: str, level: str = "INFO") -> None:
+    ts = time.strftime("%H:%M:%S")
+    icons = {
+        "ATTACK": "⚔️",
+        "CRASH":  "💥",
+        "FUZZ":   "🎯",
+        "AST":    "🔬",
+        "CEGIS":  "🔁",
+        "HAND":   "🤝",
+        "OK":     "✅",
+        "FAIL":   "❌",
+        "WARN":   "⚠",
+        "INFO":   "  ",
+    }
+    line = f"[{ts}] {icons.get(level, '  ')} [RED-TEAM] {message}"
+    print(line, flush=True)
+    with _rt_log_lock:
+        _rt_logs.append(line)
+        if len(_rt_logs) > 500:
+            _rt_logs.pop(0)
+
+
+def get_red_team_logs(n: int = 100) -> str:
+    with _rt_log_lock:
+        return "\n".join(_rt_logs[-n:])
+
+
+# ──────────────────────────────────────────────────────────────
+# DATA STRUCTURES
+# ──────────────────────────────────────────────────────────────
+
+@dataclass
+class ASTFunctionProfile:
+    """Rich profile of a function extracted from its AST node."""
+    module_path: str          # Relative path: src/utils.py
+    function_name: str
+    lineno: int
+    source_code: str          # Raw source of the function
+    signature: str            # def func(x: int, y: str) -> bool
+    arg_types: dict[str, str] # {"x": "int", "y": "str"}
+    return_type: str
+    complexity_score: float   # Cyclomatic complexity (radon)
+    has_numeric_ops: bool     # Contains arithmetic that could overflow
+    has_loops: bool
+    has_recursion: bool
+    has_state_mutation: bool  # Mutates mutable args (list, dict)
+    has_exception_handling: bool
+    docstring: str
+    calls_made: list[str]     # Other functions this calls
+    ast_summary: str          # Compact JSON summary for LLM
+
+
+@dataclass
+class FuzzTarget:
+    """A ranked attack target selected by the MCP Universal Analyzer."""
+    profile: ASTFunctionProfile
+    attack_priority: float    # 0.0–1.0 composite score
+    invariant_classes: list[str]  # Suggested: ["overflow", "roundtrip", ...]
+    attack_rationale: str     # Why this function is interesting
+
+
+@dataclass
+class GeneratedPBT:
+    """A Property-Based Test synthesized by the Red Team LLM."""
+    test_code: str            # Full Python test file content
+    test_function_name: str   # e.g., test_add_commutativity
+    invariant_description: str
+    hypothesis_strategy: str  # e.g., "st.integers(min_value=-2**63)"
+    cegis_round: int
+    prompt_hash: str
+
+
+@dataclass
+class CrashPayload:
+    """
+    The zero-day package handed to the Blue Team.
+    Contains everything needed to reproduce and patch the vulnerability.
+    """
+    target: FuzzTarget
+    pbt: GeneratedPBT
+    falsifying_example: str    # Exact inputs that crashed: "x=9223372036854775807, y=-1"
+    crash_output: str          # Full hypothesis failure output
+    crash_type: str            # "overflow" | "exception" | "assertion" | "timeout"
+    crash_hash: str            # SHA-256 of falsifying_example + crash_output
+    synthetic_test_path: str   # Path to the written failing test file
+    source_file_path: str      # Target source file to patch
+    discovered_at: str
+    cegis_rounds_taken: int
+
+
+@dataclass
+class RedTeamResult:
+    """Final result of a full CEGIS red-team run on a repository."""
+    repo_dir: str
+    targets_analyzed: int
+    crashes_found: list[CrashPayload] = field(default_factory=list)
+    targets_survived: list[str] = field(default_factory=list)
+    total_fuzz_examples: int = 0
+    duration_seconds: float = 0.0
+    cegis_rounds: int = 0
+    handoff_results: list[dict] = field(default_factory=list)
+
+
+# ──────────────────────────────────────────────────────────────
+# SECTION 1: MCP UNIVERSAL ANALYZER
+# Python AST scanner — zero external deps beyond stdlib + radon
+# ──────────────────────────────────────────────────────────────
+
+def _compute_cyclomatic_complexity(source: str) -> float:
+    """
+    Compute cyclomatic complexity using radon if available,
+    falling back to a branch-counting heuristic.
+    """
+    try:
+        from radon.complexity import cc_visit
+        results = cc_visit(source)
+        if results:
+            return float(max(r.complexity for r in results))
+        return 1.0
+    except Exception:
+        pass
+
+    # Fallback: count decision points
+    branch_keywords = {
+        "if", "elif", "for", "while", "except", "with",
+        "and", "or", "not", "assert",
+    }
+    score = 1.0
+    try:
+        tree = ast.parse(source)
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.If, ast.For, ast.While, ast.ExceptHandler,
+                                 ast.With, ast.AsyncFor, ast.AsyncWith)):
+                score += 1.0
+            elif isinstance(node, ast.BoolOp):
+                score += len(node.values) - 1
+    except SyntaxError:
+        pass
+    return score
+
+
+def _extract_arg_types(func_node: ast.FunctionDef) -> dict[str, str]:
+    """Extract argument names and their type annotations as strings."""
+    result: dict[str, str] = {}
+    for arg in func_node.args.args:
+        name = arg.arg
+        if arg.annotation:
+            try:
+                result[name] = ast.unparse(arg.annotation)
+            except Exception:
+                result[name] = "Any"
+        else:
+            result[name] = "Any"
+    return result
+
+
+def _extract_return_type(func_node: ast.FunctionDef) -> str:
+    if func_node.returns:
+        try:
+            return ast.unparse(func_node.returns)
+        except Exception:
+            return "Any"
+    return "Any"
+
+
+def _has_numeric_operations(func_node: ast.FunctionDef) -> bool:
+    numeric_ops = (
+        ast.Add, ast.Sub, ast.Mult, ast.Div, ast.FloorDiv,
+        ast.Mod, ast.Pow, ast.LShift, ast.RShift, ast.BitAnd,
+        ast.BitOr, ast.BitXor,
+    )
+    for node in ast.walk(func_node):
+        if isinstance(node, ast.BinOp) and isinstance(node.op, numeric_ops):
+            return True
+    return False
+
+
+def _has_recursion(func_node: ast.FunctionDef) -> bool:
+    fn_name = func_node.name
+    for node in ast.walk(func_node):
+        if isinstance(node, ast.Call):
+            if isinstance(node.func, ast.Name) and node.func.id == fn_name:
+                return True
+            if isinstance(node.func, ast.Attribute) and node.func.attr == fn_name:
+                return True
+    return False
+
+
+def _has_state_mutation(func_node: ast.FunctionDef) -> bool:
+    mutable_methods = {
+        "append", "extend", "insert", "remove", "pop", "clear",
+        "update", "setdefault", "sort", "reverse",
+    }
+    for node in ast.walk(func_node):
+        if isinstance(node, ast.Call):
+            if (isinstance(node.func, ast.Attribute) and
+                    node.func.attr in mutable_methods):
+                return True
+        if isinstance(node, ast.Assign):
+            for t in node.targets:
+                if isinstance(t, ast.Subscript):
+                    return True
+    return False
+
+
+def _extract_calls(func_node: ast.FunctionDef) -> list[str]:
+    calls = []
+    for node in ast.walk(func_node):
+        if isinstance(node, ast.Call):
+            if isinstance(node.func, ast.Name):
+                calls.append(node.func.id)
+            elif isinstance(node.func, ast.Attribute):
+                calls.append(f"{ast.unparse(node.func.value) if hasattr(ast, 'unparse') else '?'}.{node.func.attr}")
+    return list(set(calls[:20]))
+
+
+def _build_ast_summary(profile: "ASTFunctionProfile") -> str:
+    """
+    Compact JSON representation of the function for the LLM.
+    Keeps token count low while conveying full semantic richness.
+    """
+    return json.dumps({
+        "fn": profile.function_name,
+        "sig": profile.signature,
+        "args": profile.arg_types,
+        "returns": profile.return_type,
+        "complexity": profile.complexity_score,
+        "numeric_ops": profile.has_numeric_ops,
+        "recursive": profile.has_recursion,
+        "mutates_args": profile.has_state_mutation,
+        "loops": profile.has_loops,
+        "calls": profile.calls_made[:10],
+        "docstring": profile.docstring[:200] if profile.docstring else "",
+        "source_preview": profile.source_code[:600],
+    }, indent=None, separators=(",", ":"))
+
+
+def _score_attack_priority(p: ASTFunctionProfile) -> tuple[float, list[str], str]:
+    """
+    Compute composite attack priority and determine which invariant
+    classes are most likely to produce a crash.
+    Returns: (score, invariant_classes, rationale)
+    """
+    score = 0.0
+    classes: list[str] = []
+    rationale_parts: list[str] = []
+
+    # Complexity: high CC = more edge cases
+    if p.complexity_score >= 10:
+        score += 0.35
+        rationale_parts.append(f"high cyclomatic complexity ({p.complexity_score:.1f})")
+    elif p.complexity_score >= 5:
+        score += 0.20
+    elif p.complexity_score >= 3:
+        score += 0.10
+
+    # Numeric operations are prime overflow targets
+    if p.has_numeric_ops:
+        score += 0.25
+        classes.append("integer_overflow")
+        classes.append("boundary_value")
+        rationale_parts.append("arithmetic operations (overflow/underflow risk)")
+
+    # Recursion = stack overflow + incorrect base cases
+    if p.has_recursion:
+        score += 0.20
+        classes.append("recursion_depth")
+        classes.append("base_case_invariant")
+        rationale_parts.append("recursive structure (stack overflow / incorrect base case)")
+
+    # Mutable argument mutation = aliasing bugs
+    if p.has_state_mutation:
+        score += 0.15
+        classes.append("aliasing_mutation")
+        classes.append("idempotency")
+        rationale_parts.append("mutates mutable arguments (aliasing / idempotency risk)")
+
+    # Typed args: roundtrip testing possible
+    typed_count = sum(1 for v in p.arg_types.values() if v not in ("Any", ""))
+    if typed_count > 0:
+        score += min(0.10, typed_count * 0.03)
+        if p.return_type not in ("None", "Any", ""):
+            classes.append("roundtrip")
+            classes.append("commutativity")
+
+    # Exception handling = swallowing exceptions silently
+    if p.has_exception_handling:
+        score += 0.10
+        classes.append("exception_swallowing")
+        rationale_parts.append("exception handling (may swallow bugs silently)")
+
+    # Loops are iteration boundary targets
+    if p.has_loops:
+        score += 0.05
+        classes.append("loop_boundary")
+
+    # Deduplicate classes, maintain priority order
+    seen: set[str] = set()
+    unique_classes = [c for c in classes if not (c in seen or seen.add(c))]
+    if not unique_classes:
+        unique_classes = ["property_invariant", "boundary_value"]
+
+    rationale = "; ".join(rationale_parts) if rationale_parts else "general-purpose invariant analysis"
+    return min(score, 1.0), unique_classes, rationale
+
+
+def analyze_repository_ast(repo_dir: str) -> list[FuzzTarget]:
+    """
+    Walk all Python source files in the repo, extract function-level AST
+    profiles, score each for attack priority, and return the top targets
+    ranked by score.
+
+    Only targets functions in src/ lib/ or top-level .py files (not tests).
+    """
+    rte_log(f"Scanning AST of repository: {repo_dir}", "AST")
+
+    targets: list[FuzzTarget] = []
+    source_dirs = ["src", "lib", "core", "app", "utils", "engine", "api"]
+
+    candidate_files: list[Path] = []
+    repo_path = Path(repo_dir)
+
+    # Collect candidate source files (exclude tests)
+    for py_file in repo_path.rglob("*.py"):
+        rel = py_file.relative_to(repo_path)
+        parts = rel.parts
+        if any(p.startswith("test") or p in ("tests", ".git", "__pycache__",
+               "build", "dist", ".tox", "venv", ".venv") for p in parts):
+            continue
+        if rel.name.startswith("test_") or rel.name.startswith("conftest"):
+            continue
+        candidate_files.append(py_file)
+
+    rte_log(f"Found {len(candidate_files)} non-test Python file(s) to analyze", "AST")
+
+    for py_file in candidate_files:
+        rel_path = str(py_file.relative_to(repo_path))
+        try:
+            source = py_file.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            continue
+
+        try:
+            tree = ast.parse(source, filename=str(py_file))
+        except SyntaxError as e:
+            rte_log(f"SyntaxError in {rel_path}: {e}", "WARN")
+            continue
+
+        # Extract module-level source lines for function slicing
+        source_lines = source.splitlines()
+
+        for node in ast.walk(tree):
+            if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                continue
+            # Skip private/dunder/tiny functions
+            name = node.name
+            if name.startswith("__") and name.endswith("__"):
+                continue
+            if not node.args.args and not node.args.vararg:
+                continue  # No arguments = nothing to fuzz
+
+            # Extract function source
+            try:
+                fn_start = node.lineno - 1
+                fn_end = node.end_lineno if hasattr(node, "end_lineno") else fn_start + 30
+                fn_source = "\n".join(source_lines[fn_start:fn_end])
+            except Exception:
+                fn_source = ""
+
+            if len(fn_source.strip()) < 20:
+                continue
+
+            # Build signature string
+            try:
+                sig = ast.unparse(node) if hasattr(ast, "unparse") else name
+                sig = sig.split("\n")[0].rstrip(":")
+                if len(sig) > 200:
+                    sig = sig[:200] + "..."
+            except Exception:
+                sig = f"def {name}(...)"
+
+            # Extract docstring
+            docstring = ast.get_docstring(node) or ""
+
+            # Extract arg types and return type
+            arg_types = _extract_arg_types(node)
+            return_type = _extract_return_type(node)
+
+            # Compute complexity on the function slice only
+            complexity = _compute_cyclomatic_complexity(fn_source)
+
+            # Feature flags
+            has_loops = any(
+                isinstance(n, (ast.For, ast.While, ast.AsyncFor))
+                for n in ast.walk(node)
+            )
+            has_except = any(
+                isinstance(n, ast.ExceptHandler)
+                for n in ast.walk(node)
+            )
+            calls = _extract_calls(node)
+
+            profile = ASTFunctionProfile(
+                module_path=rel_path,
+                function_name=name,
+                lineno=node.lineno,
+                source_code=fn_source,
+                signature=sig,
+                arg_types=arg_types,
+                return_type=return_type,
+                complexity_score=complexity,
+                has_numeric_ops=_has_numeric_operations(node),
+                has_loops=has_loops,
+                has_recursion=_has_recursion(node),
+                has_state_mutation=_has_state_mutation(node),
+                has_exception_handling=has_except,
+                docstring=docstring,
+                calls_made=calls,
+                ast_summary="",  # computed below
+            )
+            profile.ast_summary = _build_ast_summary(profile)
+
+            priority, invariant_classes, rationale = _score_attack_priority(profile)
+
+            if priority < MIN_COMPLEXITY_SCORE / 10.0:
+                continue
+
+            targets.append(FuzzTarget(
+                profile=profile,
+                attack_priority=priority,
+                invariant_classes=invariant_classes,
+                attack_rationale=rationale,
+            ))
+
+    # Sort by priority descending
+    targets.sort(key=lambda t: t.attack_priority, reverse=True)
+
+    rte_log(
+        f"AST analysis complete: {len(targets)} attack targets ranked. "
+        f"Top target: {targets[0].profile.function_name if targets else 'none'} "
+        f"(score={targets[0].attack_priority:.3f})" if targets else "No targets found.",
+        "AST"
+    )
+
+    return targets[:MAX_TARGETS_PER_RUN]
+
+
+# ──────────────────────────────────────────────────────────────
+# SECTION 2: RED TEAM LLM PROMPT (THE ATTACKER)
+# ──────────────────────────────────────────────────────────────
+
+_RED_TEAM_SYSTEM_PROMPT = """You are an elite adversarial security researcher specializing in automated vulnerability discovery through Property-Based Testing and formal methods. Your role is The Attacker.
+
+You are given the AST profile and source code of a Python function that is currently passing all its test suite. Your mission is to write a Hypothesis property-based test that BREAKS this function by finding a mathematical invariant it violates.
+
+YOU MUST TARGET ONE OF THESE INVARIANT CLASSES:
+1. INTEGER OVERFLOW: Test with sys.maxsize, -sys.maxsize, 2**63-1, 2**31-1, -1, 0 as boundary inputs
+2. COMMUTATIVITY: f(a, b) == f(b, a) for all valid (a, b)
+3. ASSOCIATIVITY: f(f(a,b),c) == f(a,f(b,c)) for all valid (a, b, c)
+4. IDEMPOTENCY: f(f(x)) == f(x) — calling twice gives same result as once
+5. ROUNDTRIP: decode(encode(x)) == x — or any encode/decode symmetry
+6. MONOTONICITY: a <= b implies f(a) <= f(b) — for ordered inputs
+7. BOUNDARY / EMPTY INPUTS: empty strings, empty lists, None where not expected, 0-length inputs
+8. TYPE COERCION: Python implicit int→float conversion causing precision loss
+9. BASE CASE INVARIANT: f(0) == expected, f(1) == expected (for recursive functions)
+10. ALIASING: f(x, x) must not corrupt x when x is a mutable object
+
+STRICT OUTPUT RULES:
+- Output ONLY a valid Python test file. No explanation. No markdown. No ```python blocks.
+- The test file must be directly executable with: python -m pytest <file> -v
+- Import the target function using its exact module path
+- Use: from hypothesis import given, settings, assume, HealthCheck
+- Use: from hypothesis import strategies as st
+- Use: @settings(max_examples=MAX_EXAMPLES, suppress_health_check=[HealthCheck.too_slow], deadline=None)
+- MAX_EXAMPLES is already set in the settings decorator — use the constant 50000
+- The test MUST raise an AssertionError or an unhandled exception when the invariant is violated
+- DO NOT catch exceptions in the test body — let them propagate so hypothesis captures them
+- Use assume() to filter out invalid inputs (e.g., assume(divisor != 0))
+- Target the MOST LIKELY invariant class to produce a crash based on the AST profile
+- Keep the test file under 80 lines
+
+REMEMBER: Your goal is to find a REAL BUG. Not a contrived one. Study the source code and find a genuine mathematical invariant this function should satisfy but might violate on extreme inputs."""
+
+
+def _build_red_team_prompt(
+    target: FuzzTarget,
+    cegis_round: int,
+    survived_inputs: Optional[list[str]] = None,
+) -> str:
+    """
+    Build the adversarial LLM prompt. Each CEGIS round gets harder:
+    - Round 1: Fresh attack based on AST
+    - Round 2+: Inject survived inputs → demand deeper invariant
+    """
+    p = target.profile
+
+    sections = [
+        f"=== ATTACK MISSION (CEGIS Round {cegis_round}/{MAX_CEGIS_ROUNDS}) ===\n",
+        f"TARGET FUNCTION: {p.function_name}",
+        f"MODULE: {p.module_path}  (line {p.lineno})",
+        f"SIGNATURE: {p.signature}",
+        f"RETURN TYPE: {p.return_type}",
+        f"ATTACK RATIONALE: {target.attack_rationale}",
+        f"SUGGESTED INVARIANT CLASSES: {', '.join(target.invariant_classes)}",
+        f"\nAST PROFILE (JSON):\n{p.ast_summary}",
+        f"\nFULL FUNCTION SOURCE:\n```python\n{p.source_code[:2000]}\n```",
+    ]
+
+    if cegis_round > 1 and survived_inputs:
+        sections.append(
+            f"\n=== CEGIS FEEDBACK — ROUND {cegis_round} ===\n"
+            f"Your previous property-based test failed to find a crash after {FUZZ_MAX_EXAMPLES:,} examples.\n"
+            f"The following inputs SURVIVED (did NOT crash the function):\n"
+            + "\n".join(f"  - {inp}" for inp in survived_inputs[:15])
+            + "\n\nDO NOT repeat the same invariant. The function survived those inputs.\n"
+            "Attack a DIFFERENT invariant class. Go deeper. Try:\n"
+            "  - Adversarial numeric boundaries (sys.maxsize - 1, -(2**63))\n"
+            "  - Aliasing attacks: pass the same mutable object as multiple arguments\n"
+            "  - Zero/empty/whitespace-only inputs combined with extreme length\n"
+            "  - Unicode edge cases: null bytes, surrogate pairs, RTL text\n"
+            "  - Type coercion: st.floats() combined with integer paths\n"
+        )
+
+    module_import = p.module_path.replace("/", ".").replace(".py", "").replace("\\", ".")
+    sections.append(
+        f"\n=== IMPORT INSTRUCTION ===\n"
+        f"Import the function as:\n"
+        f"  from {module_import} import {p.function_name}\n"
+        f"OR use sys.path manipulation if the module path has non-package directories:\n"
+        f"  import sys, os; sys.path.insert(0, os.path.dirname('<repo_dir>'))\n"
+        f"  from {p.module_path.replace('/', '.').replace('.py', '')} import {p.function_name}\n"
+        f"\nNow write the property-based test file. Output ONLY valid Python. No markdown."
+    )
+
+    return "\n".join(sections)
+
+
+@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=3, max=15))
+def _call_red_team_llm(system: str, user: str, model: str) -> str:
+    """Call OpenRouter API — returns raw text response (the test code)."""
+    if not OPENROUTER_API_KEY:
+        raise RuntimeError("OPENROUTER_API_KEY not set — Red Team LLM unavailable")
+
+    headers = {
+        "Authorization": f"Bearer {OPENROUTER_API_KEY}",
+        "Content-Type": "application/json",
+        "HTTP-Referer": "https://rhodawk.ai",
+        "X-Title": "Rhodawk AI Red Team Fuzzer",
+    }
+    payload = {
+        "model": model.replace("openrouter/", ""),
+        "messages": [
+            {"role": "system", "content": system},
+            {"role": "user", "content": user},
+        ],
+        "temperature": 0.15,
+        "max_tokens": 2048,
+    }
+    resp = requests.post(
+        "https://openrouter.ai/api/v1/chat/completions",
+        headers=headers,
+        json=payload,
+        timeout=90,
+    )
+    resp.raise_for_status()
+    content = resp.json()["choices"][0]["message"]["content"]
+    return content.strip()
+
+
+def _clean_llm_test_output(raw: str) -> str:
+    """
+    Strip markdown fences and extract raw Python from LLM response.
+    The LLM is instructed not to use markdown, but be defensive.
+    """
+    # Remove ```python ... ``` blocks
+    raw = re.sub(r"```(?:python)?\s*\n?", "", raw)
+    raw = re.sub(r"```\s*$", "", raw, flags=re.MULTILINE)
+    # Remove leading/trailing commentary lines that aren't Python
+    lines = raw.splitlines()
+    code_lines = []
+    in_code = False
+    for line in lines:
+        stripped = line.strip()
+        if stripped.startswith("#") or stripped.startswith("import") or stripped.startswith("from") or stripped.startswith("def ") or stripped.startswith("@") or stripped.startswith("    ") or stripped == "" or in_code:
+            in_code = True
+            code_lines.append(line)
+        elif in_code:
+            code_lines.append(line)
+    return "\n".join(code_lines).strip()
+
+
+def synthesize_pbt(
+    target: FuzzTarget,
+    cegis_round: int,
+    survived_inputs: Optional[list[str]] = None,
+    use_strong_model: bool = False,
+) -> Optional[GeneratedPBT]:
+    """
+    Dispatch the Red Team LLM to synthesize a Property-Based Test.
+    Returns a GeneratedPBT on success, None if LLM fails.
+    """
+    model = RED_TEAM_MODEL_STRONG if use_strong_model else RED_TEAM_MODEL
+    rte_log(
+        f"Synthesizing PBT for {target.profile.function_name} "
+        f"(round {cegis_round}, model={model.split('/')[-1]})",
+        "ATTACK"
+    )
+
+    user_prompt = _build_red_team_prompt(target, cegis_round, survived_inputs)
+    prompt_hash = hashlib.sha256(user_prompt.encode()).hexdigest()[:16]
+
+    try:
+        raw_response = _call_red_team_llm(_RED_TEAM_SYSTEM_PROMPT, user_prompt, model)
+    except Exception as e:
+        rte_log(f"LLM call failed for {target.profile.function_name}: {e}", "WARN")
+        # Fallback to strong model on failure
+        if not use_strong_model:
+            try:
+                raw_response = _call_red_team_llm(
+                    _RED_TEAM_SYSTEM_PROMPT, user_prompt, RED_TEAM_MODEL_STRONG
+                )
+            except Exception as e2:
+                rte_log(f"Strong model also failed: {e2}", "FAIL")
+                return None
+        else:
+            return None
+
+    test_code = _clean_llm_test_output(raw_response)
+
+    # Validate it looks like Python with hypothesis
+    if "from hypothesis" not in test_code and "import hypothesis" not in test_code:
+        rte_log(
+            f"LLM output for {target.profile.function_name} doesn't contain hypothesis imports — retrying",
+            "WARN"
+        )
+        return None
+
+    if "def test_" not in test_code:
+        rte_log(f"LLM output missing test function — retrying", "WARN")
+        return None
+
+    # Extract test function name
+    fn_match = re.search(r"def (test_\w+)\(", test_code)
+    test_fn_name = fn_match.group(1) if fn_match else "test_invariant"
+
+    # Extract invariant description from docstring or comment
+    inv_match = re.search(r'"""([^"]{10,200}?)"""', test_code)
+    if not inv_match:
+        inv_match = re.search(r"#\s*(.{10,120})", test_code)
+    invariant_desc = inv_match.group(1).strip() if inv_match else "property invariant"
+
+    # Extract hypothesis strategy
+    strategy_match = re.search(r"@given\((.{5,200}?)\)", test_code)
+    strategy = strategy_match.group(1) if strategy_match else "unknown"
+
+    rte_log(
+        f"PBT synthesized: {test_fn_name} | "
+        f"invariant: {invariant_desc[:60]} | strategy: {strategy[:60]}",
+        "ATTACK"
+    )
+
+    return GeneratedPBT(
+        test_code=test_code,
+        test_function_name=test_fn_name,
+        invariant_description=invariant_desc,
+        hypothesis_strategy=strategy,
+        cegis_round=cegis_round,
+        prompt_hash=prompt_hash,
+    )
+
+
+# ──────────────────────────────────────────────────────────────
+# SECTION 3: DETERMINISTIC FUZZING LOOP
+# ──────────────────────────────────────────────────────────────
+
+def _install_hypothesis_if_needed(pytest_bin: str, repo_dir: str) -> bool:
+    """Ensure hypothesis is installed in the target venv."""
+    try:
+        check = subprocess.run(
+            [pytest_bin.replace("pytest", "python"), "-c", "import hypothesis"],
+            capture_output=True, timeout=15, cwd=repo_dir,
+        )
+        if check.returncode == 0:
+            return True
+    except Exception:
+        pass
+
+    rte_log("Installing hypothesis into target venv...", "FUZZ")
+    try:
+        pip_bin = pytest_bin.replace("pytest", "pip")
+        result = subprocess.run(
+            [pip_bin, "install", "hypothesis", "--quiet"],
+            capture_output=True, timeout=120, cwd=repo_dir,
+        )
+        return result.returncode == 0
+    except Exception as e:
+        rte_log(f"hypothesis install failed: {e}", "WARN")
+        return False
+
+
+def _write_pbt_to_file(pbt: GeneratedPBT, target: FuzzTarget, repo_dir: str) -> str:
+    """
+    Write the generated PBT to the red_team/ directory.
+    Injects the repo sys.path so the target module can be imported.
+    Returns absolute path to the test file.
+    """
+    os.makedirs(RED_TEAM_DIR, exist_ok=True)
+
+    fn_safe = target.profile.function_name.replace("-", "_")
+    timestamp = int(time.time())
+    filename = f"rt_{fn_safe}_r{pbt.cegis_round}_{timestamp}.py"
+    filepath = os.path.join(RED_TEAM_DIR, filename)
+
+    sys_path_injection = textwrap.dedent(f"""
+        import sys
+        import os
+        # Inject repo root so target modules are importable
+        _REPO_DIR = {repr(repo_dir)}
+        if _REPO_DIR not in sys.path:
+            sys.path.insert(0, _REPO_DIR)
+        for _sub in ["src", "lib", "core", "app"]:
+            _p = os.path.join(_REPO_DIR, _sub)
+            if os.path.isdir(_p) and _p not in sys.path:
+                sys.path.insert(0, _p)
+
+    """).lstrip()
+
+    full_content = sys_path_injection + pbt.test_code
+
+    with open(filepath, "w", encoding="utf-8") as f:
+        f.write(full_content)
+
+    return filepath
+
+
+def _extract_falsifying_example(output: str) -> str:
+    """
+    Parse hypothesis output to extract the minimal falsifying example.
+    Hypothesis prints:
+      Falsifying example: test_func(x=42, y=-1)
+    or in newer versions:
+      Falsifying explicit example: ...
+    """
+    patterns = [
+        r"Falsifying explicit example:\s*\w+\((.+?)\)",
+        r"Falsifying example:\s*\w+\((.+?)\)",
+        r"Falsifying example.*?:\s*(.+?)$",
+        r"AssertionError.*?:\s*(.+?)$",
+    ]
+    for pat in patterns:
+        m = re.search(pat, output, re.MULTILINE | re.DOTALL)
+        if m:
+            return m.group(1).strip()[:500]
+
+    # Fallback: extract any exception line
+    for line in output.splitlines():
+        if "Error" in line or "assert" in line.lower():
+            return line.strip()[:300]
+
+    return "Unknown — see full crash output"
+
+
+def _extract_crash_type(output: str) -> str:
+    """Classify the type of crash from hypothesis output."""
+    if "OverflowError" in output:
+        return "integer_overflow"
+    if "RecursionError" in output:
+        return "recursion_depth"
+    if "AssertionError" in output:
+        return "assertion_violation"
+    if "ZeroDivisionError" in output:
+        return "division_by_zero"
+    if "IndexError" in output:
+        return "index_out_of_bounds"
+    if "TypeError" in output:
+        return "type_error"
+    if "ValueError" in output:
+        return "value_error"
+    if "MemoryError" in output or "MemoryError" in output:
+        return "memory_exhaustion"
+    if "FAILED" in output:
+        return "assertion"
+    return "unknown_exception"
+
+
+def _extract_survived_inputs(output: str) -> list[str]:
+    """
+    If the fuzz run succeeded (no crash), try to extract some of the
+    inputs that were tested so CEGIS can inform the next round.
+    """
+    survived = []
+    for m in re.finditer(r"Trying example.*?\((.+?)\)", output):
+        survived.append(m.group(1)[:100])
+    # Also include any explicit example lines
+    for m in re.finditer(r"explicit example.*?\((.+?)\)", output, re.IGNORECASE):
+        survived.append(m.group(1)[:100])
+    return survived[:20]
+
+
+def run_fuzzing_loop(
+    pbt: GeneratedPBT,
+    target: FuzzTarget,
+    repo_dir: str,
+    pytest_bin: str,
+) -> tuple[bool, str, str]:
+    """
+    Execute the generated PBT via subprocess with hypothesis aggressive settings.
+
+    Returns:
+        (crashed: bool, crash_output: str, falsifying_example: str)
+
+    Security: shell=False enforced, secrets stripped from env, SIGKILL on timeout.
+    """
+    # Write test file
+    test_file = _write_pbt_to_file(pbt, target, repo_dir)
+
+    rte_log(
+        f"Fuzzing: {target.profile.function_name} | "
+        f"test={os.path.basename(test_file)} | "
+        f"max_examples={FUZZ_MAX_EXAMPLES:,} | timeout={FUZZ_TIMEOUT_SECONDS}s",
+        "FUZZ"
+    )
+
+    # Build environment — secrets stripped, hypothesis settings injected
+    env = os.environ.copy()
+    for secret_key in [
+        "OPENROUTER_API_KEY", "GITHUB_TOKEN", "GITHUB_PERSONAL_ACCESS_TOKEN",
+        "TELEGRAM_BOT_TOKEN", "SLACK_WEBHOOK_URL", "RHODAWK_WEBHOOK_SECRET",
+    ]:
+        env.pop(secret_key, None)
+
+    # Hypothesis configuration via env (overrides @settings decorator)
+    env["HYPOTHESIS_MAX_EXAMPLES"] = str(FUZZ_MAX_EXAMPLES)
+    env["HYPOTHESIS_VERBOSITY"] = "verbose"
+    # Deterministic but varied seed per CEGIS round
+    seed = (hash(target.profile.function_name) + pbt.cegis_round * 7919) % (2**31)
+    env["HYPOTHESIS_SEED"] = str(abs(seed))
+
+    cmd = [
+        pytest_bin,
+        test_file,
+        "-v",
+        "--tb=long",
+        "--no-header",
+        f"--hypothesis-seed={abs(seed)}",
+        "-x",  # Stop at first failure
+    ]
+
+    proc = None
+    try:
+        proc = subprocess.Popen(
+            cmd,
+            shell=False,
+            cwd=repo_dir,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            env=env,
+            start_new_session=True,
+        )
+        try:
+            stdout, stderr = proc.communicate(timeout=FUZZ_TIMEOUT_SECONDS)
+        except subprocess.TimeoutExpired:
+            rte_log(
+                f"Fuzz timeout ({FUZZ_TIMEOUT_SECONDS}s) for {target.profile.function_name} — killing",
+                "WARN"
+            )
+            try:
+                os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
+            except ProcessLookupError:
+                pass
+            proc.communicate()
+            return False, "TIMEOUT", "timeout"
+
+        combined = (stdout or "") + "\n" + (stderr or "")
+        crashed = proc.returncode != 0
+
+        if crashed:
+            falsifying = _extract_falsifying_example(combined)
+            crash_type = _extract_crash_type(combined)
+            rte_log(
+                f"CRASH FOUND in {target.profile.function_name}: {crash_type} | "
+                f"example: {falsifying[:80]}",
+                "CRASH"
+            )
+            return True, combined, falsifying
+        else:
+            rte_log(
+                f"No crash found in {target.profile.function_name} "
+                f"after {FUZZ_MAX_EXAMPLES:,} examples",
+                "FUZZ"
+            )
+            return False, combined, ""
+
+    except Exception as e:
+        rte_log(f"Fuzzing subprocess error for {target.profile.function_name}: {e}", "FAIL")
+        return False, str(e), ""
+    finally:
+        # Clean up test file if no crash (keep if crash for audit trail)
+        if proc and proc.returncode == 0:
+            try:
+                os.unlink(test_file)
+            except OSError:
+                pass
+
+
+# ──────────────────────────────────────────────────────────────
+# SECTION 4: CEGIS HANDOFF (RED → BLUE TEAM)
+# ──────────────────────────────────────────────────────────────
+
+def _build_synthetic_failing_test(crash: CrashPayload, repo_dir: str) -> str:
+    """
+    Rewrite the PBT crash as a DETERMINISTIC pytest that always reproduces
+    the crash using the exact falsifying example found by hypothesis.
+
+    This is what gets handed to the Blue Team — a concrete, reproducible
+    failing test with the minimal crashing input baked in.
+    """
+    p = crash.target.profile
+    example = crash.falsifying_example
+
+    # Parse the falsifying example into argument assignments
+    # hypothesis formats it as: x=42, y=-1, s='hello'
+    arg_setup_lines = []
+    example_clean = example.strip().rstrip(")")
+    for part in re.split(r",\s*(?=[a-zA-Z_]\w*=)", example_clean):
+        part = part.strip()
+        if "=" in part:
+            arg_setup_lines.append(f"    {part}")
+
+    if not arg_setup_lines:
+        # Fallback: use the raw example as a comment
+        arg_setup_lines = [f"    # Falsifying example: {example}"]
+        arg_call = ", ".join(f"None" for _ in p.arg_types)
+    else:
+        arg_call = ", ".join(
+            part.strip().split("=")[0] for part in arg_setup_lines if "=" in part
+        )
+
+    module_import_path = p.module_path.replace("/", ".").replace(".py", "").replace("\\", ".")
+
+    test_content = textwrap.dedent(f"""
+        \"\"\"
+        Rhodawk AI — Synthetic Zero-Day Reproduction Test
+        ==================================================
+        AUTO-GENERATED by Red Team Fuzzer (CEGIS Engine)
+        DO NOT EDIT — this file is managed by Rhodawk AI.
+
+        Target: {p.function_name} in {p.module_path}
+        Crash type: {crash.crash_type}
+        Falsifying example: {crash.falsifying_example[:200]}
+        Invariant violated: {crash.pbt.invariant_description[:200]}
+        CEGIS rounds taken: {crash.cegis_rounds_taken}
+        Crash hash: {crash.crash_hash}
+        Discovered: {crash.discovered_at}
+        \"\"\"
+
+        import sys
+        import os
+        import pytest
+
+        # Inject repo root for imports
+        _REPO_DIR = {repr(repo_dir)}
+        if _REPO_DIR not in sys.path:
+            sys.path.insert(0, _REPO_DIR)
+        for _sub in ["src", "lib", "core", "app"]:
+            _p = os.path.join(_REPO_DIR, _sub)
+            if os.path.isdir(_p) and _p not in sys.path:
+                sys.path.insert(0, _p)
+
+        try:
+            from {module_import_path} import {p.function_name}
+        except ImportError as _e:
+            pytest.skip(f"Cannot import target: {{_e}}")
+
+
+        def test_rhodawk_zero_day_{p.function_name}_{crash.crash_hash[:8]}():
+            \"\"\"
+            Zero-day reproduction test synthesized by Rhodawk AI Red Team.
+            Crash type: {crash.crash_type}
+            Invariant: {crash.pbt.invariant_description[:120]}
+            \"\"\"
+            # Minimal falsifying example found by hypothesis after {FUZZ_MAX_EXAMPLES:,} iterations
+            # CEGIS round {crash.cegis_rounds_taken} — this input crashes the function
+{chr(10).join(arg_setup_lines)}
+
+            # This call should NOT raise — if it does, the vulnerability is confirmed
+            # Blue Team: fix the implementation so this assertion holds for all inputs
+            try:
+                result = {p.function_name}({arg_call})
+                # If the crash was an assertion in the PBT, re-check the invariant
+                # The Blue Team must make this deterministic test pass
+                assert result is not None or result is None, (
+                    f"Function returned unexpected result: {{result!r}}"
+                )
+            except (OverflowError, RecursionError, ZeroDivisionError,
+                    IndexError, ValueError, TypeError) as e:
+                pytest.fail(
+                    f"{{type(e).__name__}} raised for input ({arg_call}): {{e}}\\n"
+                    f"Crash type: {crash.crash_type}\\n"
+                    f"Original falsifying example: {crash.falsifying_example[:200]}"
+                )
+    """).lstrip()
+
+    return test_content
+
+
+def package_crash_for_blue_team(
+    target: FuzzTarget,
+    pbt: GeneratedPBT,
+    crash_output: str,
+    falsifying_example: str,
+    cegis_rounds: int,
+    repo_dir: str,
+) -> CrashPayload:
+    """
+    Package all crash data into a CrashPayload and write the synthetic
+    deterministic failing test to the red_team/ directory.
+    """
+    crash_raw = falsifying_example + crash_output
+    crash_hash = hashlib.sha256(crash_raw.encode()).hexdigest()[:16]
+    crash_type = _extract_crash_type(crash_output)
+
+    # Write synthetic deterministic failing test
+    fn_safe = target.profile.function_name.replace("-", "_")
+    synthetic_filename = f"test_rt_zero_day_{fn_safe}_{crash_hash}.py"
+    synthetic_path = os.path.join(RED_TEAM_DIR, synthetic_filename)
+
+    payload = CrashPayload(
+        target=target,
+        pbt=pbt,
+        falsifying_example=falsifying_example,
+        crash_output=crash_output,
+        crash_type=crash_type,
+        crash_hash=crash_hash,
+        synthetic_test_path=synthetic_path,
+        source_file_path=os.path.join(repo_dir, target.profile.module_path),
+        discovered_at=time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        cegis_rounds_taken=cegis_rounds,
+    )
+
+    synthetic_content = _build_synthetic_failing_test(payload, repo_dir)
+
+    os.makedirs(RED_TEAM_DIR, exist_ok=True)
+    with open(synthetic_path, "w", encoding="utf-8") as f:
+        f.write(synthetic_content)
+
+    rte_log(
+        f"HANDOFF READY: {synthetic_filename} | "
+        f"crash_type={crash_type} | hash={crash_hash}",
+        "HAND"
+    )
+
+    return payload
+
+
+def handoff_to_blue_team(
+    crash: CrashPayload,
+    repo_dir: str,
+    pytest_bin: str,
+    mcp_config_path: str,
+    job_id: str,
+    branch_name: str,
+    blue_team_fn: Callable,
+) -> dict:
+    """
+    Execute the CEGIS Handoff — pass the synthetic failing test to the
+    Blue Team's process_failing_test() function for autonomous patching.
+
+    The Blue Team treats this exactly like a human-written failing test:
+    it runs SAST, adversarial review, supply chain scan, and opens a PR.
+    """
+    rte_log(
+        f"CEGIS HANDOFF → Blue Team: {crash.target.profile.function_name} | "
+        f"crash_type={crash.crash_type} | source={crash.source_file_path}",
+        "HAND"
+    )
+
+    # First verify the synthetic test actually fails (confirms reproducibility)
+    env = os.environ.copy()
+    for secret_key in ["OPENROUTER_API_KEY", "GITHUB_TOKEN", "GITHUB_PERSONAL_ACCESS_TOKEN"]:
+        env.pop(secret_key, None)
+
+    verify_proc = subprocess.run(
+        [pytest_bin, crash.synthetic_test_path, "-v", "--tb=short", "--no-header"],
+        capture_output=True,
+        text=True,
+        timeout=60,
+        cwd=repo_dir,
+        env=env,
+        shell=False,
+    )
+    initial_failure_output = (verify_proc.stdout or "") + "\n" + (verify_proc.stderr or "")
+
+    if verify_proc.returncode == 0:
+        rte_log(
+            f"WARNING: Synthetic test PASSED on first run — crash may not be deterministic. "
+            f"Reporting anyway for human review.",
+            "WARN"
+        )
+        initial_failure_output = (
+            f"WARNING: Non-deterministic crash detected.\n"
+            f"Original crash output:\n{crash.crash_output[:2000]}\n"
+            f"Falsifying example: {crash.falsifying_example}"
+        )
+
+    # Relative path of the synthetic test within repo context
+    rel_synthetic_test = os.path.relpath(crash.synthetic_test_path, repo_dir)
+
+    rte_log(f"Dispatching Blue Team on: {rel_synthetic_test}", "HAND")
+
+    # Call the Blue Team process_failing_test function
+    try:
+        blue_result = blue_team_fn(
+            test_path=rel_synthetic_test,
+            initial_failure=initial_failure_output,
+            pytest_bin=pytest_bin,
+            mcp_config_path=mcp_config_path,
+            job_id=job_id,
+            branch_name=branch_name,
+        )
+
+        handoff_result = {
+            "crash_hash": crash.crash_hash,
+            "crash_type": crash.crash_type,
+            "target_function": crash.target.profile.function_name,
+            "source_file": crash.target.profile.module_path,
+            "synthetic_test": rel_synthetic_test,
+            "blue_team_success": blue_result.success,
+            "blue_team_attempts": blue_result.total_attempts,
+            "failure_reason": blue_result.failure_reason,
+            "cegis_rounds": crash.cegis_rounds_taken,
+            "falsifying_example": crash.falsifying_example[:300],
+        }
+
+        status = "PATCHED" if blue_result.success else "UNRESOLVED"
+        rte_log(
+            f"Blue Team result: {status} | "
+            f"attempts={blue_result.total_attempts} | "
+            f"crash={crash.crash_type} | fn={crash.target.profile.function_name}",
+            "OK" if blue_result.success else "FAIL"
+        )
+
+        return handoff_result
+
+    except Exception as e:
+        rte_log(f"Blue Team handoff exception: {e}", "FAIL")
+        return {
+            "crash_hash": crash.crash_hash,
+            "crash_type": crash.crash_type,
+            "target_function": crash.target.profile.function_name,
+            "blue_team_success": False,
+            "failure_reason": str(e),
+        }
+
+
+# ──────────────────────────────────────────────────────────────
+# SECTION 5: MAIN CEGIS ORCHESTRATOR
+# ──────────────────────────────────────────────────────────────
+
+def run_red_team_cegis(
+    repo_dir: str,
+    pytest_bin: str,
+    mcp_config_path: str,
+    blue_team_fn: Callable,
+    tenant_id: str = "default",
+    log_audit_fn: Optional[Callable] = None,
+    notify_fn: Optional[Callable] = None,
+) -> RedTeamResult:
+    """
+    Full CEGIS Red Team orchestration loop.
+
+    Called by app.py when all tests in a repository are GREEN.
+    Returns a RedTeamResult summarizing all crashes found and Blue Team outcomes.
+
+    Args:
+        repo_dir: Absolute path to the cloned target repository
+        pytest_bin: Path to pytest binary in the isolated venv
+        mcp_config_path: Path to MCP runtime config for Blue Team Aider
+        blue_team_fn: process_failing_test() from app.py (Blue Team entry point)
+        tenant_id: Namespace for job queue
+        log_audit_fn: log_audit_event() from audit_logger.py
+        notify_fn: notify() from notifier.py
+    """
+    start_time = time.time()
+    rte_log("═" * 70, "INFO")
+    rte_log(f"RED TEAM CEGIS ENGINE ACTIVATED — repo: {repo_dir}", "ATTACK")
+    rte_log(f"Config: max_targets={MAX_TARGETS_PER_RUN} | max_examples={FUZZ_MAX_EXAMPLES:,} | cegis_rounds={MAX_CEGIS_ROUNDS}", "INFO")
+
+    result = RedTeamResult(repo_dir=repo_dir, targets_analyzed=0)
+
+    # Ensure hypothesis is available
+    if not _install_hypothesis_if_needed(pytest_bin, repo_dir):
+        rte_log("hypothesis not available — Red Team cannot run without it", "FAIL")
+        return result
+
+    # Step 1: AST Analysis — find attack targets
+    try:
+        targets = analyze_repository_ast(repo_dir)
+    except Exception as e:
+        rte_log(f"AST analysis crashed: {e}", "FAIL")
+        return result
+
+    result.targets_analyzed = len(targets)
+
+    if not targets:
+        rte_log("No suitable attack targets found in repository", "WARN")
+        return result
+
+    if log_audit_fn:
+        log_audit_fn("RED_TEAM_START", "red_team_engine", repo_dir, RED_TEAM_MODEL, {
+            "targets_found": len(targets),
+            "top_target": targets[0].profile.function_name if targets else "none",
+            "top_priority": targets[0].attack_priority if targets else 0,
+        }, "STARTED")
+
+    if notify_fn:
+        notify_fn(
+            f"⚔️ *Red Team CEGIS Activated*\n"
+            f"All tests GREEN — attacking {len(targets)} high-value function(s).\n"
+            f"Top target: `{targets[0].profile.function_name}` "
+            f"(priority={targets[0].attack_priority:.2f})"
+        )
+
+    # Step 2: CEGIS attack loop for each target
+    for target_idx, target in enumerate(targets):
+        rte_log(
+            f"Target {target_idx+1}/{len(targets)}: {target.profile.function_name} "
+            f"| priority={target.attack_priority:.3f} "
+            f"| invariants={','.join(target.invariant_classes[:3])}",
+            "ATTACK"
+        )
+
+        survived_inputs: list[str] = []
+        crash_found = False
+
+        for cegis_round in range(1, MAX_CEGIS_ROUNDS + 1):
+            rte_log(f"CEGIS round {cegis_round}/{MAX_CEGIS_ROUNDS} for {target.profile.function_name}", "CEGIS")
+
+            # Synthesize PBT — use strong model on final rounds
+            use_strong = (cegis_round >= MAX_CEGIS_ROUNDS - 1)
+            pbt = synthesize_pbt(target, cegis_round, survived_inputs, use_strong)
+
+            if pbt is None:
+                rte_log(f"PBT synthesis failed for {target.profile.function_name} round {cegis_round}", "WARN")
+                break
+
+            result.total_fuzz_examples += FUZZ_MAX_EXAMPLES
+            result.cegis_rounds += 1
+
+            # Run the fuzzer
+            crashed, crash_output, falsifying_example = run_fuzzing_loop(
+                pbt, target, repo_dir, pytest_bin
+            )
+
+            if crashed and falsifying_example != "timeout":
+                # CRASH FOUND — package and hand off to Blue Team
+                crash_payload = package_crash_for_blue_team(
+                    target=target,
+                    pbt=pbt,
+                    crash_output=crash_output,
+                    falsifying_example=falsifying_example,
+                    cegis_rounds=cegis_round,
+                    repo_dir=repo_dir,
+                )
+                result.crashes_found.append(crash_payload)
+
+                if log_audit_fn:
+                    log_audit_fn("RED_TEAM_CRASH", "red_team_engine", repo_dir, RED_TEAM_MODEL, {
+                        "function": target.profile.function_name,
+                        "module": target.profile.module_path,
+                        "crash_type": crash_payload.crash_type,
+                        "crash_hash": crash_payload.crash_hash,
+                        "cegis_round": cegis_round,
+                        "falsifying_example": falsifying_example[:200],
+                        "invariant": pbt.invariant_description[:100],
+                    }, "CRASH_FOUND")
+
+                if notify_fn:
+                    notify_fn(
+                        f"💥 *Zero-Day Discovered*\n"
+                        f"Function: `{target.profile.function_name}` in `{target.profile.module_path}`\n"
+                        f"Crash type: `{crash_payload.crash_type}`\n"
+                        f"Input: `{falsifying_example[:150]}`\n"
+                        f"Handing to Blue Team for autonomous patching..."
+                    )
+
+                # CEGIS HANDOFF — dispatch Blue Team
+                job_id_rt = hashlib.sha256(
+                    f"{repo_dir}:{target.profile.function_name}:{crash_payload.crash_hash}".encode()
+                ).hexdigest()[:16]
+                branch_name_rt = (
+                    f"rhodawk/red-team/{target.profile.function_name.replace('_','-')}"
+                    f"-{crash_payload.crash_hash}"
+                )
+
+                handoff_result = handoff_to_blue_team(
+                    crash=crash_payload,
+                    repo_dir=repo_dir,
+                    pytest_bin=pytest_bin,
+                    mcp_config_path=mcp_config_path,
+                    job_id=job_id_rt,
+                    branch_name=branch_name_rt,
+                    blue_team_fn=blue_team_fn,
+                )
+                result.handoff_results.append(handoff_result)
+
+                if log_audit_fn:
+                    log_audit_fn("RED_TEAM_HANDOFF", "red_team_engine", repo_dir, RED_TEAM_MODEL, {
+                        **handoff_result,
+                    }, "PATCHED" if handoff_result.get("blue_team_success") else "UNRESOLVED")
+
+                crash_found = True
+                break
+
+            else:
+                # No crash — feed survived inputs back for next CEGIS round
+                new_survived = _extract_survived_inputs(crash_output)
+                survived_inputs.extend(new_survived)
+                survived_inputs = survived_inputs[:30]
+                rte_log(
+                    f"Survived {cegis_round}/{MAX_CEGIS_ROUNDS} — "
+                    f"re-attacking with {len(survived_inputs)} survived input patterns",
+                    "CEGIS"
+                )
+
+        if not crash_found:
+            result.targets_survived.append(
+                f"{target.profile.function_name} ({target.profile.module_path})"
+            )
+            rte_log(
+                f"Target SURVIVED all {MAX_CEGIS_ROUNDS} CEGIS rounds: {target.profile.function_name}",
+                "OK"
+            )
+
+    # Summary
+    result.duration_seconds = time.time() - start_time
+    rte_log("═" * 70, "INFO")
+    rte_log(
+        f"RED TEAM COMPLETE — "
+        f"targets={result.targets_analyzed} | "
+        f"crashes={len(result.crashes_found)} | "
+        f"survived={len(result.targets_survived)} | "
+        f"fuzz_examples={result.total_fuzz_examples:,} | "
+        f"duration={result.duration_seconds:.1f}s",
+        "CRASH" if result.crashes_found else "OK"
+    )
+
+    if log_audit_fn:
+        log_audit_fn("RED_TEAM_COMPLETE", "red_team_engine", repo_dir, RED_TEAM_MODEL, {
+            "targets_analyzed": result.targets_analyzed,
+            "crashes_found": len(result.crashes_found),
+            "targets_survived": len(result.targets_survived),
+            "total_fuzz_examples": result.total_fuzz_examples,
+            "duration_seconds": round(result.duration_seconds, 2),
+            "cegis_rounds": result.cegis_rounds,
+            "crash_hashes": [c.crash_hash for c in result.crashes_found],
+        }, "COMPLETE")
+
+    if notify_fn:
+        if result.crashes_found:
+            notify_fn(
+                f"⚔️ *Red Team Report*\n"
+                f"Found {len(result.crashes_found)} zero-day(s) in GREEN repo!\n"
+                f"Fuzz examples: {result.total_fuzz_examples:,} | "
+                f"Duration: {result.duration_seconds:.0f}s\n"
+                f"All crashes dispatched to Blue Team for autonomous patching."
+            )
+        else:
+            notify_fn(
+                f"✅ *Red Team: Repo Survived*\n"
+                f"Attacked {result.targets_analyzed} function(s), "
+                f"{result.total_fuzz_examples:,} fuzz examples — no crashes found.\n"
+                f"Repository is HARDENED."
+            )
+
+    return result
+
+
+# ──────────────────────────────────────────────────────────────
+# STATS & DASHBOARD HELPERS (called by app.py dashboard)
+# ──────────────────────────────────────────────────────────────
+
+def get_red_team_stats() -> dict:
+    """Return summary statistics for the dashboard."""
+    try:
+        crash_files = [
+            f for f in os.listdir(RED_TEAM_DIR)
+            if f.startswith("test_rt_zero_day_") and f.endswith(".py")
+        ] if os.path.isdir(RED_TEAM_DIR) else []
+
+        pbt_files = [
+            f for f in os.listdir(RED_TEAM_DIR)
+            if f.startswith("rt_") and f.endswith(".py")
+        ] if os.path.isdir(RED_TEAM_DIR) else []
+
+        return {
+            "zero_days_discovered": len(crash_files),
+            "pbts_generated": len(pbt_files),
+            "red_team_dir": RED_TEAM_DIR,
+            "recent_logs": get_red_team_logs(20),
+        }
+    except Exception:
+        return {
+            "zero_days_discovered": 0,
+            "pbts_generated": 0,
+            "red_team_dir": RED_TEAM_DIR,
+            "recent_logs": "",
+        }

requirements.txt

@@ -0,0 +1,20 @@
+requests
+pytest
+gitpython
+gradio>=4.44.0,<5.0.0
+jinja2>=3.1.4
+aider-chat
+ruff
+tenacity
+bandit[toml]
+pip-audit
+radon
+hypothesis[cli]>=6.100.0
+semgrep>=1.45.0
+sentence-transformers>=2.7.0
+sqlite-vec>=0.1.1
+pygithub>=2.3.0
+PyJWT>=2.8.0
+datasets>=2.19.0
+numpy>=1.26.0
+psycopg2-binary>=2.9.9

sast_gate.py

@@ -0,0 +1,200 @@
+"""
+Rhodawk AI — Pre-PR SAST + Secret Detection Gate
+==================================================
+Every AI-generated diff passes through this gate BEFORE a PR is opened.
+The gate runs:
+  1. Bandit — Python SAST for known vulnerability patterns (SQLi, exec, pickle, etc.)
+  2. Secret pattern scanning — detects hardcoded credentials, API keys, tokens
+  3. Dangerous import detection — flags os.system, eval, __import__, pickle.loads
+
+This is the control plane that stops a hallucinating LLM from shipping a vulnerability.
+"""
+
+import os
+import re
+import subprocess
+import tempfile
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+# ──────────────────────────────────────────────
+# Secret patterns — compiled once at module load
+# ──────────────────────────────────────────────
+_SECRET_PATTERNS = [
+    (re.compile(r'(?i)(api[_\-]?key|apikey|secret[_\-]?key|access[_\-]?token|auth[_\-]?token)\s*=\s*["\'][a-z0-9\-_]{16,}["\']'), "Hardcoded API key / token"),
+    (re.compile(r'(?i)(password|passwd|pwd)\s*=\s*["\'][^"\']{6,}["\']'), "Hardcoded password"),
+    (re.compile(r'(?i)github[_\-]?(token|pat)\s*=\s*["\']gh[pousr]_[a-z0-9]{36,}["\']'), "Hardcoded GitHub PAT"),
+    (re.compile(r'(?i)hf_[a-z0-9]{30,}', re.IGNORECASE), "HuggingFace token"),
+    (re.compile(r'sk-[a-zA-Z0-9]{32,}'), "OpenAI / OpenRouter API key"),
+    (re.compile(r'(?i)(aws[_\-]?access[_\-]?key|AKIA)[A-Z0-9]{16,}'), "AWS access key"),
+    (re.compile(r'(?i)aws[_\-]?session[_\-]?token\s*=\s*["\'][A-Za-z0-9/+=]{80,}["\']'), "AWS session token"),
+    (re.compile(r'"type"\s*:\s*"service_account"[\s\S]{0,2000}"private_key"\s*:', re.IGNORECASE), "GCP service account JSON"),
+    (re.compile(r'-----BEGIN (RSA |EC |OPENSSH )?PRIVATE KEY-----'), "Private key in source"),
+]
+
+_DANGEROUS_PATTERNS = [
+    (re.compile(r'\bos\.system\s*\('), "os.system() call — use subprocess with shell=False"),
+    (re.compile(r'\beval\s*\('), "eval() call — arbitrary code execution risk"),
+    (re.compile(r'\bexec\s*\('), "exec() call — arbitrary code execution risk"),
+    (re.compile(r'\b__import__\s*\('), "__import__() call — dynamic import risk"),
+    (re.compile(r'\bpickle\.loads?\s*\('), "pickle.load() — deserialization attack risk"),
+    (re.compile(r'\bsubprocess\.call\s*\(.*shell\s*=\s*True'), "subprocess with shell=True — injection risk"),
+    (re.compile(r'\bsubprocess\.run\s*\(.*shell\s*=\s*True'), "subprocess.run with shell=True — injection risk"),
+]
+
+_INJECTION_PATTERNS = [
+    (re.compile(r'f["\'].*SELECT.*\{.*\}.*FROM', re.IGNORECASE), "SQL injection via f-string"),
+    (re.compile(r'["\'].*\+.*["\'].*WHERE', re.IGNORECASE), "SQL injection via concatenation"),
+    (re.compile(r'\.format\(.*\).*WHERE', re.IGNORECASE), "SQL injection via .format()"),
+]
+
+
+@dataclass
+class SastFinding:
+    severity: str
+    category: str
+    line_number: int
+    line_content: str
+    description: str
+
+
+@dataclass
+class SastReport:
+    passed: bool
+    findings: list[SastFinding] = field(default_factory=list)
+    bandit_output: str = ""
+    semgrep_output: str = ""
+    blocked_reason: Optional[str] = None
+
+    def summary(self) -> str:
+        if self.passed:
+            return f"SAST GATE PASSED — {len(self.findings)} informational findings."
+        return f"SAST GATE BLOCKED — {self.blocked_reason} | {len(self.findings)} findings."
+
+
+def _scan_diff_for_secrets(diff_text: str) -> list[SastFinding]:
+    findings = []
+    for i, line in enumerate(diff_text.splitlines(), 1):
+        if not line.startswith("+"):
+            continue
+        clean_line = line[1:]
+
+        for pattern, description in _SECRET_PATTERNS:
+            if pattern.search(clean_line):
+                findings.append(SastFinding(
+                    severity="CRITICAL",
+                    category="SECRET_EXPOSURE",
+                    line_number=i,
+                    line_content=clean_line[:120],
+                    description=description,
+                ))
+
+        for pattern, description in _DANGEROUS_PATTERNS:
+            if pattern.search(clean_line):
+                findings.append(SastFinding(
+                    severity="HIGH",
+                    category="DANGEROUS_PATTERN",
+                    line_number=i,
+                    line_content=clean_line[:120],
+                    description=description,
+                ))
+        for pattern, description in _INJECTION_PATTERNS:
+            if pattern.search(clean_line):
+                findings.append(SastFinding(
+                    severity="HIGH",
+                    category="INJECTION_RISK",
+                    line_number=i,
+                    line_content=clean_line[:120],
+                    description=description,
+                ))
+    return findings
+
+
+def _run_bandit_on_file(file_path: str) -> str:
+    try:
+        result = subprocess.run(
+            ["bandit", "-r", file_path, "-f", "text", "-ll"],
+            capture_output=True,
+            text=True,
+            timeout=60,
+            shell=False,
+        )
+        return result.stdout + result.stderr
+    except FileNotFoundError:
+        return "[bandit not installed — skipped]"
+    except subprocess.TimeoutExpired:
+        return "[bandit timed out]"
+    except Exception as e:
+        return f"[bandit error: {e}]"
+
+
+def _run_semgrep_on_file(file_path: str) -> str:
+    try:
+        result = subprocess.run(
+            ["semgrep", "--config", "p/ci", "--quiet", "--error", file_path],
+            capture_output=True,
+            text=True,
+            timeout=90,
+            shell=False,
+        )
+        return result.stdout + result.stderr
+    except FileNotFoundError:
+        return "[semgrep not installed — skipped]"
+    except subprocess.TimeoutExpired:
+        return "[semgrep timed out]"
+    except Exception as e:
+        return f"[semgrep error: {e}]"
+
+
+def run_sast_gate(diff_text: str, changed_files: list[str], repo_dir: str) -> SastReport:
+    """
+    Run the full SAST gate on an AI-generated diff.
+    Returns SastReport — if passed=False, the PR must NOT be opened.
+    """
+    all_findings: list[SastFinding] = []
+
+    pattern_findings = _scan_diff_for_secrets(diff_text)
+    all_findings.extend(pattern_findings)
+
+    bandit_combined = ""
+    semgrep_combined = ""
+    for rel_path in changed_files:
+        if not rel_path.endswith(".py"):
+            continue
+        abs_path = os.path.join(repo_dir, rel_path)
+        if os.path.exists(abs_path):
+            bandit_out = _run_bandit_on_file(abs_path)
+            bandit_combined += f"\n--- {rel_path} ---\n{bandit_out}"
+            semgrep_out = _run_semgrep_on_file(abs_path)
+            semgrep_combined += f"\n--- {rel_path} ---\n{semgrep_out}"
+
+    critical_findings = [f for f in all_findings if f.severity == "CRITICAL"]
+    high_findings = [f for f in all_findings if f.severity == "HIGH"]
+
+    if critical_findings:
+        blocked_reason = f"CRITICAL: {critical_findings[0].description}"
+        return SastReport(
+            passed=False,
+            findings=all_findings,
+            bandit_output=bandit_combined,
+            semgrep_output=semgrep_combined,
+            blocked_reason=blocked_reason,
+        )
+
+    if len(high_findings) >= 3:
+        blocked_reason = f"{len(high_findings)} HIGH severity findings exceed threshold"
+        return SastReport(
+            passed=False,
+            findings=all_findings,
+            bandit_output=bandit_combined,
+            semgrep_output=semgrep_combined,
+            blocked_reason=blocked_reason,
+        )
+
+    return SastReport(
+        passed=True,
+        findings=all_findings,
+        bandit_output=bandit_combined,
+        semgrep_output=semgrep_combined,
+    )

supply_chain.py

@@ -0,0 +1,258 @@
+"""
+Rhodawk AI — Supply Chain Security Gate
+========================================
+Every AI-generated diff that touches requirements.txt or any import statement
+passes through this gate before a PR is opened.
+
+Capabilities:
+  1. pip-audit — CVE scanning against OSV/PyPA advisory database
+  2. Typosquatting detection — 50+ known typosquatting patterns vs PyPI top packages
+  3. New dependency analysis — flags packages added by the AI that weren't in original
+  4. Package metadata validation — checks for packages with no public source repo (red flag)
+
+This catches supply chain attacks where an LLM hallucinates a plausible-sounding
+package name that happens to be a malicious clone.
+"""
+
+import re
+import requests
+import subprocess
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Optional
+
+
+# Top PyPI packages that are commonly typosquatted
+_KNOWN_PACKAGES = {
+    "requests", "numpy", "pandas", "flask", "django", "fastapi", "sqlalchemy",
+    "boto3", "pytest", "setuptools", "pip", "wheel", "cryptography", "pillow",
+    "scipy", "matplotlib", "tensorflow", "torch", "scikit-learn", "pydantic",
+    "click", "rich", "httpx", "aiohttp", "celery", "redis", "pymongo", "psycopg2",
+    "uvicorn", "gunicorn", "twisted", "paramiko", "fabric", "ansible", "docker",
+    "kubernetes", "airflow", "prefect", "dask", "ray", "transformers", "openai",
+    "anthropic", "langchain", "gradio", "streamlit", "beautifulsoup4", "lxml",
+    "selenium", "playwright", "scrapy", "arrow", "pendulum", "pyyaml", "toml",
+    "dotenv", "python-dotenv", "jwt", "pyjwt", "bcrypt", "passlib", "itsdangerous",
+}
+
+# Levenshtein distance threshold for typosquatting detection
+_TYPO_THRESHOLD = 2
+
+
+def _levenshtein(s1: str, s2: str) -> int:
+    if len(s1) < len(s2):
+        return _levenshtein(s2, s1)
+    if len(s2) == 0:
+        return len(s1)
+    prev = list(range(len(s2) + 1))
+    for i, c1 in enumerate(s1):
+        curr = [i + 1]
+        for j, c2 in enumerate(s2):
+            curr.append(min(prev[j + 1] + 1, curr[j] + 1, prev[j] + (c1 != c2)))
+        prev = curr
+    return prev[-1]
+
+
+def _extract_new_packages(diff_text: str, original_requirements: str = "") -> list[str]:
+    """Extract package names added by the AI diff to requirements.txt"""
+    added = []
+    in_requirements_block = False
+
+    for line in diff_text.splitlines():
+        if "requirements.txt" in line:
+            in_requirements_block = True
+        if in_requirements_block and line.startswith("+") and not line.startswith("+++"):
+            pkg_line = line[1:].strip()
+            if pkg_line and not pkg_line.startswith("#"):
+                pkg_name = re.split(r"[>=<!~\[]", pkg_line)[0].strip().lower()
+                if pkg_name and pkg_name not in original_requirements.lower():
+                    added.append(pkg_name)
+
+    return added
+
+
+def _check_typosquatting(package_name: str) -> Optional[str]:
+    """Check if a package name looks like a typosquat of a known package."""
+    pkg = package_name.lower().replace("-", "").replace("_", "")
+
+    for known in _KNOWN_PACKAGES:
+        known_clean = known.lower().replace("-", "").replace("_", "")
+        if pkg == known_clean:
+            return None  # exact match — it's fine
+        dist = _levenshtein(pkg, known_clean)
+        if 0 < dist <= _TYPO_THRESHOLD and len(pkg) > 3:
+            return f"'{package_name}' is {dist} edit(s) from known package '{known}' — possible typosquat"
+
+    return None
+
+
+def _run_pip_audit(packages: list[str]) -> list[dict]:
+    """Run pip-audit against a list of package names to check for CVEs."""
+    if not packages:
+        return []
+
+    try:
+        result = subprocess.run(
+            ["pip-audit", "--requirement", "/dev/stdin", "--format=json", "--no-deps"],
+            input="\n".join(packages),
+            capture_output=True,
+            text=True,
+            timeout=60,
+            shell=False,
+        )
+        if result.returncode == 0:
+            import json
+            data = json.loads(result.stdout)
+            vulns = []
+            for dep in data.get("dependencies", []):
+                for vuln in dep.get("vulns", []):
+                    vulns.append({
+                        "package": dep["name"],
+                        "version": dep.get("version", "unknown"),
+                        "vuln_id": vuln.get("id", ""),
+                        "description": vuln.get("description", "")[:200],
+                        "severity": vuln.get("aliases", ["UNKNOWN"])[0] if vuln.get("aliases") else "UNKNOWN",
+                    })
+            return vulns
+    except FileNotFoundError:
+        pass  # pip-audit not installed
+    except Exception:
+        pass
+
+    return []
+
+
+def _check_import_additions(diff_text: str) -> list[str]:
+    """Detect new import statements added by the AI."""
+    new_imports = []
+    for line in diff_text.splitlines():
+        if line.startswith("+") and not line.startswith("+++"):
+            clean = line[1:].strip()
+            if clean.startswith("import ") or clean.startswith("from "):
+                # Extract module name
+                match = re.match(r"(?:from|import)\s+(\w+)", clean)
+                if match:
+                    new_imports.append(match.group(1))
+    return list(set(new_imports))
+
+
+def _check_package_metadata(package_name: str) -> Optional[str]:
+    try:
+        resp = requests.get(f"https://pypi.org/pypi/{package_name}/json", timeout=10)
+        if resp.status_code == 404:
+            return f"Package '{package_name}' not found on PyPI — likely hallucinated"
+        resp.raise_for_status()
+        data = resp.json()
+        info = data.get("info", {})
+        urls = info.get("project_urls") or {}
+        source_url = urls.get("Source") or urls.get("Source Code") or urls.get("Repository") or info.get("home_page")
+        if not source_url:
+            return f"Package '{package_name}' has no source repository — possible malicious package"
+        upload_times = []
+        for releases in (data.get("releases") or {}).values():
+            for release in releases:
+                ts = release.get("upload_time_iso_8601")
+                if ts:
+                    try:
+                        upload_times.append(datetime.fromisoformat(ts.replace("Z", "+00:00")))
+                    except ValueError:
+                        pass
+        if upload_times:
+            first_upload = min(upload_times)
+            age_days = (datetime.now(timezone.utc) - first_upload).days
+            if age_days < 30:
+                return f"Package '{package_name}' is only {age_days} day(s) old — suspiciously new dependency"
+    except Exception:
+        return None
+    return None
+
+
+@dataclass
+class SupplyChainReport:
+    passed: bool
+    new_packages: list[str] = field(default_factory=list)
+    typosquat_findings: list[str] = field(default_factory=list)
+    cve_findings: list[dict] = field(default_factory=list)
+    new_imports: list[str] = field(default_factory=list)
+    metadata_findings: list[str] = field(default_factory=list)
+    blocked_reason: Optional[str] = None
+
+    def summary(self) -> str:
+        if self.passed:
+            return f"Supply chain OK. Checked {len(self.new_packages)} new package(s)."
+        return f"Supply chain BLOCKED: {self.blocked_reason}"
+
+
+def run_supply_chain_gate(diff_text: str, repo_dir: str = "") -> SupplyChainReport:
+    """
+    Run the full supply chain gate on an AI-generated diff.
+    Returns SupplyChainReport. If passed=False, the PR must NOT be opened.
+    """
+    import os
+    original_reqs = ""
+    req_path = os.path.join(repo_dir, "requirements.txt") if repo_dir else ""
+    if req_path and os.path.exists(req_path):
+        try:
+            with open(req_path) as f:
+                original_reqs = f.read()
+        except OSError:
+            pass
+
+    new_packages = _extract_new_packages(diff_text, original_reqs)
+    new_imports = _check_import_additions(diff_text)
+
+    typosquat_findings = []
+    for pkg in new_packages:
+        finding = _check_typosquatting(pkg)
+        if finding:
+            typosquat_findings.append(finding)
+    for imp in new_imports:
+        finding = _check_typosquatting(imp)
+        if finding:
+            typosquat_findings.append(f"[import] {finding}")
+
+    if typosquat_findings:
+        return SupplyChainReport(
+            passed=False,
+            new_packages=new_packages,
+            typosquat_findings=typosquat_findings,
+            new_imports=new_imports,
+            blocked_reason=f"Typosquatting detected: {typosquat_findings[0]}",
+        )
+
+    cve_findings = _run_pip_audit(new_packages)
+    critical_cves = [c for c in cve_findings if "CVE" in c.get("vuln_id", "")]
+
+    metadata_findings = []
+    for pkg in new_packages:
+        finding = _check_package_metadata(pkg)
+        if finding:
+            metadata_findings.append(finding)
+
+    if metadata_findings:
+        return SupplyChainReport(
+            passed=False,
+            new_packages=new_packages,
+            cve_findings=cve_findings,
+            new_imports=new_imports,
+            metadata_findings=metadata_findings,
+            blocked_reason=f"Package metadata risk: {metadata_findings[0]}",
+        )
+
+    if critical_cves:
+        return SupplyChainReport(
+            passed=False,
+            new_packages=new_packages,
+            cve_findings=cve_findings,
+            new_imports=new_imports,
+            metadata_findings=metadata_findings,
+            blocked_reason=f"CVE found in added package '{critical_cves[0]['package']}': {critical_cves[0]['vuln_id']}",
+        )
+
+    return SupplyChainReport(
+        passed=True,
+        new_packages=new_packages,
+        cve_findings=cve_findings,
+        new_imports=new_imports,
+        metadata_findings=metadata_findings,
+    )

swebench_harness.py

@@ -0,0 +1,128 @@
+"""
+Rhodawk AI — SWE-bench Verified Evaluation Harness
+===================================================
+Runs Rhodawk-compatible evaluations against SWE-bench Verified and writes
+machine-readable plus investor-ready reports.
+"""
+
+import argparse
+import json
+import os
+import subprocess
+import time
+from dataclasses import dataclass, asdict
+from typing import Any
+
+SWEBENCH_DATASET = "princeton-nlp/SWE-bench_Verified"
+RESULTS_PATH = "/data/swebench_results.json"
+REPORT_PATH = "/data/swebench_report.md"
+
+
+@dataclass
+class SwebenchOutcome:
+    instance_id: str
+    repo: str
+    resolved: bool
+    duration_seconds: float
+    error: str = ""
+
+
+def evaluate_single_instance(instance: dict[str, Any]) -> SwebenchOutcome:
+    start = time.time()
+    instance_id = instance.get("instance_id", "unknown")
+    repo = instance.get("repo", "unknown")
+    try:
+        command = os.getenv("RHODAWK_SWEBENCH_COMMAND")
+        if not command:
+            return SwebenchOutcome(
+                instance_id=instance_id,
+                repo=repo,
+                resolved=False,
+                duration_seconds=time.time() - start,
+                error="RHODAWK_SWEBENCH_COMMAND is not configured",
+            )
+        payload = json.dumps(instance)
+        proc = subprocess.run(
+            command.split(),
+            input=payload,
+            capture_output=True,
+            text=True,
+            timeout=int(os.getenv("RHODAWK_SWEBENCH_TIMEOUT", "1800")),
+            shell=False,
+        )
+        resolved = proc.returncode == 0
+        return SwebenchOutcome(
+            instance_id=instance_id,
+            repo=repo,
+            resolved=resolved,
+            duration_seconds=time.time() - start,
+            error="" if resolved else (proc.stderr or proc.stdout)[-1000:],
+        )
+    except Exception as e:
+        return SwebenchOutcome(
+            instance_id=instance_id,
+            repo=repo,
+            resolved=False,
+            duration_seconds=time.time() - start,
+            error=str(e),
+        )
+
+
+def run_swebench_eval(max_instances: int = 100, split: str = "test") -> dict:
+    from datasets import load_dataset
+
+    dataset = load_dataset(SWEBENCH_DATASET, split=split)
+    instances = list(dataset)[:max_instances]
+    outcomes = [evaluate_single_instance(inst) for inst in instances]
+    resolved = sum(1 for outcome in outcomes if outcome.resolved)
+    total = len(outcomes) or 1
+    result = {
+        "pass_at_1": resolved / total,
+        "resolved": resolved,
+        "total": len(outcomes),
+        "split": split,
+        "dataset": SWEBENCH_DATASET,
+        "results": [asdict(outcome) for outcome in outcomes],
+        "generated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+    }
+    write_reports(result)
+    return result
+
+
+def write_reports(result: dict) -> None:
+    os.makedirs(os.path.dirname(RESULTS_PATH), exist_ok=True)
+    with open(RESULTS_PATH, "w", encoding="utf-8") as f:
+        json.dump(result, f, indent=2)
+
+    pass_pct = result["pass_at_1"] * 100
+    report = [
+        "# Rhodawk AI SWE-bench Verified Report",
+        "",
+        f"- Dataset: `{result['dataset']}`",
+        f"- Split: `{result['split']}`",
+        f"- Total instances: {result['total']}",
+        f"- Resolved: {result['resolved']}",
+        f"- pass@1: {pass_pct:.1f}%",
+        f"- Generated: {result['generated_at']}",
+        "",
+        "## Instance Outcomes",
+        "",
+    ]
+    for outcome in result["results"]:
+        status = "RESOLVED" if outcome["resolved"] else "FAILED"
+        report.append(f"- `{outcome['instance_id']}` ({outcome['repo']}): {status}")
+    with open(REPORT_PATH, "w", encoding="utf-8") as f:
+        f.write("\n".join(report))
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--split", default="test")
+    parser.add_argument("--max-instances", type=int, default=100)
+    args = parser.parse_args()
+    result = run_swebench_eval(max_instances=args.max_instances, split=args.split)
+    print(json.dumps({k: result[k] for k in ("pass_at_1", "resolved", "total")}, indent=2))
+
+
+if __name__ == "__main__":
+    main()

training_store.py

@@ -0,0 +1,362 @@
+"""
+Rhodawk AI — Training Data Pipeline
+=====================================
+Every fix attempt is recorded in SQLite. This is the data flywheel.
+
+Schema captures the complete chain:
+  failure → model → prompt → diff → SAST → adversarial verdict → test result → human outcome
+
+After N examples, this becomes a proprietary fine-tuning dataset that no
+competitor can replicate — because it's trained on YOUR codebase's failure patterns.
+
+Export API produces HuggingFace-compatible JSONL for direct model fine-tuning.
+"""
+
+import hashlib
+import json
+import os
+import sqlite3
+import time
+from contextlib import contextmanager
+from typing import Optional
+
+DB_PATH = "/data/training_store.db"
+DB_BACKEND = os.getenv("DB_BACKEND", "sqlite").lower()
+DATABASE_URL = os.getenv("DATABASE_URL", "")
+
+
+@contextmanager
+def _get_conn():
+    if DB_BACKEND == "postgres":
+        import psycopg2
+        from psycopg2.extras import DictCursor
+
+        class PgConn:
+            def __init__(self, conn):
+                self.conn = conn
+
+            def execute(self, sql: str, params: tuple = ()):
+                pg_sql = sql.replace("?", "%s")
+                if "INSERT INTO fix_attempts" in pg_sql and "RETURNING id" not in pg_sql:
+                    pg_sql = pg_sql.rstrip().rstrip(";") + " RETURNING id"
+                cur = self.conn.cursor(cursor_factory=DictCursor)
+                cur.execute(pg_sql, params)
+                return cur
+
+            def executescript(self, script: str):
+                cur = self.conn.cursor()
+                cur.execute(script)
+                return cur
+
+            def commit(self):
+                self.conn.commit()
+
+            def rollback(self):
+                self.conn.rollback()
+
+            def close(self):
+                self.conn.close()
+
+        conn = PgConn(psycopg2.connect(DATABASE_URL))
+        try:
+            yield conn
+            conn.commit()
+        except Exception:
+            conn.rollback()
+            raise
+        finally:
+            conn.close()
+        return
+
+    conn = sqlite3.connect(DB_PATH, timeout=10)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute("PRAGMA foreign_keys=ON")
+    try:
+        yield conn
+        conn.commit()
+    except Exception:
+        conn.rollback()
+        raise
+    finally:
+        conn.close()
+
+
+def initialize_store():
+    os.makedirs(os.path.dirname(DB_PATH), exist_ok=True)
+    if DB_BACKEND == "postgres":
+        initialize_postgres_store()
+        return
+    with _get_conn() as conn:
+        conn.executescript("""
+            CREATE TABLE IF NOT EXISTS fix_attempts (
+                id                  INTEGER PRIMARY KEY AUTOINCREMENT,
+                created_at          TEXT NOT NULL,
+                tenant_id           TEXT NOT NULL,
+                repo                TEXT NOT NULL,
+                test_path           TEXT NOT NULL,
+                failure_signature   TEXT NOT NULL,
+                failure_output      TEXT NOT NULL,
+                model_version       TEXT NOT NULL,
+                adversary_model     TEXT,
+                prompt_hash         TEXT NOT NULL,
+                attempt_number      INTEGER DEFAULT 1,
+                diff_produced       TEXT,
+                sast_passed         INTEGER,
+                sast_findings_count INTEGER DEFAULT 0,
+                adversarial_verdict TEXT,
+                adversarial_issues  TEXT,
+                adversarial_summary TEXT,
+                test_passed_after   INTEGER,
+                pr_url              TEXT,
+                human_merged        INTEGER,
+                human_merged_at     TEXT,
+                success_signal      INTEGER GENERATED ALWAYS AS (
+                    CASE WHEN test_passed_after = 1 AND sast_passed = 1
+                         AND (adversarial_verdict IS NULL OR adversarial_verdict != 'REJECT')
+                    THEN 1 ELSE 0 END
+                ) STORED
+            );
+
+            CREATE TABLE IF NOT EXISTS fix_patterns (
+                id                  INTEGER PRIMARY KEY AUTOINCREMENT,
+                failure_signature   TEXT NOT NULL,
+                context_hash        TEXT NOT NULL,
+                fix_diff            TEXT NOT NULL,
+                success_count       INTEGER DEFAULT 0,
+                attempt_count       INTEGER DEFAULT 0,
+                last_seen           TEXT NOT NULL,
+                UNIQUE(failure_signature, context_hash)
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_fix_attempts_repo ON fix_attempts(repo, test_path);
+            CREATE INDEX IF NOT EXISTS idx_fix_attempts_success ON fix_attempts(success_signal);
+            CREATE INDEX IF NOT EXISTS idx_fix_patterns_sig ON fix_patterns(failure_signature);
+        """)
+
+
+def initialize_postgres_store():
+    if not DATABASE_URL:
+        raise EnvironmentError("DB_BACKEND=postgres requires DATABASE_URL")
+    import psycopg2
+    with psycopg2.connect(DATABASE_URL) as conn:
+        with conn.cursor() as cur:
+            cur.execute("""
+                CREATE TABLE IF NOT EXISTS fix_attempts (
+                    id                  BIGSERIAL PRIMARY KEY,
+                    created_at          TEXT NOT NULL,
+                    tenant_id           TEXT NOT NULL,
+                    repo                TEXT NOT NULL,
+                    test_path           TEXT NOT NULL,
+                    failure_signature   TEXT NOT NULL,
+                    failure_output      TEXT NOT NULL,
+                    model_version       TEXT NOT NULL,
+                    adversary_model     TEXT,
+                    prompt_hash         TEXT NOT NULL,
+                    attempt_number      INTEGER DEFAULT 1,
+                    diff_produced       TEXT,
+                    sast_passed         INTEGER,
+                    sast_findings_count INTEGER DEFAULT 0,
+                    adversarial_verdict TEXT,
+                    adversarial_issues  TEXT,
+                    adversarial_summary TEXT,
+                    test_passed_after   INTEGER,
+                    pr_url              TEXT,
+                    human_merged        INTEGER,
+                    human_merged_at     TEXT,
+                    success_signal      INTEGER DEFAULT 0
+                );
+                CREATE TABLE IF NOT EXISTS fix_patterns (
+                    id                  BIGSERIAL PRIMARY KEY,
+                    failure_signature   TEXT NOT NULL,
+                    context_hash        TEXT NOT NULL,
+                    fix_diff            TEXT NOT NULL,
+                    success_count       INTEGER DEFAULT 0,
+                    attempt_count       INTEGER DEFAULT 0,
+                    last_seen           TEXT NOT NULL,
+                    UNIQUE(failure_signature, context_hash)
+                );
+                CREATE INDEX IF NOT EXISTS idx_fix_attempts_repo ON fix_attempts(repo, test_path);
+                CREATE INDEX IF NOT EXISTS idx_fix_attempts_success ON fix_attempts(success_signal);
+                CREATE INDEX IF NOT EXISTS idx_fix_patterns_sig ON fix_patterns(failure_signature);
+            """)
+
+
+def record_attempt(
+    tenant_id: str,
+    repo: str,
+    test_path: str,
+    failure_output: str,
+    model_version: str,
+    prompt_hash: str,
+    attempt_number: int = 1,
+    diff_produced: str = "",
+    sast_passed: Optional[bool] = None,
+    sast_findings_count: int = 0,
+    adversarial_verdict: Optional[str] = None,
+    adversarial_issues: Optional[list] = None,
+    adversarial_summary: str = "",
+    adversary_model: str = "",
+    test_passed_after: Optional[bool] = None,
+    pr_url: str = "",
+) -> int:
+    failure_signature = _make_failure_signature(failure_output)
+
+    with _get_conn() as conn:
+        cursor = conn.execute("""
+            INSERT INTO fix_attempts (
+                created_at, tenant_id, repo, test_path, failure_signature, failure_output,
+                model_version, adversary_model, prompt_hash, attempt_number, diff_produced,
+                sast_passed, sast_findings_count, adversarial_verdict, adversarial_issues,
+                adversarial_summary, test_passed_after, pr_url
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """, (
+            time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+            tenant_id, repo, test_path, failure_signature,
+            failure_output[:5000], model_version, adversary_model, prompt_hash,
+            attempt_number, diff_produced[:8000],
+            1 if sast_passed else 0 if sast_passed is False else None,
+            sast_findings_count,
+            adversarial_verdict,
+            json.dumps(adversarial_issues or []),
+            adversarial_summary,
+            1 if test_passed_after else 0 if test_passed_after is False else None,
+            pr_url,
+        ))
+        if DB_BACKEND == "postgres":
+            row = cursor.fetchone()
+            return row[0] if row else 0
+        return cursor.lastrowid
+
+
+def update_test_result(attempt_id: int, test_passed: bool, pr_url: str = ""):
+    with _get_conn() as conn:
+        conn.execute(
+            "UPDATE fix_attempts SET test_passed_after=?, pr_url=? WHERE id=?",
+            (1 if test_passed else 0, pr_url, attempt_id)
+        )
+
+
+def mark_human_merged(repo: str, test_path: str):
+    with _get_conn() as conn:
+        conn.execute("""
+            UPDATE fix_attempts SET human_merged=1, human_merged_at=?
+            WHERE repo=? AND test_path=? AND pr_url IS NOT NULL
+            AND human_merged IS NULL
+            ORDER BY id DESC LIMIT 1
+        """, (time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), repo, test_path))
+
+
+def record_pattern(failure_output: str, context_hash: str, fix_diff: str, success: bool):
+    sig = _make_failure_signature(failure_output)
+    with _get_conn() as conn:
+        conn.execute("""
+            INSERT INTO fix_patterns (failure_signature, context_hash, fix_diff, success_count, attempt_count, last_seen)
+            VALUES (?, ?, ?, ?, 1, ?)
+            ON CONFLICT(failure_signature, context_hash) DO UPDATE SET
+                success_count = success_count + ?,
+                attempt_count = attempt_count + 1,
+                fix_diff = CASE WHEN ? = 1 THEN ? ELSE fix_diff END,
+                last_seen = ?
+        """, (
+            sig, context_hash, fix_diff[:4000],
+            1 if success else 0, time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+            1 if success else 0,
+            1 if success else 0, fix_diff[:4000],
+            time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        ))
+
+
+def get_statistics() -> dict:
+    with _get_conn() as conn:
+        total = conn.execute("SELECT COUNT(*) FROM fix_attempts").fetchone()[0]
+        success = conn.execute("SELECT COUNT(*) FROM fix_attempts WHERE success_signal=1").fetchone()[0]
+        sast_blocked = conn.execute("SELECT COUNT(*) FROM fix_attempts WHERE sast_passed=0").fetchone()[0]
+        adv_rejected = conn.execute(
+            "SELECT COUNT(*) FROM fix_attempts WHERE adversarial_verdict='REJECT'"
+        ).fetchone()[0]
+        patterns = conn.execute("SELECT COUNT(*) FROM fix_patterns").fetchone()[0]
+        merged = conn.execute("SELECT COUNT(*) FROM fix_attempts WHERE human_merged=1").fetchone()[0]
+
+        top_failing = conn.execute("""
+            SELECT test_path, COUNT(*) as cnt FROM fix_attempts
+            GROUP BY test_path ORDER BY cnt DESC LIMIT 5
+        """).fetchall()
+
+    return {
+        "total_attempts": total,
+        "successful_fixes": success,
+        "fix_success_rate": f"{(success/total*100):.1f}%" if total > 0 else "0%",
+        "sast_blocked": sast_blocked,
+        "adversarially_rejected": adv_rejected,
+        "patterns_learned": patterns,
+        "human_merged": merged,
+        "top_failing_tests": [{"path": r["test_path"], "attempts": r["cnt"]} for r in top_failing],
+    }
+
+
+def export_training_data(limit: int = 1000) -> str:
+    """Export successful fixes as JSONL for fine-tuning."""
+    with _get_conn() as conn:
+        rows = conn.execute("""
+            SELECT repo, test_path, failure_output, model_version,
+                   diff_produced, adversarial_verdict, adversarial_summary,
+                   sast_passed, attempt_number, created_at
+            FROM fix_attempts
+            WHERE success_signal = 1
+            ORDER BY created_at DESC
+            LIMIT ?
+        """, (limit,)).fetchall()
+
+    lines = []
+    for row in rows:
+        entry = {
+            "messages": [
+                {
+                    "role": "system",
+                    "content": "You are an autonomous DevSecOps engineer. Fix failing tests in Python repositories."
+                },
+                {
+                    "role": "user",
+                    "content": f"Fix the following failing test in repo '{row['repo']}':\n\n{row['failure_output'][:2000]}"
+                },
+                {
+                    "role": "assistant",
+                    "content": f"```diff\n{row['diff_produced']}\n```"
+                }
+            ],
+            "metadata": {
+                "repo": row["repo"],
+                "test_path": row["test_path"],
+                "model": row["model_version"],
+                "adversarial_verdict": row["adversarial_verdict"],
+                "attempt_number": row["attempt_number"],
+                "created_at": row["created_at"],
+            }
+        }
+        lines.append(json.dumps(entry))
+
+    return "\n".join(lines)
+
+
+def export_hf_dataset(repo_id: str, limit: int = 1000, private: bool = True) -> str:
+    from datasets import Dataset
+
+    raw = export_training_data(limit=limit)
+    rows = [json.loads(line) for line in raw.splitlines() if line.strip()]
+    dataset = Dataset.from_list(rows)
+    dataset.push_to_hub(repo_id, private=private)
+    return f"Exported {len(rows)} training examples to {repo_id}"
+
+
+def _make_failure_signature(failure_output: str) -> str:
+    lines = failure_output.splitlines()
+    key_lines = [l for l in lines if any(kw in l for kw in [
+        "FAILED", "ERROR", "assert", "ImportError", "AttributeError",
+        "TypeError", "ValueError", "ModuleNotFoundError", "Exception"
+    ])]
+    signature_text = " ".join(key_lines[:5])[:200]
+    return hashlib.sha256(signature_text.encode()).hexdigest()[:32]
+
+
+initialize_store()

verification_loop.py

@@ -0,0 +1,141 @@
+"""
+Rhodawk AI — Closed Verification Loop Engine
+=============================================
+This is the core capability that separates Rhodawk from every other AI CI tool.
+
+Standard tools: AI generates fix → open PR (no idea if fix works)
+Rhodawk:        AI generates fix → re-run tests → if still failing, retry with
+                new failure context + what was tried → up to MAX_RETRIES rounds
+
+The loop:
+  1. Run tests → get failure output
+  2. Dispatch Aider with failure context + memory-retrieved similar fixes
+  3. Re-run tests on the modified code
+  4. If GREEN → gate through adversarial review → open PR
+  5. If STILL RED → append new failure + what was tried → goto 2
+  6. After MAX_RETRIES → mark as FAILED, escalate
+"""
+
+import os
+import time
+from dataclasses import dataclass, field
+from typing import Optional
+
+MAX_RETRIES = int(os.getenv("RHODAWK_MAX_RETRIES", "5"))
+ADVERSARIAL_REJECTION_MULTIPLIER = int(os.getenv("RHODAWK_ADVERSARIAL_REJECTION_MULTIPLIER", "0"))
+RETRY_BACKOFF_SECONDS = 5
+
+
+@dataclass
+class VerificationAttempt:
+    attempt_number: int
+    prompt_hash: str
+    aider_exit_code: int
+    test_exit_code: int
+    test_output: str
+    diff_produced: str
+    timestamp: str = field(default_factory=lambda: time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()))
+
+
+@dataclass
+class VerificationResult:
+    success: bool
+    attempts: list[VerificationAttempt] = field(default_factory=list)
+    final_diff: str = ""
+    final_test_output: str = ""
+    failure_reason: str = ""
+    total_attempts: int = 0
+
+
+def build_retry_prompt(
+    test_path: str,
+    src_file: str,
+    branch_name: str,
+    original_failure: str,
+    attempt_history: list[VerificationAttempt],
+    similar_fixes: list[dict],
+) -> str:
+    """
+    Build an increasingly rich prompt for each retry attempt.
+    Each retry includes:
+      - The original failure
+      - What was tried in previous attempts and why it failed
+      - Retrieved similar successful fixes from memory
+    """
+    sections = []
+
+    sections.append(
+        f"The pytest test '{test_path}' is STILL FAILING. This is attempt "
+        f"{len(attempt_history) + 1} of {MAX_RETRIES}.\n"
+    )
+
+    sections.append(
+        f"ORIGINAL FAILURE:\n```\n{original_failure[:2000]}\n```\n"
+    )
+
+    if attempt_history:
+        sections.append("PREVIOUS ATTEMPTS THAT DID NOT WORK:")
+        for a in attempt_history:
+            sections.append(
+                f"\nAttempt {a.attempt_number}:\n"
+                f"  Test output after fix:\n```\n{a.test_output[:800]}\n```\n"
+                f"  Diff that was applied:\n```diff\n{a.diff_produced[:600]}\n```"
+            )
+        sections.append(
+            "\nDo NOT repeat the same fix approach. Analyze why previous attempts failed "
+            "and try a fundamentally different strategy.\n"
+        )
+
+    if similar_fixes:
+        sections.append("\nSIMILAR FIXES FROM MEMORY (from previously healed tests — use as guidance):")
+        for i, fix in enumerate(similar_fixes[:2], 1):
+            sections.append(
+                f"\nSimilar fix {i} (success rate: {fix.get('success_rate', 'unknown')}):\n"
+                f"  Failure pattern: {fix.get('failure_signature', '')[:200]}\n"
+                f"  Fix applied:\n```diff\n{fix.get('fix_diff', '')[:400]}\n```"
+            )
+
+    sections.append(
+        f"\nINSTRUCTIONS:\n"
+        f"1. Fix the source code in '{src_file}' or 'requirements.txt' ONLY. Do NOT modify test files.\n"
+        f"2. Use the 'fetch-docs' MCP tool to look up library documentation if needed.\n"
+        f"3. Work on branch '{branch_name}'. Commit the minimal fix when complete.\n"
+        f"4. The fix MUST be different from all previous attempts.\n"
+        f"5. Ensure the fix is minimal and does not introduce regressions."
+    )
+
+    return "\n".join(sections)
+
+
+def build_initial_prompt(
+    test_path: str,
+    src_file: str,
+    branch_name: str,
+    failure_output: str,
+    similar_fixes: list[dict],
+) -> str:
+    sections = []
+    sections.append(
+        f"The pytest test '{test_path}' is failing:\n\n"
+        f"```\n{failure_output[:3000]}\n```\n"
+    )
+
+    if similar_fixes:
+        sections.append("RELEVANT FIXES FROM MEMORY (similar past failures that were healed):")
+        for i, fix in enumerate(similar_fixes[:2], 1):
+            sections.append(
+                f"\nSimilar case {i} (success rate: {fix.get('success_rate', 'unknown')}):\n"
+                f"  Failure: {fix.get('failure_signature', '')[:150]}\n"
+                f"  What worked:\n```diff\n{fix.get('fix_diff', '')[:400]}\n```"
+            )
+
+    sections.append(
+        f"\nINSTRUCTIONS:\n"
+        f"1. If there is an import error or version conflict, use 'fetch-docs' MCP to look up "
+        f"   documentation on docs.python.org or pypi.org.\n"
+        f"2. Fix '{src_file}' or 'requirements.txt' to make the test pass. Do NOT modify test files.\n"
+        f"3. Work on branch '{branch_name}'. Commit the minimal fix when complete.\n"
+        f"4. The fix must be minimal and must not introduce regressions."
+    )
+
+    return "\n".join(sections)

webhook_server.py

@@ -0,0 +1,235 @@
+"""
+Rhodawk AI — Event-Driven Webhook Server
+==========================================
+Accepts GitHub push events, CI failure webhooks, and manual triggers.
+Runs alongside Gradio in a separate thread on port 7861.
+
+Supported events:
+  POST /webhook/github       — GitHub push/status/check_run webhooks (HMAC-SHA256 validated)
+  POST /webhook/ci           — Generic CI failure payload (any CI system)
+  POST /webhook/trigger      — Manual trigger with repo + test path
+  GET  /webhook/health       — Health check
+  GET  /webhook/queue        — Current job queue status
+
+This makes Rhodawk a first-class CI/CD participant — not a side tool you run manually.
+"""
+
+import hashlib
+import hmac
+import json
+import os
+import threading
+import time
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from typing import Callable
+from urllib.parse import urlparse
+
+WEBHOOK_SECRET = os.getenv("RHODAWK_WEBHOOK_SECRET", "")
+WEBHOOK_PORT = int(os.getenv("RHODAWK_WEBHOOK_PORT", "7861"))
+
+_webhook_log: list[dict] = []
+_webhook_lock = threading.Lock()
+_job_dispatcher: Callable = None  # Set at runtime by app.py
+_rate_limit: dict[str, list[float]] = {}
+_RATE_LIMIT_MAX_EVENTS = int(os.getenv("RHODAWK_WEBHOOK_RATE_LIMIT", "10"))
+_RATE_LIMIT_WINDOW_SECONDS = 60
+
+
+def set_job_dispatcher(fn: Callable):
+    """Register the function that app.py uses to spawn audit jobs."""
+    global _job_dispatcher
+    _job_dispatcher = fn
+
+
+def _log_webhook(event_type: str, payload: dict, status: str, detail: str = ""):
+    with _webhook_lock:
+        _webhook_log.append({
+            "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+            "event_type": event_type,
+            "status": status,
+            "detail": detail,
+            "repo": payload.get("repository", {}).get("full_name", payload.get("repo", "unknown")),
+        })
+        if len(_webhook_log) > 200:
+            _webhook_log.pop(0)
+
+
+def get_webhook_log(limit: int = 50) -> list[dict]:
+    with _webhook_lock:
+        return list(reversed(_webhook_log[-limit:]))
+
+
+def _verify_github_signature(body: bytes, signature_header: str) -> bool:
+    if not WEBHOOK_SECRET:
+        return True  # Skip validation if secret not configured
+    if not signature_header or not signature_header.startswith("sha256="):
+        return False
+    mac = hmac.new(WEBHOOK_SECRET.encode(), msg=body, digestmod=hashlib.sha256)
+    expected = mac.hexdigest()
+    received = signature_header[7:]
+    return hmac.compare_digest(expected, received)
+
+
+def _rate_limit_allows(ip: str) -> bool:
+    now = time.time()
+    with _webhook_lock:
+        events = [t for t in _rate_limit.get(ip, []) if now - t < _RATE_LIMIT_WINDOW_SECONDS]
+        if len(events) >= _RATE_LIMIT_MAX_EVENTS:
+            _rate_limit[ip] = events
+            return False
+        events.append(now)
+        _rate_limit[ip] = events
+        return True
+
+
+def _parse_github_event(event_type: str, payload: dict) -> dict:
+    """Extract repo, branch, and context from a GitHub webhook payload."""
+    repo = payload.get("repository", {}).get("full_name", "")
+    branch = (
+        payload.get("ref", "").replace("refs/heads/", "") or
+        payload.get("check_run", {}).get("head_branch", "main") or
+        "main"
+    )
+    context = {
+        "repo": repo,
+        "branch": branch,
+        "event_type": event_type,
+        "commit_sha": payload.get("after") or payload.get("check_run", {}).get("head_sha", ""),
+        "triggered_by": "github_webhook",
+    }
+
+    if event_type == "check_run":
+        check = payload.get("check_run", {})
+        if check.get("conclusion") == "failure":
+            context["failing_check"] = check.get("name", "")
+            context["details_url"] = check.get("details_url", "")
+            return context
+        return {}  # Only care about failures
+
+    if event_type == "status":
+        if payload.get("state") == "failure":
+            context["failing_context"] = payload.get("context", "")
+            return context
+        return {}
+
+    # push event — trigger full audit
+    return context
+
+
+class WebhookHandler(BaseHTTPRequestHandler):
+    def log_message(self, format, *args):
+        pass  # Suppress default HTTP server logs
+
+    def _send_json(self, status_code: int, data: dict):
+        body = json.dumps(data).encode()
+        self.send_response(status_code)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", len(body))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_GET(self):
+        path = urlparse(self.path).path
+
+        if path == "/webhook/health":
+            self._send_json(200, {
+                "status": "ok",
+                "dispatcher_ready": _job_dispatcher is not None,
+                "webhook_events_received": len(_webhook_log),
+                "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+            })
+
+        elif path == "/webhook/queue":
+            from job_queue import list_all_jobs, get_metrics
+            self._send_json(200, {
+                "metrics": get_metrics(),
+                "recent_jobs": list_all_jobs()[:10],
+            })
+
+        elif path == "/webhook/log":
+            self._send_json(200, {"events": get_webhook_log(50)})
+
+        else:
+            self._send_json(404, {"error": "Not found"})
+
+    def do_POST(self):
+        path = urlparse(self.path).path
+        client_ip = self.client_address[0] if self.client_address else "unknown"
+        if not _rate_limit_allows(client_ip):
+            _log_webhook("rate_limit", {"repo": "unknown"}, "REJECTED", f"Too many events from {client_ip}")
+            self._send_json(429, {"error": "Rate limit exceeded"})
+            return
+        length = int(self.headers.get("Content-Length", 0))
+        body = self.rfile.read(length)
+
+        try:
+            payload = json.loads(body) if body else {}
+        except json.JSONDecodeError:
+            self._send_json(400, {"error": "Invalid JSON"})
+            return
+
+        if path == "/webhook/github":
+            sig = self.headers.get("X-Hub-Signature-256", "")
+            if not _verify_github_signature(body, sig):
+                _log_webhook("github", payload, "REJECTED", "Invalid HMAC signature")
+                self._send_json(401, {"error": "Invalid signature"})
+                return
+
+            event_type = self.headers.get("X-GitHub-Event", "push")
+            context = _parse_github_event(event_type, payload)
+
+            if not context or not context.get("repo"):
+                _log_webhook(event_type, payload, "IGNORED", "Event not actionable")
+                self._send_json(200, {"status": "ignored", "reason": "Event not actionable"})
+                return
+
+            _log_webhook(event_type, payload, "ACCEPTED", f"Triggering audit for {context['repo']}")
+
+            if _job_dispatcher:
+                threading.Thread(
+                    target=_job_dispatcher,
+                    kwargs={"repo_override": context.get("repo"), "branch": context.get("branch", "main")},
+                    daemon=True,
+                ).start()
+
+            self._send_json(202, {"status": "accepted", "context": context})
+
+        elif path == "/webhook/ci":
+            repo = payload.get("repo") or payload.get("repository", "")
+            test_path = payload.get("test_path") or payload.get("failing_test", "")
+            failure_output = payload.get("failure_output") or payload.get("log", "")
+
+            if not repo:
+                self._send_json(400, {"error": "Missing 'repo' field"})
+                return
+
+            _log_webhook("ci_failure", payload, "ACCEPTED", f"CI failure from {repo}")
+
+            if _job_dispatcher:
+                threading.Thread(
+                    target=_job_dispatcher,
+                    kwargs={"repo_override": repo, "specific_test": test_path},
+                    daemon=True,
+                ).start()
+
+            self._send_json(202, {"status": "accepted", "repo": repo, "test": test_path})
+
+        elif path == "/webhook/trigger":
+            repo = payload.get("repo", os.getenv("GITHUB_REPO", ""))
+            if _job_dispatcher:
+                threading.Thread(target=_job_dispatcher, daemon=True).start()
+                _log_webhook("manual_trigger", payload, "ACCEPTED", f"Manual trigger for {repo}")
+                self._send_json(202, {"status": "accepted", "repo": repo})
+            else:
+                self._send_json(503, {"error": "Dispatcher not ready"})
+
+        else:
+            self._send_json(404, {"error": "Unknown webhook path"})
+
+
+def start_webhook_server():
+    """Start the webhook server in a daemon thread."""
+    server = HTTPServer(("0.0.0.0", WEBHOOK_PORT), WebhookHandler)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    return server

worker_pool.py

@@ -0,0 +1,76 @@
+"""
+Rhodawk AI — Concurrent Worker Pool
+====================================
+ThreadPoolExecutor-based audit orchestration for parallel test healing.
+"""
+
+import concurrent.futures
+import os
+import threading
+from typing import Callable
+
+MAX_WORKERS = int(os.getenv("RHODAWK_WORKERS", "8"))
+_pool_lock = threading.Lock()
+
+
+def run_parallel_audit(
+    test_files: list[str],
+    process_fn: Callable,
+    pytest_bin: str,
+    mcp_config_path: str,
+    tenant_id: str,
+    target_repo: str,
+) -> dict:
+    results = {"healed": 0, "failed": 0, "skipped": 0, "prs": [], "errors": []}
+
+    if not test_files:
+        return results
+
+    with concurrent.futures.ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
+        futures = {
+            executor.submit(
+                _process_one_test,
+                test_path=t,
+                process_fn=process_fn,
+                pytest_bin=pytest_bin,
+                mcp_config_path=mcp_config_path,
+                tenant_id=tenant_id,
+                repo=target_repo,
+            ): t
+            for t in test_files
+        }
+        for future in concurrent.futures.as_completed(futures):
+            try:
+                outcome = future.result()
+            except Exception as e:
+                outcome = {"success": False, "error": str(e)}
+
+            if outcome.get("skipped"):
+                results["skipped"] += 1
+            elif outcome.get("success"):
+                results["healed"] += 1
+                if outcome.get("pr_url"):
+                    results["prs"].append(outcome.get("pr_url"))
+            else:
+                results["failed"] += 1
+                if outcome.get("error"):
+                    results["errors"].append(outcome["error"])
+
+    return results
+
+
+def _process_one_test(
+    test_path: str,
+    process_fn: Callable,
+    pytest_bin: str,
+    mcp_config_path: str,
+    tenant_id: str,
+    repo: str,
+) -> dict:
+    return process_fn(
+        test_path=test_path,
+        pytest_bin=pytest_bin,
+        mcp_config_path=mcp_config_path,
+        tenant_id=tenant_id,
+        target_repo=repo,
+    )