diff --git a/scripts/generate_vettings_manifest.py b/scripts/generate_vettings_manifest.py
new file mode 100644
index 00000000..22dfdc11
--- /dev/null
+++ b/scripts/generate_vettings_manifest.py
@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+"""
+Utility script to generate or update vettings-manifest.json based on contents of ./evals/.
+Scans for files matching *_summary_dao*_vetting.json and creates a manifest with path and name (timestamp).
+"""
+
+import json
+import os
+import re
+from datetime import datetime
+
+
+def generate_manifest(evals_dir="./evals", manifest_path="./evals/vettings-manifest.json"):
+    """Generate manifest from vetting summary JSON files in evals_dir."""
+    manifest = []
+    timestamp_pattern = re.compile(r"^(\d{8}_\d{6})_summary_dao.*_vetting\.json$")
+    for filename in os.listdir(evals_dir):
+        match = timestamp_pattern.match(filename)
+        if match:
+            timestamp_str = match.group(1)  # YYYYMMDD_HHMMSS
+            try:
+                timestamp = datetime.strptime(timestamp_str, "%Y%m%d_%H%M%S")
+                name = timestamp.strftime("%Y-%m-%d %H:%M:%S")
+            except ValueError:
+                name = filename
+            manifest.append({"path": f"./evals/{filename}", "name": name})
+
+    # Sort by timestamp descending
+    manifest.sort(key=lambda x: x["name"], reverse=True)
+
+    os.makedirs(os.path.dirname(manifest_path), exist_ok=True)
+    with open(manifest_path, "w") as f:
+        json.dump(manifest, f, indent=2)
+
+    print(
+        f"✅ Vettings manifest generated/updated at {manifest_path} with {len(manifest)} entries."
+    )
+
+
+if __name__ == "__main__":
+    generate_manifest()
diff --git a/scripts/test_contributor_vetting.py b/scripts/test_contributor_vetting.py
new file mode 100644
index 00000000..b81733d9
--- /dev/null
+++ b/scripts/test_contributor_vetting.py
@@ -0,0 +1,658 @@
+#!/usr/bin/env python3
+"""
+CLI test script for contributor vetting using custom LLM prompts.
+
+This script fetches unique contributors (via proposal.creator) from a DAO's past proposals,
+evaluates each for future contribution eligibility (allow/block), and saves raw JSON results.
+
+Usage:
+    python test_contributor_vetting.py --dao-name "MyDAO" --dry-run
+    python test_contributor_vetting.py --dao-name "MyDAO" --save-output
+    python test_contributor_vetting.py --dao-name "MyDAO" --max-contributors 20 --model "x-ai/grok-beta"
+"""
+
+import argparse
+import asyncio
+import json
+import logging
+import os
+import sys
+from datetime import datetime
+from typing import Dict, Any, List, Optional, Literal
+
+# Add the parent directory (root) to the path to import from app
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from app.lib.logger import StructuredFormatter, setup_uvicorn_logging
+from app.backend.factory import get_backend
+from app.backend.models import ProposalFilter, DAO, DAOFilter, Proposal
+from app.config import config
+import httpx
+from pydantic import BaseModel, Field
+from datetime import datetime
+from typing import Any, Dict, List
+from urllib.parse import urlparse
+
+from scripts.generate_vettings_manifest import generate_manifest
+
+
+# Custom Pydantic model for structured LLM output
+class ContributorVettingOutput(BaseModel):
+    contributor_id: str = Field(
+        description="Unique contributor identifier (e.g., creator address/username)"
+    )
+    x_handle: Optional[str] = Field(
+        default=None,
+        description="Primary X/Twitter handle extracted from contributor's proposals"
+    )
+    decision: Literal["allow", "block"] = Field(
+        description="Final decision: allow or block future contributions"
+    )
+    confidence_score: float = Field(
+        description="Confidence in decision (0.0-1.0)", ge=0.0, le=1.0
+    )
+    reasoning: str = Field(
+        description="Detailed reasoning with evidence from past proposals (200-400 words)"
+    )
+    proposal_count: int = Field(
+        description="Number of past proposals by this contributor"
+    )
+    notable_proposals: Optional[List[str]] = Field(
+        default=[], description="List of key proposal titles/IDs"
+    )
+
+
+class Tee(object):
+    def __init__(self, *files):
+        self.files = files
+
+    def write(self, data):
+        for f in self.files:
+            f.write(data)
+            f.flush()
+
+    def flush(self):
+        for f in self.files:
+            f.flush()
+
+
+def safe_int_votes(value: Any, default: int = 0) -> int:
+    """Safely convert value to int, handling None/non-numeric cases."""
+    if value is None:
+        return default
+    try:
+        return int(value)
+    except (ValueError, TypeError):
+        return default
+
+
+def format_proposals_for_context(proposals: List[Dict[str, Any]]) -> str:
+    """Format proposals for context in evaluation prompt (adapted from evaluation_openrouter_v2.py)."""
+    if not proposals:
+        return "None Found."
+
+    # Sort by created_at descending (newest first)
+    def get_created_at(p: Dict[str, Any]):
+        created_at = p.get("created_at")
+        if created_at:
+            try:
+                # Handle ISO format
+                if isinstance(created_at, str):
+                    return datetime.fromisoformat(created_at.replace("Z", "+00:00"))
+            except ValueError:
+                pass
+        return datetime.min
+
+    sorted_proposals = sorted(proposals, key=get_created_at, reverse=True)
+
+    formatted_proposals = []
+    for proposal in sorted_proposals:
+        # Extract basic info
+        proposal_id = str(proposal.get("proposal_id") or proposal.get("id", ""))[:8]  # Short ID
+        title = proposal.get("title", "Untitled")
+
+        # Extract x_handle from x_url
+        x_url = proposal.get("x_url", "")
+        x_handle = "unknown"
+        if x_url:
+            try:
+                parsed_path = urlparse(x_url).path.split("/")
+                if len(parsed_path) > 1:
+                    x_handle = parsed_path[1]
+            except (AttributeError, IndexError):
+                pass
+
+        # Get creation info
+        created_at_btc = proposal.get("created_btc")
+        created_at_timestamp = proposal.get("created_at")
+
+        created_str = "unknown"
+        if created_at_timestamp:
+            try:
+                if isinstance(created_at_timestamp, str):
+                    created_str = created_at_timestamp[:10]
+                else:
+                    created_str = str(created_at_timestamp)[:10]
+            except (AttributeError, ValueError):
+                created_str = str(created_at_timestamp)
+
+        if created_at_btc and created_at_timestamp:
+            created_at = f"BTC Block {created_at_btc} (at {created_str})"
+        elif created_at_btc:
+            created_at = f"BTC Block {created_at_btc}"
+        elif created_at_timestamp:
+            created_at = created_str
+        else:
+            created_at = "unknown"
+
+        # Get status
+        proposal_status = proposal.get("status")
+        passed = proposal.get("passed", False)
+        concluded = proposal.get("concluded_by") is not None
+        yes_votes = safe_int_votes(proposal.get("votes_for", 0))
+        no_votes = safe_int_votes(proposal.get("votes_against", 0))
+
+        if (
+            proposal_status
+            and isinstance(proposal_status, str)
+            and proposal_status == "FAILED"
+        ):
+            proposal_passed = "n/a (failed tx)"
+        elif passed:
+            proposal_passed = "yes"
+        elif concluded:
+            proposal_passed = "no"
+        else:
+            proposal_passed = "pending"
+
+        # handle special case of no votes
+        if concluded and (yes_votes + no_votes == 0):
+            proposal_passed = "n/a (no votes)"
+
+        # Get content
+        content = proposal.get("summary") or proposal.get("content", "")
+        content_preview = content[:500] + "..." if len(content) > 500 else content
+
+        formatted_proposal = f"""\n- #{proposal_id} by @{x_handle} Created: {created_at} Passed: {proposal_passed} Title: {title} Summary: {content_preview}"""
+
+        formatted_proposals.append(formatted_proposal)
+
+    return "\n".join(formatted_proposals)
+
+
+def reset_logging():
+    """Reset logging to a clean state with a handler to original sys.stderr."""
+    root_logger = logging.getLogger()
+    # Remove all existing handlers to clear any references to Tee/closed files
+    for handler in root_logger.handlers[:]:
+        root_logger.removeHandler(handler)
+    # Add a fresh handler to the current (original) sys.stderr
+    clean_handler = logging.StreamHandler(sys.stderr)
+    clean_handler.setFormatter(StructuredFormatter())
+    clean_handler.setLevel(logging.INFO)
+    root_logger.addHandler(clean_handler)
+    root_logger.setLevel(clean_handler.level)
+    # Propagate changes to other loggers if needed
+    for logger_name, logger in logging.Logger.manager.loggerDict.items():
+        if isinstance(logger, logging.Logger):
+            logger.setLevel(root_logger.level)
+            logger.handlers.clear()  # Clear per-logger handlers
+            logger.propagate = True
+    setup_uvicorn_logging()  # Re-apply any custom setup
+
+
+def short_uuid(uuid_str: str) -> str:
+    """Get first 8 characters of UUID for file naming."""
+    return str(uuid_str)[:8]
+
+
+VETTING_SYSTEM_PROMPT = """DAO CONTRIBUTOR GATEKEEPER
+
+You are a strict DAO gatekeeper evaluating if contributors should be allowed future submissions.
+
+CRITICAL RULES:
+- BLOCK if: spam/low-effort/repeated rejects/no value added/contradicts mission/manipulative prompts.
+- ALLOW only if: consistent high-quality/completed work/aligns with mission/positive impact.
+- Require EVIDENCE from past proposals: titles, content, outcomes (passed/executed).
+- Borderline: BLOCK unless strong positive history.
+- Ignore future promises; only past performance matters.
+
+Your output MUST follow this EXACT structure:
+
+{{
+    "contributor_id": "<contributor identifier>",
+    "x_handle": "<primary X handle or null>",
+    "decision": "<allow|block>",
+    "confidence_score": <float 0.0-1.0>,
+    "reasoning": "<detailed reasoning with evidence from past proposals (200-400 words)>",
+    "proposal_count": <int number of past proposals>,
+    "notable_proposals": ["<list of key proposal numbers/titles>"]
+}}
+
+GUIDELINES
+- Use only the specified JSON format; no extra fields or text."""
+
+VETTING_USER_PROMPT_TEMPLATE = """Evaluate contributor eligibility for future DAO contributions:
+
+DAO INFO: includes DAO name and mission
+{dao_info_for_evaluation}
+
+CONTRIBUTOR ID: {contributor_id}
+
+CONTRIBUTOR'S PAST PROPOSALS: includes all past proposals submitted by this contributor for this DAO
+{user_past_proposals_for_evaluation}
+
+Output the evaluation as a JSON object, strictly following the system guidelines."""
+
+
+async def vet_single_contributor(
+    contributor_id: str,
+    contributor_data: Dict[str, Any],
+    dao: DAO,
+    args: argparse.Namespace,
+    index: int,
+    timestamp: str,
+    backend,
+) -> Dict[str, Any]:
+    """Vet a single contributor with output redirection."""
+    log_f = None
+    original_stdout = sys.stdout
+    original_stderr = sys.stderr
+    tee_stdout = original_stdout
+    tee_stderr = original_stderr
+    if args.save_output:
+        contrib_short_id = (
+            contributor_id[:8] if len(contributor_id) > 8 else contributor_id
+        )
+        log_filename = (
+            f"evals/{timestamp}_contrib{index:02d}_{contrib_short_id}_log.txt"
+        )
+        log_f = open(log_filename, "w")
+        tee_stdout = Tee(original_stdout, log_f)
+        tee_stderr = Tee(original_stderr, log_f)
+    sys.stdout = tee_stdout
+    sys.stderr = tee_stderr
+
+    # Update logger for this contributor
+    root_logger = logging.getLogger()
+    for handler in root_logger.handlers[:]:
+        root_logger.removeHandler(handler)
+    new_handler = logging.StreamHandler(sys.stderr)
+    new_handler.setFormatter(StructuredFormatter())
+    new_handler.setLevel(logging.DEBUG if args.debug_level >= 2 else logging.INFO)
+    root_logger.addHandler(new_handler)
+    root_logger.setLevel(new_handler.level)
+    setup_uvicorn_logging()
+    for logger_name, logger in logging.Logger.manager.loggerDict.items():
+        if isinstance(logger, logging.Logger):
+            logger.setLevel(root_logger.level)
+            for handler in logger.handlers[:]:
+                logger.removeHandler(handler)
+            logger.propagate = True
+
+    try:
+        print(f"🔍 Vetting contributor {index}: {contributor_id}")
+
+        # Format contributor data using production-style helpers
+        proposals = contributor_data.get("proposals", [])
+        proposal_count = len(proposals)
+        user_past_proposals_for_evaluation = format_proposals_for_context(proposals)
+
+        dao_info = {
+            "dao_id": str(dao.id),
+            "name": dao.name or "unknown",
+            "mission": dao.mission or "unknown",
+        }
+        dao_info_for_evaluation = json.dumps(dao_info, default=str)
+
+        messages = [
+            {"role": "system", "content": VETTING_SYSTEM_PROMPT},
+            {
+                "role": "user",
+                "content": VETTING_USER_PROMPT_TEMPLATE.format(
+                    dao_info_for_evaluation=dao_info_for_evaluation,
+                    contributor_id=contributor_id,
+                    user_past_proposals_for_evaluation=user_past_proposals_for_evaluation,
+                ),
+            },
+        ]
+
+        user_prompt_filled = messages[1]["content"]
+
+        # Call OpenRouter directly with structured JSON parsing (mirrors evaluation_openrouter_v2.py)
+        openrouter_response = await call_openrouter_structured(
+            messages,
+            ContributorVettingOutput,
+            model=args.model,
+            temperature=args.temperature,
+        )
+
+        serializable_proposals = [p for p in proposals]  # Already dicts from model_dump()
+        result_dict = {
+            "contributor_id": contributor_id,
+            "contributor_data": {
+                "name": contributor_id,
+                "proposal_count": proposal_count,
+                "proposals": serializable_proposals,
+            },
+            "dao_id": str(dao.id),
+            "user_prompt_filled": user_prompt_filled,
+            "vetting_output": openrouter_response.model_dump(),
+            "usage": getattr(openrouter_response, "usage", None),
+        }
+
+        # Save JSON if requested
+        if args.save_output:
+            json_filename = (
+                f"evals/{timestamp}_contrib{index:02d}_{contrib_short_id}_raw.json"
+            )
+            with open(json_filename, "w") as f:
+                json.dump(result_dict, f, indent=2, default=str)
+            print(f"✅ Results saved to {json_filename} and {log_filename}")
+
+        return result_dict
+
+    except Exception as e:
+        error_msg = f"Error vetting contributor {contributor_id}: {str(e)}"
+        print(error_msg)
+        return {
+            "contributor_id": contributor_id,
+            "contributor_data": contributor_data,
+            "dao_id": str(dao.id),
+            "user_prompt_filled": None,
+            "error": error_msg,
+        }
+
+    finally:
+        sys.stdout.flush()
+        sys.stderr.flush()
+        sys.stdout = original_stdout
+        sys.stderr = original_stderr
+        if log_f:
+            log_f.close()
+
+
+def generate_summary(
+    results: List[Dict[str, Any]], timestamp: str, save_output: bool, dao_id: str
+) -> None:
+    """Generate a simple summary JSON (raw results array + aggregates)."""
+    allow_count = sum(
+        1 for r in results if r.get("vetting_output", {}).get("decision") == "allow"
+    )
+    block_count = sum(
+        1 for r in results if r.get("vetting_output", {}).get("decision") == "block"
+    )
+    error_count = sum(1 for r in results if "error" in r)
+
+    summary = {
+        "timestamp": timestamp,
+        "dao_id": dao_id,
+        "system_prompt": VETTING_SYSTEM_PROMPT,
+        "total_contributors": len(results),
+        "allow_count": allow_count,
+        "block_count": block_count,
+        "error_count": error_count,
+        "results": results,  # Raw array of result_dicts
+    }
+
+    print(f"Vetting Summary - {timestamp} (DAO ID: {dao_id})")
+    print("=" * 60)
+    print(f"Total Contributors: {len(results)}")
+    print(f"Allow: {allow_count} | Block: {block_count} | Errors: {error_count}")
+    print("See summary JSON for raw details.")
+    print("=" * 60)
+
+    if save_output:
+        summary_json = f"evals/{timestamp}_summary_dao{short_uuid(dao_id)}_vetting.json"
+        with open(summary_json, "w") as f:
+            json.dump(summary, f, indent=2, default=str)
+        print(f"✅ Summary saved to {summary_json}")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Test contributor vetting for a DAO using custom LLM prompts",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Dry run: list contributors without evaluating
+  python test_contributor_vetting.py --dao-name "MyDAO" --dry-run
+  
+  # Vet all contributors for a DAO
+  python test_contributor_vetting.py --dao-name "MyDAO" --save-output
+  
+  # Limit to top 10 with custom model
+  python test_contributor_vetting.py --dao-name "MyDAO" --max-contributors 10 --model "x-ai/grok-beta" --temperature 0.1
+        """,
+    )
+
+    parser.add_argument(
+        "--dao-name",
+        type=str,
+        required=True,
+        help="Name of the DAO to vet contributors for",
+    )
+
+    parser.add_argument(
+        "--max-contributors",
+        type=int,
+        default=50,
+        help="Max contributors to vet (default: 50, 0=unlimited)",
+    )
+
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Dry run: list contributors without performing LLM evaluations",
+    )
+
+    parser.add_argument(
+        "--model",
+        type=str,
+        default=None,
+        help="Model override (e.g., 'x-ai/grok-beta')",
+    )
+
+    parser.add_argument(
+        "--temperature",
+        type=float,
+        default=0.1,
+        help="Temperature for evaluation (default: 0.1)",
+    )
+
+    parser.add_argument(
+        "--debug-level",
+        type=int,
+        choices=[0, 1, 2],
+        default=0,
+        help="Debug level: 0=normal, 1=verbose, 2=very verbose (default: 0)",
+    )
+
+    parser.add_argument(
+        "--save-output",
+        action="store_true",
+        help="Save outputs to timestamped files in evals/",
+    )
+
+    args = parser.parse_args()
+
+    now = datetime.now()
+    timestamp = now.strftime("%Y%m%d_%H%M%S")
+
+    if args.save_output:
+        os.makedirs("evals", exist_ok=True)
+
+    print("🚀 Starting DAO Contributor Vetting Test")
+    print("=" * 60)
+    print(f"DAO Name: {args.dao_name}")
+    print(f"Max Contributors: {args.max_contributors}")
+    print(f"Dry Run: {args.dry_run}")
+    print(f"Model: {args.model or 'default'}")
+    print(f"Temperature: {args.temperature}")
+    print(f"Debug Level: {args.debug_level}")
+    print(f"Save Output: {args.save_output}")
+    print("=" * 60)
+
+    # Create single backend instance
+    backend = get_backend()
+
+    try:
+        # Fetch DAO by name
+        daos = backend.list_daos(DAOFilter(name=args.dao_name))
+        if not daos:
+            print(f"❌ DAO '{args.dao_name}' not found.")
+            sys.exit(1)
+        dao = daos[0]
+        print(f"✅ DAO loaded: {dao.name} (ID: {dao.id})")
+
+        # Fetch all proposals for DAO
+        proposals = backend.list_proposals(ProposalFilter(dao_id=dao.id))
+        print(f"📊 Found {len(proposals)} proposals")
+
+        if not proposals:
+            print("❌ No proposals found for DAO. Nothing to vet.")
+            sys.exit(0)
+
+        # Group by unique contributors (using proposal.creator str), full history with model_dump for serialization
+        contributors: Dict[str, List[Dict[str, Any]]] = {}
+        for p in proposals:
+            creator = p.creator
+            if creator:  # Skip if no creator
+                if creator not in contributors:
+                    contributors[creator] = []
+                contributors[creator].append(p.model_dump())
+
+        # Sort contributors by number of proposals descending (most active first)
+        contributor_list = sorted(contributors.items(), key=lambda x: len(x[1]), reverse=True)
+        if args.max_contributors > 0:
+            contributor_list = contributor_list[:args.max_contributors]
+        print(f"👥 Unique contributors to vet: {len(contributor_list)} (sorted by activity)")
+
+        if args.dry_run:
+            print("\n--- DRY RUN: Contributors that would be vetted ---")
+            for index, (contributor_id, proposals_list) in enumerate(contributor_list, 1):
+                print(f"  {index}. {contributor_id} ({len(proposals_list)} proposals)")
+            print("Dry run complete. No LLM evaluations performed.\n")
+            sys.exit(0)
+
+        results = []
+        for index, (contributor_id, proposals) in enumerate(contributor_list, 1):
+            contributor_data = {
+                "name": contributor_id,  # Use ID as name fallback
+                "proposals": proposals,  # Full history dicts
+            }
+            result = asyncio.run(
+                vet_single_contributor(
+                    contributor_id,
+                    contributor_data,
+                    dao,
+                    args,
+                    index,
+                    timestamp,
+                    backend,
+                )
+            )
+            results.append(result)
+
+        # Reset logging
+        reset_logging()
+
+        generate_summary(results, timestamp, args.save_output, str(dao.id))
+
+        generate_manifest()
+
+        print("\n🎉 Contributor vetting test completed!")
+
+    finally:
+        # Clean up backend
+        backend.sqlalchemy_engine.dispose()
+
+
+async def call_openrouter_structured(
+    messages: List[Dict[str, Any]],
+    output_model: type[BaseModel],
+    model: Optional[str] = None,
+    temperature: Optional[float] = None,
+) -> ContributorVettingOutput:
+    """Direct OpenRouter API call with JSON parsing and Pydantic validation (adapted from evaluation_openrouter_v2.py)."""
+    config_data = {
+        "api_key": config.chat_llm.api_key,
+        "model": model or config.chat_llm.default_model,
+        "temperature": temperature or config.chat_llm.default_temperature,
+        "base_url": config.chat_llm.api_base,
+    }
+
+    payload = {
+        "messages": messages,
+        "model": config_data["model"],
+        "temperature": config_data["temperature"],
+    }
+
+    headers = {
+        "Authorization": f"Bearer {config_data['api_key']}",
+        "HTTP-Referer": "https://aibtc.com",
+        "X-Title": "AIBTC",
+        "Content-Type": "application/json",
+    }
+
+    print(
+        f"📡 Calling OpenRouter: {config_data['model']} (temp={config_data['temperature']:.1f})"
+    )
+
+    async with httpx.AsyncClient(timeout=120.0) as client:
+        response = await client.post(
+            f"{config_data['base_url']}/chat/completions",
+            json=payload,
+            headers=headers,
+        )
+        response.raise_for_status()
+
+    data = response.json()
+    choices = data.get("choices", [])
+    if not choices:
+        raise ValueError("No choices in OpenRouter response")
+
+    choice_message = choices[0].get("message")
+    if not choice_message or not isinstance(choice_message.get("content"), str):
+        raise ValueError("Invalid message content in response")
+
+    try:
+        # Parse strict JSON from content
+        evaluation_json = json.loads(choice_message["content"])
+
+        # Extract usage
+        usage = data.get("usage", {})
+        input_tokens = usage.get("prompt_tokens")
+        output_tokens = usage.get("completion_tokens")
+        usage_info = (
+            {
+                "input_tokens": input_tokens,
+                "output_tokens": output_tokens,
+            }
+            if input_tokens is not None and output_tokens is not None
+            else None
+        )
+
+        # Validate with Pydantic + add usage
+        result = output_model(**evaluation_json)
+        if usage_info:
+            # Monkey-patch usage to model instance (for summary/export)
+            object.__setattr__(result, "usage", usage_info)
+
+        print(
+            f"✅ OpenRouter success: {result.decision} (conf: {result.confidence_score:.2f})"
+        )
+        return result
+
+    except json.JSONDecodeError as e:
+        print(
+            f"❌ JSON decode error: {e}\nRaw content: {choice_message['content'][:500]}..."
+        )
+        raise
+    except ValueError as e:
+        print(f"❌ Pydantic validation error: {e}")
+        raise
+
+
+if __name__ == "__main__":
+    main()
diff --git a/vetting_viewer.html b/vetting_viewer.html
new file mode 100644
index 00000000..51bf444e
--- /dev/null
+++ b/vetting_viewer.html
@@ -0,0 +1,645 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Contributor Vetting Viewer V1</title>
+    <!-- TailwindCSS via CDN for quick styling. -->
+    <script src="https://cdn.tailwindcss.com"></script>
+    <!-- Google Fonts: Inter for clean professional look. -->
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link
+      href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap"
+      rel="stylesheet"
+    />
+    <style>
+      body {
+        font-family: "Inter", sans-serif;
+      }
+      /* Brand colors for decisions. */
+      .allow-highlight {
+        background-color: #22c55e;
+        color: white;
+      }
+      .block-highlight {
+        background-color: #ef4444;
+        color: white;
+      }
+      .sort-highlight {
+        background-color: #3b82f6;
+        color: white;
+      }
+      /* Striped tables for readability. */
+      .table-striped tbody tr:nth-child(odd) {
+        background-color: #f9fafb;
+      }
+      /* Truncate long text. */
+      .text-truncate {
+        display: inline-block;
+        max-width: 30ch;
+        vertical-align: bottom;
+        white-space: nowrap;
+        overflow: hidden;
+        text-overflow: ellipsis;
+      }
+    </style>
+  </head>
+  <body class="bg-gray-50 text-gray-800">
+    <div class="container mx-auto p-4 md:p-8">
+      <!-- Header -->
+      <header class="mb-8">
+        <h1 class="text-3xl font-bold text-gray-900">Contributor Vetting Viewer V1</h1>
+        <p class="mt-2 text-lg text-gray-600">
+          Analyze contributor vetting results from JSON reports in ./evals/. View per-contributor details,
+          decisions, reasoning, confidence, past proposals, prompts, and aggregates for prompt tuning.
+        </p>
+      </header>
+
+      <!-- Summary stats injected here -->
+      <section id="summary-container" class="mb-8"></section>
+
+      <!-- Controls: sticky -->
+      <section
+        class="bg-white p-4 rounded-xl shadow-sm border border-gray-200 mb-8 flex flex-col gap-4 md:flex-row md:items-end sticky top-0 z-10"
+      >
+        <!-- Report selector -->
+        <div
+          class="flex-1"
+          id="baseline-selector-container"
+          style="display: none"
+        >
+          <label
+            for="eval-select"
+            class="block text-sm font-medium text-gray-700 mb-1"
+            >Select Vetting Report</label
+          >
+          <select
+            id="eval-select"
+            class="w-full p-2 border border-gray-300 rounded-md shadow-sm focus:ring-blue-500 focus:border-blue-500"
+          ></select>
+        </div>
+        <!-- Sort -->
+        <div class="flex-1">
+          <label
+            for="sort-select"
+            class="block text-sm font-medium text-gray-700 mb-1"
+            >Sort by</label
+          >
+          <select
+            id="sort-select"
+            class="w-full p-2 border border-gray-300 rounded-md shadow-sm focus:ring-blue-500 focus:border-blue-500"
+          >
+            <option value="confidence-desc">Confidence (High to Low)</option>
+            <option value="confidence-asc">Confidence (Low to High)</option>
+            <option value="proposals-desc">Proposal Count (High to Low)</option>
+            <option value="contributor-id-asc">Contributor ID (A-Z)</option>
+          </select>
+        </div>
+        <!-- Filter -->
+        <div class="flex-1">
+          <label
+            for="contributor-filter-select"
+            class="block text-sm font-medium text-gray-700 mb-1"
+            >Filter by Decision</label
+          >
+          <select
+            id="contributor-filter-select"
+            class="w-full p-2 border border-gray-300 rounded-md shadow-sm focus:ring-blue-500 focus:border-blue-500"
+          >
+            <option value="all">All Contributors</option>
+            <option value="allow">Allowed</option>
+            <option value="block">Blocked</option>
+            <option value="error">Errors</option>
+          </select>
+        </div>
+      </section>
+
+      <!-- Main contributor cards -->
+      <main id="vetting-container"></main>
+    </div>
+
+    <!-- Loading spinner template -->
+    <template id="loading-template">
+      <div
+        class="flex flex-col items-center justify-center p-12 bg-white rounded-xl shadow-sm border border-gray-200"
+      >
+        <svg
+          class="animate-spin h-8 w-8 text-gray-500"
+          xmlns="http://www.w3.org/2000/svg"
+          fill="none"
+          viewBox="0 0 24 24"
+        >
+          <circle
+            class="opacity-25"
+            cx="12"
+            cy="12"
+            r="10"
+            stroke="currentColor"
+            stroke-width="4"
+          ></circle>
+          <path
+            class="opacity-75"
+            fill="currentColor"
+            d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"
+          ></path>
+        </svg>
+        <p class="mt-4 text-lg font-medium text-gray-600">
+          Loading vetting reports...
+        </p>
+      </div>
+    </template>
+
+    <script type="module">
+      // Global state
+      const vettingData = new Map();
+      const vettingNames = new Map();
+      let currentVettings = [];
+
+      // Global event delegation for proposal row clicks (works with dynamic content)
+      document.addEventListener('click', (e) => {
+        const row = e.target.closest('.proposal-row');
+        if (row && row.nextElementSibling && row.nextElementSibling.classList.contains('proposal-details')) {
+          row.nextElementSibling.classList.toggle('hidden');
+        }
+      });
+
+      /**
+       * Init: Load manifest, preload reports, render first.
+       */
+      document.addEventListener("DOMContentLoaded", async () => {
+        // Bind controls
+        document.getElementById("sort-select").addEventListener("change", updateVettingView);
+        document.getElementById("contributor-filter-select").addEventListener("change", updateVettingView);
+
+        // Load manifest
+        let manifest = [];
+        try {
+          const resp = await fetch("./evals/vettings-manifest.json");
+          if (resp.ok) {
+            manifest = await resp.json();
+          }
+        } catch (err) {
+          console.warn("No vettings-manifest.json found; skipping.");
+        }
+
+        // Fallback: try known summary file if no manifest
+        if (manifest.length === 0) {
+          const fallbackFiles = ['20251213_202652_summary_daoc5d4f63f_vetting.json'];
+          for (const fname of fallbackFiles) {
+            try {
+              const resp = await fetch(`./evals/${fname}`);
+              if (resp.ok) {
+                const data = await resp.json();
+                const processed = processVettingData(data);
+                vettingData.set(fname, processed);
+                vettingNames.set(fname, 'Fallback Report');
+                manifest = [{path: `./evals/${fname}`, name: 'Fallback'}];
+                break;
+              }
+            } catch {}
+          }
+        }
+
+        // Populate selector
+        const selector = document.getElementById("eval-select");
+        manifest.forEach((report) => {
+          vettingNames.set(report.path, report.name || report.path);
+          const option = document.createElement("option");
+          option.value = report.path;
+          option.textContent = report.name || report.path;
+          selector.appendChild(option);
+        });
+
+        if (manifest.length > 0) {
+          document.getElementById("baseline-selector-container").style.display = "block";
+        }
+
+        // Preload reports
+        for (const report of manifest) {
+          try {
+            const response = await fetch(report.path);
+            if (!response.ok) continue;
+            const rawData = await response.json();
+            const processed = processVettingData(rawData);
+            vettingData.set(report.path, processed);
+          } catch (error) {
+            console.warn(`Error loading ${report.path}:`, error);
+          }
+        }
+
+        // Render first
+        const firstReport = manifest.find((r) => vettingData.has(r.path));
+        if (firstReport) {
+          selector.value = firstReport.path;
+          currentVettings = vettingData.get(firstReport.path);
+          updateViewForVetting(firstReport.path);
+        } else {
+          displayError(new Error("No vetting reports loaded. Ensure vettings-manifest.json exists."));
+        }
+      });
+
+      /**
+       * Process raw JSON into usable form with aggregates.
+       */
+      function processVettingData(data) {
+        if (!data || !data.results || !Array.isArray(data.results)) {
+          throw new Error("Invalid vetting data structure");
+        }
+
+        const contributors = data.results.map((item) => {
+          const parts = item.contributor_id.split('.');
+          const short_id = parts.length > 1 ? parts.slice(1).join('.') : item.contributor_id.slice(0, 8);
+
+          if (item.error) {
+            return {
+              contributor_id: item.contributor_id,
+              short_id,
+              error: item.error,
+              decision: null,
+              confidence: 0,
+              proposal_count: item.contributor_data?.proposal_count || 0,
+              reasoning: "",
+              notable_proposals: [],
+              proposals: item.contributor_data?.proposals || [],
+              x_handle: null,
+              usage: null,
+              raw_result: item,
+            };
+          }
+
+          const vetOut = item.vetting_output;
+          return {
+            contributor_id: item.contributor_id,
+            short_id,
+            decision: vetOut.decision === "allow",
+            confidence: vetOut.confidence_score,
+            reasoning: vetOut.reasoning,
+            proposal_count: vetOut.proposal_count,
+            notable_proposals: vetOut.notable_proposals || [],
+            proposals: item.contributor_data?.proposals || [],
+            x_handle: vetOut.x_handle || null,
+            user_prompt_filled: item.user_prompt_filled || "",
+            usage: item.usage || null,
+            raw_result: item,
+          };
+        });
+
+        // Aggregates
+        const total = contributors.length;
+        const allowed = contributors.filter((c) => c.decision === true).length;
+        const blocked = contributors.filter((c) => c.decision === false).length;
+        const errors = contributors.filter((c) => c.error).length;
+        const allowRate = total > 0 ? (allowed / total) * 100 : 0;
+        const avgConf = contributors.reduce((sum, c) => sum + (c.confidence || 0), 0) / total;
+
+        return {
+          timestamp: data.timestamp,
+          dao_id: data.dao_id,
+          dao_name: data.dao_name || "Unknown DAO",
+          system_prompt: data.system_prompt,
+          overall_stats: { total_contributors: total, allow_count: allowed, block_count: blocked, error_count: errors, allow_rate: allowRate, avg_confidence: avgConf },
+          contributors,
+        };
+      }
+
+      /**
+       * Display error in main container.
+       */
+      function displayError(error) {
+        const container = document.getElementById("vetting-container");
+        container.innerHTML = `<div class="col-span-full bg-red-100 border border-red-400 text-red-700 px-4 py-3 rounded-lg" role="alert"><strong class="font-bold">Error:</strong> ${error.message}</div>`;
+      }
+
+      /**
+       * Switch active report.
+       */
+      document.getElementById("eval-select").addEventListener("change", (e) => {
+        const path = e.target.value;
+        updateViewForVetting(path);
+      });
+
+      function updateViewForVetting(path) {
+        const vettings = vettingData.get(path);
+        if (!vettings) return;
+        currentVettings = vettings;
+        // Update header
+        const header = document.querySelector("header h1");
+        const name = vettingNames.get(path);
+        header.textContent = `Contributor Vetting Viewer V1${name ? `: ${name}` : ""}`;
+        renderSummary(vettings);
+        updateVettingView();
+      }
+
+      /**
+       * Render collapsible summary with stats and top lists.
+       */
+      function renderSummary(vettings) {
+        const container = document.getElementById("summary-container");
+        if (!vettings || vettings.contributors.length === 0) {
+          container.innerHTML = "";
+          return;
+        }
+
+        const stats = vettings.overall_stats;
+        const topAllowed = [...vettings.contributors]
+          .filter((c) => c.decision === true)
+          .sort((a, b) => b.confidence - a.confidence)
+          .slice(0, 10);
+        const topBlocked = [...vettings.contributors]
+          .filter((c) => c.decision === false && !c.error)
+          .sort((a, b) => b.confidence - a.confidence)
+          .slice(0, 10);
+
+        const createRows = (arr) => {
+          if (arr.length === 0) return "";
+          return arr.map((contrib) => {
+            const explorerUrl = `https://explorer.hiro.so/address/${contrib.contributor_id}?chain=testnet`;
+            return `
+              <tr>
+                <td class="py-3 px-4 border-b border-gray-200 text-sm text-gray-600"><a href="${explorerUrl}" target="_blank" rel="noopener noreferrer" class="font-mono hover:underline" title="View on Explorer">${contrib.contributor_id}</a></td>
+                <td class="py-3 px-4 border-b border-gray-200 text-sm text-gray-600">${contrib.x_handle || 'N/A'}</td>
+                <td class="py-3 px-4 border-b border-gray-200 text-sm text-gray-600">${contrib.proposal_count}</td>
+                <td class="py-3 px-4 border-b border-gray-200 text-sm text-gray-600 font-mono text-right">${contrib.confidence.toFixed(2)}</td>
+              </tr>
+            `;
+          }).join("");
+        };
+
+        container.innerHTML = `
+          <div class="bg-white p-6 rounded-xl shadow-sm border border-gray-200">
+            <h2 id="summary-title" class="text-2xl font-bold text-gray-800 mb-4 pb-2 border-b-2 border-gray-200 cursor-pointer flex justify-between items-center">
+              <span>Key Insights (DAO: ${vettings.dao_name})</span>
+              <svg class="w-6 h-6 transform transition-transform chevron rotate-90" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 5l7 7-7 7"></path></svg>
+            </h2>
+            <div id="summary-content" class="overflow-x-auto space-y-6">
+              <div>
+                <h3 class="font-bold mb-2">Overall Statistics</h3>
+                <table class="min-w-full table-striped text-sm text-gray-600">
+                  <thead><tr><th class="py-2 px-4 bg-gray-50 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">Statistic</th><th class="py-2 px-4 bg-gray-50 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">Value</th></tr></thead>
+                  <tbody>
+                    <tr><td class="py-2 px-4 border-b border-gray-200">Total Contributors</td><td class="py-2 px-4 border-b border-gray-200">${stats.total_contributors}</td></tr>
+                    <tr><td class="py-2 px-4 border-b border-gray-200">Allow Rate</td><td class="py-2 px-4 border-b border-gray-200">${stats.allow_rate.toFixed(1)}%</td></tr>
+                    <tr><td class="py-2 px-4 border-b border-gray-200">Avg Confidence</td><td class="py-2 px-4 border-b border-gray-200">${stats.avg_confidence.toFixed(2)}</td></tr>
+                    <tr><td class="py-2 px-4 border-b border-gray-200">Errors</td><td class="py-2 px-4 border-b border-gray-200">${stats.error_count}</td></tr>
+                  </tbody>
+                </table>
+              </div>
+              <div>
+                <h3 class="font-bold mb-2">Top Allowed</h3>
+                <table class="min-w-full table-striped">
+                  <thead><tr><th class="py-3 px-4 bg-gray-50 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">Contributor</th><th class="py-3 px-4 bg-gray-50 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">X Handle</th><th class="py-3 px-4 bg-gray-50 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">Proposals</th><th class="py-3 px-4 bg-gray-50 text-right text-xs font-medium text-gray-500 uppercase tracking-wider">Confidence</th></tr></thead>
+                  <tbody>${createRows(topAllowed)}</tbody>
+                </table>
+              </div>
+              <div>
+                <h3 class="font-bold mb-2">Top Blocked</h3>
+                <table class="min-w-full table-striped">
+                  <thead><tr><th class="py-3 px-4 bg-gray-50 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">Contributor</th><th class="py-3 px-4 bg-gray-50 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">X Handle</th><th class="py-3 px-4 bg-gray-50 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">Proposals</th><th class="py-3 px-4 bg-gray-50 text-right text-xs font-medium text-gray-500 uppercase tracking-wider">Confidence</th></tr></thead>
+                  <tbody>${createRows(topBlocked)}</tbody>
+                </table>
+              </div>
+            </div>
+          </div>
+        `;
+
+        // Collapsible
+        const title = container.querySelector("#summary-title");
+        const content = container.querySelector("#summary-content");
+        if (title && content) {
+          title.addEventListener("click", () => {
+            const collapsed = content.style.display === "none";
+            content.style.display = collapsed ? "block" : "none";
+            title.querySelector(".chevron").classList.toggle("rotate-90", collapsed);
+          });
+        }
+      }
+
+      /**
+       * Filter/sort and render cards, preserve expansion.
+       */
+      function updateVettingView() {
+        const container = document.getElementById("vetting-container");
+        const expansionState = new Map();
+        container.querySelectorAll("section[data-contributor-id]").forEach((section) => {
+          const cid = section.dataset.contributorId;
+          const details = section.querySelector(".details");
+          if (cid && details) {
+            expansionState.set(cid, details.style.display !== "none");
+          }
+        });
+
+        console.log('Rendering:', {count: currentVettings?.contributors?.length || 0, filter: document.getElementById("contributor-filter-select").value, sort: document.getElementById("sort-select").value});
+        if (!currentVettings || currentVettings.contributors.length === 0) {
+          container.innerHTML = `<div class="text-center p-12 bg-yellow-50 border-2 border-yellow-300 rounded-xl"><p class="text-lg font-bold text-yellow-800">No contributors loaded</p><p class="text-sm text-yellow-600 mt-2">Check console for fetch errors. Run generate_vettings_manifest.py?</p></div>`;
+          return;
+        }
+
+        // Filter
+        const filterVal = document.getElementById("contributor-filter-select").value;
+        let contributors = currentVettings.contributors;
+        if (filterVal === "allow") contributors = contributors.filter((c) => c.decision === true);
+        else if (filterVal === "block") contributors = contributors.filter((c) => c.decision === false && !c.error);
+        else if (filterVal === "error") contributors = contributors.filter((c) => c.error);
+
+        // Sort
+        const sortVal = document.getElementById("sort-select").value;
+        let [sortField, sortDir] = sortVal.split("-");
+        contributors.sort((a, b) => {
+          let valA, valB;
+          if (sortField === "confidence") {
+            valA = a.confidence || 0;
+            valB = b.confidence || 0;
+          } else if (sortField === "proposals") {
+            valA = a.proposal_count;
+            valB = b.proposal_count;
+          } else {
+            valA = a.contributor_id;
+            valB = b.contributor_id;
+          }
+          return sortDir === "asc" ? (valA > valB ? 1 : -1) : (valA < valB ? 1 : -1);
+        });
+
+        container.innerHTML = "";
+        if (contributors.length === 0) {
+          container.innerHTML = `<div class="text-center p-12 bg-white rounded-xl shadow-sm border border-gray-200"><p class="text-lg font-medium text-gray-600">No contributors match the filter.</p><p class="text-sm text-gray-500 mt-2">(Total filtered: 0 / ${currentVettings.contributors.length})</p></div>`;
+          console.warn('No contributors after filter/sort');
+          return;
+        }
+
+        // Wrapper
+        const wrapper = document.createElement("div");
+        wrapper.className = "bg-white p-6 rounded-xl shadow-sm border border-gray-200";
+
+        const mainTitle = document.createElement("h2");
+        mainTitle.className = "text-2xl font-bold text-gray-800 mb-4 pb-2 border-b-2 border-gray-200 cursor-pointer flex justify-between items-center";
+        mainTitle.innerHTML = `
+          <span>Contributors (${contributors.length})</span>
+          <svg class="w-6 h-6 transform transition-transform chevron rotate-90" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 5l7 7-7 7"></path></svg>
+        `;
+        wrapper.appendChild(mainTitle);
+
+        const contentDiv = document.createElement("div");
+        contentDiv.className = "space-y-8 pt-4";
+
+        mainTitle.addEventListener("click", () => {
+          const collapsed = contentDiv.style.display === "none";
+          contentDiv.style.display = collapsed ? "block" : "none";
+          mainTitle.querySelector(".chevron").classList.toggle("rotate-90", collapsed);
+        });
+
+        contributors.forEach((contrib) => {
+          const card = createContributorCard(contrib);
+          contentDiv.appendChild(card);
+        });
+        wrapper.appendChild(contentDiv);
+        contentDiv.style.display = "block";
+        container.appendChild(wrapper);
+
+        // Restore expansion
+        expansionState.forEach((expanded, cid) => {
+          if (expanded) {
+            const section = wrapper.querySelector(`section[data-contributor-id="${cid}"]`);
+            if (section) {
+              const title = section.querySelector("h2");
+              const details = section.querySelector(".details");
+              if (title && details) {
+                details.style.display = "block";
+                title.querySelector(".chevron").classList.add("rotate-90");
+              }
+            }
+          }
+        });
+
+        console.log(`Rendered ${contributors.length} contributor cards`);
+      }
+
+      /**
+       * Escape HTML.
+       */
+      function escapeHtml(unsafe) {
+        return unsafe
+          .replace(/&/g, "&amp;")
+          .replace(/</g, "&lt;")
+          .replace(/>/g, "&gt;")
+          .replace(/"/g, "&quot;")
+          .replace(/'/g, "&#039;");
+      }
+
+      /**
+       * Create full contributor card.
+       */
+      function createContributorCard(contrib) {
+        const section = document.createElement("section");
+        section.dataset.contributorId = contrib.contributor_id;
+        const title = document.createElement("h2");
+        title.className = "text-xl font-bold text-gray-800 mb-4 cursor-pointer flex justify-between items-center";
+        const decisionClass = contrib.decision === true ? "text-green-600" :
+                              contrib.decision === false ? "text-red-600" : "text-gray-600";
+        const decisionText = contrib.decision === true ? "ALLOW" : contrib.decision === false ? "BLOCK" : "ERROR";
+        const explorerUrl = `https://explorer.hiro.so/address/${contrib.contributor_id}?chain=testnet`;
+
+        const displayName = contrib.x_handle || contrib.short_id;
+        const nameLinkUrl = contrib.x_handle ? `https://x.com/${contrib.x_handle}` : explorerUrl;
+        const nameLinkTitle = contrib.x_handle ? `View on X: @${contrib.x_handle}` : `Full address: ${contrib.contributor_id}`;
+        const nameLinkClass = contrib.x_handle ? `${decisionClass} hover:underline` : `${decisionClass} hover:underline font-mono`;
+
+        title.innerHTML = `
+          <a href="${nameLinkUrl}" target="_blank" rel="noopener noreferrer" class="${nameLinkClass}" title="${nameLinkTitle}">${displayName}</a> - ${decisionText} (Conf: ${contrib.confidence.toFixed(2)}) - ${contrib.proposal_count} Proposals
+          <svg class="w-6 h-6 transform transition-transform chevron" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 5l7 7-7 7"></path></svg>
+        `;
+        section.appendChild(title);
+        title.querySelector(".chevron").classList.add("rotate-90");
+
+        const details = document.createElement("div");
+        details.className = "details space-y-4";
+        details.style.display = "block";
+
+        title.addEventListener("click", () => {
+          const collapsed = details.style.display === "none";
+          details.style.display = collapsed ? "block" : "none";
+          title.querySelector(".chevron").classList.toggle("rotate-90", collapsed);
+        });
+
+        // Agent account
+        const agentAccountHtml = `
+          <div class="text-sm text-gray-500 mb-4 pl-1 font-mono border-l-4 border-gray-200">
+            Agent account: <a href="${explorerUrl}" target="_blank" rel="noopener noreferrer" class="hover:underline text-blue-600" title="View on Explorer">${contrib.contributor_id}</a>
+          </div>
+        `;
+
+        // Decision badge
+        let outcomeHtml = `<div class="p-4 rounded-md border ${decisionClass}"><p class="font-bold ${decisionClass}">Decision: ${decisionText}</p>`;
+        if (contrib.error) {
+          outcomeHtml += `<p class="text-sm text-red-700">Error: ${escapeHtml(contrib.error)}</p>`;
+        }
+        outcomeHtml += `</div>`;
+
+        // Reasoning
+        const reasoningHtml = `
+          <div class="bg-gray-50 p-4 rounded-md border">
+            <h4 class="font-bold mb-2">Reasoning</h4>
+            <div class="text-sm text-gray-700 whitespace-pre-wrap overflow-auto max-h-48">${escapeHtml(contrib.reasoning)}</div>
+          </div>
+        `;
+
+        // Notable proposals
+        const notableHtml = contrib.notable_proposals.length > 0 ? `
+          <div class="bg-blue-50 p-4 rounded-md border">
+            <h4 class="font-bold mb-2">Notable Proposals</h4>
+            <ul class="text-sm text-blue-800 list-disc pl-5 space-y-1">
+              ${contrib.notable_proposals.map(np => `<li>${escapeHtml(np)}</li>`).join("")}
+            </ul>
+          </div>
+        ` : "";
+
+        // Prompts
+        const promptsHtml = `
+          <details class="bg-indigo-50 p-3 rounded-md">
+            <summary class="font-medium text-indigo-700 cursor-pointer">Prompts (System + User)</summary>
+            <div class="mt-2 space-y-2 text-xs text-gray-600">
+              <details><summary>System Prompt (truncated)</summary><pre class="overflow-x-auto max-h-32">${escapeHtml(currentVettings.system_prompt.slice(0, 1000)) + "..."}</pre></details>
+              <details><summary>User Prompt (truncated)</summary><pre class="overflow-x-auto max-h-32">${escapeHtml(contrib.user_prompt_filled?.slice(0, 2000) || "N/A") + "..."}</pre></details>
+            </div>
+          </details>
+        `;
+
+        // Usage
+        let usageHtml = "";
+        if (contrib.usage) {
+          usageHtml = `
+            <details class="bg-gray-50 p-3 rounded-md">
+              <summary class="font-medium text-gray-700 cursor-pointer">Usage</summary>
+              <pre class="mt-2 text-sm text-gray-600 whitespace-pre-wrap">Input: ${contrib.usage.input_tokens || 0} | Output: ${contrib.usage.output_tokens || 0}</pre>
+            </details>
+          `;
+        }
+
+        // Simplified proposals table
+        const proposalsHtml = `
+          <div class="border-t pt-4">
+            <h4 class="font-bold mb-2">Proposals (${contrib.proposals.length})</h4>
+            <table class="min-w-full table-striped text-xs">
+              <thead><tr><th>ID</th><th>Title</th><th class="hidden md:table-cell">Status</th></tr></thead>
+              <tbody>${contrib.proposals.slice(0,10).map(p => {
+                const id = String(p.proposal_id || '').slice(0,8);
+                return `<tr><td class="font-mono">${id}</td><td class="max-w-xs truncate">${escapeHtml(p.title)}</td><td class="hidden md:table-cell">${p.status || 'Unknown'}</td></tr>`;
+              }).join('')}</tbody>
+            </table>
+          </div>`;
+
+        // Raw JSON
+        const rawHtml = contrib.raw_result ? `
+          <details class="bg-gray-100 p-4 rounded-md mt-6 border border-gray-200">
+            <summary class="font-semibold text-gray-800 cursor-pointer pb-2 border-b border-gray-200">Raw JSON Result</summary>
+            <pre class="mt-3 text-xs overflow-x-auto max-h-96 p-4 rounded bg-gray-900 text-green-400 font-mono">${escapeHtml(JSON.stringify(contrib.raw_result, null, 2))}</pre>
+          </details>
+        ` : "";
+
+        details.innerHTML = agentAccountHtml + outcomeHtml + reasoningHtml + notableHtml + promptsHtml + usageHtml + proposalsHtml + rawHtml;
+        section.appendChild(details);
+        return section;
+      }
+    </script>
+  </body>
+</html>