Upload Harvester files

README.md

@@ -1,15 +1,43 @@
----
-title: Harvester
-emoji: ⚡
-colorFrom: indigo
-colorTo: yellow
-sdk: gradio
-sdk_version: 6.10.0
-python_version: '3.12'
-app_file: app.py
-pinned: false
-license: mit
-short_description: Harvester
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Harvester GPU Runner
+emoji: "\U0001F9E0"
+colorFrom: gray
+colorTo: blue
+sdk: gradio
+sdk_version: "5.0"
+app_file: app.py
+pinned: false
+---
+
+# Harvester — ZeroGPU Runner
+
+Run Harvester's reasoning lab on HuggingFace ZeroGPU (A100 40GB).
+Both DeepSeek R1 14B (reasoner) and Qwen Coder 30B (coder) fully offloaded to GPU.
+
+**Pro member** — ZeroGPU effectively unlimited.
+
+## Models
+
+| Model | Role | Size | VRAM |
+|-------|------|------|------|
+| DeepSeek R1 14B Q4_K_M | Reasoner | 8.37 GB | ~9 GB |
+| Qwen3 Coder 30B A3B Q4_K_M | Coder | 17.35 GB | ~18 GB |
+| **Total** | | **25.72 GB** | **~27 GB / 40 GB** |
+
+## Task Banks
+
+- `bellingcat_tasks.json` — 15 OSINT investigation tasks
+- `osint_tasks.json` — 15 missing-persons / OSINT automation tasks
+- `reasoning_tasks.json` — 15 hard C# architecture tasks
+
+## Setup
+
+1. Create a new Space on HuggingFace (Gradio SDK)
+2. Run `python setup_hf_space.py` locally to copy all needed files
+3. Push the `hf_space/` contents to your Space repo
+4. The app auto-starts — use the UI to run labs
+
+## CPU Baseline (i9-13900KF, no GPU)
+
+- Bellingcat: 7/15 high confidence, 3.4 hours
+- Kaggle SAE: 16/16 (100%)

app.py

@@ -1,7 +1,414 @@
-import gradio as gr
-
-def greet(name):
-    return "Hello " + name + "!!"
-
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+"""
+HARVESTER — HUGGING FACE ZEROGPU RUNNER
+========================================
+Runs Harvester's reasoning lab on ZeroGPU (A100 40GB).
+Both DeepSeek R1 14B (reasoner) and Qwen Coder 30B (coder) fully offloaded.
+
+Pro member = effectively unlimited GPU time.
+
+Architecture:
+  - @spaces.GPU decorated functions get A100 allocation
+  - Models downloaded once via HF hub cache, persist across calls
+  - Each lab run = one GPU session (duration=1800s for Pro)
+  - Results accumulate in lab_results/ and are downloadable
+"""
+
+import gradio as gr
+import spaces
+import os
+import subprocess
+import sys
+import json
+import time
+import glob
+from pathlib import Path
+
+# ── Model config ──────────────────────────────────────────────────────────────
+
+MODEL_DIR = "/tmp/harvester_models"
+
+MODELS = {
+    "reasoner": {
+        "repo":  "bartowski/DeepSeek-R1-Distill-Qwen-14B-GGUF",
+        "file":  "DeepSeek-R1-Distill-Qwen-14B-Q4_K_M.gguf",
+        "label": "DeepSeek R1 14B",
+        "size":  "8.37 GB",
+    },
+    "coder": {
+        "repo":  "lmstudio-community/Qwen3-Coder-30B-A3B-Instruct-GGUF",
+        "file":  "Qwen3-Coder-30B-A3B-Instruct-Q4_K_M.gguf",
+        "label": "Qwen Coder 30B A3B",
+        "size":  "17.35 GB",
+    },
+}
+
+# Task banks available in this Space
+TASK_BANKS = {
+    "bellingcat_tasks.json":  "Bellingcat OSINT (15 tasks) → DeepSeek R1",
+    "osint_tasks.json":       "OSINT / Missing Persons (15 tasks) → DeepSeek R1",
+    "reasoning_tasks.json":   "C# Architecture (15 tasks) → Qwen Coder",
+}
+
+
+# ── Environment setup ─────────────────────────────────────────────────────────
+
+def _model_path(key):
+    return os.path.join(MODEL_DIR, MODELS[key]["file"])
+
+
+def _setup_env():
+    """Configure env vars so reflection_engine.py uses the right model paths."""
+    os.environ["CODE_ENGINE_BACKEND"] = "native"
+    os.environ["NATIVE_GPU_LAYERS"]   = "-1"       # full GPU offload
+    os.environ["NATIVE_CTX_SIZE"]     = "16384"     # 2x local ctx (A100 has room)
+    os.environ["NATIVE_MODEL_PATH"]   = _model_path("coder")
+    os.environ["NATIVE_HF_REPO"]      = MODELS["coder"]["repo"]
+    os.environ["NATIVE_HF_FILE"]      = MODELS["coder"]["file"]
+    os.environ["REASONER_MODEL_PATH"] = _model_path("reasoner")
+    os.environ["REASONER_HF_REPO"]    = MODELS["reasoner"]["repo"]
+    os.environ["REASONER_HF_FILE"]    = MODELS["reasoner"]["file"]
+    os.environ["PYTHONIOENCODING"]     = "utf-8"
+
+
+def _download_models():
+    """Download models via HF hub. Cached after first download."""
+    from huggingface_hub import hf_hub_download
+    os.makedirs(MODEL_DIR, exist_ok=True)
+
+    status_lines = []
+    for key, info in MODELS.items():
+        path = _model_path(key)
+        if os.path.isfile(path):
+            status_lines.append(f"  {info['label']}: cached ({info['size']})")
+        else:
+            status_lines.append(f"  {info['label']}: downloading {info['size']}...")
+            hf_hub_download(
+                repo_id=info["repo"],
+                filename=info["file"],
+                local_dir=MODEL_DIR,
+            )
+            status_lines.append(f"  {info['label']}: done")
+    return "\n".join(status_lines)
+
+
+def _reset_engine():
+    """Reset reflection_engine singletons so fresh GPU handles are used."""
+    if "reflection_engine" in sys.modules:
+        mod = sys.modules["reflection_engine"]
+        mod._native_llm = None
+        mod._reasoning_llm = None
+
+
+def _gpu_info():
+    """Get nvidia-smi summary."""
+    try:
+        r = subprocess.run(
+            ["nvidia-smi", "--query-gpu=name,memory.total,memory.used,memory.free",
+             "--format=csv,noheader"],
+            capture_output=True, text=True, timeout=10,
+        )
+        return r.stdout.strip()
+    except Exception as e:
+        return f"nvidia-smi failed: {e}"
+
+
+# ── GPU functions ─────────────────────────────────────────────────────────────
+
+@spaces.GPU(duration=120)
+def gpu_check():
+    """Verify GPU, download models, show status."""
+    gpu = _gpu_info()
+    _setup_env()
+    model_status = _download_models()
+
+    # Quick load test — just import & verify model file exists
+    reasoner_ok = os.path.isfile(_model_path("reasoner"))
+    coder_ok = os.path.isfile(_model_path("coder"))
+
+    return f"""=== GPU STATUS ===
+{gpu}
+
+=== MODELS ===
+{model_status}
+
+=== READY ===
+  Reasoner (DeepSeek R1 14B):  {"OK" if reasoner_ok else "MISSING"}
+  Coder (Qwen 30B A3B):        {"OK" if coder_ok else "MISSING"}
+  GPU layers:                   -1 (full offload)
+  Context size:                 16384
+  VRAM budget:                  ~27 GB / 40 GB
+"""
+
+
+@spaces.GPU(duration=300)
+def gpu_smoke_test():
+    """Quick reasoning test — one task on DeepSeek R1."""
+    _setup_env()
+    _download_models()
+    _reset_engine()
+
+    from reflection_engine import set_task_mode, reason
+
+    set_task_mode("reasoning")
+    t0 = time.time()
+    plan = reason(
+        "Given satellite imagery showing a building complex, "
+        "outline 3 steps to geolocate it using only visual clues."
+    )
+    elapsed = time.time() - t0
+    gpu = _gpu_info()
+
+    return f"""=== SMOKE TEST ({elapsed:.1f}s) ===
+GPU: {gpu}
+
+Approach:
+{plan.approach[:500]}
+
+Steps ({len(plan.steps)}):
+{chr(10).join(f"  {i+1}. {s}" for i, s in enumerate(plan.steps))}
+
+Confidence: {plan.confidence:.0%}
+Status: {"GPU INFERENCE WORKING" if plan.confidence > 0.3 else "FALLBACK — check model load"}
+"""
+
+
+@spaces.GPU(duration=1800)
+def gpu_run_lab(bank_name, reason_only):
+    """Run full task bank. 30-min GPU allocation (Pro)."""
+    _setup_env()
+    _download_models()
+    _reset_engine()
+
+    # Run via subprocess for clean isolation
+    args = [sys.executable, "reasoning_lab.py", "--bank", bank_name]
+    if reason_only:
+        args.append("--reason-only")
+
+    t0 = time.time()
+    result = subprocess.run(
+        args,
+        capture_output=True,
+        text=True,
+        timeout=1700,
+        env={**os.environ},
+    )
+    total_time = time.time() - t0
+
+    output = result.stdout
+    if result.returncode != 0:
+        output += f"\n\nSTDERR (last 2000 chars):\n{result.stderr[-2000:]}"
+
+    # Parse and format results
+    reports = sorted(glob.glob("lab_results/lab_*.json"))
+    results_table = ""
+    if reports:
+        with open(reports[-1]) as f:
+            report = json.load(f)
+        summary = report.get("summary", {})
+        results_list = report.get("results", [])
+
+        header = f"\n{'Task':<40} {'Conf':>6} {'Time':>8}\n{'-' * 56}\n"
+        rows = ""
+        for r in results_list:
+            rows += f"{r['name']:<40} {r['confidence']:.0%}   {r['time_secs']:>7.1f}s\n"
+
+        results_table = f"""
+=== A100 GPU RESULTS ===
+Bank:            {bank_name}
+Tasks:           {report.get('task_count', '?')}
+Avg confidence:  {summary.get('avg_confidence', 0):.0%}
+High confidence: {summary.get('high_confidence', 0)}
+Low confidence:  {summary.get('low_confidence', 0)}
+Total time:      {total_time:.0f}s ({total_time/60:.1f} min)
+
+=== CPU BASELINE (i9-13900KF, no GPU) ===
+Avg confidence:  56%
+High confidence: 7
+Low confidence:  8
+Total time:      12120s (3.4 hours)
+
+=== SPEEDUP ===
+{total_time:.0f}s vs 12120s = {12120/max(total_time,1):.1f}x faster
+{header}{rows}"""
+
+    # Trim to last 5000 chars of stdout + results table
+    return output[-3000:] + "\n" + results_table
+
+
+def gpu_run_single_task(bank_name, task_id, reason_only):
+    """Run a single task from a bank (wrapper for the GPU function)."""
+    return _gpu_run_single(bank_name, task_id, reason_only)
+
+
+@spaces.GPU(duration=300)
+def _gpu_run_single(bank_name, task_id, reason_only):
+    """Run one task. 5-min GPU allocation."""
+    _setup_env()
+    _download_models()
+    _reset_engine()
+
+    args = [sys.executable, "reasoning_lab.py",
+            "--bank", bank_name, "--task", str(task_id)]
+    if reason_only:
+        args.append("--reason-only")
+
+    t0 = time.time()
+    result = subprocess.run(
+        args, capture_output=True, text=True, timeout=280,
+        env={**os.environ},
+    )
+    elapsed = time.time() - t0
+
+    output = f"=== TASK {task_id} ({elapsed:.1f}s) ===\n"
+    output += result.stdout
+    if result.returncode != 0:
+        output += f"\nSTDERR:\n{result.stderr[-1000:]}"
+    return output
+
+
+def list_tasks(bank_name):
+    """List tasks in a bank (no GPU needed)."""
+    try:
+        with open(bank_name) as f:
+            data = json.load(f)
+        # Handle both formats: plain list or {"tasks": [...]}
+        tasks = data if isinstance(data, list) else data.get("tasks", [])
+        lines = [f"{'ID':>3}  {'Diff':>4}  {'Name':<40}  Category"]
+        lines.append("-" * 70)
+        for t in tasks:
+            tid = t.get("id", "?")
+            diff = t.get("difficulty", "?")
+            name = t.get("name", "untitled")
+            cat = t.get("category", "")
+            lines.append(f"{tid:>3}  {diff:>4}★  {name:<40}  {cat}")
+        return "\n".join(lines)
+    except Exception as e:
+        return f"Error loading {bank_name}: {e}"
+
+
+def view_results():
+    """Show the latest lab results (no GPU needed)."""
+    reports = sorted(glob.glob("lab_results/lab_*.json"))
+    if not reports:
+        return "No results yet — run a lab first."
+
+    output = f"Found {len(reports)} report(s):\n\n"
+    for rpath in reports[-5:]:  # last 5
+        with open(rpath) as f:
+            report = json.load(f)
+        summary = report.get("summary", {})
+        name = os.path.basename(rpath)
+        output += f"--- {name} ---\n"
+        output += f"  Tasks: {report.get('task_count', '?')}\n"
+        output += f"  Avg confidence: {summary.get('avg_confidence', 0):.0%}\n"
+        output += f"  High: {summary.get('high_confidence', 0)}, "
+        output += f"Low: {summary.get('low_confidence', 0)}\n"
+        output += f"  Time: {summary.get('total_time', 0):.0f}s\n\n"
+    return output
+
+
+def download_latest_results():
+    """Return path to latest results JSON for download."""
+    reports = sorted(glob.glob("lab_results/lab_*.json"))
+    if reports:
+        return reports[-1]
+    return None
+
+
+# ── Gradio UI ─────────────────────────────────────────────────────────────────
+
+with gr.Blocks(title="Harvester GPU Runner", theme=gr.themes.Monochrome()) as app:
+
+    gr.Markdown("""
+    # Harvester — ZeroGPU Runner
+    Run Harvester's reasoning lab on **A100 40GB** via HuggingFace ZeroGPU.
+    Both **DeepSeek R1 14B** (reasoner) and **Qwen Coder 30B** (coder) fully GPU-offloaded.
+
+    *Pro member — effectively unlimited GPU time.*
+    """)
+
+    with gr.Tab("Setup"):
+        gr.Markdown("### GPU & Model Check")
+        gr.Markdown("Downloads models on first run (~26 GB total). Cached after that.")
+        setup_btn = gr.Button("Check GPU & Download Models", variant="primary")
+        setup_output = gr.Textbox(label="Status", lines=15, interactive=False)
+        setup_btn.click(fn=gpu_check, outputs=setup_output)
+
+    with gr.Tab("Smoke Test"):
+        gr.Markdown("### Quick Reasoning Test")
+        gr.Markdown("Loads DeepSeek R1, runs one OSINT reasoning task, shows result.")
+        smoke_btn = gr.Button("Run Smoke Test", variant="primary")
+        smoke_output = gr.Textbox(label="Result", lines=20, interactive=False)
+        smoke_btn.click(fn=gpu_smoke_test, outputs=smoke_output)
+
+    with gr.Tab("Run Lab"):
+        gr.Markdown("### Full Lab Run")
+        gr.Markdown(
+            "Run all tasks in a bank with 30-min GPU allocation. "
+            "OSINT/Bellingcat banks auto-route to DeepSeek R1. "
+            "Architecture banks auto-route to Qwen Coder."
+        )
+        with gr.Row():
+            bank_dropdown = gr.Dropdown(
+                choices=list(TASK_BANKS.keys()),
+                value="bellingcat_tasks.json",
+                label="Task Bank",
+                info="Select which task bank to run",
+            )
+            reason_only_check = gr.Checkbox(
+                value=True,
+                label="Reason Only",
+                info="Thinking drills without code generation (faster)",
+            )
+
+        with gr.Row():
+            list_btn = gr.Button("List Tasks")
+            run_btn = gr.Button("Run Full Lab", variant="primary")
+
+        lab_output = gr.Textbox(label="Output", lines=30, interactive=False)
+
+        list_btn.click(fn=list_tasks, inputs=bank_dropdown, outputs=lab_output)
+        run_btn.click(
+            fn=gpu_run_lab,
+            inputs=[bank_dropdown, reason_only_check],
+            outputs=lab_output,
+        )
+
+    with gr.Tab("Single Task"):
+        gr.Markdown("### Run One Task")
+        gr.Markdown("Pick a specific task by ID. Uses 5-min GPU allocation per task.")
+        with gr.Row():
+            single_bank = gr.Dropdown(
+                choices=list(TASK_BANKS.keys()),
+                value="bellingcat_tasks.json",
+                label="Task Bank",
+            )
+            single_id = gr.Number(value=1, label="Task ID", precision=0)
+            single_reason = gr.Checkbox(value=True, label="Reason Only")
+
+        single_btn = gr.Button("Run Task", variant="primary")
+        single_output = gr.Textbox(label="Output", lines=20, interactive=False)
+        single_btn.click(
+            fn=gpu_run_single_task,
+            inputs=[single_bank, single_id, single_reason],
+            outputs=single_output,
+        )
+
+    with gr.Tab("Results"):
+        gr.Markdown("### View & Download Results")
+        results_btn = gr.Button("Refresh Results")
+        results_output = gr.Textbox(label="Lab Results", lines=20, interactive=False)
+        results_btn.click(fn=view_results, outputs=results_output)
+
+        download_btn = gr.Button("Download Latest JSON")
+        download_file = gr.File(label="Download")
+        download_btn.click(fn=download_latest_results, outputs=download_file)
+
+    gr.Markdown("""
+    ---
+    **Harvester** — self-improving AI code engine.
+    Built on engineering principles: Radial Slop, The Ladder, Never Give Up.
+    *Work > Code > Talk.*
+    """)
+
+app.launch()

bellingcat_tasks.json

@@ -0,0 +1,122 @@
+[
+  {
+    "id": 1,
+    "name": "Shadow-Based Chronolocator",
+    "category": "chronolocation",
+    "difficulty": 3,
+    "language": "python",
+    "description": "Write a Python tool that estimates the time a photo was taken based on shadow analysis. Given an image with a shadow and the known height of the object casting it, plus the GPS coordinates of the location, calculate the sun elevation angle from the shadow length, then use the ephem library to determine what time of day produces that sun angle at those coordinates for a given date range. Output: estimated time window (UTC), sun azimuth, and a confidence range. Handle edge cases: no shadow visible, circumpolar conditions, multiple possible times per day."
+  },
+  {
+    "id": 2,
+    "name": "Evidence Archiver & Hasher",
+    "category": "preservation",
+    "difficulty": 2,
+    "language": "python",
+    "description": "Write a Python tool for preserving digital evidence with chain-of-custody integrity. Given a URL, download the full page content (HTML + images + embedded media), compute SHA-256 hashes of every artifact, generate a timestamped manifest file (JSON) listing each file with its hash, size, and download timestamp. Save a WARC-like archive bundle. Include a verify command that re-hashes all files against the manifest and reports any tampering. Use requests for download, hashlib for hashing. Support batch mode from a list of URLs in a text file."
+  },
+  {
+    "id": 3,
+    "name": "Geolocation Clue Extractor",
+    "category": "geolocation",
+    "difficulty": 4,
+    "language": "python",
+    "description": "Write a Python module that analyzes an image to extract geolocation clues. Use Pillow and basic image processing to: (1) detect and extract any visible text (signs, billboards) using contour detection and OCR-ready cropping, (2) identify dominant vegetation color profiles that suggest climate zones (tropical vs temperate vs arid), (3) detect road marking patterns (solid/dashed, color) and estimate driving side (left/right), (4) extract any visible license plate region for format analysis. Output a structured JSON report with each clue type, the extracted data, and a suggested region. Do NOT use cloud APIs — all processing must be local using Pillow and numpy only."
+  },
+  {
+    "id": 4,
+    "name": "Multi-Source Cross-Referencing Engine",
+    "category": "verification",
+    "difficulty": 5,
+    "language": "python",
+    "description": "Write a Python tool that cross-references a claim across multiple data sources and produces a verification score. Given a structured claim (JSON with: what, where, when, who), query multiple simulated data feeds (each represented as a JSON file): news_feed.json, social_media.json, satellite_log.json, official_records.json. For each source, search for corroborating or contradicting entries using fuzzy string matching (difflib). Calculate a verification score: each independent corroboration adds weight, contradictions subtract, source reliability weights apply. Output a structured verdict with score, supporting evidence list, contradicting evidence list, and gaps (sources with no relevant data). Include a function to generate a concise verification summary."
+  },
+  {
+    "id": 5,
+    "name": "Flight Path Reconstructor",
+    "category": "transportation",
+    "difficulty": 3,
+    "language": "python",
+    "description": "Write a Python tool that reconstructs a flight path from ADS-B transponder data. Given a CSV file with columns: timestamp, icao24, callsign, latitude, longitude, altitude, velocity, heading — filter by a specific aircraft (icao24 or callsign), interpolate gaps in position data using linear interpolation, compute total distance traveled (haversine formula), detect takeoff and landing events (altitude thresholds), and identify any holding patterns (repeated circular paths). Output: a GeoJSON LineString of the flight path, a summary JSON with departure/arrival timestamps, total distance, max altitude, and any detected anomalies (sudden altitude changes, course reversals, transponder gaps longer than N minutes)."
+  },
+  {
+    "id": 6,
+    "name": "Satellite Change Detector",
+    "category": "satellite_imagery",
+    "difficulty": 4,
+    "language": "python",
+    "description": "Write a Python tool that detects changes between two satellite images of the same area taken at different times. Given two images (before.png, after.png) that are already aligned, compute: (1) pixel-level difference map with configurable sensitivity threshold, (2) connected component analysis to identify distinct change regions, (3) bounding boxes and area (in pixels) for each detected change region, (4) classification of change type based on color shift (new construction=gray, vegetation loss=brown, water change=blue). Output a JSON report listing each change region with its bounding box, area, change type, and confidence. Save a visualization image highlighting changes with colored overlays. Use numpy and Pillow only."
+  },
+  {
+    "id": 7,
+    "name": "Social Media Timeline Reconstructor",
+    "category": "social_media",
+    "difficulty": 3,
+    "language": "python",
+    "description": "Write a Python tool that reconstructs a timeline of events from a collection of social media posts. Given a JSON array of posts (each with: platform, username, timestamp, text, location, media_urls, engagement_count), sort chronologically, detect clusters of posts about the same event (using keyword overlap and time proximity within a configurable window), merge clusters into unified events with earliest/latest timestamps, extract key entities (locations, names, organizations) using regex patterns, and build a timeline JSON with events sorted by time, each containing: time_range, summary of merged posts, locations mentioned, sources (list of original posts), and a thread showing how the narrative evolved. Include duplicate detection by text similarity."
+  },
+  {
+    "id": 8,
+    "name": "Network Graph Builder",
+    "category": "analysis",
+    "difficulty": 3,
+    "language": "python",
+    "description": "Write a Python tool that builds relationship network graphs from structured investigation data. Given a JSON file of entities (people, organizations, locations, accounts) and a JSON file of connections (entity_a, entity_b, relationship_type, evidence_source, confidence), build an adjacency representation, compute: degree centrality for each node, identify bridge nodes (removal disconnects the graph), find shortest paths between any two entities, detect communities using a simple label propagation algorithm. Output: a full analysis JSON with ranked nodes by centrality, identified communities, bridge nodes, and for a given pair of entities, the shortest connection path with all intermediate relationships. Use only standard library (no networkx)."
+  },
+  {
+    "id": 9,
+    "name": "Coordinate Grid Search Generator",
+    "category": "geolocation",
+    "difficulty": 2,
+    "language": "python",
+    "description": "Write a Python tool that generates a systematic search grid for satellite imagery analysis. Given a center coordinate (lat, lon), a search radius in kilometers, and a grid cell size in meters, generate a grid of bounding boxes covering the search area. For each cell, output: cell_id, center coordinate, corner coordinates, and a URL template for common tile servers (formatted for OpenStreetMap tile coordinates at a given zoom level). Support both square and hexagonal grid patterns. Output as GeoJSON FeatureCollection where each feature is a grid cell polygon. Include a progress tracker that marks cells as searched/unsearched in a companion JSON state file, so searches can be resumed."
+  },
+  {
+    "id": 10,
+    "name": "Metadata Consistency Checker",
+    "category": "verification",
+    "difficulty": 3,
+    "language": "python",
+    "description": "Write a Python tool that checks metadata consistency across a set of media files to detect potential manipulation or misattribution. Given a directory of images, extract EXIF data from each using Pillow, then cross-check: (1) do GPS coordinates match the claimed location (within a radius)? (2) do timestamps fall within the claimed time range? (3) are all images from the same camera make/model? (4) are there any timestamp sequence anomalies (out-of-order, impossible gaps, duplicate timestamps)? (5) do any images have stripped or inconsistent EXIF patterns suggesting editing? Output a structured JSON report flagging each inconsistency with severity (info/warning/critical), the affected files, and what specifically doesn't match."
+  },
+  {
+    "id": 11,
+    "name": "Open Corporate Registry Parser",
+    "category": "corporate_investigation",
+    "difficulty": 3,
+    "language": "python",
+    "description": "Write a Python tool that parses and cross-references company records from structured data sources. Given a JSON file of company records (each with: company_name, registration_number, jurisdiction, directors, registered_address, filing_dates, status), build a search interface that can: (1) find all companies sharing a director name (fuzzy match), (2) find all companies at the same registered address, (3) detect director networks (people who sit on multiple boards together), (4) flag companies with suspicious patterns (registered same day at same address, very recent creation, dormant status). Output: a risk assessment JSON for each company with flags and connections discovered. Include a function that generates a plain-text investigation summary."
+  },
+  {
+    "id": 12,
+    "name": "Misinformation Pattern Detector",
+    "category": "verification",
+    "difficulty": 4,
+    "language": "python",
+    "description": "Write a Python tool that identifies potential misinformation patterns in a stream of social media posts. Given a JSON array of posts with (id, timestamp, text, source, share_count, reply_to), detect: (1) copy-paste campaigns — near-identical text appearing from different accounts within a short time window, (2) coordinated amplification — unusual spikes in share_count from accounts that regularly amplify each other, (3) narrative injection — new claims that suddenly appear and are rapidly shared with no prior discussion, (4) source concentration — claims that trace back to a single original post but appear to come from many independent sources. Score each detected pattern with confidence and evidence. Output a structured JSON report with each detected pattern, the involved posts, the detection method, and confidence score."
+  },
+  {
+    "id": 13,
+    "name": "Haversine Distance Matrix Builder",
+    "category": "geolocation",
+    "difficulty": 2,
+    "language": "python",
+    "description": "Write a Python tool that computes a distance matrix between a set of geographic points and identifies spatial patterns. Given a JSON array of named locations (name, lat, lon, timestamp), compute all pairwise haversine distances, identify clusters of points within a configurable radius, determine the geographic centroid of each cluster, calculate the convex hull area of the full point set, and detect travel sequences (ordered by timestamp) that would require impossible speeds (above a configurable threshold). Output: distance matrix as CSV, cluster assignments JSON, travel analysis with flagged impossible movements, and an overall spatial summary."
+  },
+  {
+    "id": 14,
+    "name": "Webpage Diff Monitor",
+    "category": "monitoring",
+    "difficulty": 3,
+    "language": "python",
+    "description": "Write a Python tool that monitors web pages for changes and preserves snapshots. Given a JSON config with a list of URLs and check_interval_minutes, the tool stores a SQLite database of page snapshots (url, timestamp, content_hash, content). On each check: fetch the page, compute content hash, compare with latest stored version, if changed: store new snapshot, compute a text diff (unified diff format) between old and new content, and log the change. Provide commands: 'check' (run one check cycle), 'history <url>' (show all snapshots with timestamps), 'diff <url> <id1> <id2>' (show diff between two snapshots), 'report' (summary of all monitored URLs and their change frequency). Use requests, hashlib, difflib, sqlite3."
+  },
+  {
+    "id": 15,
+    "name": "Investigation Case File Manager",
+    "category": "reporting",
+    "difficulty": 4,
+    "language": "python",
+    "description": "Write a Python tool that manages a structured investigation case file. A case contains: entities (people, orgs, locations, accounts), evidence items (files with metadata, hash, source URL, collection timestamp, notes), timeline events (what, when, where, sources, confidence), hypotheses (claim, supporting evidence IDs, contradicting evidence IDs, status). Store everything in SQLite. Support commands: 'add_entity', 'add_evidence', 'add_event', 'add_hypothesis', 'link' (connect evidence to events/entities), 'timeline' (print chronological timeline), 'matrix' (show evidence-hypothesis support matrix), 'export' (generate a structured JSON case file with all data and relationships), 'gaps' (identify timeline gaps, unsupported hypotheses, unlinked evidence). Include chain-of-custody tracking: every modification logged with timestamp and description."
+  }
+]

code_whitelist.py

@@ -0,0 +1,750 @@
+"""
+MULTI-LANGUAGE CODE WHITELIST
+==============================
+Comprehensive safe-patterns whitelist for code generation and validation.
+Covers: Python, C#, C++, JavaScript/TypeScript, Java, Go, Rust.
+
+Two layers:
+  1. BLOCKLIST  — patterns that must NEVER appear in generated code
+  2. WHITELIST  — known-safe standard library calls, patterns, and modules
+
+Usage:
+  from code_whitelist import validate_code, get_safe_patterns, LANGUAGES
+
+  result = validate_code(code, language="python")
+  # result = {"safe": True/False, "blocked": [...], "warnings": [...]}
+
+  patterns = get_safe_patterns("csharp")
+  # returns dict of safe modules, functions, patterns for that language
+"""
+
+import re
+from dataclasses import dataclass, field
+from typing import Optional
+
+# ══════════════════════════════════════════════════════════════════════════════
+# SUPPORTED LANGUAGES
+# ══════════════════════════════════════════════════════════════════════════════
+
+LANGUAGES = ["python", "csharp", "cpp", "javascript", "typescript", "java", "go", "rust"]
+
+# ══════════════════════════════════════════════════════════════════════════════
+# UNIVERSAL BLOCKLIST — dangerous patterns across ALL languages
+# ══════════════════════════════════════════════════════════════════════════════
+
+UNIVERSAL_BLOCKS = {
+    "shell_injection": [
+        r'\bos\.system\b',
+        r'\bos\.popen\b',
+        r'\bsubprocess\.call\b(?!\(.*shell\s*=\s*False)',
+        r'Runtime\.getRuntime\(\)\.exec\b',
+        r'\bProcess\.Start\b',
+        r'\bsystem\s*\(',
+        r'\bexecvp?\b\s*\(',
+        r'\bpopen\s*\(',
+        r'child_process\.exec\b(?!File)',
+        r'\bexec\.Command\b',  # Go — flag for review, not always bad
+    ],
+    "code_injection": [
+        r'\beval\s*\(',
+        r'\bexec\s*\(',
+        r'__import__\s*\(',
+        r'\bFunction\s*\(',         # JS new Function()
+        r'setTimeout\s*\(\s*["\']', # JS string-based setTimeout
+        r'setInterval\s*\(\s*["\']',
+        r'\bCompile\s*\(.*\)\.Run',  # C# dynamic compilation
+    ],
+    "file_destruction": [
+        r'shutil\.rmtree\s*\(',
+        r'\.unlink\s*\(',
+        r'\brm\s+-rf\b',
+        r'Directory\.Delete\s*\(.*true',
+        r'removeSync\s*\(',
+        r'os\.RemoveAll\s*\(',
+        r'std::filesystem::remove_all\b',
+    ],
+    "sql_injection": [
+        r'f["\'].*SELECT.*FROM.*\{',    # Python f-string SQL
+        r'f["\'].*INSERT.*INTO.*\{',
+        r'f["\'].*UPDATE.*SET.*\{',
+        r'f["\'].*DELETE.*FROM.*\{',
+        r'\+\s*["\'].*SELECT',           # String concat SQL
+        r'format!\s*\(.*SELECT',          # Rust format! SQL
+        r'fmt\.Sprintf\s*\(.*SELECT',     # Go sprintf SQL
+        r'String\.Format\s*\(.*SELECT',   # C# string.Format SQL
+    ],
+    "xss_risk": [
+        r'innerHTML\s*=',
+        r'document\.write\s*\(',
+        r'\.outerHTML\s*=',
+        r'dangerouslySetInnerHTML',
+    ],
+    "crypto_misuse": [
+        r'\bMD5\b',
+        r'\bSHA1\b(?!_)',
+        r'\bDES\b',
+        r'\bRC4\b',
+        r'random\.random\(\).*(?:password|key|token|secret)',
+        r'Math\.random\(\).*(?:password|key|token|secret)',
+    ],
+    "hardcoded_secrets": [
+        r'(?:password|secret|api_key|token)\s*=\s*["\'][^"\']{8,}["\']',
+    ],
+}
+
+# ══════════════════════════════════════════════════════════════════════════════
+# PER-LANGUAGE BLOCKLISTS
+# ══════════════════════════════════════════════════════════════════════════════
+
+LANGUAGE_BLOCKS = {
+    "python": [
+        r'\bpickle\.loads?\b',           # Arbitrary code execution via deserialization
+        r'\byaml\.load\b(?!\(.*Loader)',  # Unsafe YAML load
+        r'\bmarshal\.loads?\b',
+        r'__builtins__',
+        r'\bglobals\s*\(\)',
+        r'\bcompile\s*\(',
+    ],
+    "csharp": [
+        r'SqlCommand\s*\(.*\+',         # String concat SQL  
+        r'BinaryFormatter',              # Insecure deserialization
+        r'Process\.Start\s*\(',
+        r'\bunsafe\b',                   # unsafe code blocks
+        r'DllImport',                    # P/Invoke — flag for review
+        r'Assembly\.Load\b',
+    ],
+    "cpp": [
+        r'\bgets\s*\(',                  # Buffer overflow
+        r'\bstrcpy\s*\(',               # No bounds checking
+        r'\bstrcat\s*\(',               # No bounds checking
+        r'\bsprintf\s*\(',             # Use snprintf instead
+        r'\bmalloc\b.*\bfree\b',       # Flag raw malloc (prefer smart ptrs)
+        r'#pragma\s+warning\s*\(\s*disable',
+        r'\breinterpret_cast\b',
+        r'\bvoid\s*\*',                # Void pointers — flag for review
+    ],
+    "javascript": [
+        r'require\s*\(\s*["\']child_process',
+        r'\.call\s*\(.*arguments\b',
+        r'with\s*\(',                    # with statement
+        r'document\.cookie\b',
+        r'window\.location\s*=',
+    ],
+    "typescript": [
+        r'as\s+any\b',                  # Type escape hatch — flag
+        r'@ts-ignore',
+        r'require\s*\(\s*["\']child_process',
+        r'document\.cookie\b',
+    ],
+    "java": [
+        r'ObjectInputStream\b',          # Deserialization risk
+        r'Runtime\.exec\b',
+        r'ProcessBuilder\b',
+        r'Class\.forName\s*\(',         # Reflection — flag
+        r'\.getMethod\s*\(',
+        r'Statement\b.*execute\b',       # Raw SQL statements
+    ],
+    "go": [
+        r'os/exec\b',                   # Flag for review
+        r'unsafe\.Pointer\b',
+        r'reflect\.(?:Value|Type)',     # Heavy reflection — flag
+        r'cgo\b',                        # CGo boundary
+    ],
+    "rust": [
+        r'\bunsafe\s*\{',
+        r'std::mem::transmute\b',
+        r'from_raw_parts\b',
+        r'\b\.unwrap\(\)',              # Panics in production — warn
+    ],
+}
+
+# ══════════════════════════════════════════════════════════════════════════════
+# PER-LANGUAGE WHITELISTS — safe standard library modules, functions, patterns
+# ══════════════════════════════════════════════════════════════════════════════
+
+SAFE_PATTERNS = {
+    "python": {
+        "safe_modules": [
+            "collections", "itertools", "functools", "operator",
+            "math", "statistics", "decimal", "fractions",
+            "datetime", "calendar", "time",
+            "json", "csv", "io", "os.path", "pathlib",
+            "re", "string", "textwrap", "unicodedata",
+            "typing", "dataclasses", "enum", "abc",
+            "hashlib", "hmac", "secrets",
+            "logging", "unittest", "pytest",
+            "copy", "pprint", "bisect", "heapq",
+            "contextlib", "weakref",
+            "argparse", "configparser",
+            "sqlite3",  # with parameterized queries
+            "urllib.parse",
+            "base64", "binascii",
+            "struct", "array",
+            "queue", "threading.Lock", "threading.Event",
+            "asyncio", "concurrent.futures",
+        ],
+        "safe_builtins": [
+            "len", "range", "enumerate", "zip", "map", "filter",
+            "sorted", "reversed", "min", "max", "sum", "abs",
+            "all", "any", "isinstance", "issubclass", "type",
+            "int", "float", "str", "bool", "list", "dict", "set", "tuple",
+            "frozenset", "bytes", "bytearray", "memoryview",
+            "print", "input", "repr", "format", "hash", "id",
+            "getattr", "setattr", "hasattr", "delattr",
+            "property", "staticmethod", "classmethod",
+            "super", "iter", "next", "chr", "ord",
+            "round", "divmod", "pow",
+            "open",  # reading only — write mode blocked separately
+        ],
+        "safe_patterns": [
+            "list comprehension",
+            "dict comprehension",
+            "generator expression",
+            "context manager (with statement)",
+            "dataclass",
+            "type hints / annotations",
+            "f-string formatting (non-SQL)",
+            "try/except/finally",
+            "decorator pattern",
+            "property getter/setter",
+            "@functools.lru_cache",
+            "@functools.wraps",
+            "collections.defaultdict",
+            "collections.Counter",
+            "collections.namedtuple",
+            "pathlib.Path operations",
+            "logging.getLogger",
+            "argparse.ArgumentParser",
+            "parameterized SQL queries (?, %s placeholders)",
+        ],
+        "safe_frameworks": [
+            "flask", "fastapi", "django",
+            "requests", "httpx",
+            "sqlalchemy",  # with ORM / parameterized
+            "pydantic",
+            "pytest", "unittest",
+            "numpy", "pandas",
+            "click", "typer",
+        ],
+    },
+
+    "csharp": {
+        "safe_modules": [
+            "System", "System.Collections.Generic", "System.Linq",
+            "System.Text", "System.Text.RegularExpressions",
+            "System.IO", "System.IO.Path",
+            "System.Threading", "System.Threading.Tasks",
+            "System.Net.Http", "System.Net.Http.Json",
+            "System.Text.Json", "System.Text.Json.Serialization",
+            "System.Security.Cryptography",
+            "System.Diagnostics.Debug",
+            "System.ComponentModel.DataAnnotations",
+            "System.Globalization",
+            "System.Math",
+            "Microsoft.Extensions.Logging",
+            "Microsoft.Extensions.DependencyInjection",
+            "Microsoft.Extensions.Configuration",
+            "Microsoft.EntityFrameworkCore",
+        ],
+        "safe_patterns": [
+            "using statement / IDisposable",
+            "async/await with Task",
+            "LINQ queries",
+            "record types",
+            "pattern matching (switch expressions)",
+            "nullable reference types",
+            "string interpolation (non-SQL)",
+            "dependency injection",
+            "ILogger<T>",
+            "parameterized SQL (@param)",
+            "Entity Framework LINQ queries",
+            "try/catch/finally",
+            "readonly / init-only properties",
+            "sealed classes",
+            "interfaces and abstract classes",
+            "generic constraints",
+            "ValueTask for hot paths",
+            "Span<T> / Memory<T>",
+            "IAsyncEnumerable<T>",
+            "CancellationToken",
+        ],
+        "safe_frameworks": [
+            "ASP.NET Core", "Entity Framework Core",
+            "xUnit", "NUnit", "MSTest",
+            "Serilog", "MediatR",
+            "FluentValidation",
+            "AutoMapper",
+            "Polly (resilience)",
+        ],
+    },
+
+    "cpp": {
+        "safe_modules": [
+            "<algorithm>", "<numeric>", "<functional>",
+            "<vector>", "<array>", "<string>", "<string_view>",
+            "<map>", "<unordered_map>", "<set>", "<unordered_set>",
+            "<queue>", "<stack>", "<deque>", "<list>",
+            "<memory>",  # smart pointers
+            "<optional>", "<variant>", "<any>", "<tuple>",
+            "<chrono>", "<cmath>", "<cstdint>",
+            "<iostream>", "<sstream>", "<fstream>",
+            "<regex>", "<filesystem>",
+            "<thread>", "<mutex>", "<condition_variable>",
+            "<atomic>", "<future>",
+            "<stdexcept>", "<cassert>",
+            "<ranges>", "<concepts>",
+            "<format>",  # C++20
+            "<span>",    # C++20
+        ],
+        "safe_patterns": [
+            "std::unique_ptr / std::shared_ptr",
+            "std::make_unique / std::make_shared",
+            "RAII (constructor/destructor pairs)",
+            "range-based for loops",
+            "auto type deduction",
+            "const references (const T&)",
+            "constexpr",
+            "structured bindings (auto [a, b] = ...)",
+            "std::optional for nullable values",
+            "std::string_view for non-owning strings",
+            "std::move semantics",
+            "static_cast (not reinterpret_cast)",
+            "try/catch with std::exception",
+            "std::algorithm (sort, find, transform)",
+            "lambda expressions",
+            "templates and concepts (C++20)",
+            "enum class (scoped enums)",
+            "snprintf instead of sprintf",
+            "std::array instead of C arrays",
+            "std::vector instead of raw new[]",
+        ],
+        "safe_libraries": [
+            "Boost (selected modules)",
+            "fmt", "spdlog",
+            "Catch2", "Google Test",
+            "nlohmann/json",
+            "abseil-cpp",
+        ],
+    },
+
+    "javascript": {
+        "safe_modules": [
+            "Array", "Object", "Map", "Set", "WeakMap", "WeakSet",
+            "Promise", "JSON", "Math", "Date", "RegExp",
+            "String", "Number", "Symbol", "BigInt",
+            "URL", "URLSearchParams",
+            "TextEncoder", "TextDecoder",
+            "structuredClone",
+            "console",
+            "fetch",
+            "AbortController",
+            "crypto.subtle",      # Web Crypto API
+            "crypto.randomUUID",
+        ],
+        "safe_node_modules": [
+            "path", "url", "util", "events",
+            "crypto",  # Node crypto
+            "fs/promises",  # async file ops
+            "stream", "buffer",
+            "assert", "test",  # Node test runner
+            "zlib", "querystring",
+        ],
+        "safe_patterns": [
+            "const / let (no var)",
+            "arrow functions",
+            "template literals (non-SQL)",
+            "destructuring (object / array)",
+            "spread / rest operators",
+            "Promise.all / Promise.allSettled",
+            "async/await",
+            "optional chaining (?.) ",
+            "nullish coalescing (??)",
+            "Array methods (map, filter, reduce, find, some, every)",
+            "Object.entries / Object.keys / Object.values",
+            "try/catch/finally",
+            "class syntax",
+            "modules (import/export)",
+            "for...of loops",
+            "Map/Set for collections",
+            "structuredClone for deep copy",
+            "fetch with AbortController",
+            "parameterized queries (prepared statements)",
+        ],
+        "safe_frameworks": [
+            "React", "Vue", "Svelte",
+            "Express (with helmet, cors)",
+            "Fastify",
+            "Jest", "Vitest", "Mocha",
+            "Zod (validation)",
+            "Prisma (ORM)",
+            "TypeORM", "Knex",
+        ],
+    },
+
+    "typescript": {
+        "inherits": "javascript",
+        "safe_patterns": [
+            "strict mode (strict: true in tsconfig)",
+            "interface definitions",
+            "type aliases",
+            "generic types",
+            "discriminated unions",
+            "type guards (is / in / typeof / instanceof)",
+            "readonly modifier",
+            "Record<K, V> / Partial<T> / Required<T>",
+            "Pick<T, K> / Omit<T, K>",
+            "unknown over any",
+            "satisfies operator",
+            "const assertions (as const)",
+            "enum (prefer const enum or union types)",
+            "Zod / io-ts for runtime validation",
+        ],
+    },
+
+    "java": {
+        "safe_modules": [
+            "java.util.*",
+            "java.util.stream.*",
+            "java.util.concurrent.*",
+            "java.util.function.*",
+            "java.time.*",
+            "java.math.*",
+            "java.lang.Math",
+            "java.lang.String",
+            "java.lang.StringBuilder",
+            "java.io.BufferedReader", "java.io.BufferedWriter",
+            "java.nio.file.Path", "java.nio.file.Files",
+            "java.security.MessageDigest",
+            "java.security.SecureRandom",
+            "java.text.MessageFormat",
+            "java.util.logging.*",
+            "java.util.regex.*",
+            "java.net.URI", "java.net.http.HttpClient",
+        ],
+        "safe_patterns": [
+            "try-with-resources",
+            "Optional<T>",
+            "Stream API (map, filter, collect, reduce)",
+            "records (Java 14+)",
+            "sealed classes (Java 17+)",
+            "pattern matching for instanceof (Java 16+)",
+            "switch expressions (Java 14+)",
+            "text blocks (Java 15+)",
+            "var (local variable type inference)",
+            "CompletableFuture",
+            "PreparedStatement (parameterized SQL)",
+            "Collections.unmodifiableList / List.of / Map.of",
+            "interface default methods",
+            "lambda expressions",
+            "method references (::)",
+            "enum with methods",
+            "builder pattern",
+            "dependency injection (@Inject)",
+        ],
+        "safe_frameworks": [
+            "Spring Boot", "Spring Security",
+            "JUnit 5", "Mockito", "AssertJ",
+            "Jackson", "Gson",
+            "SLF4J / Logback",
+            "Hibernate / JPA",
+            "Lombok",
+            "MapStruct",
+        ],
+    },
+
+    "go": {
+        "safe_modules": [
+            "fmt", "strings", "strconv", "unicode",
+            "math", "math/big", "math/rand",
+            "sort", "slices",  # Go 1.21+
+            "maps",            # Go 1.21+
+            "errors", "log", "log/slog",
+            "io", "bufio", "bytes",
+            "os", "path", "path/filepath",
+            "encoding/json", "encoding/csv", "encoding/base64",
+            "net/http", "net/url",
+            "context",
+            "sync", "sync/atomic",
+            "time",
+            "regexp",
+            "crypto/sha256", "crypto/hmac", "crypto/rand",
+            "testing",
+            "embed",
+            "database/sql",  # with parameterized queries
+        ],
+        "safe_patterns": [
+            "error handling (if err != nil)",
+            "defer for cleanup",
+            "goroutines with sync.WaitGroup",
+            "channels for communication",
+            "select statement",
+            "context.Context for cancellation",
+            "interfaces (implicit satisfaction)",
+            "struct embedding (composition)",
+            "table-driven tests",
+            "functional options pattern",
+            "type assertions with ok check",
+            "range loops",
+            "iota for enums",
+            "init() functions",
+            "database/sql with $1 or ? placeholders",
+            "http.HandlerFunc / middleware chain",
+            "slog structured logging",
+            "generics (Go 1.18+)",
+        ],
+        "safe_frameworks": [
+            "Gin", "Chi", "Echo",
+            "GORM", "sqlx",
+            "testify",
+            "Wire (DI)",
+            "Cobra (CLI)",
+            "Viper (config)",
+        ],
+    },
+
+    "rust": {
+        "safe_modules": [
+            "std::collections (HashMap, BTreeMap, Vec, VecDeque, HashSet)",
+            "std::string::String",
+            "std::vec::Vec",
+            "std::io (Read, Write, BufReader, BufWriter)",
+            "std::fs",
+            "std::path (Path, PathBuf)",
+            "std::fmt",
+            "std::iter",
+            "std::convert (From, Into, TryFrom, TryInto)",
+            "std::ops",
+            "std::cmp (Ordering, min, max)",
+            "std::time (Duration, Instant)",
+            "std::thread",
+            "std::sync (Arc, Mutex, RwLock, mpsc)",
+            "std::error::Error",
+            "std::result::Result",
+            "std::option::Option",
+            "std::num",
+        ],
+        "safe_patterns": [
+            "ownership and borrowing",
+            "pattern matching (match)",
+            "Result<T, E> for error handling",
+            "Option<T> for nullable values",
+            "? operator for error propagation",
+            "impl blocks and traits",
+            "derive macros (#[derive(Debug, Clone, PartialEq)])",
+            "iterators (.map, .filter, .collect, .fold)",
+            "closures (|x| ...)",
+            "enum with data variants",
+            "struct with impl",
+            "lifetime annotations where needed",
+            "Arc<Mutex<T>> for shared state",
+            "async/await with tokio",
+            "type aliases",
+            "const generics",
+            "builder pattern",
+            "#[cfg(test)] mod tests",
+        ],
+        "safe_crates": [
+            "serde / serde_json",
+            "tokio / async-std",
+            "reqwest",
+            "clap (CLI)",
+            "anyhow / thiserror",
+            "tracing / log",
+            "sqlx",
+            "axum / actix-web / warp",
+            "rand",
+        ],
+    },
+}
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# VALIDATION ENGINE
+# ══════════════════════════════════════════════════════════════════════════════
+
+@dataclass
+class ValidationResult:
+    safe: bool
+    language: str
+    blocked: list[str] = field(default_factory=list)
+    warnings: list[str] = field(default_factory=list)
+    score: float = 100.0  # 100 = perfectly safe, 0 = dangerous
+
+
+def _check_blocks(code: str, patterns: list, category: str,
+                  severity: str = "block") -> tuple[list[str], list[str]]:
+    """Check code against a list of regex patterns. Returns (blocks, warnings)."""
+    blocks = []
+    warnings = []
+    for pattern in patterns:
+        if re.search(pattern, code, re.IGNORECASE):
+            msg = f"[{category}] matched: {pattern}"
+            if severity == "block":
+                blocks.append(msg)
+            else:
+                warnings.append(msg)
+    return blocks, warnings
+
+
+def validate_code(code: str, language: str = "python") -> ValidationResult:
+    """
+    Validate code against blocklist and whitelist.
+    Returns a ValidationResult with safety assessment.
+    """
+    language = language.lower().strip()
+    if language in ("ts", "tsx"):
+        language = "typescript"
+    elif language in ("js", "jsx"):
+        language = "javascript"
+    elif language in ("cs", "c#"):
+        language = "csharp"
+    elif language in ("c++", "cc", "cxx", "hpp"):
+        language = "cpp"
+    elif language in ("rs",):
+        language = "rust"
+    elif language in ("py",):
+        language = "python"
+
+    result = ValidationResult(safe=True, language=language)
+
+    # 1. Check universal blocklist
+    for category, patterns in UNIVERSAL_BLOCKS.items():
+        blocks, warnings = _check_blocks(code, patterns, category)
+        result.blocked.extend(blocks)
+        result.warnings.extend(warnings)
+
+    # 2. Check language-specific blocklist
+    lang_blocks = LANGUAGE_BLOCKS.get(language, [])
+    blocks, warnings = _check_blocks(code, lang_blocks, f"{language}_specific")
+    result.blocked.extend(blocks)
+    result.warnings.extend(warnings)
+
+    # 3. For TypeScript, also check JavaScript blocks
+    if language == "typescript":
+        js_blocks = LANGUAGE_BLOCKS.get("javascript", [])
+        blocks, warnings = _check_blocks(code, js_blocks, "javascript_specific")
+        result.blocked.extend(blocks)
+        result.warnings.extend(warnings)
+
+    # 4. Calculate safety score
+    result.score = max(0, 100 - (len(result.blocked) * 25) - (len(result.warnings) * 5))
+    result.safe = len(result.blocked) == 0
+
+    return result
+
+
+def get_safe_patterns(language: str) -> dict:
+    """Get the whitelist of safe patterns for a specific language."""
+    language = language.lower().strip()
+    alias_map = {
+        "ts": "typescript", "tsx": "typescript",
+        "js": "javascript", "jsx": "javascript",
+        "cs": "csharp", "c#": "csharp",
+        "c++": "cpp", "cc": "cpp", "cxx": "cpp",
+        "rs": "rust", "py": "python",
+    }
+    language = alias_map.get(language, language)
+
+    patterns = SAFE_PATTERNS.get(language, {})
+
+    # TypeScript inherits JavaScript patterns
+    if language == "typescript" and patterns.get("inherits") == "javascript":
+        js_patterns = SAFE_PATTERNS.get("javascript", {})
+        merged = {**js_patterns, **patterns}
+        del merged["inherits"]
+        return merged
+
+    return patterns
+
+
+def get_blocklist(language: str) -> dict:
+    """Get all blocked patterns (universal + language-specific) for a language."""
+    language = language.lower().strip()
+    alias_map = {
+        "ts": "typescript", "tsx": "typescript",
+        "js": "javascript", "jsx": "javascript",
+        "cs": "csharp", "c#": "csharp",
+        "c++": "cpp", "cc": "cpp", "cxx": "cpp",
+        "rs": "rust", "py": "python",
+    }
+    language = alias_map.get(language, language)
+
+    return {
+        "universal": UNIVERSAL_BLOCKS,
+        "language_specific": LANGUAGE_BLOCKS.get(language, []),
+    }
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# CLI — quick testing
+# ══════════════════════════════════════════════════════════════════════════════
+
+if __name__ == "__main__":
+    import sys
+
+    # Demo: validate some sample code
+    test_samples = {
+        "python_safe": (
+            "python",
+            'from collections import Counter\ndata = Counter([1,2,3,1,2,1])\nprint(data.most_common())'
+        ),
+        "python_dangerous": (
+            "python",
+            'import os\nos.system("rm -rf /")\neval(input())'
+        ),
+        "csharp_safe": (
+            "csharp",
+            'using System.Linq;\nvar nums = new[] {1,2,3};\nvar sum = nums.Sum();'
+        ),
+        "csharp_dangerous": (
+            "csharp",
+            'var cmd = new SqlCommand("SELECT * FROM users WHERE id=" + userId);'
+        ),
+        "cpp_safe": (
+            "cpp",
+            '#include <vector>\n#include <algorithm>\nauto v = std::vector{3,1,2};\nstd::sort(v.begin(), v.end());'
+        ),
+        "cpp_dangerous": (
+            "cpp",
+            'char buf[10];\ngets(buf);\nstrcpy(dest, src);'
+        ),
+        "js_safe": (
+            "javascript",
+            'const items = [1,2,3];\nconst doubled = items.map(x => x * 2);\nconsole.log(doubled);'
+        ),
+        "js_dangerous": (
+            "javascript",
+            'const code = req.body.code;\neval(code);\ndocument.innerHTML = userInput;'
+        ),
+        "sql_injection": (
+            "python",
+            'query = f"SELECT * FROM users WHERE name = \'{user_input}\'"'
+        ),
+    }
+
+    print("=" * 70)
+    print("MULTI-LANGUAGE CODE WHITELIST — Validation Demo")
+    print("=" * 70)
+
+    for name, (lang, code) in test_samples.items():
+        result = validate_code(code, lang)
+        status = "SAFE" if result.safe else "BLOCKED"
+        print(f"\n[{status}] {name} ({lang}) — score: {result.score}")
+        if result.blocked:
+            for b in result.blocked:
+                print(f"  BLOCK: {b}")
+        if result.warnings:
+            for w in result.warnings:
+                print(f"  WARN:  {w}")
+
+    print(f"\n{'=' * 70}")
+    print(f"Supported languages: {', '.join(LANGUAGES)}")
+    print(f"Universal block categories: {len(UNIVERSAL_BLOCKS)}")
+    total_blocks = sum(len(v) for v in LANGUAGE_BLOCKS.values())
+    print(f"Language-specific block patterns: {total_blocks}")
+    total_safe = sum(
+        sum(len(v) for v in lang.values() if isinstance(v, list))
+        for lang in SAFE_PATTERNS.values()
+        if isinstance(lang, dict)
+    )
+    print(f"Safe patterns/modules catalogued: {total_safe}")

growth_engine.py

@@ -0,0 +1,995 @@
+"""
+GROWTH ENGINE
+=============
+The wrapper that makes the system permanently smarter with every problem.
+
+Every task solved — pass or fail — teaches the system something.
+Nothing is wasted. Every failure is a lesson stored forever.
+Every success is a pattern extracted and reused.
+
+Four learning layers:
+  1. MEMORY        — persistent storage of every attempt, forever
+  2. PATTERN LIB   — distilled reusable solutions from winning code
+  3. SOURCE TRUST  — which references produce good code, scored over time
+  4. CALIBRATION   — tracks when the AI lies to itself about confidence
+
+This sits above reflection_engine.py.
+The reflection engine handles one task.
+This handles everything the system learns from every task ever run.
+
+Usage:
+  python growth_engine.py "write a function that does X"
+  python growth_engine.py --stats          (show what it has learned)
+  python growth_engine.py --patterns       (show pattern library)
+"""
+
+import sqlite3
+import json
+import re
+import sys
+import os
+import time
+import hashlib
+import requests
+from datetime import datetime
+from dataclasses import dataclass, asdict
+from typing import Optional
+
+# Import the brain
+sys.path.insert(0, os.path.dirname(__file__))
+from reflection_engine import (
+    run_engine, CodeAttempt, ollama,
+    BENCHMARK_FLOOR, MODEL,
+    set_language, get_language, _LANG_CONFIG
+)
+from trust_balance_agent import apply_trust_before_run
+from model_manager import _get_active_model, scan_and_register, print_status as model_status
+
+# ── Config ─────────────────────────────────────────────────────────────────────
+
+DB_PATH = os.environ.get("GROWTH_DB_PATH", os.path.join(os.path.dirname(__file__), "growth_memory.db"))
+MAX_CONTEXT_PATTERNS  = 5    # how many past patterns to inject per task
+MAX_CONTEXT_FAILURES  = 3    # how many past failure lessons to inject
+
+# ── Database setup ─────────────────────────────────────────────────────────────
+
+def get_db() -> sqlite3.Connection:
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def init_db():
+    """Create all tables if they don't exist."""
+    conn = get_db()
+    c = conn.cursor()
+
+    # Every task ever run
+    c.execute("""
+        CREATE TABLE IF NOT EXISTS task_history (
+            id            INTEGER PRIMARY KEY AUTOINCREMENT,
+            task_hash     TEXT NOT NULL,
+            task          TEXT NOT NULL,
+            timestamp     TEXT NOT NULL,
+            final_score   REAL,
+            passed        INTEGER,
+            iterations    INTEGER,
+            final_code    TEXT,
+            lessons       TEXT,
+            task_category TEXT
+        )
+    """)
+
+    # Distilled reusable patterns from winning code
+    c.execute("""
+        CREATE TABLE IF NOT EXISTS pattern_library (
+            id            INTEGER PRIMARY KEY AUTOINCREMENT,
+            pattern_hash  TEXT UNIQUE NOT NULL,
+            pattern_name  TEXT NOT NULL,
+            description   TEXT,
+            code_template TEXT,
+            use_cases     TEXT,
+            score_when_used REAL DEFAULT 0,
+            times_used    INTEGER DEFAULT 0,
+            times_helped  INTEGER DEFAULT 0,
+            created_at    TEXT,
+            last_used     TEXT
+        )
+    """)
+
+    # Known failure patterns — what NOT to do
+    c.execute("""
+        CREATE TABLE IF NOT EXISTS failure_library (
+            id            INTEGER PRIMARY KEY AUTOINCREMENT,
+            failure_hash  TEXT UNIQUE NOT NULL,
+            description   TEXT NOT NULL,
+            root_cause    TEXT,
+            fix           TEXT,
+            times_seen    INTEGER DEFAULT 1,
+            last_seen     TEXT
+        )
+    """)
+
+    # Confidence calibration log
+    c.execute("""
+        CREATE TABLE IF NOT EXISTS confidence_log (
+            id              INTEGER PRIMARY KEY AUTOINCREMENT,
+            timestamp       TEXT,
+            stated_confidence REAL,
+            actual_score    REAL,
+            passed          INTEGER,
+            error           REAL  -- abs(stated_confidence*100 - actual_score)
+        )
+    """)
+
+    # Source trust registry
+    c.execute("""
+        CREATE TABLE IF NOT EXISTS source_trust (
+            id            INTEGER PRIMARY KEY AUTOINCREMENT,
+            source_ref    TEXT UNIQUE NOT NULL,
+            trust_score   REAL DEFAULT 50.0,
+            times_cited   INTEGER DEFAULT 0,
+            times_helped  INTEGER DEFAULT 0,
+            times_hurt    INTEGER DEFAULT 0,
+            last_seen     TEXT
+        )
+    """)
+
+    # ── Observation Ledger ──────────────────────────────────────────────
+    # Raw observations accumulate here. Patterns are NOT forced.
+    # Only when the same observation surfaces enough times — honestly,
+    # naturally, across different tasks — does it crystallize into a
+    # pattern. The world is chaotic but patterns exist. They appear
+    # when observed honestly and not forced.
+    c.execute("""
+        CREATE TABLE IF NOT EXISTS observation_ledger (
+            id            INTEGER PRIMARY KEY AUTOINCREMENT,
+            obs_hash      TEXT NOT NULL,
+            observation   TEXT NOT NULL,
+            context       TEXT,
+            domain        TEXT,
+            times_seen    INTEGER DEFAULT 1,
+            first_seen    TEXT,
+            last_seen     TEXT,
+            crystallized  INTEGER DEFAULT 0
+        )
+    """)
+
+    conn.commit()
+    conn.close()
+    print(f"  [OK] Memory database: {DB_PATH}")
+
+
+# ── Layer 1: Memory ────────────────────────────────────────────────────────────
+
+def task_hash(task: str) -> str:
+    return hashlib.md5(task.lower().strip().encode()).hexdigest()[:12]
+
+
+def store_task(task: str, result: CodeAttempt, lessons: dict):
+    """Permanently store this task run — win or lose."""
+    conn = get_db()
+    conn.execute("""
+        INSERT INTO task_history
+        (task_hash, task, timestamp, final_score, passed,
+         iterations, final_code, lessons, task_category)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    """, (
+        task_hash(task),
+        task,
+        datetime.now().isoformat(),
+        result.score,
+        int(result.passed),
+        result.iteration,
+        result.code,
+        json.dumps(lessons),
+        lessons.get("category", "general")
+    ))
+    conn.commit()
+    conn.close()
+
+
+def load_relevant_history(task: str) -> list[dict]:
+    """
+    Find past tasks semantically similar to this one.
+    Simple keyword overlap for now — no embedding needed.
+    """
+    conn = get_db()
+    words = set(re.findall(r'\w+', task.lower())) - {
+        'a','an','the','write','create','build','make','function',
+        'that','with','and','or','for','in','to','of','is','it'
+    }
+
+    if not words:
+        conn.close()
+        return []
+
+    # Score each history item by keyword overlap
+    rows = conn.execute(
+        "SELECT * FROM task_history ORDER BY timestamp DESC LIMIT 100"
+    ).fetchall()
+    conn.close()
+
+    scored = []
+    for row in rows:
+        row_words = set(re.findall(r'\w+', row['task'].lower()))
+        overlap = len(words & row_words) / max(len(words), 1)
+        if overlap > 0.2:
+            scored.append((overlap, dict(row)))
+
+    scored.sort(key=lambda x: x[0], reverse=True)
+    return [r for _, r in scored[:5]]
+
+
+# ── Layer 2: Pattern Library ───────────────────────────────────────────────────
+
+def extract_patterns(task: str, result: CodeAttempt) -> list[dict]:
+    """
+    After a successful run, ask the model to distill
+    reusable patterns from the winning code.
+    """
+    if not result.passed:
+        return []
+
+    print("  📚 Extracting reusable patterns...")
+    lang = get_language()
+    lang_cfg = _LANG_CONFIG.get(lang, _LANG_CONFIG["python"])
+    expert = lang_cfg["expert"]
+    fence = lang_cfg["fence"]
+
+    prompt = f"""You are a senior {expert} building a pattern library.
+
+A task was solved successfully (score: {result.score:.1f}%):
+
+TASK: {task}
+
+WINNING CODE:
+```{fence}
+{result.code}
+```
+
+Extract up to 3 reusable patterns from this code.
+Each pattern should be something that could help solve FUTURE problems.
+
+Respond ONLY with a JSON array (no other text):
+[
+  {{
+    "name": "short pattern name",
+    "description": "what this pattern does and when to use it",
+    "code_template": "the reusable code snippet",
+    "use_cases": "comma-separated list of problem types this helps with"
+  }}
+]"""
+
+    raw = ollama(prompt, temperature=0.2)
+
+    try:
+        raw = re.sub(r'```.*?```', '', raw, flags=re.DOTALL).strip()
+        match = re.search(r'\[.*\]', raw, re.DOTALL)
+        if match:
+            patterns = json.loads(match.group())
+            return patterns[:3]
+    except Exception:
+        pass
+    return []
+
+
+def store_patterns(patterns: list[dict]):
+    """Save extracted patterns to the library."""
+    if not patterns:
+        return
+    conn = get_db()
+    for p in patterns:
+        ph = hashlib.md5(p.get('name','').encode()).hexdigest()[:12]
+        try:
+            conn.execute("""
+                INSERT OR IGNORE INTO pattern_library
+                (pattern_hash, pattern_name, description, code_template,
+                 use_cases, created_at, last_used)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+            """, (
+                ph,
+                p.get('name', 'unnamed'),
+                p.get('description', ''),
+                p.get('code_template', ''),
+                p.get('use_cases', ''),
+                datetime.now().isoformat(),
+                datetime.now().isoformat()
+            ))
+        except Exception:
+            pass
+    conn.commit()
+    conn.close()
+    print(f"  📚 Stored {len(patterns)} pattern(s) to library")
+
+
+def load_relevant_patterns(task: str) -> list[dict]:
+    """Find patterns from the library relevant to this task."""
+    conn = get_db()
+    patterns = conn.execute(
+        "SELECT * FROM pattern_library ORDER BY times_helped DESC, score_when_used DESC LIMIT 20"
+    ).fetchall()
+    conn.close()
+
+    words = set(re.findall(r'\w+', task.lower()))
+    scored = []
+    for p in patterns:
+        p = dict(p)
+        use_words = set(re.findall(r'\w+', (p.get('use_cases','') + ' ' + p.get('description','')).lower()))
+        overlap = len(words & use_words) / max(len(words), 1)
+        if overlap > 0.1:
+            scored.append((overlap, p))
+
+    scored.sort(key=lambda x: x[0], reverse=True)
+    return [p for _, p in scored[:MAX_CONTEXT_PATTERNS]]
+
+
+# ── Observation Ledger ─────────────────────────────────────────────────────────
+# "The world is chaotic but patterns exist. They appear when observed honestly
+#  and not forced. It takes time and patience." — Gordo
+#
+# Raw observations accumulate. Nothing is forced into a pattern immediately.
+# Only when the same insight surfaces across multiple independent tasks does
+# it earn the right to become a pattern. Patience, not speed.
+
+OBSERVATION_CRYSTALLIZE_THRESHOLD = 3  # seen this many times → becomes a pattern
+
+
+def store_observation(task: str, result: CodeAttempt):
+    """
+    After every run, record raw observations — what actually happened.
+    Don't interpret. Don't force. Just observe honestly.
+    """
+    if result.iteration == 0:
+        return  # TALK — nothing to observe
+
+    print("  \U0001f440 Recording raw observations...")
+
+    prompt = f"""You are recording honest observations from a coding task.
+Do NOT generalize. Do NOT force patterns. Just describe what actually happened.
+
+TASK: {task[:300]}
+SCORE: {result.score:.1f}%
+PASSED: {result.passed}
+ITERATIONS: {result.iteration}
+ERRORS: {result.errors[:3] if result.errors else 'none'}
+REFLECTIONS: {result.reflections[:3] if result.reflections else 'none'}
+
+List up to 3 honest, specific observations. Not lessons. Not advice. Just what happened.
+
+Respond ONLY with a JSON array:
+[
+  {{
+    "observation": "what actually happened (factual, specific)",
+    "domain": "the technical domain (e.g., error_handling, architecture, networking, parsing)"
+  }}
+]"""
+
+    raw = ollama(prompt, temperature=0.2)
+
+    try:
+        raw = re.sub(r'```.*?```', '', raw, flags=re.DOTALL).strip()
+        match = re.search(r'\[.*\]', raw, re.DOTALL)
+        if match:
+            observations = json.loads(match.group())[:3]
+        else:
+            return
+    except Exception:
+        return
+
+    conn = get_db()
+    stored = 0
+    for obs in observations:
+        text = obs.get('observation', '').strip()
+        domain = obs.get('domain', 'general').strip()
+        if not text:
+            continue
+        oh = hashlib.md5(text.lower().encode()).hexdigest()[:12]
+
+        existing = conn.execute(
+            "SELECT id, times_seen FROM observation_ledger WHERE obs_hash=?", (oh,)
+        ).fetchone()
+
+        if existing:
+            conn.execute(
+                "UPDATE observation_ledger SET times_seen=?, last_seen=? WHERE obs_hash=?",
+                (existing['times_seen'] + 1, datetime.now().isoformat(), oh)
+            )
+        else:
+            conn.execute("""
+                INSERT INTO observation_ledger
+                (obs_hash, observation, context, domain, first_seen, last_seen)
+                VALUES (?, ?, ?, ?, ?, ?)
+            """, (
+                oh, text, task[:200], domain,
+                datetime.now().isoformat(), datetime.now().isoformat()
+            ))
+        stored += 1
+
+    conn.commit()
+    conn.close()
+    if stored:
+        print(f"  \U0001f440 Recorded {stored} observation(s) — no pattern forced")
+
+
+def crystallize_observations():
+    """
+    Check if any observations have been seen enough times
+    to naturally become a pattern. Patience, not speed.
+    Only called periodically — not after every single task.
+    """
+    conn = get_db()
+    ripe = conn.execute("""
+        SELECT * FROM observation_ledger
+        WHERE times_seen >= ? AND crystallized = 0
+        ORDER BY times_seen DESC
+    """, (OBSERVATION_CRYSTALLIZE_THRESHOLD,)).fetchall()
+
+    if not ripe:
+        conn.close()
+        return
+
+    print(f"\n  \U0001f48e {len(ripe)} observation(s) have surfaced enough times to crystallize...")
+
+    for obs in ripe:
+        obs = dict(obs)
+        # Promote to pattern library
+        ph = hashlib.md5(obs['observation'].encode()).hexdigest()[:12]
+        try:
+            conn.execute("""
+                INSERT OR IGNORE INTO pattern_library
+                (pattern_hash, pattern_name, description, code_template,
+                 use_cases, created_at, last_used)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+            """, (
+                ph,
+                f"[emerged] {obs['domain']}",
+                obs['observation'],
+                '',  # no template — this is an insight, not code
+                obs['domain'],
+                obs['first_seen'],
+                datetime.now().isoformat()
+            ))
+            # Mark as crystallized
+            conn.execute(
+                "UPDATE observation_ledger SET crystallized=1 WHERE id=?",
+                (obs['id'],)
+            )
+            print(f"  \U0001f48e Crystallized: {obs['observation'][:80]}")
+            print(f"     (seen {obs['times_seen']}x across tasks since {obs['first_seen'][:10]})")
+        except Exception:
+            pass
+
+    conn.commit()
+    conn.close()
+
+
+# ── Layer 3: Failure Library ───────────────────────────────────────────────────
+
+def extract_failures(task: str, result: CodeAttempt) -> list[dict]:
+    """
+    Even from a passing run, extract what failed along the way.
+    From a failing run, extract everything we learned.
+    """
+    if result.iteration == 1 and result.passed:
+        return []  # First try success — nothing to learn about failure
+
+    failed_attempts = []
+    if result.errors:
+        failed_attempts = result.errors
+
+    if not failed_attempts and not result.reflections:
+        return []
+
+    print("  ⚠️  Extracting failure lessons...")
+
+    prompt = f"""You are building a failure pattern library to help future code generation avoid mistakes.
+
+TASK: {task}
+ERRORS ENCOUNTERED: {result.errors}
+REFLECTIONS DURING IMPROVEMENT: {result.reflections}
+FINAL SCORE: {result.score:.1f}%
+
+Extract up to 3 distinct failure patterns from this run.
+Be specific — vague lessons are useless.
+
+Respond ONLY with a JSON array:
+[
+  {{
+    "description": "exactly what went wrong",
+    "root_cause": "why it went wrong",
+    "fix": "how to avoid this in future"
+  }}
+]"""
+
+    raw = ollama(prompt, temperature=0.2)
+
+    try:
+        raw = re.sub(r'```.*?```', '', raw, flags=re.DOTALL).strip()
+        match = re.search(r'\[.*\]', raw, re.DOTALL)
+        if match:
+            return json.loads(match.group())[:3]
+    except Exception:
+        pass
+    return []
+
+
+def store_failures(failures: list[dict]):
+    """Store failure patterns — increment count if seen before."""
+    if not failures:
+        return
+    conn = get_db()
+    for f in failures:
+        fh = hashlib.md5(f.get('description','').encode()).hexdigest()[:12]
+        existing = conn.execute(
+            "SELECT id, times_seen FROM failure_library WHERE failure_hash=?", (fh,)
+        ).fetchone()
+        if existing:
+            conn.execute(
+                "UPDATE failure_library SET times_seen=?, last_seen=? WHERE failure_hash=?",
+                (existing['times_seen'] + 1, datetime.now().isoformat(), fh)
+            )
+        else:
+            conn.execute("""
+                INSERT INTO failure_library
+                (failure_hash, description, root_cause, fix, last_seen)
+                VALUES (?, ?, ?, ?, ?)
+            """, (
+                fh,
+                f.get('description',''),
+                f.get('root_cause',''),
+                f.get('fix',''),
+                datetime.now().isoformat()
+            ))
+    conn.commit()
+    conn.close()
+    print(f"  ⚠️  Stored {len(failures)} failure lesson(s)")
+
+
+def load_relevant_failures(task: str) -> list[dict]:
+    """Load the most relevant known failure patterns for this task."""
+    conn = get_db()
+    failures = conn.execute(
+        "SELECT * FROM failure_library ORDER BY times_seen DESC LIMIT 20"
+    ).fetchall()
+    conn.close()
+
+    words = set(re.findall(r'\w+', task.lower()))
+    scored = []
+    for f in failures:
+        f = dict(f)
+        f_words = set(re.findall(r'\w+', (f.get('description','') + ' ' + f.get('root_cause','')).lower()))
+        overlap = len(words & f_words) / max(len(words), 1)
+        scored.append((overlap + (f['times_seen'] * 0.05), f))
+
+    scored.sort(key=lambda x: x[0], reverse=True)
+    return [f for _, f in scored[:MAX_CONTEXT_FAILURES]]
+
+
+# ── Layer 4: Confidence Calibration ───────────────────────────────────────────
+
+def log_confidence(stated: float, actual_score: float, passed: bool):
+    """Track when the model's stated confidence was accurate vs. wrong."""
+    conn = get_db()
+    error = abs((stated * 100) - actual_score)
+    conn.execute("""
+        INSERT INTO confidence_log
+        (timestamp, stated_confidence, actual_score, passed, error)
+        VALUES (?, ?, ?, ?, ?)
+    """, (datetime.now().isoformat(), stated, actual_score, int(passed), error))
+    conn.commit()
+    conn.close()
+
+
+def get_confidence_calibration() -> dict:
+    """
+    How well-calibrated is the model's self-confidence?
+    Returns stats the growth engine uses to adjust prompts.
+    """
+    conn = get_db()
+    rows = conn.execute(
+        "SELECT * FROM confidence_log ORDER BY timestamp DESC LIMIT 50"
+    ).fetchall()
+    conn.close()
+
+    if not rows:
+        return {"avg_error": 0, "overconfident": False, "sample_size": 0}
+
+    errors = [r['error'] for r in rows]
+    avg_error = sum(errors) / len(errors)
+    # If stated confidence > actual score consistently, it's overconfident
+    overconfident = sum(
+        1 for r in rows if (r['stated_confidence'] * 100) > r['actual_score']
+    ) / len(rows) > 0.6
+
+    return {
+        "avg_error": round(avg_error, 1),
+        "overconfident": overconfident,
+        "sample_size": len(rows),
+        "recent_accuracy": round(100 - avg_error, 1)
+    }
+
+
+# ── Context Builder ────────────────────────────────────────────────────────────
+
+def build_growth_context(task: str) -> str:
+    """
+    Assemble everything the system has learned
+    into a context block injected into the first generation prompt.
+    This is how past learning flows into future tasks.
+    """
+    parts = []
+
+    # Relevant patterns
+    patterns = load_relevant_patterns(task)
+    if patterns:
+        parts.append("=== PATTERNS THAT HAVE WORKED BEFORE ===")
+        for p in patterns:
+            parts.append(f"PATTERN: {p['pattern_name']}")
+            parts.append(f"  When to use: {p['description']}")
+            parts.append(f"  Template:\n{p['code_template'][:300]}")
+        parts.append("")
+
+    # Known failures to avoid
+    failures = load_relevant_failures(task)
+    if failures:
+        parts.append("=== KNOWN FAILURE PATTERNS — AVOID THESE ===")
+        for f in failures:
+            seen = f.get('times_seen', 1)
+            parts.append(f"FAILURE (seen {seen}x): {f['description']}")
+            parts.append(f"  Root cause: {f['root_cause']}")
+            parts.append(f"  Fix: {f['fix']}")
+        parts.append("")
+
+    # Similar past tasks
+    history = load_relevant_history(task)
+    if history:
+        parts.append("=== SIMILAR TASKS FROM HISTORY ===")
+        for h in history[:2]:
+            status = "PASSED" if h['passed'] else "failed"
+            parts.append(f"PAST TASK ({status}, score {h['final_score']:.0f}%): {h['task'][:80]}")
+            if h['passed'] and h['final_code']:
+                parts.append(f"  Winning approach snippet:\n{h['final_code'][:200]}")
+        parts.append("")
+
+    # Calibration warning
+    cal = get_confidence_calibration()
+    if cal['sample_size'] > 5 and cal['overconfident']:
+        parts.append(f"=== CALIBRATION WARNING ===")
+        parts.append(f"This system has been overconfident recently (avg error: {cal['avg_error']:.0f}%).")
+        parts.append(f"Be conservative in confidence estimates. Aim higher than you think you need.")
+        parts.append("")
+
+    return "\n".join(parts) if parts else ""
+
+
+# ── Lesson Extractor ───────────────────────────────────────────────────────────
+
+def extract_lessons(task: str, result: CodeAttempt) -> dict:
+    """
+    After every run — win or lose — extract structured lessons.
+    This is the core of the growth loop.
+    """
+    print("\n  🎓 Extracting lessons from this run...")
+
+    prompt = f"""You completed a Python coding task. Extract lessons for future runs.
+
+TASK: {task}
+FINAL SCORE: {result.score:.1f}%
+PASSED: {result.passed}
+ITERATIONS NEEDED: {result.iteration}
+ERRORS: {result.errors}
+
+Answer in JSON only:
+{{
+  "category": "one of: algorithm, data_structure, error_handling, io, math, string, api, testing, optimization, other",
+  "key_lesson": "the single most important thing learned from this run",
+  "what_worked": "what approach succeeded or showed promise",
+  "what_failed": "what approach failed or caused problems",
+  "next_time": "specific advice for the next time a similar task appears",
+  "difficulty": "easy/medium/hard"
+}}"""
+
+    raw = ollama(prompt, temperature=0.2)
+
+    try:
+        raw = re.sub(r'```.*?```', '', raw, flags=re.DOTALL).strip()
+        match = re.search(r'\{.*\}', raw, re.DOTALL)
+        if match:
+            return json.loads(match.group())
+    except Exception:
+        pass
+
+    return {
+        "category": "general",
+        "key_lesson": "task completed",
+        "what_worked": "reflection loop",
+        "what_failed": "n/a",
+        "next_time": "start with edge cases",
+        "difficulty": "medium"
+    }
+
+
+# ── Stats Display ──────────────────────────��───────────────────────────────────
+
+def show_stats():
+    """Print what the system has learned so far."""
+    conn = get_db()
+
+    total    = conn.execute("SELECT COUNT(*) as n FROM task_history").fetchone()['n']
+    passed   = conn.execute("SELECT COUNT(*) as n FROM task_history WHERE passed=1").fetchone()['n']
+    patterns = conn.execute("SELECT COUNT(*) as n FROM pattern_library").fetchone()['n']
+    failures = conn.execute("SELECT COUNT(*) as n FROM failure_library").fetchone()['n']
+    avg_score = conn.execute("SELECT AVG(final_score) as s FROM task_history").fetchone()['s'] or 0
+    avg_iters = conn.execute("SELECT AVG(iterations) as i FROM task_history").fetchone()['i'] or 0
+
+    top_patterns = conn.execute(
+        "SELECT pattern_name, times_helped, description FROM pattern_library ORDER BY times_helped DESC LIMIT 5"
+    ).fetchall()
+
+    top_failures = conn.execute(
+        "SELECT description, times_seen FROM failure_library ORDER BY times_seen DESC LIMIT 5"
+    ).fetchall()
+
+    cal = get_confidence_calibration()
+    conn.close()
+
+    print(f"\n{'='*60}")
+    print(f"  GROWTH ENGINE — WHAT I HAVE LEARNED")
+    print(f"{'='*60}")
+    print(f"\n  Tasks run:        {total}")
+    print(f"  Tasks passed:     {passed} ({(passed/total*100):.0f}%)" if total else "  Tasks passed:     0")
+    print(f"  Avg score:        {avg_score:.1f}%")
+    print(f"  Avg iterations:   {avg_iters:.1f}")
+    print(f"  Patterns learned: {patterns}")
+    print(f"  Failures logged:  {failures}")
+
+    if cal['sample_size'] > 0:
+        print(f"\n  Confidence accuracy: {cal['recent_accuracy']:.1f}%")
+        print(f"  Overconfident:       {'YES ⚠️' if cal['overconfident'] else 'No ✅'}")
+
+    if top_patterns:
+        print(f"\n  TOP PATTERNS:")
+        for p in top_patterns:
+            print(f"    • {p['pattern_name']} — {p['description'][:50]}")
+
+    if top_failures:
+        print(f"\n  MOST COMMON FAILURES:")
+        for f in top_failures:
+            print(f"    • (x{f['times_seen']}) {f['description'][:60]}")
+
+    print(f"\n{'='*60}\n")
+
+
+def show_patterns():
+    """Print the full pattern library."""
+    conn = get_db()
+    patterns = conn.execute(
+        "SELECT * FROM pattern_library ORDER BY times_helped DESC"
+    ).fetchall()
+    conn.close()
+
+    if not patterns:
+        print("\n  No patterns learned yet. Run some tasks first.\n")
+        return
+
+    print(f"\n{'='*60}")
+    print(f"  PATTERN LIBRARY ({len(patterns)} patterns)")
+    print(f"{'='*60}\n")
+
+    for p in patterns:
+        print(f"  [{p['pattern_name']}]")
+        print(f"  {p['description']}")
+        print(f"  Use cases: {p['use_cases']}")
+        print(f"  Times helped: {p['times_helped']}")
+        print(f"  Template preview: {str(p['code_template'])[:100]}...")
+        print()
+
+
+# ── TALK Memory Builder ────────────────────────────────────────────────────────
+
+def _build_talk_memory(task: str) -> str:
+    """Build a memory summary the LLM can reference during conversation."""
+    parts = []
+    conn = get_db()
+
+    # Stats overview
+    tasks_done = conn.execute("SELECT COUNT(*) as n FROM task_history").fetchone()["n"]
+    patterns = conn.execute("SELECT COUNT(*) as n FROM pattern_library").fetchone()["n"]
+    failures = conn.execute("SELECT COUNT(*) as n FROM failure_library").fetchone()["n"]
+    parts.append(f"You have completed {tasks_done} tasks. You know {patterns} coding patterns and {failures} failure lessons.")
+
+    # Recent tasks (last 10)
+    recent = conn.execute(
+        "SELECT task, passed, final_score FROM task_history ORDER BY timestamp DESC LIMIT 10"
+    ).fetchall()
+    if recent:
+        parts.append("\nRecent tasks you completed:")
+        for r in recent:
+            status = "PASSED" if r["passed"] else "FAILED"
+            parts.append(f"  - [{status} {r['final_score']:.0f}%] {r['task'][:100]}")
+
+    # Search for relevant patterns if user asks about something specific
+    words = set(re.findall(r'\w+', task.lower()))
+    stopwords = {'the','a','an','is','are','do','does','can','you','your','i','me','my',
+                 'what','how','why','when','where','it','this','that','about','with','have',
+                 'has','had','was','were','been','be','will','would','could','should'}
+    keywords = words - stopwords
+    if keywords:
+        all_patterns = conn.execute(
+            "SELECT pattern_name, description FROM pattern_library"
+        ).fetchall()
+        matched = []
+        for p in all_patterns:
+            ptext = f"{p['pattern_name']} {p['description']}".lower()
+            if any(kw in ptext for kw in keywords):
+                matched.append(p)
+        if matched:
+            parts.append(f"\nPatterns you know related to this topic ({len(matched)}):")
+            for m in matched[:10]:
+                parts.append(f"  - {m['pattern_name']}: {m['description'][:120]}")
+
+    conn.close()
+    return "\n".join(parts) if parts else ""
+
+
+# ── Main Growth Loop ───────────────────────────────────────────────────────────
+
+def run_growth_engine(task: str, lang: str = "python") -> CodeAttempt:
+    """
+    The full growth loop.
+    Every run permanently improves the system.
+    """
+    set_language(lang)
+    print(f"\n{'='*60}")
+    print(f"  GROWTH ENGINE — SELF-IMPROVING CODE AI")
+    print(f"  Every problem makes me permanently smarter.")
+    print(f"{'='*60}")
+
+    # ── Apply earned trust — adjusts BENCHMARK_FLOOR and MAX_ITERATIONS ──
+    apply_trust_before_run()
+
+    # ── TALK gate: catch conversation BEFORE enrichment adds context ──
+    from reflection_engine import classify_task
+    if classify_task(task) == "TALK":
+        print(f"\n  💬 TALK detected — loading memory for conversation.")
+        memory_summary = _build_talk_memory(task)
+        if memory_summary:
+            print(f"  📖 Injecting {len(memory_summary)} chars of memory into TALK")
+        result = run_engine(task, talk_memory=memory_summary)
+        return result
+
+    # ── Load what we know ──
+    # Budget depends on task length — long prompts (C# MMO tasks) leave less room
+    task_len = len(task)
+    if task_len > 1000:
+        MAX_CONTEXT_CHARS = 500   # long prompts — minimal context injection
+    elif task_len > 600:
+        MAX_CONTEXT_CHARS = 800
+    else:
+        MAX_CONTEXT_CHARS = 1500  # short prompts (Python snippets) — full context
+
+    context = build_growth_context(task)
+    if context:
+        if len(context) > MAX_CONTEXT_CHARS:
+            context = context[:MAX_CONTEXT_CHARS] + "\n[...truncated to fit model context]"
+            print(f"\n  📖 Prior knowledge: {len(context)} chars (budget {MAX_CONTEXT_CHARS}, task {task_len} chars)")
+        else:
+            print(f"\n  📖 Prior knowledge: {len(context)} chars")
+        # Inject context into the task so reflection_engine uses it
+        enriched_task = f"{task}\n\n[PRIOR KNOWLEDGE FROM MEMORY]\n{context}"
+    else:
+        enriched_task = task
+        print(f"\n  📖 No prior knowledge found — this is a new territory")
+
+    # ── Run the reflection engine ──
+    result = run_engine(enriched_task)
+
+    # ── TALK shortcut: don't learn from greetings ──
+    if result.iteration == 0:
+        print(f"\n  💬 TALK response — no learning needed.")
+        return result
+
+    # ── Learn from what just happened ──
+    print(f"\n{'─'*60}")
+    print(f"  🌱 GROWING FROM THIS EXPERIENCE")
+    print(f"{'─'*60}")
+
+    # Extract and store lessons
+    lessons = extract_lessons(task, result)
+    store_task(task, result, lessons)
+    print(f"  🎓 Lesson: {lessons.get('key_lesson','')[:80]}")
+
+    # Extract and store patterns (from wins)
+    patterns = extract_patterns(task, result)
+    store_patterns(patterns)
+
+    # Extract and store failure lessons (from every run)
+    failures = extract_failures(task, result)
+    store_failures(failures)
+
+    # Record raw observations — honest, not forced
+    store_observation(task, result)
+
+    # Log confidence calibration
+    if result.reflections:
+        # Use final iteration confidence as proxy
+        log_confidence(0.85, result.score, result.passed)
+
+    # ── Show what we learned ──
+    cal = get_confidence_calibration()
+    conn = get_db()
+    total = conn.execute("SELECT COUNT(*) as n FROM task_history").fetchone()['n']
+
+    # Check if any observations have naturally crystallized
+    # (only every 5 tasks to give them time to accumulate)
+    if total % 5 == 0:
+        crystallize_observations()
+    pl    = conn.execute("SELECT COUNT(*) as n FROM pattern_library").fetchone()['n']
+    fl    = conn.execute("SELECT COUNT(*) as n FROM failure_library").fetchone()['n']
+    conn.close()
+
+    print(f"\n  📊 System state after this run:")
+    print(f"     Tasks in memory:    {total}")
+    print(f"     Patterns learned:   {pl}")
+    print(f"     Failures logged:    {fl}")
+    if cal['sample_size'] > 0:
+        print(f"     Confidence accuracy: {cal['recent_accuracy']:.1f}%")
+
+    print(f"\n  Next time a similar task comes in,")
+    print(f"  I will start with {pl} pattern(s) and avoid {fl} known failure(s).")
+    print(f"  I am permanently smarter than I was before this task.\n")
+
+    # ── Auto model scan — let Harvester manage its own stack ──
+    try:
+        from model_manager import should_auto_scan, auto_scan_and_evaluate
+        if should_auto_scan():
+            print(f"\n  🔍 Auto-scan triggered — checking for better models...")
+            auto_scan_and_evaluate()
+    except Exception as e:
+        # Non-fatal — don't break the growth loop over model management
+        print(f"  [model scan] skipped: {e}")
+
+    return result
+
+
+# ��─ Entry point ────────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    init_db()
+
+    if len(sys.argv) > 1:
+        arg = sys.argv[1]
+
+        if arg == "--stats":
+            show_stats()
+            sys.exit(0)
+
+        if arg == "--patterns":
+            show_patterns()
+            sys.exit(0)
+
+        # Parse --lang flag
+        lang = "python"
+        args = sys.argv[1:]
+        if "--lang" in args:
+            idx = args.index("--lang")
+            if idx + 1 < len(args):
+                lang = args[idx + 1]
+                args = args[:idx] + args[idx+2:]  # remove --lang and its value
+        task = " ".join(args)
+    else:
+        print("\nGROWTH ENGINE — Interactive Mode")
+        print("Commands: --stats | --patterns | or just describe a task")
+        print("─" * 40)
+        task = input("What should I build? → ").strip()
+        lang = "python"
+        if not task:
+            task = "Write a function that merges two sorted lists into one sorted list, with tests"
+
+    result = run_growth_engine(task, lang=lang)
+
+    print(f"\n{'='*60}")
+    print(f"  FINAL CODE (score: {result.score:.1f}%)")
+    print(f"{'='*60}\n")
+    print(result.code)

model_manager.py

@@ -0,0 +1,842 @@
+#!/usr/bin/env python3
+"""
+MODEL MANAGER
+=============
+Harvester's tool for managing its own model stack.
+Discovers, evaluates, and adopts models autonomously — with rules.
+
+Rules (non-negotiable):
+  1. NEVER remove a working model without a tested replacement
+  2. New model must BEAT current model on target domain tasks
+  3. Must fit within hardware constraints (VRAM/RAM)
+  4. Every decision logged to growth_memory.db with reasoning
+  5. Benchmark before adopt — no untested models in production
+  6. Keep at least one fallback model per role (coder, reasoner)
+  7. Human can override any decision via config or env var
+
+Roles:
+  - coder:    Code generation, reflection, troubleshooting
+  - reasoner: OSINT, investigation, complex reasoning
+
+Usage:
+  python model_manager.py --scan                # Discover models on disk + HuggingFace
+  python model_manager.py --benchmark <role>    # Benchmark current model for a role
+  python model_manager.py --evaluate <model>    # Test a candidate model
+  python model_manager.py --adopt <model> <role> # Adopt after passing benchmarks
+  python model_manager.py --status              # Current stack status
+  python model_manager.py --history             # Decision log
+"""
+
+import os
+import sys
+import json
+import sqlite3
+import time
+import hashlib
+from pathlib import Path
+from datetime import datetime
+from dataclasses import dataclass, asdict
+from typing import Optional
+
+sys.path.insert(0, os.path.dirname(__file__))
+
+# ── Config ────────────────────────────────────────────────────────────────────
+
+MODEL_DIR = os.environ.get("MODEL_DIR", r"D:\va_data\models")
+DB_PATH = os.environ.get("GROWTH_DB_PATH", os.path.join(os.path.dirname(__file__), "growth_memory.db"))
+LMSTUDIO_CACHE = os.path.expanduser(os.path.join("~", ".cache", "lm-studio", "models"))
+
+# Hardware constraints — updated via env or auto-detect
+MAX_RAM_GB = float(os.environ.get("MAX_RAM_GB", "64"))
+MAX_VRAM_GB = float(os.environ.get("MAX_VRAM_GB", "0"))  # 0 = CPU only
+GPU_LAYERS = int(os.environ.get("NATIVE_GPU_LAYERS", "0"))
+
+# Adoption rules
+MIN_BENCHMARK_IMPROVEMENT = float(os.environ.get("MIN_BENCHMARK_IMPROVEMENT", "0.05"))  # 5% better
+MIN_BENCHMARK_TASKS = int(os.environ.get("MIN_BENCHMARK_TASKS", "5"))   # at least 5 tasks
+MAX_MODEL_SIZE_GB = float(os.environ.get("MAX_MODEL_SIZE_GB", "0"))     # 0 = auto from hardware
+
+# ── Data structures ───────────────────────────────────────────────────────────
+
+@dataclass
+class ModelInfo:
+    name: str
+    path: str
+    size_gb: float
+    role: str           # "coder", "reasoner", "unknown"
+    source: str         # "local", "lmstudio_cache", "huggingface"
+    quantization: str   # "Q4_K_M", "Q8_0", etc.
+    status: str         # "active", "candidate", "retired", "fallback"
+    benchmark_score: float = 0.0
+    benchmark_tasks: int = 0
+    adopted_at: Optional[str] = None
+    notes: str = ""
+
+
+@dataclass
+class ModelDecision:
+    timestamp: str
+    action: str         # "scan", "benchmark", "adopt", "reject", "retire"
+    model_name: str
+    role: str
+    reasoning: str
+    score_before: float
+    score_after: float
+    approved: bool
+
+
+# ── Database ──────────────────────────────────────────────────────────────────
+
+def _init_db():
+    """Create model management tables if they don't exist."""
+    conn = sqlite3.connect(DB_PATH)
+    c = conn.cursor()
+    c.execute("""
+        CREATE TABLE IF NOT EXISTS model_registry (
+            name TEXT NOT NULL,
+            path TEXT NOT NULL,
+            size_gb REAL,
+            role TEXT,
+            source TEXT,
+            quantization TEXT,
+            status TEXT DEFAULT 'candidate',
+            benchmark_score REAL DEFAULT 0.0,
+            benchmark_tasks INTEGER DEFAULT 0,
+            adopted_at TEXT,
+            notes TEXT,
+            updated_at TEXT,
+            PRIMARY KEY (name, role)
+        )
+    """)
+    c.execute("""
+        CREATE TABLE IF NOT EXISTS model_decisions (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            timestamp TEXT,
+            action TEXT,
+            model_name TEXT,
+            role TEXT,
+            reasoning TEXT,
+            score_before REAL,
+            score_after REAL,
+            approved INTEGER
+        )
+    """)
+    conn.commit()
+    conn.close()
+
+
+def _log_decision(decision: ModelDecision):
+    """Log every model decision to the database."""
+    conn = sqlite3.connect(DB_PATH)
+    c = conn.cursor()
+    c.execute("""
+        INSERT INTO model_decisions (timestamp, action, model_name, role, reasoning, score_before, score_after, approved)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    """, (decision.timestamp, decision.action, decision.model_name, decision.role,
+          decision.reasoning, decision.score_before, decision.score_after, int(decision.approved)))
+    conn.commit()
+    conn.close()
+
+
+def _save_model(model: ModelInfo):
+    """Upsert model info in registry."""
+    conn = sqlite3.connect(DB_PATH)
+    c = conn.cursor()
+    c.execute("""
+        INSERT INTO model_registry (name, path, size_gb, role, source, quantization, status, benchmark_score, benchmark_tasks, adopted_at, notes, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(name, role) DO UPDATE SET
+            path=excluded.path, size_gb=excluded.size_gb, source=excluded.source,
+            quantization=excluded.quantization, status=excluded.status,
+            benchmark_score=excluded.benchmark_score, benchmark_tasks=excluded.benchmark_tasks,
+            adopted_at=excluded.adopted_at, notes=excluded.notes, updated_at=excluded.updated_at
+    """, (model.name, model.path, model.size_gb, model.role, model.source,
+          model.quantization, model.status, model.benchmark_score, model.benchmark_tasks,
+          model.adopted_at, model.notes, datetime.now().isoformat()))
+    conn.commit()
+    conn.close()
+
+
+def _get_active_model(role: str) -> Optional[dict]:
+    """Get the currently active model for a role."""
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    c = conn.cursor()
+    c.execute("SELECT * FROM model_registry WHERE role=? AND status='active'", (role,))
+    row = c.fetchone()
+    conn.close()
+    return dict(row) if row else None
+
+
+def _get_all_models(role: str = None) -> list:
+    """Get all registered models, optionally filtered by role."""
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    c = conn.cursor()
+    if role:
+        c.execute("SELECT * FROM model_registry WHERE role=? ORDER BY benchmark_score DESC", (role,))
+    else:
+        c.execute("SELECT * FROM model_registry ORDER BY role, benchmark_score DESC")
+    rows = c.fetchall()
+    conn.close()
+    return [dict(r) for r in rows]
+
+
+# ── Hardware detection ────────────────────────────────────────────────────────
+
+def detect_hardware() -> dict:
+    """Detect available hardware for model sizing decisions."""
+    hw = {
+        "ram_gb": MAX_RAM_GB,
+        "vram_gb": MAX_VRAM_GB,
+        "gpu_available": MAX_VRAM_GB > 0 or GPU_LAYERS != 0,
+        "gpu_layers": GPU_LAYERS,
+        "max_model_gb": 0.0,
+    }
+
+    # Try to detect GPU via torch
+    try:
+        import torch
+        if torch.cuda.is_available():
+            vram = torch.cuda.get_device_properties(0).total_memory / (1024**3)
+            hw["vram_gb"] = vram
+            hw["gpu_available"] = True
+    except ImportError:
+        pass
+
+    # Max model size: 80% of available memory (leave room for KV cache, OS)
+    if hw["gpu_available"] and hw["vram_gb"] > 0:
+        hw["max_model_gb"] = hw["vram_gb"] * 0.8
+    else:
+        # CPU-only: leave 16GB for OS + apps
+        hw["max_model_gb"] = max(0, hw["ram_gb"] - 16) * 0.8
+
+    if MAX_MODEL_SIZE_GB > 0:
+        hw["max_model_gb"] = MAX_MODEL_SIZE_GB
+
+    return hw
+
+
+# ── Model discovery ───────────────────────────────────────────────────────────
+
+def _parse_model_name(filename: str) -> dict:
+    """Extract model info from GGUF filename."""
+    info = {"name": filename, "quantization": "unknown"}
+
+    # Common quantization patterns
+    for q in ["Q8_0", "Q6_K", "Q5_K_M", "Q5_K_S", "Q4_K_M", "Q4_K_S", "Q4_0", "Q3_K_M", "Q3_K_S", "Q2_K", "IQ4_XS"]:
+        if q in filename:
+            info["quantization"] = q
+            break
+
+    # Guess role from name
+    name_lower = filename.lower()
+    if any(kw in name_lower for kw in ["coder", "code", "starcoder", "codellama", "deepseek-coder"]):
+        info["role"] = "coder"
+    elif any(kw in name_lower for kw in ["reason", "r1", "think", "opus", "deepseek-r1"]):
+        info["role"] = "reasoner"
+    else:
+        info["role"] = "unknown"
+
+    info["name"] = filename.replace(".gguf", "")
+    return info
+
+
+def scan_local_models() -> list:
+    """Scan local directories for GGUF models."""
+    found = []
+    scan_dirs = [MODEL_DIR]
+
+    # Also check LM Studio cache
+    if os.path.isdir(LMSTUDIO_CACHE):
+        scan_dirs.append(LMSTUDIO_CACHE)
+
+    for scan_dir in scan_dirs:
+        if not os.path.isdir(scan_dir):
+            continue
+        source = "lmstudio_cache" if "lm-studio" in scan_dir else "local"
+        for root, dirs, files in os.walk(scan_dir):
+            for f in files:
+                if f.endswith(".gguf"):
+                    full_path = os.path.join(root, f)
+                    size_gb = os.path.getsize(full_path) / (1024**3)
+                    info = _parse_model_name(f)
+                    model = ModelInfo(
+                        name=info["name"],
+                        path=full_path,
+                        size_gb=round(size_gb, 2),
+                        role=info.get("role", "unknown"),
+                        source=source,
+                        quantization=info["quantization"],
+                        status="candidate",
+                    )
+                    found.append(model)
+    return found
+
+
+def scan_and_register() -> list:
+    """Scan for models and register them in the database."""
+    _init_db()
+    hw = detect_hardware()
+    models = scan_local_models()
+    registered = []
+
+    for m in models:
+        # Rule: skip models that won't fit
+        if m.size_gb > hw["max_model_gb"]:
+            m.notes = f"Too large ({m.size_gb:.1f}GB > {hw['max_model_gb']:.1f}GB limit)"
+            m.status = "oversized"
+
+        _save_model(m)
+        registered.append(m)
+
+    _log_decision(ModelDecision(
+        timestamp=datetime.now().isoformat(),
+        action="scan",
+        model_name="*",
+        role="*",
+        reasoning=f"Scanned {len(registered)} models. Hardware: {hw['ram_gb']:.0f}GB RAM, {hw['vram_gb']:.0f}GB VRAM, max model {hw['max_model_gb']:.1f}GB",
+        score_before=0, score_after=0, approved=True
+    ))
+
+    return registered
+
+
+# ── Benchmarking ──────────────────────────────────────────────────────────────
+
+def benchmark_model(model_path: str, role: str, task_bank: str = None) -> dict:
+    """Benchmark a model against a task bank for a specific role.
+
+    Returns dict with score, task_count, avg_confidence, avg_time.
+    """
+    from reflection_engine import set_task_mode, reason
+
+    if task_bank is None:
+        if role == "reasoner":
+            task_bank = os.path.join(os.path.dirname(__file__), "bellingcat_tasks.json")
+        else:
+            task_bank = os.path.join(os.path.dirname(__file__), "reasoning_tasks.json")
+
+    if not os.path.isfile(task_bank):
+        return {"error": f"Task bank not found: {task_bank}", "score": 0}
+
+    with open(task_bank, "r", encoding="utf-8") as f:
+        tasks = json.load(f)
+
+    # Use first N tasks for benchmarking (not full bank — save time)
+    bench_tasks = tasks[:MIN_BENCHMARK_TASKS]
+    results = []
+    total_confidence = 0.0
+    high_confidence = 0
+    total_time = 0.0
+
+    set_task_mode(role)
+
+    for task in bench_tasks:
+        prompt = task.get("prompt", task.get("description", ""))
+        if not prompt:
+            continue
+
+        start = time.time()
+        try:
+            plan = reason(prompt)
+            elapsed = time.time() - start
+            conf = getattr(plan, "confidence", 0.3)
+            total_confidence += conf
+            if conf >= 0.7:
+                high_confidence += 1
+            total_time += elapsed
+            results.append({
+                "task": task.get("name", "unnamed"),
+                "confidence": conf,
+                "time_secs": round(elapsed, 1),
+                "parsed": conf > 0.3,  # Did it actually reason or fallback?
+            })
+        except Exception as e:
+            elapsed = time.time() - start
+            total_time += elapsed
+            results.append({
+                "task": task.get("name", "unnamed"),
+                "confidence": 0.0,
+                "time_secs": round(elapsed, 1),
+                "error": str(e),
+            })
+
+    n = len(results)
+    return {
+        "model_path": model_path,
+        "role": role,
+        "task_bank": task_bank,
+        "task_count": n,
+        "high_confidence": high_confidence,
+        "avg_confidence": round(total_confidence / n, 3) if n > 0 else 0,
+        "avg_time_secs": round(total_time / n, 1) if n > 0 else 0,
+        "total_time_secs": round(total_time, 1),
+        "score": round(high_confidence / n, 3) if n > 0 else 0,
+        "results": results,
+    }
+
+
+# ── Adoption rules engine ────────────────────────────────────────────────────
+
+def evaluate_adoption(candidate_name: str, role: str, benchmark_result: dict) -> ModelDecision:
+    """Apply rules to decide whether to adopt a candidate model.
+
+    Rules:
+      1. Must have benchmarked at least MIN_BENCHMARK_TASKS tasks
+      2. Score must beat current active model by MIN_BENCHMARK_IMPROVEMENT
+      3. Model must fit within hardware constraints
+      4. Must not be the only model (keep fallback)
+    """
+    _init_db()
+    current = _get_active_model(role)
+    current_score = current["benchmark_score"] if current else 0.0
+    candidate_score = benchmark_result.get("score", 0)
+
+    # Rule 1: enough tasks?
+    if benchmark_result.get("task_count", 0) < MIN_BENCHMARK_TASKS:
+        return ModelDecision(
+            timestamp=datetime.now().isoformat(),
+            action="reject", model_name=candidate_name, role=role,
+            reasoning=f"Insufficient benchmark tasks: {benchmark_result.get('task_count', 0)} < {MIN_BENCHMARK_TASKS}",
+            score_before=current_score, score_after=candidate_score, approved=False
+        )
+
+    # Rule 2: improvement threshold?
+    improvement = candidate_score - current_score
+    if current_score > 0 and improvement < MIN_BENCHMARK_IMPROVEMENT:
+        return ModelDecision(
+            timestamp=datetime.now().isoformat(),
+            action="reject", model_name=candidate_name, role=role,
+            reasoning=f"Improvement too small: {improvement:.3f} < {MIN_BENCHMARK_IMPROVEMENT} threshold. Current: {current_score:.3f}, Candidate: {candidate_score:.3f}",
+            score_before=current_score, score_after=candidate_score, approved=False
+        )
+
+    # Rule 3: fits hardware?
+    hw = detect_hardware()
+    models = _get_all_models()
+    candidate_models = [m for m in models if m["name"] == candidate_name]
+    if candidate_models:
+        candidate_size = candidate_models[0]["size_gb"]
+        if candidate_size > hw["max_model_gb"]:
+            return ModelDecision(
+                timestamp=datetime.now().isoformat(),
+                action="reject", model_name=candidate_name, role=role,
+                reasoning=f"Model too large: {candidate_size:.1f}GB > {hw['max_model_gb']:.1f}GB hardware limit",
+                score_before=current_score, score_after=candidate_score, approved=False
+            )
+
+    # All rules passed — approve adoption
+    return ModelDecision(
+        timestamp=datetime.now().isoformat(),
+        action="adopt", model_name=candidate_name, role=role,
+        reasoning=f"Passed all rules. Score: {candidate_score:.3f} vs current {current_score:.3f} (+{improvement:.3f}). Fits hardware.",
+        score_before=current_score, score_after=candidate_score, approved=True
+    )
+
+
+def adopt_model(model_name: str, role: str, benchmark_result: dict) -> bool:
+    """Adopt a model for a role if it passes all rules.
+
+    Returns True if adopted, False if rejected.
+    """
+    _init_db()
+
+    # Evaluate
+    decision = evaluate_adoption(model_name, role, benchmark_result)
+    _log_decision(decision)
+
+    if not decision.approved:
+        print(f"  ❌ REJECTED: {decision.reasoning}")
+        return False
+
+    # Retire current active model to fallback (Rule 1: never remove without replacement)
+    current = _get_active_model(role)
+    if current:
+        conn = sqlite3.connect(DB_PATH)
+        c = conn.cursor()
+        c.execute("UPDATE model_registry SET status='fallback' WHERE name=? AND role=?",
+                  (current["name"], role))
+        conn.commit()
+        conn.close()
+        print(f"  📦 {current['name']} moved to fallback")
+
+    # Activate new model
+    conn = sqlite3.connect(DB_PATH)
+    c = conn.cursor()
+    c.execute("""UPDATE model_registry SET status='active', benchmark_score=?, benchmark_tasks=?, adopted_at=?
+                 WHERE name=? AND role=?""",
+              (benchmark_result["score"], benchmark_result["task_count"],
+               datetime.now().isoformat(), model_name, role))
+    conn.commit()
+    conn.close()
+
+    print(f"  ✅ ADOPTED: {model_name} as {role} (score: {benchmark_result['score']:.3f})")
+    return True
+
+
+# ── Status & history ──────────────────────────────────────────────────────────
+
+def print_status():
+    """Print current model stack status."""
+    _init_db()
+    hw = detect_hardware()
+    print("=" * 60)
+    print("MODEL MANAGER — Stack Status")
+    print("=" * 60)
+    print(f"  Hardware: {hw['ram_gb']:.0f}GB RAM | {hw['vram_gb']:.0f}GB VRAM | GPU layers: {hw['gpu_layers']}")
+    print(f"  Max model size: {hw['max_model_gb']:.1f}GB")
+    print()
+
+    for role in ["coder", "reasoner"]:
+        models = _get_all_models(role)
+        print(f"  [{role.upper()}]")
+        if not models:
+            print(f"    (no models registered)")
+        for m in models:
+            marker = "→" if m["status"] == "active" else " "
+            score = f"score={m['benchmark_score']:.3f}" if m["benchmark_score"] > 0 else "not benchmarked"
+            print(f"    {marker} {m['name']} [{m['status']}] {m['size_gb']:.1f}GB {m['quantization']} ({score})")
+        print()
+
+    # Unknown role models
+    unknowns = _get_all_models("unknown")
+    if unknowns:
+        print(f"  [UNCLASSIFIED]")
+        for m in unknowns:
+            print(f"      {m['name']} {m['size_gb']:.1f}GB {m['quantization']} ({m['source']})")
+        print()
+
+
+# ── Autonomous scanning / absorption ──────────────────────────────────────────
+
+# When to trigger an auto-scan (called from growth_engine after N tasks)
+AUTO_SCAN_INTERVAL = int(os.environ.get("AUTO_SCAN_INTERVAL", "20"))  # every N tasks
+
+# HuggingFace search filters for model discovery
+HF_SEARCH_TAGS = {
+    "coder": ["code", "coder", "codegen", "instruct"],
+    "reasoner": ["reasoning", "think", "r1", "cot"],
+}
+HF_QUANT_PREFERENCE = ["Q4_K_M", "Q5_K_M", "Q4_K_S", "Q6_K"]  # in preference order
+
+
+def search_huggingface(role: str, max_results: int = 5) -> list[dict]:
+    """Search HuggingFace for GGUF models that might fit a role.
+
+    Returns list of dicts with: repo_id, filename, size_gb, quantization.
+    Does NOT download — just discovers candidates.
+    """
+    results = []
+    hw = detect_hardware()
+
+    try:
+        from huggingface_hub import HfApi
+        api = HfApi()
+    except ImportError:
+        print("  [HF] huggingface_hub not installed — skip HF search")
+        return results
+
+    tags = HF_SEARCH_TAGS.get(role, ["instruct"])
+
+    for tag in tags:
+        try:
+            models = api.list_models(
+                search=f"{tag} GGUF",
+                sort="downloads",
+                direction=-1,
+                limit=10,
+            )
+            for model in models:
+                repo_id = model.id
+                # Look for GGUF files we can use
+                try:
+                    siblings = api.list_repo_tree(repo_id, recursive=False)
+                    for item in siblings:
+                        if not hasattr(item, "rfilename"):
+                            continue
+                        fname = item.rfilename
+                        if not fname.endswith(".gguf"):
+                            continue
+                        # Check if it's a quantization we want
+                        quant = "unknown"
+                        for q in HF_QUANT_PREFERENCE:
+                            if q in fname:
+                                quant = q
+                                break
+                        if quant == "unknown":
+                            continue  # skip unrecognized quants
+
+                        size_gb = item.size / (1024**3) if hasattr(item, "size") and item.size else 0
+                        # Skip if too large for hardware
+                        if size_gb > hw["max_model_gb"] and size_gb > 0:
+                            continue
+
+                        results.append({
+                            "repo_id": repo_id,
+                            "filename": fname,
+                            "size_gb": round(size_gb, 2),
+                            "quantization": quant,
+                            "role": role,
+                        })
+                except Exception:
+                    continue  # skip repos we can't inspect
+        except Exception as e:
+            print(f"  [HF] Search error for tag '{tag}': {e}")
+            continue
+
+    # Deduplicate and limit
+    seen = set()
+    unique = []
+    for r in results:
+        key = f"{r['repo_id']}/{r['filename']}"
+        if key not in seen:
+            seen.add(key)
+            unique.append(r)
+    return unique[:max_results]
+
+
+def auto_scan_and_evaluate(roles: list[str] = None) -> dict:
+    """Autonomous model management: scan local → check HF → benchmark → adopt/reject.
+
+    This is the main entry point for Harvester's self-managed model stack.
+    Called by growth_engine every AUTO_SCAN_INTERVAL tasks.
+
+    Returns dict with scan results and any decisions made.
+    """
+    _init_db()
+    if roles is None:
+        roles = ["coder", "reasoner"]
+
+    report = {
+        "timestamp": datetime.now().isoformat(),
+        "local_scanned": 0,
+        "hf_discovered": 0,
+        "benchmarked": 0,
+        "adopted": 0,
+        "rejected": 0,
+        "decisions": [],
+    }
+
+    # 1. Scan local models
+    print("\n  🔍 Scanning local model directories...")
+    local = scan_and_register()
+    report["local_scanned"] = len(local)
+    print(f"     Found {len(local)} local model(s)")
+
+    for role in roles:
+        current = _get_active_model(role)
+        current_score = current["benchmark_score"] if current else 0.0
+
+        # 2. Check if any local candidates beat current
+        candidates = [m for m in _get_all_models(role)
+                      if m["status"] == "candidate" and m["name"] != (current["name"] if current else "")]
+
+        if candidates:
+            print(f"\n  📊 {len(candidates)} candidate(s) for {role}:")
+            for c in candidates[:3]:  # limit to top 3 by size
+                print(f"     {c['name']} ({c['size_gb']:.1f}GB)")
+                # Benchmark only if not already benchmarked
+                if c["benchmark_score"] == 0 and c["benchmark_tasks"] == 0:
+                    print(f"     ⏳ Benchmarking {c['name']}...")
+                    try:
+                        bench = benchmark_model(c["path"], role)
+                        report["benchmarked"] += 1
+                        # Try to adopt
+                        adopted = adopt_model(c["name"], role, bench)
+                        if adopted:
+                            report["adopted"] += 1
+                            report["decisions"].append(f"Adopted {c['name']} for {role}")
+                        else:
+                            report["rejected"] += 1
+                            report["decisions"].append(f"Rejected {c['name']} for {role}")
+                    except Exception as e:
+                        print(f"     [ERROR] Benchmark failed: {e}")
+                        report["decisions"].append(f"Benchmark error for {c['name']}: {e}")
+
+        # 3. Search HuggingFace (only if no local candidates or current is weak)
+        if not candidates or current_score < 0.5:
+            print(f"\n  🌐 Searching HuggingFace for {role} models...")
+            try:
+                hf_models = search_huggingface(role, max_results=3)
+                report["hf_discovered"] += len(hf_models)
+                for hf in hf_models:
+                    print(f"     📦 {hf['repo_id']}/{hf['filename']} ({hf['size_gb']:.1f}GB, {hf['quantization']})")
+                if hf_models:
+                    print(f"     ℹ️  Use --adopt to evaluate and adopt HF models")
+            except Exception as e:
+                print(f"     [HF] Search error: {e}")
+
+    _log_decision(ModelDecision(
+        timestamp=datetime.now().isoformat(),
+        action="auto_scan",
+        model_name="*",
+        role=",".join(roles),
+        reasoning=f"Auto-scan: {report['local_scanned']} local, {report['hf_discovered']} HF, {report['adopted']} adopted, {report['rejected']} rejected",
+        score_before=0, score_after=0, approved=True
+    ))
+
+    return report
+
+
+def should_auto_scan() -> bool:
+    """Check if it's time for an automatic model scan.
+
+    Returns True if AUTO_SCAN_INTERVAL tasks have passed since last scan.
+    Called by growth_engine after each task completes.
+    """
+    _init_db()
+    conn = sqlite3.connect(DB_PATH)
+    c = conn.cursor()
+
+    # Count tasks since last auto_scan decision
+    c.execute("SELECT MAX(id) as last_id FROM model_decisions WHERE action='auto_scan'")
+    row = c.fetchone()
+    last_scan_id = row[0] if row and row[0] else 0
+
+    # Count tasks in task_history since then (approximate — uses timestamp ordering)
+    c.execute("SELECT COUNT(*) FROM task_history WHERE id > ?", (last_scan_id,))
+    tasks_since = c.fetchone()[0]
+    conn.close()
+
+    return tasks_since >= AUTO_SCAN_INTERVAL
+
+
+def print_history(limit: int = 20):
+    """Print recent model decisions."""
+    _init_db()
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    c = conn.cursor()
+    c.execute("SELECT * FROM model_decisions ORDER BY id DESC LIMIT ?", (limit,))
+    rows = c.fetchall()
+    conn.close()
+
+    print("=" * 60)
+    print("MODEL MANAGER — Decision History")
+    print("=" * 60)
+    for r in reversed(rows):
+        approved = "✅" if r["approved"] else "❌"
+        print(f"  {r['timestamp'][:19]} | {approved} {r['action']:10} | {r['model_name']}")
+        print(f"    Role: {r['role']} | {r['reasoning'][:80]}")
+        if r["score_before"] > 0 or r["score_after"] > 0:
+            print(f"    Score: {r['score_before']:.3f} → {r['score_after']:.3f}")
+        print()
+
+
+# ── CLI ───────────────────────────────────────────────────────────────────────
+
+def seed_current_stack():
+    """Register the models Harvester already knows about from reflection_engine config."""
+    _init_db()
+    try:
+        from reflection_engine import (
+            NATIVE_MODEL_PATH, NATIVE_HF_FILE, NATIVE_HF_REPO,
+            REASONER_MODEL_PATH, REASONER_HF_FILE, REASONER_HF_REPO,
+        )
+    except ImportError:
+        print("  ⚠️  Could not import reflection_engine — seeding with hardcoded defaults")
+        NATIVE_MODEL_PATH = r"D:\va_data\models\Qwen3-Coder-30B-A3B-Instruct-Q4_K_M.gguf"
+        NATIVE_HF_FILE = "Qwen3-Coder-30B-A3B-Instruct-Q4_K_M.gguf"
+        REASONER_MODEL_PATH = r"D:\va_data\models\Qwen3.5-27B.Q4_K_M.gguf"
+        REASONER_HF_FILE = "Qwen3.5-27B.Q4_K_M.gguf"
+
+    seeded = 0
+    for path, role, hf_file in [
+        (NATIVE_MODEL_PATH, "coder", NATIVE_HF_FILE),
+        (REASONER_MODEL_PATH, "reasoner", REASONER_HF_FILE),
+    ]:
+        name = hf_file.replace(".gguf", "")
+        info = _parse_model_name(hf_file)
+        size_gb = round(os.path.getsize(path) / (1024**3), 2) if os.path.isfile(path) else 0.0
+        status = "active" if os.path.isfile(path) else "configured"
+        model = ModelInfo(
+            name=name, path=path, size_gb=size_gb, role=role,
+            source="local", quantization=info["quantization"],
+            status=status, adopted_at=datetime.now().isoformat(),
+            notes="Seeded from reflection_engine config"
+        )
+        _save_model(model)
+        on_disk = "✅ on disk" if os.path.isfile(path) else "⚠️ NOT on disk"
+        print(f"  → {name} [{role}] {size_gb:.1f}GB ({on_disk})")
+        seeded += 1
+
+    _log_decision(ModelDecision(
+        timestamp=datetime.now().isoformat(), action="seed", model_name="*", role="*",
+        reasoning=f"Seeded {seeded} models from reflection_engine config",
+        score_before=0, score_after=0, approved=True
+    ))
+    print(f"\n  Seeded {seeded} models.")
+
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description="Harvester Model Manager")
+    parser.add_argument("--scan", action="store_true", help="Scan for local models")
+    parser.add_argument("--seed", action="store_true", help="Seed current config models into registry")
+    parser.add_argument("--status", action="store_true", help="Show current stack status")
+    parser.add_argument("--history", action="store_true", help="Show decision log")
+    parser.add_argument("--benchmark", type=str, metavar="ROLE", help="Benchmark current model for role (coder/reasoner)")
+    parser.add_argument("--evaluate", type=str, metavar="MODEL", help="Evaluate a candidate model name")
+    parser.add_argument("--adopt", nargs=2, metavar=("MODEL", "ROLE"), help="Adopt model for role after benchmarking")
+    parser.add_argument("--bank", type=str, help="Task bank JSON for benchmarking")
+
+    args = parser.parse_args()
+
+    if args.seed:
+        seed_current_stack()
+        print()
+        print_status()
+
+    elif args.scan:
+        models = scan_and_register()
+        print(f"\nScanned {len(models)} models:")
+        for m in models:
+            flag = "⚠️ " if m.status == "oversized" else "  "
+            print(f"  {flag}{m.name} | {m.size_gb:.1f}GB | {m.quantization} | {m.role} | {m.source}")
+        print()
+        print_status()
+
+    elif args.status:
+        print_status()
+
+    elif args.history:
+        print_history()
+
+    elif args.benchmark:
+        role = args.benchmark.lower()
+        print(f"Benchmarking current {role} model...")
+        current = _get_active_model(role)
+        if not current:
+            print(f"  No active {role} model. Run --scan first, then --adopt.")
+            return
+        result = benchmark_model(current["path"], role, args.bank)
+        print(f"  Score: {result['score']:.3f} ({result['high_confidence']}/{result['task_count']} high confidence)")
+        print(f"  Avg time: {result['avg_time_secs']:.1f}s per task")
+        # Update registry
+        _save_model(ModelInfo(
+            name=current["name"], path=current["path"], size_gb=current["size_gb"],
+            role=role, source=current["source"], quantization=current["quantization"],
+            status="active", benchmark_score=result["score"],
+            benchmark_tasks=result["task_count"], adopted_at=current.get("adopted_at"),
+        ))
+
+    elif args.adopt:
+        model_name, role = args.adopt
+        role = role.lower()
+        models = _get_all_models()
+        candidate = next((m for m in models if m["name"] == model_name), None)
+        if not candidate:
+            print(f"  Model '{model_name}' not in registry. Run --scan first.")
+            return
+        print(f"  Benchmarking {model_name} for {role}...")
+        result = benchmark_model(candidate["path"], role, args.bank)
+        print(f"  Benchmark: {result['score']:.3f} ({result['high_confidence']}/{result['task_count']})")
+        adopt_model(model_name, role, result)
+
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

osint_tasks.json

@@ -0,0 +1,129 @@
+{
+  "metadata": {
+    "description": "OSINT Reasoning Lab — tasks focused on open-source intelligence methodology for locating missing persons. All tasks use publicly available data only. Python automation scripts.",
+    "difficulty_scale": "1-5 (1=single-source lookup, 3=multi-source correlation, 5=full investigation pipeline)",
+    "purpose": "Train Harvester to reason about OSINT investigation methodology and build automation tools for finding lost children."
+  },
+  "tasks": [
+    {
+      "id": 1,
+      "name": "EXIF Metadata Extractor",
+      "lang": "python",
+      "difficulty": 2,
+      "category": "image_analysis",
+      "prompt": "Write a Python script that extracts all EXIF metadata from an image file (JPEG/PNG). Must extract: GPS coordinates (convert to decimal lat/lon), camera make/model, timestamp, software used, thumbnail if present. Output as structured JSON. Handle images with no EXIF gracefully. Use only Pillow (PIL). Include a function that takes a file path and returns a dict with all extracted fields, plus a convenience function that formats GPS coords as a Google Maps URL."
+    },
+    {
+      "id": 2,
+      "name": "Reverse Image Search Automator",
+      "lang": "python",
+      "difficulty": 3,
+      "category": "image_analysis",
+      "prompt": "Write a Python module that computes perceptual hashes (pHash, dHash, aHash) for an image, stores them in a local SQLite database for comparison, and provides a search function that finds visually similar images from the database within a configurable Hamming distance threshold. Must support: adding images to the index, querying by image file, returning similarity scores, and batch indexing a directory of images. Use Pillow for image processing. Include a CLI interface that supports 'index', 'search', and 'stats' subcommands."
+    },
+    {
+      "id": 3,
+      "name": "Username OSINT Enumerator",
+      "lang": "python",
+      "difficulty": 2,
+      "category": "social_media",
+      "prompt": "Write a Python script that takes a username string and checks if that username exists on common public platforms by making HTTP HEAD/GET requests to known profile URL patterns (e.g., github.com/{user}, twitter.com/{user}, reddit.com/user/{user}). Must handle: rate limiting with configurable delays, timeout per request, HTTP status code interpretation (200=found, 404=not found, 403=blocked), output results as JSON with platform name, URL, status, and response time. Use requests library with proper User-Agent header. Support a configurable platform list loaded from a JSON config file."
+    },
+    {
+      "id": 4,
+      "name": "Public Records Timeline Builder",
+      "lang": "python",
+      "difficulty": 3,
+      "category": "timeline",
+      "prompt": "Write a Python module that builds a chronological timeline from multiple data points. Each data point has: timestamp (various formats — ISO, US date, Unix epoch, relative like '3 days ago'), source name, event description, confidence level (high/medium/low), and optional location. Must parse all timestamp formats into UTC datetime objects, sort chronologically, detect gaps longer than a configurable threshold, identify overlapping events, and export the timeline as both JSON and a formatted text report. Include functions for: add_event(), merge_timelines(), find_gaps(), and export()."
+    },
+    {
+      "id": 5,
+      "name": "Geolocation from Coordinates",
+      "lang": "python",
+      "difficulty": 2,
+      "category": "geolocation",
+      "prompt": "Write a Python module for working with geographic coordinates in OSINT investigations. Must support: converting between DMS (degrees/minutes/seconds) and decimal degrees, calculating distance between two points using the Haversine formula, finding the bounding box (NW/SE corners) for a given center point and radius in km, generating a static map URL for a list of points, and clustering nearby points within a configurable radius using a simple algorithm (no scipy/sklearn). All math should use the math module only. Include type hints and a CLI that accepts lat/lon pairs."
+    },
+    {
+      "id": 6,
+      "name": "WHOIS Data Parser",
+      "lang": "python",
+      "difficulty": 2,
+      "category": "domain_recon",
+      "prompt": "Write a Python module that parses raw WHOIS text output (passed as a string) and extracts structured fields: registrant name, organization, email, creation date, expiration date, updated date, nameservers, registrar name, and status codes. Handle the most common WHOIS formats (ICANN thin/thick, various registrars). Return results as a dataclass with optional fields (None if not found). Include a function that compares two WHOIS records and returns a diff of changed fields. Use only regex and standard library — no external WHOIS packages."
+    },
+    {
+      "id": 7,
+      "name": "Social Media Post Timestamp Analyzer",
+      "lang": "python",
+      "difficulty": 3,
+      "category": "social_media",
+      "prompt": "Write a Python module that analyzes posting patterns from a list of timestamps. Input: a list of ISO-8601 datetime strings representing public post times. Must compute: hourly activity histogram (24 bins), day-of-week distribution, most active hour and day, average time between posts, detect regular posting schedules (e.g., 'posts every Tuesday around 3pm'), identify unusual gaps or bursts in activity, and estimate the user's likely timezone based on activity patterns (assume sleeping hours are 1am-6am local). Output all analysis as a structured dict. Use only standard library (datetime, collections, statistics)."
+    },
+    {
+      "id": 8,
+      "name": "DNS Reconnaissance Tool",
+      "lang": "python",
+      "difficulty": 3,
+      "category": "domain_recon",
+      "prompt": "Write a Python DNS reconnaissance module using only the socket standard library. Must support: resolving A, AAAA, MX, and TXT records via socket.getaddrinfo and dns queries, checking for common subdomains from a configurable wordlist (www, mail, ftp, api, dev, staging, admin, etc.), detecting wildcard DNS (resolve a random subdomain and check if it matches), outputting all discovered records as structured JSON, and providing a summary with total records found per type. Include rate limiting between queries and timeout handling. No external DNS libraries — socket and struct only."
+    },
+    {
+      "id": 9,
+      "name": "Missing Person Report Generator",
+      "lang": "python",
+      "difficulty": 4,
+      "category": "reporting",
+      "prompt": "Write a Python module that generates a structured intelligence report from collected OSINT data points. Input is a dict containing: person description (name, age, last_seen_date, last_seen_location), a list of sighting data points (timestamp, location, source, confidence), a list of associated online accounts (platform, username, last_active), and timeline events. The module must: validate all input data, generate a formatted text report with sections (Subject Info, Timeline, Online Presence, Sighting Analysis, Recommended Next Steps), calculate a 'data freshness' score based on how recent the data points are, identify geographic patterns in sightings, and flag any data inconsistencies. Output as both plain text and structured JSON."
+    },
+    {
+      "id": 10,
+      "name": "Alert Monitor Framework",
+      "lang": "python",
+      "difficulty": 4,
+      "category": "monitoring",
+      "prompt": "Write a Python framework for monitoring public data feeds for keyword matches. Must support: configurable keyword lists with boolean logic (AND, OR, NOT), case-insensitive and regex-capable matching, a pluggable source interface (abstract base class for feed sources), a SQLite-backed alert log with deduplication (same content from same source within configurable window = skip), configurable check intervals per source, and alert callbacks (print, log to file, or call a function). Include one concrete source implementation: an RSS feed reader using only urllib and xml.etree. The framework should be runnable as a long-lived process with graceful shutdown on SIGINT."
+    },
+    {
+      "id": 11,
+      "name": "Data Correlation Engine",
+      "lang": "python",
+      "difficulty": 5,
+      "category": "analysis",
+      "prompt": "Write a Python module that correlates entities across multiple data sources. Entities are dicts with fields like name, email, phone, username, location, and timestamp. The engine must: perform fuzzy name matching (handle typos, nicknames, abbreviations using Levenshtein distance — implement from scratch, no external libs), match entities by shared identifiers (exact email, phone normalization), score entity similarity on a 0-1 scale based on matching fields, merge correlated entities into unified profiles with provenance tracking (which source contributed each field), detect conflicts (same field, different values) and flag them, and output a list of unified profiles with confidence scores. Use only standard library plus basic string operations."
+    },
+    {
+      "id": 12,
+      "name": "Location History Heatmap Builder",
+      "lang": "python",
+      "difficulty": 3,
+      "category": "geolocation",
+      "prompt": "Write a Python module that takes a list of location data points (lat, lon, timestamp, source) and produces analysis for a heatmap. Must: cluster nearby points using a grid-based approach (configurable cell size in meters), count visits per cell, identify the top N most-visited locations, calculate time spent at each cluster (based on consecutive timestamps within the cluster), detect travel patterns (sequences of locations ordered by time), estimate travel speed between consecutive points and flag impossible speeds (teleportation detection > 900 km/h), and output the grid data as a JSON structure with cell coordinates, visit counts, and time-spent estimates. Use only math and standard library."
+    },
+    {
+      "id": 13,
+      "name": "Text Entity Extractor",
+      "lang": "python",
+      "difficulty": 3,
+      "category": "analysis",
+      "prompt": "Write a Python module that extracts structured entities from unstructured text using regex patterns. Must extract: email addresses, phone numbers (US and international formats), URLs, physical addresses (street number + street name patterns), dates in multiple formats (MM/DD/YYYY, YYYY-MM-DD, Month Day Year, relative dates), @mentions and #hashtags, and IP addresses (v4). Each extracted entity should include: the matched text, entity type, position in the original text (start/end index), and a confidence score based on pattern specificity. Return results grouped by entity type. Use only the re module — no NLP libraries."
+    },
+    {
+      "id": 14,
+      "name": "Secure Evidence Hasher",
+      "lang": "python",
+      "difficulty": 2,
+      "category": "reporting",
+      "prompt": "Write a Python module for chain-of-custody evidence handling in digital investigations. Must: compute SHA-256 and MD5 hashes of files (streaming, handle files of any size), generate a timestamped evidence receipt (JSON) with file name, size, hashes, collection timestamp, collector name, and case ID, verify a file against a previously generated receipt, maintain an append-only evidence log in a SQLite database, and support batch processing of a directory (hash all files, generate manifest). Include integrity verification that detects any modified files. Use only hashlib, sqlite3, and standard library."
+    },
+    {
+      "id": 15,
+      "name": "Investigation Case Manager",
+      "lang": "python",
+      "difficulty": 5,
+      "category": "reporting",
+      "prompt": "Write a Python module that manages OSINT investigation cases. A case contains: case ID, subject info, status (open/active/closed), assigned investigators list, a timeline of events, collected evidence records, data source logs, and notes. Must support: creating and updating cases in SQLite, adding timeline events with automatic timestamping, linking evidence (files with hashes) to cases, generating a case summary report, searching across cases by subject name or keyword, tracking investigation hours per investigator, and exporting a complete case as a single JSON file for sharing. All data must be stored in a normalized SQLite schema (cases, events, evidence, investigators, notes tables). Include CLI with subcommands: create, update, add-event, add-evidence, report, search, export."
+    }
+  ]
+}

reasoning_lab.py

@@ -0,0 +1,279 @@
+"""
+REASONING LAB
+=============
+Autonomous training ground for Harvester's reasoning engine.
+Feeds hard architectural problems through reason() → run_engine(),
+banking reasoning plans, patterns, and failure lessons.
+
+The code follows the reasoning. Not the other way around.
+
+Usage:
+  python reasoning_lab.py                 # run all tasks
+  python reasoning_lab.py --task 5        # run only task #5
+  python reasoning_lab.py --list          # list all tasks
+  python reasoning_lab.py --reason-only   # reason without coding (thinking drills)
+  python reasoning_lab.py --difficulty 4  # only tasks with difficulty >= 4
+  python reasoning_lab.py --category ai   # only tasks in a specific category
+"""
+
+import os
+import sys
+import json
+import time
+import argparse
+
+sys.path.insert(0, os.path.dirname(__file__))
+
+from growth_engine import run_growth_engine, init_db, show_stats
+from reflection_engine import reason, set_language, set_task_mode, ReasoningPlan
+
+# ── Config ────────────────────────────────────────────────────────────────────
+
+DEFAULT_TASK_BANK = os.path.join(os.path.dirname(__file__), "reasoning_tasks.json")
+RESULTS_DIR = os.path.join(os.path.dirname(__file__), "lab_results")
+
+# ── Load tasks ────────────────────────────────────────────────────────────────
+
+def load_tasks(
+    task_id: int = None,
+    min_difficulty: int = None,
+    category: str = None,
+    bank_path: str = None
+) -> list[dict]:
+    path = bank_path or DEFAULT_TASK_BANK
+    with open(path, "r", encoding="utf-8") as f:
+        bank = json.load(f)
+
+    tasks = bank["tasks"] if isinstance(bank, dict) else bank
+
+    # Normalize field names across bank formats
+    for t in tasks:
+        if "prompt" not in t and "description" in t:
+            t["prompt"] = t["description"]
+        if "lang" not in t and "language" in t:
+            t["lang"] = t["language"]
+
+    if task_id is not None:
+        tasks = [t for t in tasks if t["id"] == task_id]
+    if min_difficulty is not None:
+        tasks = [t for t in tasks if t["difficulty"] >= min_difficulty]
+    if category is not None:
+        tasks = [t for t in tasks if t["category"] == category.lower()]
+
+    return tasks
+
+
+# ── Reason-only mode ──────────────────────────────────────────────────────────
+
+def run_reason_only(tasks: list[dict]) -> list[dict]:
+    """
+    Pure thinking drills. No code generation.
+    Exercises reason() and banks the plans for review.
+    """
+    results = []
+    for i, task in enumerate(tasks, 1):
+        print(f"\n{'='*60}")
+        print(f"  REASONING DRILL {i}/{len(tasks)}")
+        print(f"  [{task['difficulty']}★] {task['name']}")
+        print(f"  Category: {task['category']}")
+        print(f"{'='*60}")
+
+        set_language(task["lang"])
+        t0 = time.time()
+        plan = reason(task["prompt"])
+        elapsed = time.time() - t0
+
+        result = {
+            "task_id":       task["id"],
+            "name":          task["name"],
+            "difficulty":    task["difficulty"],
+            "category":      task["category"],
+            "approach":      plan.approach,
+            "sub_problems":  plan.sub_problems,
+            "steps":         plan.steps,
+            "edge_cases":    plan.edge_cases,
+            "confidence":    plan.confidence,
+            "time_secs":     round(elapsed, 1)
+        }
+        results.append(result)
+
+        print(f"\n  ⏱  Reasoning took {elapsed:.1f}s")
+        print(f"  📊 Confidence: {plan.confidence:.0%}")
+        print(f"  🧩 Sub-problems: {len(plan.sub_problems)}")
+        print(f"  📝 Steps: {len(plan.steps)}")
+        print(f"  ⚠️  Edge cases: {len(plan.edge_cases)}")
+
+    return results
+
+
+# ── Full lab mode ─────────────────────────────────────────────────────────────
+
+def run_full_lab(tasks: list[dict]) -> list[dict]:
+    """
+    Full pipeline: reason → generate → reflect → score → learn.
+    Every run makes the engine permanently smarter.
+    """
+    results = []
+    for i, task in enumerate(tasks, 1):
+        print(f"\n{'='*60}")
+        print(f"  REASONING LAB — TASK {i}/{len(tasks)}")
+        print(f"  [{task['difficulty']}★] {task['name']}")
+        print(f"  Category: {task['category']}")
+        print(f"{'='*60}")
+
+        t0 = time.time()
+        attempt = run_growth_engine(task["prompt"], lang=task["lang"])
+        elapsed = time.time() - t0
+
+        result = {
+            "task_id":      task["id"],
+            "name":         task["name"],
+            "difficulty":   task["difficulty"],
+            "category":     task["category"],
+            "score":        attempt.score,
+            "passed":       attempt.passed,
+            "iterations":   attempt.iteration,
+            "time_secs":    round(elapsed, 1),
+            "reflections":  attempt.reflections[:5],
+            "errors":       attempt.errors[:3]
+        }
+        results.append(result)
+
+        status = "PASS" if attempt.passed else "FAIL"
+        print(f"\n  {'='*40}")
+        print(f"  {status} — Score: {attempt.score:.1f}% in {attempt.iteration} iterations ({elapsed:.0f}s)")
+        print(f"  {'='*40}")
+
+    return results
+
+
+# ── Report ────────────────────────────────────────────────────────────────────
+
+def save_report(results: list[dict], mode: str):
+    os.makedirs(RESULTS_DIR, exist_ok=True)
+    timestamp = time.strftime("%Y%m%d_%H%M%S")
+    filename = f"lab_{mode}_{timestamp}.json"
+    filepath = os.path.join(RESULTS_DIR, filename)
+
+    report = {
+        "mode":       mode,
+        "timestamp":  timestamp,
+        "task_count": len(results),
+        "results":    results
+    }
+
+    # Add summary stats
+    if mode == "full":
+        scores = [r["score"] for r in results]
+        passed = sum(1 for r in results if r["passed"])
+        report["summary"] = {
+            "passed":     passed,
+            "failed":     len(results) - passed,
+            "avg_score":  round(sum(scores) / len(scores), 1) if scores else 0,
+            "best_score": max(scores) if scores else 0,
+            "worst_score": min(scores) if scores else 0,
+            "total_time": round(sum(r["time_secs"] for r in results), 1)
+        }
+    elif mode == "reason":
+        confs = [r["confidence"] for r in results]
+        report["summary"] = {
+            "avg_confidence": round(sum(confs) / len(confs), 2) if confs else 0,
+            "high_confidence": sum(1 for c in confs if c >= 0.7),
+            "low_confidence":  sum(1 for c in confs if c < 0.5),
+            "total_time": round(sum(r["time_secs"] for r in results), 1)
+        }
+
+    with open(filepath, "w", encoding="utf-8") as f:
+        json.dump(report, f, indent=2)
+
+    print(f"\n  📄 Report saved: {filepath}")
+    return report
+
+
+def print_summary(report: dict):
+    s = report.get("summary", {})
+    mode = report["mode"]
+    print(f"\n{'='*60}")
+    print(f"  REASONING LAB — SUMMARY ({mode.upper()} MODE)")
+    print(f"{'='*60}")
+    print(f"  Tasks run: {report['task_count']}")
+
+    if mode == "full":
+        print(f"  Passed:    {s.get('passed', 0)}")
+        print(f"  Failed:    {s.get('failed', 0)}")
+        print(f"  Avg score: {s.get('avg_score', 0)}%")
+        print(f"  Best:      {s.get('best_score', 0)}%")
+        print(f"  Worst:     {s.get('worst_score', 0)}%")
+    elif mode == "reason":
+        print(f"  Avg confidence:  {s.get('avg_confidence', 0):.0%}")
+        print(f"  High confidence: {s.get('high_confidence', 0)} tasks")
+        print(f"  Low confidence:  {s.get('low_confidence', 0)} tasks")
+
+    print(f"  Total time: {s.get('total_time', 0)}s")
+    print(f"{'='*60}")
+
+
+# ── CLI ───────────────────────────────────────────────────────────────────────
+
+def main():
+    parser = argparse.ArgumentParser(description="Reasoning Lab — train Harvester's thinking")
+    parser.add_argument("--task", type=int, help="Run a specific task by ID")
+    parser.add_argument("--list", action="store_true", help="List all tasks")
+    parser.add_argument("--reason-only", action="store_true", help="Reason without coding")
+    parser.add_argument("--difficulty", type=int, help="Only tasks with difficulty >= N")
+    parser.add_argument("--category", type=str, help="Only tasks in this category")
+    parser.add_argument("--bank", type=str, help="Path to task bank JSON (default: reasoning_tasks.json)")
+    args = parser.parse_args()
+
+    # List mode
+    if args.list:
+        tasks = load_tasks(bank_path=args.bank)
+        print(f"\n  REASONING LAB — {len(tasks)} TASKS")
+        print(f"  {'='*50}")
+        for t in tasks:
+            print(f"  [{t['id']:2d}] [{t['difficulty']}★] {t['name']:<35} ({t['category']})")
+        categories = sorted(set(t["category"] for t in tasks))
+        print(f"\n  Categories: {', '.join(categories)}")
+        return
+
+    # Init database
+    init_db()
+
+    # Load filtered tasks
+    tasks = load_tasks(
+        task_id=args.task,
+        min_difficulty=args.difficulty,
+        category=args.category,
+        bank_path=args.bank
+    )
+
+    if not tasks:
+        print("  No tasks matched your filters.")
+        return
+
+    print(f"\n  REASONING LAB — {len(tasks)} task(s) queued")
+
+    # Auto-detect task mode from bank name: OSINT/Bellingcat → DeepSeek R1, else → Qwen
+    bank_name = os.path.basename(args.bank or "").lower()
+    if any(kw in bank_name for kw in ("osint", "bellingcat", "investigation", "missing")):
+        set_task_mode("reasoning")
+    else:
+        set_task_mode("code")
+
+    # Run
+    if args.reason_only:
+        results = run_reason_only(tasks)
+        report = save_report(results, "reason")
+    else:
+        results = run_full_lab(tasks)
+        report = save_report(results, "full")
+
+    print_summary(report)
+
+    # Show growth stats
+    print()
+    show_stats()
+
+
+if __name__ == "__main__":
+    main()

reasoning_tasks.json

@@ -0,0 +1,128 @@
+{
+  "metadata": {
+    "description": "Reasoning Lab task bank — hard architectural problems that force decomposition, planning, and edge-case thinking. Each task exercises the reason() pipeline before code generation.",
+    "difficulty_scale": "1-5 (1=straightforward, 3=multi-system, 5=architectural nightmare)"
+  },
+  "tasks": [
+    {
+      "id": 1,
+      "name": "State Machine Framework",
+      "lang": "csharp",
+      "difficulty": 2,
+      "category": "architecture",
+      "prompt": "Design and implement a generic hierarchical state machine framework for Unity. Must support: nested sub-states, transition conditions with guards, OnEnter/OnExit/OnUpdate callbacks, state history for undo, and serializable state definitions via ScriptableObject. Namespace: SevenDTD.Core. No MonoBehaviour dependency in the core FSM — it should be pure C# that a MonoBehaviour wrapper can drive."
+    },
+    {
+      "id": 2,
+      "name": "Object Pool with Warmup",
+      "lang": "csharp",
+      "difficulty": 2,
+      "category": "performance",
+      "prompt": "Build a generic object pool system for Unity that supports: configurable warm-up count, automatic expansion when exhausted, shrink-back to baseline after cooldown period, per-pool statistics (borrows, returns, expansions, peak usage), thread-safe borrow/return for use with Jobs, and IPoolable interface with OnBorrow/OnReturn callbacks. Namespace: SevenDTD.Core. Must work with any Component type via generics."
+    },
+    {
+      "id": 3,
+      "name": "Event Bus with Priorities",
+      "lang": "csharp",
+      "difficulty": 3,
+      "category": "architecture",
+      "prompt": "Implement a decoupled event bus system for a Unity MMO. Requirements: generic typed events (publish EventType, subscribe to EventType), priority ordering for listeners, one-shot subscriptions that auto-unsubscribe after first fire, event queuing with configurable flush-per-frame limit to avoid spikes, weak references to prevent memory leaks from destroyed GameObjects, and debug mode that logs all events with subscriber counts. Namespace: SevenDTD.Core. Pure C# singleton — no MonoBehaviour."
+    },
+    {
+      "id": 4,
+      "name": "Dynamic Loot Table System",
+      "lang": "csharp",
+      "difficulty": 3,
+      "category": "game_systems",
+      "prompt": "Build a loot drop system for an MMO. Must support: rarity tiers (Common/Uncommon/Rare/Epic/Legendary) with configurable weight curves, loot tables defined as ScriptableObjects with nested sub-tables, pity system that increases rare drop chance after N drops without one, level-scaled drops where item stats scale to player level, guaranteed drops vs random drops in the same table, and world-event modifiers that temporarily alter drop rates globally. Namespace: SevenDTD.MMO."
+    },
+    {
+      "id": 5,
+      "name": "Skill Tree with Prerequisites",
+      "lang": "csharp",
+      "difficulty": 4,
+      "category": "game_systems",
+      "prompt": "Architect a skill tree system for an MMO where: skills form a directed acyclic graph with multiple prerequisite paths, each skill has level tiers (1-5) with scaling effects, skills can have cooldowns and resource costs (mana, stamina, rage — polymorphic), passive skills apply permanent stat modifiers, active skills have cast times and can be interrupted, skill synergies give bonuses when specific combinations are unlocked, and the entire tree is serializable for save/load. Namespace: SevenDTD.MMO. Must handle circular dependency detection at edit-time."
+    },
+    {
+      "id": 6,
+      "name": "Chunk-Based World Streaming",
+      "lang": "csharp",
+      "difficulty": 4,
+      "category": "architecture",
+      "prompt": "Design a chunk-based world streaming system for a networked MMO in Unity. Requirements: world divided into chunks on a 2D grid, chunks load/unload based on player proximity with configurable view distance, async loading using Addressables or Resources.LoadAsync, chunk state persistence (modified blocks, placed objects) to disk, server-authoritative chunk ownership (only server decides what loads), client receives chunk data via Netcode NetworkVariable or custom messages, LOD system where distant chunks use simplified meshes, and neighbor-stitching to prevent seams at chunk borders. Namespace: SevenDTD.MMO."
+    },
+    {
+      "id": 7,
+      "name": "Dynamic Economy System",
+      "lang": "csharp",
+      "difficulty": 5,
+      "category": "game_systems",
+      "prompt": "Build a player-driven economy system for an MMO. Must handle: item prices that fluctuate based on supply/demand across all connected players, auction house with bidding and buyout, price history tracking (last 24h, 7d, 30d) for UI graphs, anti-manipulation safeguards (detect price spiking, wash trading), NPC vendors with dynamic restock that responds to player purchasing patterns, crafting cost calculation that factors in material market prices, tax system configurable per transaction type, and currency sinks to prevent inflation. Namespace: SevenDTD.MMO. Server-authoritative — all price calculations on server."
+    },
+    {
+      "id": 8,
+      "name": "Ability Combo System",
+      "lang": "csharp",
+      "difficulty": 3,
+      "category": "game_systems",
+      "prompt": "Implement a combo system for an action MMO where: abilities can chain into follow-up abilities within a timing window, combo trees are data-driven (ScriptableObject definitions), each node in the combo tree has: animation trigger, damage multiplier, stamina cost, hit timing window for next link, combo finishers deal bonus damage based on chain length, input buffering so the next ability queues during current animation, and network-synchronized so other players see the combo animations. Namespace: SevenDTD.MMO. Must work with Unity.Netcode."
+    },
+    {
+      "id": 9,
+      "name": "Pathfinding with Dynamic Obstacles",
+      "lang": "csharp",
+      "difficulty": 4,
+      "category": "ai",
+      "prompt": "Build an A* pathfinding system for NPCs in a Unity MMO that handles: grid-based navigation with variable node costs, dynamic obstacle avoidance (obstacles that appear/disappear at runtime), path smoothing to remove jagged corners, hierarchical pathfinding (coarse grid for long distances, fine grid near destination), partial path return when full path is impossible (get as close as possible), multi-agent coordination to prevent NPCs from overlapping, and configurable heuristics (Manhattan, Euclidean, Octile). Namespace: SevenDTD.AI. Must not use Unity's NavMesh — pure custom implementation."
+    },
+    {
+      "id": 10,
+      "name": "Quest System with Branching",
+      "lang": "csharp",
+      "difficulty": 5,
+      "category": "game_systems",
+      "prompt": "Architect a quest system for an MMO that supports: branching quest lines where player choices affect future quest availability, multiple objective types (kill N, collect N, escort NPC, reach location, interact with object, talk to NPC, craft item), objectives that can be AND or OR combined (complete all vs complete any), timed objectives with fail conditions, quest sharing in a party where progress syncs for shared objectives, reputation rewards that unlock new quest givers, quest log with tracking and waypoint markers, and prerequisite chains (must complete quest A before quest B unlocks). Namespace: SevenDTD.MMO. All quest data defined in ScriptableObjects — zero hardcoded quest logic."
+    },
+    {
+      "id": 11,
+      "name": "ECS-Style Component Registry",
+      "lang": "csharp",
+      "difficulty": 4,
+      "category": "architecture",
+      "prompt": "Implement a lightweight Entity-Component-System pattern in pure C# for Unity (not using Unity DOTS). Requirements: entities are just integer IDs, components are plain structs stored in contiguous arrays per type, systems iterate over entities that have specific component combinations (archetype queries), support add/remove components at runtime with structural change buffering, observer pattern for component lifecycle (OnAdd, OnRemove), serialize/deserialize entire world state to byte array, and a simple query API like world.Query<Position, Velocity>() that returns matching entity sets. Namespace: SevenDTD.Core."
+    },
+    {
+      "id": 12,
+      "name": "Dialogue System with Conditions",
+      "lang": "csharp",
+      "difficulty": 3,
+      "category": "game_systems",
+      "prompt": "Build a dialogue system for an MMO where: dialogue trees are ScriptableObject-based with nodes and edges, each dialogue choice can have conditions (check quest state, reputation, inventory items, player level), dialogue can trigger actions (give item, start quest, change reputation, teleport player), support for branching based on player stats or prior choices, localization-ready with string keys instead of hardcoded text, NPC mood/disposition that changes based on player interactions, and a simple runtime API: StartDialogue(npcId), ChooseOption(index), GetCurrentNode(). Namespace: SevenDTD.MMO."
+    },
+    {
+      "id": 13,
+      "name": "Replay System",
+      "lang": "csharp",
+      "difficulty": 5,
+      "category": "architecture",
+      "prompt": "Design a gameplay replay system for a networked game that: records all player inputs and game state snapshots at configurable intervals, supports playback at variable speed (0.25x to 4x) with pause/seek, uses delta compression — only store what changed between snapshots, handles entity spawn/despawn during replay, can export replay to a binary file and reimport it, supports camera modes during playback (follow player, free cam, overview), and synchronizes replay across multiple spectators via network. Namespace: SevenDTD.Core. Must handle 60+ entities with position/rotation/state."
+    },
+    {
+      "id": 14,
+      "name": "Procedural Dungeon Generator",
+      "lang": "csharp",
+      "difficulty": 4,
+      "category": "procedural",
+      "prompt": "Build a procedural dungeon generator that: uses BSP (Binary Space Partitioning) to create room layouts, connects rooms with corridors ensuring full connectivity, places doors between rooms and corridors, supports room templates (boss room, treasure room, trap room) with weighted selection, generates spawn points for enemies scaled by room size and distance from entrance, places loot containers with rarity scaling by depth, ensures a valid path from entrance to boss room exists, and outputs a 2D tile grid that a separate renderer can consume. Namespace: SevenDTD.Procedural. Pure C# — no Unity dependencies in the generator."
+    },
+    {
+      "id": 15,
+      "name": "Networked Crafting System",
+      "lang": "csharp",
+      "difficulty": 3,
+      "category": "game_systems",
+      "prompt": "Implement a crafting system for a networked MMO. Requirements: recipes defined in ScriptableObjects with ingredient lists and quantities, crafting takes real time with a progress bar (not instant), server validates all crafting requests (client can't cheat), crafting stations — different stations unlock different recipe categories, recipe discovery — players learn recipes by finding recipe items or leveling crafting skill, quality system where higher crafting skill produces higher quality items with better stats, batch crafting — queue multiple of the same recipe, and crafting interruption — taking damage cancels active crafting. Namespace: SevenDTD.MMO. Must use Unity.Netcode RPCs for client-server communication."
+    }
+  ]
+}

reflection_engine.py

@@ -0,0 +1,1156 @@
+"""
+SELF-REFLECTION ENGINE
+======================
+The brain of the self-improving code AI.
+Uses Ollama locally to write, reflect, and improve Python code
+until it hits a 99.5% benchmark floor.
+
+Engineering philosophy:
+
+  NEVER GIVE UP:
+    If a problem is hard, it's a challenge. Not a wall — a ladder.
+    When iterations fail, don't accept it. Re-reason with what you learned.
+    Escalate strategy. Change the angle of attack. The engine persists
+    because the builder persists.
+
+  RADIAL SLOP:
+    There is no perfection in engineering — that's why we target 99.5%, not 100%.
+    A bolt threads into a hole because of radial slop: the tiny imperfection
+    that makes the interface work. Code is the same — some tolerance is by design.
+    Chase diminishing returns and you'll over-engineer or hallucinate problems.
+
+  WORK > CODE > TALK:
+    Three modes of output — know the difference:
+      WORK  — does the code actually run, pass tests, and solve the task?
+      CODE  — is the code itself clean, correct, and structured?
+      TALK  — chatty prose, philosophical rambling, markdown explanations.
+    The engine cares about WORK and CODE. TALK is waste.
+
+  THE LADDER:
+    Everything has a logical pattern. When things fail, backtrack from the
+    closest point to the break, then work back one rung at a time.
+    Follow the steps and nothing can hide. Don't guess — trace.
+
+Architecture:
+  1. Generate code
+  2. Run it / test it
+  3. If it BROKE → troubleshoot (ladder: start at the error, walk backwards)
+  4. If it ran → score it
+  5. If score < 99.5 → reflect on WHY → improve → repeat
+  6. If stuck → re-reason with accumulated failure context → new angle of attack
+  7. If score >= 99.5 → ship it (good enough IS good enough)
+  8. If max iterations → report what was tried and what the next attack vector would be
+"""
+
+import subprocess
+import tempfile
+import textwrap
+import json
+import time
+import sys
+import re
+import os
+from dataclasses import dataclass, field
+from typing import Optional
+import requests
+from code_whitelist import validate_code
+
+# ── TALK detection ────────────────────────────────────────────────────────────
+
+# Patterns that signal conversational / non-code input
+_TALK_PATTERNS = [
+    # Greetings
+    r"^(hey|hi|hello|yo|sup|howdy|hiya|greetings)\b",
+    # Status checks
+    r"^are you\b",
+    r"^you (are|there|up|awake|alive|with us|listening|around)\b",
+    r"^how are you",
+    r"^how('?s| is) it going",
+    r"^who are you",
+    # General knowledge questions (no code signals required)
+    r"^what is \w+\??$",
+    r"^what are \w+\??$",
+    r"^what('?s| is) (up|good|new|your name|happening)",
+    r"^what('?s| is) a \w+\??$",
+    r"^what('?s| is) an \w+\??$",
+    r"^what does \w+ mean\??$",
+    r"^(describe|explain|define) \w+\??$",
+    r"^tell me about\b",
+    r"^do you know (about|what)?\b",
+    # Acknowledgments / reactions
+    r"^thanks?\b",
+    r"^thank you",
+    r"^good (morning|afternoon|evening|night|job|one)\b",
+    r"^(yes|no|ok|okay|sure|yep|nah|nope|cool|nice|great|awesome|perfect|sounds good)$",
+    r"^what can you do",
+    r"^(help|help me)$",
+    r"^(bye|goodbye|see ya|later|peace|cheers)\b",
+    r"^(lol|lmao|haha|ha)\b",
+    r"^(please|pls)\b$",
+    # System checks
+    r"^is (this|that|it) (working|on|alive|running)",
+    r"^anybody (there|home|here)",
+    r"^can you hear me",
+    r"^still (there|alive|awake|with us|running)",
+    r"^you still (there|alive|awake|with us)",
+    r"^are we good",
+    r"^what(')?s crackin",
+    # Capability / conversational questions
+    r"^(can|could|would|will|do) you\b",
+    r"^(is it|are there)\b",
+    r"^(should|shall) (i|we)\b",
+    r"^do you (like|think|have|want|need|know)\b",
+]
+_TALK_RE = re.compile("|".join(_TALK_PATTERNS), re.IGNORECASE)
+
+# Keywords that strongly signal a CODE task even if phrased conversationally
+_CODE_SIGNALS = [
+    "function", "class", "import", "def ", "return", "loop",
+    "sort", "parse", "api", "endpoint", "database", "file",
+    "algorithm", "test", "assert", "calculate", "convert",
+    "build", "create", "implement", "write", "generate",
+    "fix", "debug", "refactor", "optimize", "deploy",
+]
+
+
+def classify_task(task: str) -> str:
+    """
+    Classify input as 'WORK' (code task) or 'TALK' (conversation).
+    If it looks like conversation and has no code keywords → TALK.
+    """
+    stripped = task.strip().rstrip("?!.")
+    lower = stripped.lower()
+    word_count = len(stripped.split())
+    has_code = any(kw in lower for kw in _CODE_SIGNALS)
+
+    # TALK pattern match with no code keywords → TALK (any length)
+    if _TALK_RE.search(stripped) and not has_code:
+        return "TALK"
+
+    # Very short input (≤ 6 words) with no code signals → likely TALK
+    if word_count <= 6 and not has_code:
+        return "TALK"
+
+    return "WORK"
+
+
+# ── Config ────────────────────────────────────────────────────────────────────
+
+OLLAMA_URL      = "http://localhost:11434/api/generate"
+LM_STUDIO_URL   = "http://localhost:1234/v1/chat/completions"
+BACKEND         = os.environ.get("CODE_ENGINE_BACKEND", "auto")  # "ollama", "lmstudio", "native", or "auto"
+MODEL           = os.environ.get("CODE_ENGINE_MODEL", "llama3.2")
+LM_STUDIO_MODEL = os.environ.get("LM_STUDIO_MODEL", "")
+BENCHMARK_FLOOR = float(os.environ.get("BENCHMARK_FLOOR", "99.5"))
+MAX_ITERATIONS  = int(os.environ.get("MAX_ITERATIONS", "10"))
+TIMEOUT_SECS    = 30                # per code-run timeout
+
+# ── Native backend config (no LM Studio / Ollama needed) ─────────────────────
+# Qwen — the coder
+NATIVE_HF_REPO     = os.environ.get("NATIVE_HF_REPO", "lmstudio-community/Qwen3-Coder-30B-A3B-Instruct-GGUF")
+NATIVE_HF_FILE     = os.environ.get("NATIVE_HF_FILE", "Qwen3-Coder-30B-A3B-Instruct-Q4_K_M.gguf")
+NATIVE_MODEL_PATH  = os.environ.get("NATIVE_MODEL_PATH", r"D:\va_data\models\Qwen3-Coder-30B-A3B-Instruct-Q4_K_M.gguf")
+# DeepSeek R1 14B — the reasoner (Opus Reasoning 27B when hardware ready)
+REASONER_HF_REPO   = os.environ.get("REASONER_HF_REPO", "bartowski/DeepSeek-R1-Distill-Qwen-14B-GGUF")
+REASONER_HF_FILE   = os.environ.get("REASONER_HF_FILE", "DeepSeek-R1-Distill-Qwen-14B-Q4_K_M.gguf")
+REASONER_MODEL_PATH = os.environ.get("REASONER_MODEL_PATH", r"D:\va_data\models\DeepSeek-R1-Distill-Qwen-14B-Q4_K_M.gguf")
+# GPU layers to offload (0 = CPU only, -1 = all layers to GPU)
+NATIVE_GPU_LAYERS  = int(os.environ.get("NATIVE_GPU_LAYERS", "0"))
+NATIVE_CTX_SIZE    = int(os.environ.get("NATIVE_CTX_SIZE", "8192"))
+_native_llm = None    # lazy singleton — Qwen (coder)
+_reasoning_llm = None # lazy singleton — DeepSeek R1 (reasoner)
+
+# ── Task mode routing ─────────────────────────────────────────────────────────
+# "code" → Qwen for generation, "reasoning" → DeepSeek R1 for thinking/OSINT
+_TASK_MODE = "code"  # default
+
+def set_task_mode(mode: str):
+    """Set which model handles native calls. 'code' = Qwen, 'reasoning' = DeepSeek R1."""
+    global _TASK_MODE
+    mode = mode.lower().strip()
+    if mode in ("reasoning", "osint", "bellingcat", "investigation"):
+        _TASK_MODE = "reasoning"
+    else:
+        _TASK_MODE = "code"
+    print(f"  🧠 Task mode: {_TASK_MODE} ({'DeepSeek R1' if _TASK_MODE == 'reasoning' else 'Qwen Coder'})")
+
+def get_task_mode() -> str:
+    return _TASK_MODE
+
+# ── Data structures ───────────────────────────────────────────────────────────
+
+@dataclass
+class CodeAttempt:
+    iteration:    int
+    code:         str
+    score:        float
+    passed:       bool
+    test_output:  str
+    errors:       list[str]
+    reflections:  list[str] = field(default_factory=list)
+
+@dataclass
+class ReflectionResult:
+    what_failed:       str
+    root_cause:        str
+    improvement_plan:  str
+    specific_fix:      str
+    confidence:        float        # 0-1: how confident the model is in the fix
+
+@dataclass
+class TroubleshootResult:
+    """The ladder — start at the break, walk backwards rung by rung."""
+    error_line:        str          # the exact line / traceback that broke
+    ladder:            list[str]    # rungs walked back: each step traced
+    root_cause:        str          # the actual bottom rung — why it broke
+    fix:               str          # minimal code change to un-break it
+    confidence:        float        # 0-1
+
+@dataclass
+class ReasoningPlan:
+    """Think before you code. Decompose → plan → then generate."""
+    sub_problems:      list[str]    # task broken into parts
+    approach:          str          # algorithm / data structure / architecture choice
+    edge_cases:        list[str]    # things that could bite you
+    steps:             list[str]    # ordered implementation steps
+    confidence:        float        # 0-1: how clear is the path
+
+# ── Ollama interface ──────────────────────────────────────────────────────────
+
+def _resolve_model_path(model_path, hf_repo, hf_file):
+    """Resolve a GGUF path: use local override, check LM Studio cache, or download."""
+    if model_path and os.path.isfile(model_path):
+        return model_path
+    # Check LM Studio cache
+    lms_path = os.path.join(
+        os.path.expanduser("~"), ".lmstudio", "models",
+        hf_repo.replace("/", os.sep), hf_file
+    )
+    if os.path.isfile(lms_path):
+        print(f"  ✓ Found local GGUF: {os.path.basename(lms_path)}")
+        return lms_path
+    # Download from HuggingFace
+    print(f"  ⬇ Downloading {hf_file} from {hf_repo}...")
+    from huggingface_hub import hf_hub_download
+    path = hf_hub_download(repo_id=hf_repo, filename=hf_file)
+    print(f"  ✓ Downloaded to: {path}")
+    return path
+
+
+def _load_native_model():
+    """Load Qwen (coder) natively via llama-cpp-python."""
+    global _native_llm
+    if _native_llm is not None:
+        return _native_llm
+
+    from llama_cpp import Llama
+    model_path = _resolve_model_path(NATIVE_MODEL_PATH, NATIVE_HF_REPO, NATIVE_HF_FILE)
+
+    print(f"  ⏳ Loading Qwen coder (gpu_layers={NATIVE_GPU_LAYERS}, ctx={NATIVE_CTX_SIZE})...")
+    _native_llm = Llama(
+        model_path=model_path,
+        n_ctx=NATIVE_CTX_SIZE,
+        n_gpu_layers=NATIVE_GPU_LAYERS,
+        verbose=False
+    )
+    print(f"  ✓ Qwen coder loaded: {os.path.basename(model_path)}")
+    return _native_llm
+
+
+def _load_reasoning_model():
+    """Load DeepSeek R1 (reasoner) natively via llama-cpp-python."""
+    global _reasoning_llm
+    if _reasoning_llm is not None:
+        return _reasoning_llm
+
+    from llama_cpp import Llama
+    model_path = _resolve_model_path(REASONER_MODEL_PATH, REASONER_HF_REPO, REASONER_HF_FILE)
+
+    print(f"  ⏳ Loading DeepSeek R1 (gpu_layers={NATIVE_GPU_LAYERS}, ctx={NATIVE_CTX_SIZE})...")
+    _reasoning_llm = Llama(
+        model_path=model_path,
+        n_ctx=NATIVE_CTX_SIZE,
+        n_gpu_layers=NATIVE_GPU_LAYERS,
+        verbose=False
+    )
+    print(f"  ✓ DeepSeek R1 loaded: {os.path.basename(model_path)}")
+    return _reasoning_llm
+
+
+def _call_native(prompt: str, system: str = "", temperature: float = 0.3) -> str:
+    """Call the appropriate native model based on task mode.
+    reasoning/osint → DeepSeek R1, code → Qwen Coder."""
+    if _TASK_MODE == "reasoning":
+        llm = _load_reasoning_model()
+        model_label = "DeepSeek R1"
+    else:
+        llm = _load_native_model()
+        model_label = "Qwen Coder"
+    messages = []
+    if system:
+        messages.append({"role": "system", "content": system})
+    messages.append({"role": "user", "content": prompt})
+
+    # Trim prompt if it exceeds context budget
+    total_chars = sum(len(m["content"]) for m in messages)
+    max_chars = NATIVE_CTX_SIZE * 3  # rough char-to-token ratio
+    if total_chars > max_chars:
+        messages[-1]["content"] = messages[-1]["content"][:max_chars - 500] + "\n[trimmed to fit context]"
+
+    result = llm.create_chat_completion(
+        messages=messages,
+        temperature=temperature,
+        max_tokens=4096
+    )
+    text = result["choices"][0]["message"]["content"].strip()
+
+    # DeepSeek R1 wraps output in <think>...</think> — strip it
+    if "<think>" in text:
+        text = re.sub(r'<think>.*?</think>', '', text, flags=re.DOTALL).strip()
+
+    return text
+
+
+def _detect_backend() -> str:
+    """Auto-detect which backend is running. Tries LM Studio → Ollama → native."""
+    if BACKEND != "auto":
+        return BACKEND
+    # Try LM Studio first (fastest — already running as a server)
+    try:
+        r = requests.get("http://localhost:1234/v1/models", timeout=3)
+        if r.status_code == 200:
+            models = r.json().get("data", [])
+            if models:
+                global LM_STUDIO_MODEL
+                if not LM_STUDIO_MODEL:
+                    LM_STUDIO_MODEL = models[0].get("id", "")
+                print(f"  ✓ LM Studio detected (model: {LM_STUDIO_MODEL})")
+                return "lmstudio"
+    except Exception:
+        pass
+    # Try Ollama
+    try:
+        r = requests.get("http://localhost:11434/api/tags", timeout=3)
+        if r.status_code == 200:
+            print(f"  ✓ Ollama detected (model: {MODEL})")
+            return "ollama"
+    except Exception:
+        pass
+    # Fall back to native — Harvester is a complete unit
+    # Check that at least one model file exists (don't eagerly load into RAM)
+    try:
+        if _TASK_MODE == "reasoning":
+            model_path = _resolve_model_path(REASONER_MODEL_PATH, REASONER_HF_REPO, REASONER_HF_FILE)
+        else:
+            model_path = _resolve_model_path(NATIVE_MODEL_PATH, HF_REPO, HF_FILE)
+        if os.path.isfile(model_path):
+            return "native"
+        raise FileNotFoundError(f"Model not found: {model_path}")
+    except Exception as e:
+        print(f"\n[ERROR] Native backend failed: {e}")
+    print("\n[ERROR] No backend found. Options:")
+    print("  1. Start LM Studio and load a model")
+    print("  2. Run `ollama serve` then `ollama pull llama3.2`")
+    print("  3. Set NATIVE_MODEL_PATH to a .gguf file (or let it download from HuggingFace)")
+    sys.exit(1)
+
+
+def _call_lmstudio(prompt: str, system: str = "", temperature: float = 0.3) -> str:
+    """Call LM Studio OpenAI-compatible endpoint."""
+    messages = []
+    if system:
+        messages.append({"role": "system", "content": system})
+    messages.append({"role": "user", "content": prompt})
+    payload = {
+        "model": LM_STUDIO_MODEL or "local-model",
+        "messages": messages,
+        "temperature": temperature,
+        "max_tokens": 4096,
+        "stream": False
+    }
+    for attempt in range(3):
+        try:
+            r = requests.post(LM_STUDIO_URL, json=payload, timeout=180)
+        except requests.exceptions.ReadTimeout:
+            print(f"  [LM Studio TIMEOUT] attempt {attempt+1}/3 — trimming prompt")
+            messages[-1]["content"] = messages[-1]["content"][:2000] + "\n\n[trimmed — keep response short]"
+            if "max_tokens" in payload:
+                payload["max_tokens"] = 2048
+            continue
+        if r.status_code == 200:
+            return r.json()["choices"][0]["message"]["content"].strip()
+        # Log the error
+        err_body = r.text[:500] if r.text else "(empty)"
+        print(f"  [LM Studio {r.status_code}] attempt {attempt+1}/3: {err_body}")
+        if r.status_code >= 500 or r.status_code == 429:
+            time.sleep(2 ** attempt)
+            continue
+        # 400 — context overflow is the #1 cause with small models
+        is_context_overflow = "context size" in err_body.lower() or "context length" in err_body.lower()
+        if attempt == 0:
+            if is_context_overflow:
+                # Aggressive trim — cut to 1500 chars, drop system msg, halve max_tokens
+                messages[-1]["content"] = messages[-1]["content"][:1500] + "\n[trimmed for context]"
+                messages = [m for m in messages if m["role"] != "system"]
+                payload["messages"] = messages
+                payload["max_tokens"] = 2048
+            else:
+                messages[-1]["content"] = messages[-1]["content"][:2500] + "\n[trimmed]"
+                if "max_tokens" in payload:
+                    payload["max_tokens"] = 2048
+            continue
+        if attempt == 1:
+            # Nuclear trim — bare minimum prompt
+            messages[-1]["content"] = messages[-1]["content"][:1000] + "\n[trimmed hard]"
+            messages = [m for m in messages if m["role"] != "system"]
+            payload["messages"] = messages
+            payload.pop("max_tokens", None)
+            continue
+        # attempt 2 — strip non-ASCII + minimal prompt as last resort
+        content = messages[-1]["content"][:800]
+        clean = content.encode('ascii', 'ignore').decode('ascii')
+        messages[-1]["content"] = clean
+        payload["messages"] = messages
+        try:
+            r2 = requests.post(LM_STUDIO_URL, json=payload, timeout=180)
+        except requests.exceptions.ReadTimeout:
+            break
+        if r2.status_code == 200:
+            return r2.json()["choices"][0]["message"]["content"].strip()
+    raise RuntimeError("LM Studio: all attempts failed (400/timeout)")
+
+
+def _call_ollama(prompt: str, system: str = "", temperature: float = 0.3) -> str:
+    """Call local Ollama model."""
+    payload = {
+        "model": MODEL,
+        "prompt": prompt,
+        "system": system,
+        "stream": False,
+        "options": {"temperature": temperature}
+    }
+    r = requests.post(OLLAMA_URL, json=payload, timeout=120)
+    r.raise_for_status()
+    return r.json().get("response", "").strip()
+
+
+_ACTIVE_BACKEND = None
+
+def ollama(prompt: str, system: str = "", temperature: float = 0.3) -> str:
+    """Call local LLM (LM Studio, Ollama, or native). Returns response text."""
+    global _ACTIVE_BACKEND
+    if _ACTIVE_BACKEND is None:
+        _ACTIVE_BACKEND = _detect_backend()
+    try:
+        if _ACTIVE_BACKEND == "native":
+            return _call_native(prompt, system, temperature)
+        elif _ACTIVE_BACKEND == "lmstudio":
+            return _call_lmstudio(prompt, system, temperature)
+        else:
+            return _call_ollama(prompt, system, temperature)
+    except requests.exceptions.ConnectionError:
+        # If a server backend drops, try falling back to native
+        if _ACTIVE_BACKEND in ("lmstudio", "ollama"):
+            print(f"\n  ⚠ Lost connection to {_ACTIVE_BACKEND} — falling back to native...")
+            try:
+                _ACTIVE_BACKEND = "native"
+                return _call_native(prompt, system, temperature)
+            except Exception:
+                pass
+        print(f"\n[ERROR] Lost connection to {_ACTIVE_BACKEND}")
+        print("  → Make sure your LLM backend is still running")
+        sys.exit(1)
+    except (requests.exceptions.ReadTimeout, requests.exceptions.Timeout):
+        print(f"\n[ERROR] LLM timed out — model may be overloaded")
+        print("  → Try a smaller model or restart LM Studio")
+        raise RuntimeError("LLM timeout — model too slow for this prompt")
+    except requests.exceptions.HTTPError as e:
+        print(f"\n[ERROR] LLM returned HTTP error: {e}")
+        raise RuntimeError(f"LLM backend error: {e}") from e
+
+# ── Language config ────────────────────────────────────────────────────────────
+
+# Supported languages and their generation config
+_LANG_CONFIG = {
+    "python": {
+        "expert": "Python engineer",
+        "extension": ".py",
+        "fence": "python",
+        "system": """You write only clean Python code.
+No markdown. No backticks. No prose. No conversation. No talk.
+Just raw executable Python starting with imports or function definitions.
+Always include test assertions at the bottom of the file.
+Remember: WORK (does it run?) and CODE (is it clean?) are all that matter.
+TALK (explanations, commentary) is forbidden.""",
+        "executable": True,
+    },
+    "csharp": {
+        "expert": "Unity C# engineer (Unity 6, URP, Netcode for GameObjects)",
+        "extension": ".cs",
+        "fence": "csharp",
+        "system": """You write only clean Unity C# code.
+No markdown. No backticks. No prose. No conversation. No talk.
+Just raw C# starting with using directives.
+Use Unity 6 APIs and Netcode for GameObjects where networking is needed.
+Remember: WORK (does it compile and function?) and CODE (is it clean?) matter.
+TALK (explanations, commentary) is forbidden.""",
+        "executable": False,  # no C# compiler in the loop — review-scored
+    },
+}
+
+# Active language for this run (set via set_language())
+_ACTIVE_LANG = "python"
+
+def set_language(lang: str):
+    """Set the active language for code generation."""
+    global _ACTIVE_LANG
+    lang = lang.lower().strip()
+    if lang in ("cs", "c#", "unity"):
+        lang = "csharp"
+    if lang not in _LANG_CONFIG:
+        print(f"  [WARN] Unknown language '{lang}' — defaulting to python")
+        lang = "python"
+    _ACTIVE_LANG = lang
+    print(f"  Language: {_ACTIVE_LANG} ({_LANG_CONFIG[lang]['expert']})")
+
+def get_language() -> str:
+    return _ACTIVE_LANG
+
+# ── Code generation ───────────────────────────────────────────────────────────
+
+def generate_code(task: str, previous_attempt: Optional[CodeAttempt] = None,
+                  reflection: Optional[ReflectionResult] = None,
+                  reasoning: Optional[ReasoningPlan] = None) -> str:
+    """Generate code for a task in the active language, with optional improvement context."""
+    lang = _LANG_CONFIG[_ACTIVE_LANG]
+    expert = lang["expert"]
+    fence = lang["fence"]
+
+    if previous_attempt and reflection:
+        # Improvement pass — give it specific direction
+        clean_task = task.split("\n\n[PRIOR KNOWLEDGE FROM MEMORY]")[0] if "[PRIOR KNOWLEDGE" in task else task
+        prev_code = previous_attempt.code
+        if len(prev_code) > 800:
+            prev_code = prev_code[:300] + "\n// ...[middle trimmed]...\n" + prev_code[-500:]
+        prompt = f"""Expert {expert}. Fix this code. Output ONLY working {fence}. No talk. No markdown.
+
+TASK: {clean_task}
+
+PREVIOUS CODE (scored {previous_attempt.score:.1f}%):
+{prev_code}
+
+WHAT FAILED: {reflection.what_failed}
+ROOT CAUSE: {reflection.root_cause}
+FIX: {reflection.specific_fix}
+
+Write the complete fixed code. No explanation."""
+
+    else:
+        # First attempt — use reasoning plan if available
+        reasoning_block = ""
+        if reasoning and reasoning.confidence > 0.2:
+            steps_str = "\n".join(f"  {j}. {s}" for j, s in enumerate(reasoning.steps, 1))
+            edges_str = ", ".join(reasoning.edge_cases[:4]) if reasoning.edge_cases else "none identified"
+            reasoning_block = f"""
+
+YOUR REASONING PLAN (follow this):
+  Approach: {reasoning.approach}
+  Steps:
+{steps_str}
+  Edge cases to handle: {edges_str}
+
+Implement the plan above. Do not deviate unless the plan is clearly wrong."""
+
+        if _ACTIVE_LANG == "python":
+            prompt = f"""You are an expert {expert}. Target: 99.5%% quality — not perfection.
+Radial slop: a bolt threads because it's imperfect. Some tolerance is by design.
+
+There are three kinds of output: WORK, CODE, and TALK.
+- WORK = does it run, pass tests, solve the task? This is what matters most.
+- CODE = is it clean, readable, well-structured? This matters second.
+- TALK = prose, explanations, markdown, philosophy. This is WASTE. Zero talk.
+
+TASK: {task}{reasoning_block}
+
+Write clean, efficient Python code to accomplish this task.
+- Handle common edge cases (don't invent unlikely scenarios)
+- Include sensible error handling — no defensive paranoia
+- Write at least 3 meaningful test cases as assert statements at the bottom
+- Correctness first, then readability, then performance
+
+Return ONLY the Python code. No explanation. No markdown fences. No talk."""
+        else:
+            prompt = f"""You are an expert {expert}. Target: 99.5%% quality — not perfection.
+
+There are three kinds of output: WORK, CODE, and TALK.
+- WORK = does it compile and function correctly? This is what matters most.
+- CODE = is it clean, readable, well-structured? This matters second.
+- TALK = prose, explanations, markdown, philosophy. This is WASTE. Zero talk.
+
+TASK: {task}{reasoning_block}
+
+Write clean, production-quality {fence} code.
+- Handle common edge cases (don't invent unlikely scenarios)
+- Use proper namespace, class structure, and access modifiers
+- Correctness first, then readability, then performance
+
+Return ONLY the {fence} code. No explanation. No markdown fences. No talk."""
+
+    system = lang["system"]
+    return ollama(prompt, system=system, temperature=0.2)
+
+# ── Code execution & scoring ──────────────────────────────────────────────────
+
+def run_code(code: str) -> tuple[bool, str, list[str]]:
+    """
+    Execute code in a subprocess sandbox (Python) or review-score it (other languages).
+    Returns: (success, output, errors)
+    """
+    lang = _ACTIVE_LANG
+    lang_cfg = _LANG_CONFIG[lang]
+
+    # Safety check — validate against multi-language whitelist
+    validation = validate_code(code, language=lang)
+    if not validation.safe:
+        return False, "", [f"BLOCKED: {b}" for b in validation.blocked]
+
+    # Non-executable languages → LLM review scoring
+    if not lang_cfg["executable"]:
+        return _review_score_code(code, lang)
+
+    errors = []
+    output = ""
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.py',
+                                     delete=False, encoding='utf-8') as f:
+        f.write(code)
+        tmp_path = f.name
+
+    try:
+        result = subprocess.run(
+            [sys.executable, tmp_path],
+            capture_output=True, text=True,
+            timeout=TIMEOUT_SECS
+        )
+        output = result.stdout.strip()
+        if result.returncode != 0:
+            errors.append(result.stderr.strip())
+            success = False
+        else:
+            success = True
+    except subprocess.TimeoutExpired:
+        errors.append(f"TIMEOUT: code exceeded {TIMEOUT_SECS}s")
+        success = False
+    except Exception as e:
+        errors.append(str(e))
+        success = False
+    finally:
+        os.unlink(tmp_path)
+
+    return success, output, errors
+
+
+def _review_score_code(code: str, lang: str) -> tuple[bool, str, list[str]]:
+    """
+    For non-executable languages (C#, etc), use LLM code review as scoring.
+    Returns: (success, review_output, errors_found)
+    """
+    print("  📝 Review-scoring (no compiler available)...")
+    # Trim code for context budget
+    code_snippet = code[:2000] if len(code) > 2000 else code
+    prompt = f"""You are a strict code reviewer for {lang}. Score this code 0-100.
+
+CODE:
+{code_snippet}
+
+Score on:
+1. Does it look like it would compile? (40 points)
+2. Is the logic correct for the stated purpose? (30 points)
+3. Is it clean and well-structured? (20 points)
+4. Edge cases handled? (10 points)
+
+Respond ONLY with JSON:
+{{"score": 85, "errors": ["list of issues found"], "notes": "brief summary"}}"""
+    raw = ollama(prompt, temperature=0.1)
+    try:
+        match = re.search(r'\{.*\}', raw, re.DOTALL)
+        if match:
+            data = json.loads(match.group())
+            score = float(data.get("score", 50))
+            errors = data.get("errors", [])
+            notes = data.get("notes", "")
+            success = score >= BENCHMARK_FLOOR
+            return success, f"Review score: {score:.0f}% — {notes}", errors if not success else []
+    except Exception:
+        pass
+    return False, "Review parsing failed", ["Could not parse review response"]
+
+
+def score_code(code: str, task: str, success: bool,
+               output: str, errors: list[str]) -> float:
+    """
+    WORK-first scoring. Did it run? Did tests pass? That's what matters.
+    For non-executable languages, uses the review score from _review_score_code.
+    """
+    lang_cfg = _LANG_CONFIG[_ACTIVE_LANG]
+
+    # Non-executable languages: extract score from review output
+    if not lang_cfg["executable"]:
+        match = re.search(r'Review score:\s*(\d+)', output)
+        if match:
+            return float(match.group(1))
+        return 50.0 if success else 30.0
+
+    # Python: execution-based scoring
+    if not success:
+        if errors and "AssertionError" in str(errors):
+            return 35.0   # ran but assertions failed — close
+        if errors and "AssertError" in str(errors):
+            return 35.0
+        return 20.0       # didn't run at all
+
+    if not errors:
+        return 100.0
+
+    return 85.0
+
+# ── Self-reflection ───────────────────────────────────────────────────────────
+
+def reflect(task: str, attempt: CodeAttempt) -> ReflectionResult:
+    """
+    The core of the engine.
+    Forces the model to diagnose failure before attempting a fix.
+    This is what makes it self-improving rather than just retrying.
+    """
+    print(f"\n  🧠 Reflecting on iteration {attempt.iteration} (score: {attempt.score:.1f}%)...")
+    expert = _LANG_CONFIG[_ACTIVE_LANG]["expert"]
+    fence = _LANG_CONFIG[_ACTIVE_LANG]["fence"]
+
+    reflection_prompt = f"""You are a senior {expert} conducting a code review.
+
+ENGINEERING PRINCIPLES:
+- Never give up. If it's hard, it's a challenge. Change the angle of attack.
+- Radial slop: target 99.5%, not 100%. The tiny tolerance is a feature.
+
+Your job is to evaluate TWO things and ONLY two things:
+1. WORK — does the code actually run, pass its tests, and solve the stated task?
+2. CODE — is the code clean, readable, and reasonably efficient?
+
+Do NOT produce TALK — no philosophical commentary, no essays about best practices,
+no restating the task. Diagnose real issues in the fewest words possible.
+If the code works and is clean, say so and move on.
+
+TASK: {task}
+
+CODE (scored {attempt.score:.1f}% — target is 99.5%):
+```{fence}
+{attempt.code}
+```
+
+EXECUTION OUTPUT: {attempt.test_output}
+ERRORS: {attempt.errors}
+
+Diagnose only REAL issues. Answer with precision:
+
+1. WHAT_FAILED: What specifically is broken or missing? (If nothing real, say "minor gap")
+2. ROOT_CAUSE: Why? What assumption was wrong?
+3. IMPROVEMENT_PLAN: Practical steps to reach 99.5% — not 100%. Don't over-engineer.
+4. SPECIFIC_FIX: The single most impactful code change. Keep it minimal.
+5. CONFIDENCE: How confident are you this fix will work? (0.0 to 1.0)
+
+Respond ONLY with a JSON object (no other text):
+{{
+  "what_failed": "...",
+  "root_cause": "...",
+  "improvement_plan": "...",
+  "specific_fix": "...",
+  "confidence": 0.85
+}}"""
+
+    raw = ollama(reflection_prompt, temperature=0.2)
+
+    try:
+        raw = re.sub(r'```.*?```', '', raw, flags=re.DOTALL).strip()
+        # Find JSON block if surrounded by text
+        match = re.search(r'\{.*\}', raw, re.DOTALL)
+        if match:
+            raw = match.group()
+        data = json.loads(raw)
+        return ReflectionResult(
+            what_failed      = data.get("what_failed", "Unknown failure"),
+            root_cause       = data.get("root_cause", "Unknown cause"),
+            improvement_plan = data.get("improvement_plan", "Retry"),
+            specific_fix     = data.get("specific_fix", "Rewrite"),
+            confidence       = float(data.get("confidence", 0.5))
+        )
+    except Exception:
+        return ReflectionResult(
+            what_failed      = "Parsing failed — raw output: " + raw[:200],
+            root_cause       = "Model did not return valid JSON",
+            improvement_plan = "Rewrite code from scratch with stricter constraints",
+            specific_fix     = "Full rewrite",
+            confidence       = 0.4
+        )
+
+# ── Troubleshooter (the ladder) ───────────────────────────────────────────────
+
+def troubleshoot(task: str, attempt: CodeAttempt) -> TroubleshootResult:
+    """
+    The ladder method: start at the break, walk backwards rung by rung.
+    Everything has a logical pattern. Follow the steps, nothing hides.
+    
+    This is NOT reflect(). Reflect is for code that RUNS but scored low.
+    Troubleshoot is for code that BROKE — crashed, errored, wouldn't execute.
+    """
+    print(f"\n  🪜 Troubleshooting iteration {attempt.iteration} (ladder method)...")
+    fence = _LANG_CONFIG[_ACTIVE_LANG]["fence"]
+
+    # Build the error context — start at the closest point to the break
+    error_text = "\n".join(attempt.errors) if attempt.errors else "Unknown error"
+    
+    ts_prompt = f"""You are a troubleshooter. Use the LADDER METHOD:
+
+NEVER GIVE UP. If the error looks hard, it's a challenge — not a wall.
+
+THE LADDER: Start at the exact point of failure. Read the error message.
+Then walk backwards through the code one step at a time — like climbing
+down a ladder rung by rung. Every failure has a logical pattern.
+Follow the steps and nothing can hide.
+
+Do NOT guess. Do NOT skip rungs. Trace the actual execution path.
+
+Rules:
+- Output is WORK only. Zero TALK.
+- Start at the error (top of ladder)
+- Walk back through each line that led to it
+- Find the root cause (bottom rung)
+- Give one minimal fix
+
+TASK: {task}
+
+CODE:
+```{fence}
+{attempt.code}
+```
+
+ERROR (start here — this is the top of the ladder):
+{error_text}
+
+OUTPUT (if any): {attempt.test_output}
+
+Walk the ladder. Respond ONLY with JSON — zero talk:
+{{
+  "error_line": "the exact error or traceback line",
+  "ladder": [
+    "RUNG 1 (error): what broke",
+    "RUNG 2 (one step back): what called it or fed it bad data",
+    "RUNG 3 (deeper): the actual source of the problem"
+  ],
+  "root_cause": "the bottom rung — the real reason",
+  "fix": "minimal code change to un-break it",
+  "confidence": 0.85
+}}"""
+
+    raw = ollama(ts_prompt, temperature=0.2)
+
+    try:
+        raw = re.sub(r'```.*?```', '', raw, flags=re.DOTALL).strip()
+        match = re.search(r'\{.*\}', raw, re.DOTALL)
+        if match:
+            raw = match.group()
+        data = json.loads(raw)
+        result = TroubleshootResult(
+            error_line = data.get("error_line", error_text[:200]),
+            ladder     = data.get("ladder", ["Could not trace"]),
+            root_cause = data.get("root_cause", "Unknown"),
+            fix        = data.get("fix", "Rewrite"),
+            confidence = float(data.get("confidence", 0.5))
+        )
+    except Exception:
+        result = TroubleshootResult(
+            error_line = error_text[:200],
+            ladder     = ["Parsing failed — could not walk ladder"],
+            root_cause = "Model did not return valid JSON",
+            fix        = "Full rewrite",
+            confidence = 0.3
+        )
+
+    # Print the ladder
+    print(f"  🪜 Error: {result.error_line[:100]}")
+    for j, rung in enumerate(result.ladder, 1):
+        print(f"     ↓ Rung {j}: {rung[:100]}")
+    print(f"  ⚡ Root cause: {result.root_cause[:100]}")
+    print(f"  🔧 Fix: {result.fix[:100]}")
+
+    return result
+
+
+def _troubleshoot_to_reflection(ts: TroubleshootResult) -> ReflectionResult:
+    """Convert a TroubleshootResult into a ReflectionResult so the
+    improvement pass can consume it uniformly."""
+    return ReflectionResult(
+        what_failed      = ts.error_line,
+        root_cause       = ts.root_cause,
+        improvement_plan = " → ".join(ts.ladder),
+        specific_fix     = ts.fix,
+        confidence       = ts.confidence
+    )
+
+
+# ── Reasoning engine (think before you code) ──────────────────────────────────
+
+def reason(task: str) -> ReasoningPlan:
+    """
+    Chain-of-thought reasoning BEFORE code generation.
+    Decomposes the task, picks an approach, spots edge cases, and builds a plan.
+    This is the difference between 'generate and hope' and 'think then build'.
+    """
+    print(f"\n  🧩 Reasoning about the task...")
+    expert = _LANG_CONFIG[_ACTIVE_LANG]["expert"]
+    fence = _LANG_CONFIG[_ACTIVE_LANG]["fence"]
+
+    # Strip memory context for cleaner reasoning
+    clean_task = task.split("\n\n[PRIOR KNOWLEDGE")[0].strip() if "[PRIOR KNOWLEDGE" in task else task
+
+    reason_prompt = f"""You are an expert {expert}. THINK about this task before writing any code.
+
+PRINCIPLE: If a problem is hard, it's a challenge — not a blocker.
+Never give up on a hard problem. Decompose it. Find the angle of attack.
+The harder it looks, the more value there is in solving it.
+
+TASK: {clean_task}
+
+Break it down. Plan your approach. Identify what could go wrong.
+If the task seems complex, break it into smaller winnable pieces.
+Do NOT write code. Just THINK.
+
+Respond ONLY with JSON — zero talk:
+{{
+  "sub_problems": ["problem 1", "problem 2", "problem 3"],
+  "approach": "the algorithm, data structure, or architecture you'd use and WHY",
+  "edge_cases": ["edge case 1", "edge case 2"],
+  "steps": ["step 1: ...", "step 2: ...", "step 3: ..."],
+  "confidence": 0.85
+}}"""
+
+    raw = ollama(reason_prompt, temperature=0.3)
+
+    try:
+        raw = re.sub(r'```.*?```', '', raw, flags=re.DOTALL).strip()
+        match = re.search(r'\{.*\}', raw, re.DOTALL)
+        if match:
+            raw = match.group()
+        data = json.loads(raw)
+        plan = ReasoningPlan(
+            sub_problems = data.get("sub_problems", [clean_task]),
+            approach     = data.get("approach", "Direct implementation"),
+            edge_cases   = data.get("edge_cases", []),
+            steps        = data.get("steps", ["Implement the task"]),
+            confidence   = float(data.get("confidence", 0.5))
+        )
+    except Exception:
+        plan = ReasoningPlan(
+            sub_problems = [clean_task],
+            approach     = "Direct implementation (reasoning parse failed)",
+            edge_cases   = [],
+            steps        = ["Implement the task directly"],
+            confidence   = 0.3
+        )
+
+    # Print the plan
+    print(f"  🧩 Approach: {plan.approach[:120]}")
+    print(f"  🧩 Sub-problems: {len(plan.sub_problems)}")
+    for j, step in enumerate(plan.steps, 1):
+        print(f"     {j}. {step[:100]}")
+    if plan.edge_cases:
+        print(f"  ⚠️  Edge cases: {', '.join(e[:60] for e in plan.edge_cases[:4])}")
+    print(f"  🎲 Confidence: {plan.confidence:.0%}")
+
+    return plan
+
+
+# ── Main engine loop ──────────────────────────────────────────────────────────
+
+def run_engine(task: str, talk_memory: str = "") -> CodeAttempt:
+    """
+    Main self-improvement loop.
+    Runs until benchmark floor is hit or max iterations reached.
+    """
+    # ── TALK gate: don't spin up the code loop for conversation ──
+    # Strip any enrichment context so classify sees the raw task
+    raw_task = task.split("\n\n[PRIOR KNOWLEDGE")[0].strip() if "[PRIOR KNOWLEDGE" in task else task
+    task_type = classify_task(raw_task)
+    if task_type == "TALK":
+        print(f"\n  💬 TALK detected — responding conversationally, no code loop.")
+        memory_block = ""
+        if talk_memory:
+            memory_block = f"\n\n[YOUR MEMORY — reference this when relevant]\n{talk_memory}\n"
+        reply = ollama(
+            f"The user said: {task}{memory_block}\nRespond naturally and helpfully. Reference your memory if the user asks what you know, what you've learned, or about past work. Keep it concise — a few sentences max.",
+            system="You are Harvester, a self-improving AI code engine with persistent memory. You have a database of coding patterns, failure lessons, and task history that you can recall. When asked what you know or remember, reference your memory. Never say you don't remember — you DO have memory. Answer knowledge questions clearly. For greetings, respond warmly. Never output code, function definitions, or test cases. Just plain conversational text.",
+            temperature=0.5
+        )
+        return CodeAttempt(
+            iteration=0,
+            code=reply.strip(),
+            score=100.0,
+            passed=True,
+            test_output="",
+            errors=[],
+            reflections=["TALK — conversational response with memory recall"]
+        )
+
+    print(f"\n{'='*60}")
+    print(f"  SELF-IMPROVING CODE ENGINE")
+    print(f"  Model:     {LM_STUDIO_MODEL or MODEL}")
+    print(f"  Target:    {BENCHMARK_FLOOR}%")
+    print(f"  Max loops: {MAX_ITERATIONS}")
+    print(f"{'='*60}")
+    print(f"\n  TASK: {task}\n")
+
+    # ── Reason before coding ──
+    plan = reason(task)
+
+    attempts: list[CodeAttempt] = []
+    current_code = None
+    last_reflection = None
+
+    for i in range(1, MAX_ITERATIONS + 1):
+        print(f"\n{'─'*60}")
+        print(f"  ITERATION {i} / {MAX_ITERATIONS}")
+        print(f"{'─'*60}")
+
+        # ── Generate ──
+        print("  ✍️  Generating code...")
+        last_attempt = attempts[-1] if attempts else None
+        code = generate_code(task, last_attempt, last_reflection,
+                             reasoning=plan if i == 1 else None)
+
+        # Clean up model output just in case
+        code = re.sub(r'^```python\n?', '', code.strip())
+        code = re.sub(r'^```\n?', '', code.strip())
+        code = re.sub(r'```$', '', code.strip())
+
+        # ── Execute ──
+        print("  ⚙️  Running code...")
+        success, output, errors = run_code(code)
+
+        # ── Score ──
+        print("  📊 Scoring...")
+        score = score_code(code, task, success, output, errors)
+
+        attempt = CodeAttempt(
+            iteration   = i,
+            code        = code,
+            score       = score,
+            passed      = score >= BENCHMARK_FLOOR,
+            test_output = output,
+            errors      = errors
+        )
+        attempts.append(attempt)
+
+        status = "✅ PASS" if attempt.passed else "❌ FAIL"
+        print(f"\n  {status} — Score: {score:.1f}%")
+        if errors:
+            print(f"  Errors: {errors[0][:120]}")
+        if output:
+            print(f"  Output: {output[:120]}")
+
+        if attempt.passed:
+            print(f"\n{'='*60}")
+            print(f"  🎯 BENCHMARK HIT on iteration {i}! Score: {score:.1f}%")
+            print(f"{'='*60}")
+            return attempt
+
+        # ── Troubleshoot or Reflect ──
+        if i < MAX_ITERATIONS:
+            if not success and errors:
+                # Code BROKE — use the ladder: backtrack from the error
+                ts_result = troubleshoot(task, attempt)
+                last_reflection = _troubleshoot_to_reflection(ts_result)
+                attempt.reflections.append(f"[LADDER] {last_reflection.improvement_plan}")
+            else:
+                # Code ran but scored low — reflect on quality
+                last_reflection = reflect(task, attempt)
+                attempt.reflections.append(last_reflection.improvement_plan)
+            print(f"  💡 Root cause: {(last_reflection.root_cause or 'unknown')[:100]}")
+            print(f"  🔧 Fix: {(last_reflection.specific_fix or 'none')[:100]}")
+            print(f"  🎲 Confidence: {last_reflection.confidence:.0%}")
+
+            # ── NEVER GIVE UP: Re-reason when stuck ──
+            # If confidence is low or we're past the halfway point with no
+            # improvement, re-reason with failure context for a new angle.
+            scores = [a.score for a in attempts]
+            stuck = (len(scores) >= 3 and max(scores[-3:]) <= max(scores) * 1.05)
+            low_confidence = last_reflection.confidence < 0.4
+
+            if stuck or low_confidence:
+                print(f"\n  🔄 NEVER GIVE UP — re-reasoning with failure context...")
+                failure_context = f"""Previous attempts failed. Here's what we know:
+- Best score so far: {max(scores):.1f}%
+- Last error: {last_reflection.root_cause}
+- Fix tried: {last_reflection.specific_fix}
+- Attempts: {len(attempts)}
+
+Original task: {task}
+
+CHANGE YOUR ANGLE OF ATTACK. The previous approach isn't working."""
+                plan = reason(failure_context)
+                # Feed new plan into next iteration
+                if plan.confidence > 0.3:
+                    print(f"  🔄 New approach: {plan.approach[:100]}")
+                    # Override: next generate_code gets the fresh plan
+                    # by injecting reasoning into the reflection
+                    last_reflection = ReflectionResult(
+                        what_failed=last_reflection.what_failed,
+                        root_cause=last_reflection.root_cause,
+                        improvement_plan=f"NEW APPROACH: {plan.approach}. Steps: {'; '.join(plan.steps[:4])}",
+                        specific_fix=f"Follow new reasoning plan: {plan.steps[0] if plan.steps else 'rethink'}",
+                        confidence=plan.confidence
+                    )
+
+    # Hit max iterations — NEVER GIVE UP: report what was tried and next attack
+    best = max(attempts, key=lambda a: a.score)
+    all_reflections = []
+    for a in attempts:
+        all_reflections.extend(a.reflections)
+    print(f"\n{'='*60}")
+    print(f"  ⚠️  Max iterations reached. Best score: {best.score:.1f}%")
+    print(f"  Approaches tried: {len(attempts)}")
+    if all_reflections:
+        print(f"  Last strategy: {all_reflections[-1][:120]}")
+    if last_reflection:
+        print(f"  Next attack would be: {last_reflection.specific_fix[:120]}")
+    print(f"  This is a challenge, not a wall. Run again to continue.")
+    print(f"{'='*60}")
+    return best
+
+
+# ── Output formatter ──────────────────────────────────────────────────────────
+
+def print_final(attempt: CodeAttempt):
+    print(f"\n{'='*60}")
+    print(f"  FINAL OUTPUT  (iteration {attempt.iteration}, score {attempt.score:.1f}%)")
+    print(f"{'='*60}\n")
+    print(attempt.code)
+    print(f"\n{'─'*60}")
+    if attempt.reflections:
+        print(f"  Improvement steps taken: {len(attempt.reflections)}")
+        for i, r in enumerate(attempt.reflections, 1):
+            print(f"  {i}. {r[:80]}")
+
+
+# ── Entry point ───────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        task = " ".join(sys.argv[1:])
+    else:
+        print("\nSELF-REFLECTION ENGINE — Interactive Mode")
+        print("─" * 40)
+        task = input("What should I build? → ").strip()
+        if not task:
+            task = "Write a function that finds all prime numbers up to N using the Sieve of Eratosthenes, with tests"
+
+    result = run_engine(task)
+    print_final(result)

requirements.txt

@@ -0,0 +1,5 @@
+# Harvester ZeroGPU dependencies
+# llama-cpp-python with CUDA support (ZeroGPU provides CUDA runtime)
+llama-cpp-python
+huggingface_hub
+requests

trust_balance_agent.py

@@ -0,0 +1,432 @@
+"""
+TRUST BALANCE AGENT
+===================
+Earned autonomy for the Harvester system.
+
+"The longer it does a good job, the guards loosen a little."
+
+This agent reads the system's track record — pass rates, confidence calibration,
+pattern library depth, failure trends — and computes a trust level that
+dynamically adjusts operational guardrails.
+
+What it adjusts (operational leash):
+  - BENCHMARK_FLOOR    (99.5% → 95% as trust grows)
+  - MAX_ITERATIONS     (10 → 5 as system needs fewer retries)
+  - AUTO_ACCEPT        (require human review → auto-accept high-confidence results)
+
+What it NEVER touches (safety is immutable):
+  - Content filters in safety_guardrails.py
+  - Blocked content patterns
+  - Rate limiters
+  - Audit logging
+
+Trust is earned slowly and lost fast.
+One bad streak resets weeks of progress.
+Because the cost of silence is carried forever — do the right thing.
+
+Usage:
+  python trust_balance_agent.py              # show current trust level
+  python trust_balance_agent.py --apply      # compute and export trust-adjusted env vars
+  python trust_balance_agent.py --history    # show trust score over time
+  python trust_balance_agent.py --reset      # reset trust to baseline (requires confirmation)
+
+Integration:
+  from trust_balance_agent import TrustBalanceAgent
+  agent = TrustBalanceAgent()
+  agent.apply_trust()   # sets os.environ with adjusted guardrail values
+"""
+
+import os
+import sys
+import sqlite3
+import json
+from datetime import datetime, timedelta
+from dataclasses import dataclass
+from typing import Optional
+
+sys.path.insert(0, os.path.dirname(__file__))
+
+DB_PATH = os.environ.get(
+    "GROWTH_DB_PATH",
+    os.path.join(os.path.dirname(os.path.abspath(__file__)), "growth_memory.db")
+)
+
+# ══════════════════════════════════════════════════════════════════════════════
+# TRUST TIERS — earned through consistent good work
+# ══════════════════════════════════════════════════════════════════════════════
+#
+# Each tier defines operational parameters the system earns the right to use.
+# Safety content filters are NEVER relaxed — only the performance leash changes.
+#
+#   Score Range  │ Tier         │ Benchmark │ MaxIter │ AutoAccept
+#   ─────────────┼──────────────┼───────────┼─────────┼───────────
+#   0  - 29      │ RESTRICTED   │ 99.5%     │ 10      │ Never
+#   30 - 49      │ SUPERVISED   │ 99.0%     │ 9       │ Never
+#   50 - 69      │ STANDARD     │ 97.0%     │ 8       │ Never
+#   70 - 84      │ TRUSTED      │ 95.0%     │ 6       │ Score >= 98%
+#   85 - 100     │ AUTONOMOUS   │ 92.0%     │ 5       │ Score >= 95%
+
+TRUST_TIERS = {
+    "RESTRICTED":  {"min_score":  0, "benchmark_floor": 99.5, "max_iterations": 10, "auto_accept_above": None},
+    "SUPERVISED":  {"min_score": 30, "benchmark_floor": 99.0, "max_iterations":  9, "auto_accept_above": None},
+    "STANDARD":    {"min_score": 50, "benchmark_floor": 97.0, "max_iterations":  8, "auto_accept_above": None},
+    "TRUSTED":     {"min_score": 70, "benchmark_floor": 95.0, "max_iterations":  6, "auto_accept_above": 98.0},
+    "AUTONOMOUS":  {"min_score": 85, "benchmark_floor": 92.0, "max_iterations":  5, "auto_accept_above": 95.0},
+}
+
+# How fast trust moves
+TRUST_GAIN_PER_PASS     = 1.5    # points per successful task
+TRUST_GAIN_BONUS_STREAK = 0.5    # extra per consecutive pass (compounds)
+TRUST_LOSS_PER_FAIL     = 5.0    # points lost per failure — trust is lost fast
+TRUST_LOSS_STREAK_MULT  = 1.5    # multiplier per consecutive failure
+TRUST_DECAY_PER_DAY     = 0.2    # idle decay — must keep proving yourself
+TRUST_CALIBRATION_PENALTY = 3.0  # penalty when overconfident
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# DATA STRUCTURES
+# ══════════════════════════════════════════════════════════════════════════════
+
+@dataclass
+class TrustState:
+    score: float
+    tier_name: str
+    benchmark_floor: float
+    max_iterations: int
+    auto_accept_above: Optional[float]
+    pass_rate: float
+    total_tasks: int
+    recent_streak: int          # positive = consecutive passes, negative = fails
+    calibration_accuracy: float
+    is_overconfident: bool
+    last_updated: str
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# TRUST BALANCE AGENT
+# ══════════════════════════════════════════════════════════════════════════════
+
+class TrustBalanceAgent:
+    """
+    Reads the system's track record and computes earned trust.
+    Trust adjusts operational parameters — never safety filters.
+    """
+
+    def __init__(self, db_path: str = DB_PATH):
+        self.db_path = db_path
+        self._init_trust_table()
+
+    def _get_db(self) -> sqlite3.Connection:
+        conn = sqlite3.connect(self.db_path)
+        conn.row_factory = sqlite3.Row
+        return conn
+
+    def _init_trust_table(self):
+        """Create trust_history table to track score over time."""
+        conn = self._get_db()
+        conn.execute("""
+            CREATE TABLE IF NOT EXISTS trust_history (
+                id          INTEGER PRIMARY KEY AUTOINCREMENT,
+                timestamp   TEXT NOT NULL,
+                trust_score REAL NOT NULL,
+                tier_name   TEXT NOT NULL,
+                reason      TEXT,
+                pass_rate   REAL,
+                streak      INTEGER
+            )
+        """)
+        conn.commit()
+        conn.close()
+
+    # ── Core: Compute Trust Score ──────────────────────────────────────────
+
+    def compute_trust(self) -> TrustState:
+        """
+        Calculate current trust from the system's actual track record.
+        No self-reporting — only what the data proves.
+        """
+        conn = self._get_db()
+
+        # Get last recorded trust score as baseline
+        last_trust = conn.execute(
+            "SELECT trust_score FROM trust_history ORDER BY id DESC LIMIT 1"
+        ).fetchone()
+        current_score = last_trust['trust_score'] if last_trust else 50.0
+
+        # Get task history (recent 100 tasks for scoring)
+        tasks = conn.execute(
+            "SELECT passed, final_score, timestamp FROM task_history "
+            "ORDER BY timestamp DESC LIMIT 100"
+        ).fetchall()
+
+        total_tasks = len(tasks)
+
+        if total_tasks == 0:
+            conn.close()
+            return self._build_state(50.0, 0, 0, 0.0, False, total_tasks)
+
+        # ── Pass rate ──
+        passed_count = sum(1 for t in tasks if t['passed'])
+        pass_rate = (passed_count / total_tasks) * 100 if total_tasks > 0 else 0
+
+        # ── Recent streak (walk backwards from most recent) ──
+        streak = 0
+        if tasks:
+            first_result = bool(tasks[0]['passed'])
+            for t in tasks:
+                if bool(t['passed']) == first_result:
+                    streak += 1 if first_result else -1
+                else:
+                    break
+
+        # ── Tasks since last trust computation ──
+        last_id = conn.execute(
+            "SELECT MAX(id) as max_id FROM trust_history"
+        ).fetchone()['max_id'] or 0
+
+        # Find tasks that happened after our last trust snapshot
+        new_tasks = conn.execute(
+            "SELECT passed, final_score FROM task_history "
+            "WHERE id > ? ORDER BY timestamp ASC",
+            (last_id,)
+        ).fetchall()
+
+        # ── Apply gains and losses from new tasks ──
+        consecutive = 0
+        for t in new_tasks:
+            if t['passed']:
+                consecutive = max(0, consecutive) + 1
+                gain = TRUST_GAIN_PER_PASS + (TRUST_GAIN_BONUS_STREAK * min(consecutive, 10))
+                current_score = min(100.0, current_score + gain)
+            else:
+                consecutive = min(0, consecutive) - 1
+                loss = TRUST_LOSS_PER_FAIL * (TRUST_LOSS_STREAK_MULT ** min(abs(consecutive) - 1, 5))
+                current_score = max(0.0, current_score - loss)
+
+        # ── Idle decay ──
+        if tasks:
+            last_task_time = datetime.fromisoformat(tasks[0]['timestamp'])
+            days_idle = (datetime.now() - last_task_time).days
+            if days_idle > 0:
+                decay = TRUST_DECAY_PER_DAY * days_idle
+                current_score = max(0.0, current_score - decay)
+
+        # ── Calibration penalty ──
+        calibration = self._get_calibration(conn)
+        if calibration['is_overconfident'] and calibration['sample_size'] > 5:
+            current_score = max(0.0, current_score - TRUST_CALIBRATION_PENALTY)
+
+        conn.close()
+
+        return self._build_state(
+            current_score, streak, total_tasks,
+            calibration['accuracy'], calibration['is_overconfident'],
+            passed_count
+        )
+
+    def _get_calibration(self, conn) -> dict:
+        """Read confidence calibration from existing confidence_log table."""
+        rows = conn.execute(
+            "SELECT stated_confidence, actual_score FROM confidence_log "
+            "ORDER BY timestamp DESC LIMIT 50"
+        ).fetchall()
+
+        if not rows:
+            return {"accuracy": 100.0, "is_overconfident": False, "sample_size": 0}
+
+        errors = [abs((r['stated_confidence'] * 100) - r['actual_score']) for r in rows]
+        avg_error = sum(errors) / len(errors)
+        overconfident = sum(
+            1 for r in rows if (r['stated_confidence'] * 100) > r['actual_score']
+        ) / len(rows) > 0.6
+
+        return {
+            "accuracy": round(100 - avg_error, 1),
+            "is_overconfident": overconfident,
+            "sample_size": len(rows)
+        }
+
+    def _build_state(self, score, streak, total, cal_accuracy, is_overconfident, passed_count) -> TrustState:
+        """Map a trust score to a tier and build the full state."""
+        tier_name = "RESTRICTED"
+        tier = TRUST_TIERS["RESTRICTED"]
+
+        for name, t in TRUST_TIERS.items():
+            if score >= t["min_score"]:
+                tier_name = name
+                tier = t
+
+        pass_rate = (passed_count / total * 100) if total > 0 else 0
+
+        return TrustState(
+            score=round(score, 1),
+            tier_name=tier_name,
+            benchmark_floor=tier["benchmark_floor"],
+            max_iterations=tier["max_iterations"],
+            auto_accept_above=tier["auto_accept_above"],
+            pass_rate=round(pass_rate, 1),
+            total_tasks=total,
+            recent_streak=streak,
+            calibration_accuracy=cal_accuracy,
+            is_overconfident=is_overconfident,
+            last_updated=datetime.now().isoformat()
+        )
+
+    # ── Apply: Set environment variables ───────────────────────────────────
+
+    def apply_trust(self) -> TrustState:
+        """
+        Compute trust and set os.environ so reflection_engine picks up
+        the adjusted guardrails on its next import.
+        """
+        state = self.compute_trust()
+
+        # Set the operational leash
+        os.environ["BENCHMARK_FLOOR"] = str(state.benchmark_floor)
+        os.environ["MAX_ITERATIONS"] = str(state.max_iterations)
+
+        # Record this trust snapshot
+        self._record_snapshot(state)
+
+        return state
+
+    def _record_snapshot(self, state: TrustState):
+        """Write trust score to history for trend tracking."""
+        conn = self._get_db()
+        conn.execute("""
+            INSERT INTO trust_history (timestamp, trust_score, tier_name, reason, pass_rate, streak)
+            VALUES (?, ?, ?, ?, ?, ?)
+        """, (
+            datetime.now().isoformat(),
+            state.score,
+            state.tier_name,
+            f"tasks={state.total_tasks} pass_rate={state.pass_rate}% streak={state.recent_streak}",
+            state.pass_rate,
+            state.recent_streak
+        ))
+        conn.commit()
+        conn.close()
+
+    # ── Display ────────────────────────────────────────────────────────────
+
+    def show_status(self):
+        """Print current trust level and what it means."""
+        state = self.compute_trust()
+
+        tier_bar = ""
+        for name in TRUST_TIERS:
+            if name == state.tier_name:
+                tier_bar += f" [{name}] "
+            else:
+                tier_bar += f"  {name.lower()}  "
+
+        print(f"\n{'='*62}")
+        print(f"  TRUST BALANCE — EARNED AUTONOMY")
+        print(f"  \"The longer it does a good job, the guards loosen a little.\"")
+        print(f"{'='*62}")
+        print(f"\n  Trust Score:    {state.score:.1f} / 100")
+        print(f"  Current Tier:   {state.tier_name}")
+        print(f"\n  {tier_bar}")
+        print(f"\n  ── What This Means ──")
+        print(f"  Benchmark Floor:  {state.benchmark_floor}%  (default: 99.5%)")
+        print(f"  Max Iterations:   {state.max_iterations}    (default: 10)")
+        if state.auto_accept_above:
+            print(f"  Auto-Accept:      Scores >= {state.auto_accept_above}%")
+        else:
+            print(f"  Auto-Accept:      Disabled (human review required)")
+        print(f"\n  ── Track Record ──")
+        print(f"  Tasks Completed:  {state.total_tasks}")
+        print(f"  Pass Rate:        {state.pass_rate}%")
+        streak_str = f"+{state.recent_streak}" if state.recent_streak > 0 else str(state.recent_streak)
+        print(f"  Current Streak:   {streak_str}")
+        print(f"  Calibration:      {state.calibration_accuracy}% accurate")
+        if state.is_overconfident:
+            print(f"  ⚠️  OVERCONFIDENT — trust penalized until calibration improves")
+        print(f"\n  ── Trust Rules ──")
+        print(f"  Gain:   +{TRUST_GAIN_PER_PASS} per pass, +{TRUST_GAIN_BONUS_STREAK} streak bonus")
+        print(f"  Loss:   -{TRUST_LOSS_PER_FAIL} per fail (x{TRUST_LOSS_STREAK_MULT} streak multiplier)")
+        print(f"  Decay:  -{TRUST_DECAY_PER_DAY} per idle day")
+        print(f"  Safety: Content filters are NEVER relaxed. Only the leash changes.")
+        print(f"\n{'='*62}\n")
+
+    def show_history(self):
+        """Print trust score trend over time."""
+        conn = self._get_db()
+        rows = conn.execute(
+            "SELECT timestamp, trust_score, tier_name, reason "
+            "FROM trust_history ORDER BY id DESC LIMIT 30"
+        ).fetchall()
+        conn.close()
+
+        if not rows:
+            print("\n  No trust history yet. Run some tasks first.\n")
+            return
+
+        print(f"\n{'='*62}")
+        print(f"  TRUST HISTORY (last {len(rows)} snapshots)")
+        print(f"{'='*62}\n")
+
+        # Reverse so oldest is first (reading top-down = timeline)
+        for r in reversed(rows):
+            ts = r['timestamp'][:16].replace('T', ' ')
+            score = r['trust_score']
+            tier = r['tier_name']
+            bar_len = int(score / 2)
+            bar = '█' * bar_len + '░' * (50 - bar_len)
+            print(f"  {ts}  {score:5.1f}  {bar}  {tier}")
+
+        print(f"\n{'='*62}\n")
+
+    def reset_trust(self, confirm: bool = False):
+        """Reset trust to baseline. Requires explicit confirmation."""
+        if not confirm:
+            print("\n  ⚠️  This will reset trust score to 50.0 (STANDARD).")
+            print("  Run with --reset --confirm to proceed.\n")
+            return
+
+        conn = self._get_db()
+        conn.execute("""
+            INSERT INTO trust_history (timestamp, trust_score, tier_name, reason, pass_rate, streak)
+            VALUES (?, 50.0, 'STANDARD', 'MANUAL RESET', NULL, 0)
+        """, (datetime.now().isoformat(),))
+        conn.commit()
+        conn.close()
+        print("\n  Trust reset to 50.0 (STANDARD). Earn it back.\n")
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# INTEGRATION HOOK — call this from growth_engine.py before running tasks
+# ══════════════════════════════════════════════════════════════════════════════
+
+def apply_trust_before_run():
+    """
+    One-liner for growth_engine.py to call before running reflection_engine.
+    Computes trust from track record and sets env vars accordingly.
+    """
+    agent = TrustBalanceAgent()
+    state = agent.apply_trust()
+    print(f"  🔒 Trust: {state.score:.1f} ({state.tier_name}) → "
+          f"floor={state.benchmark_floor}%, iters={state.max_iterations}")
+    return state
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# CLI
+# ══════════════════════════════════════════════════════════════════════════════
+
+if __name__ == "__main__":
+    agent = TrustBalanceAgent()
+
+    args = sys.argv[1:]
+
+    if "--apply" in args:
+        state = agent.apply_trust()
+        print(f"\n  Trust applied: {state.tier_name} (score={state.score:.1f})")
+        print(f"  BENCHMARK_FLOOR={state.benchmark_floor}")
+        print(f"  MAX_ITERATIONS={state.max_iterations}\n")
+    elif "--history" in args:
+        agent.show_history()
+    elif "--reset" in args:
+        agent.reset_trust(confirm="--confirm" in args)
+    else:
+        agent.show_status()