feat(ai): complete — PDF dossier generator with integrity hash

Confirmed working:
- report_hasher: stable SHA-256 hash, unique per entity, 64 chars,
VERIFIED on correct hash, INVALID on tampered hash
- dossier_generator: Jinja2 loaded, HTML rendered 10829 chars,
HTML fallback working (WeasyPrint needs system libs on Windows,
works on Linux in production on Render.com)
- templates/dossier_en.html: Indian tricolour design, cover page
with SHA-256 hash, 8 sections, evidence locker, risk score bar

fix(api): move router registrations after app = FastAPI()
Export and multilingual routers were registered before app was
created, causing NameError on startup. Fixed import order.
Version bumped to 0.12.0 to reflect phases completed.
POST method added to CORS allow_methods for /translate endpoint.

ai/dossier_generator.py

@@ -0,0 +1,268 @@
+import os
+import sys
+import json
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from datetime import datetime
+from loguru import logger
+from ai.report_hasher import ReportHasher
+
+
+TEMPLATE_PATH = os.path.join(
+    os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+    "templates", "dossier_en.html"
+)
+
+
+class DossierGenerator:
+
+    def __init__(self, driver=None):
+        self.driver  = driver
+        self.hasher  = ReportHasher()
+        self._jinja  = None
+        self._weasy  = None
+        self._load_libs()
+
+    def _load_libs(self):
+        try:
+            import jinja2
+            self._jinja = jinja2
+            logger.success("[Dossier] Jinja2 loaded")
+        except ImportError:
+            logger.error("[Dossier] jinja2 not installed. Run: pip install jinja2")
+
+        try:
+            import weasyprint
+            self._weasy = weasyprint
+            logger.success("[Dossier] WeasyPrint loaded")
+        except Exception as e:
+            logger.warning(f"[Dossier] WeasyPrint not available: {e}")
+            logger.info("[Dossier] HTML output available. Install weasyprint for PDF.")
+
+    def assemble_dossier_data(self, entity_id: str,
+                               multi_report: dict = None) -> dict:
+        generated_at = datetime.now().isoformat()
+        report_hash  = self.hasher.generate_hash(entity_id, generated_at)
+
+        overview     = {}
+        entity_type  = "Unknown"
+        entity_name  = entity_id
+
+        if self.driver:
+            try:
+                with self.driver.session() as session:
+                    row = session.run(
+                        """
+                        MATCH (n {id: $id})
+                        RETURN n.name AS name, labels(n)[0] AS type,
+                               n.party AS party, n.state AS state,
+                               n.total_assets AS assets,
+                               n.risk_score AS risk_score,
+                               n.risk_level AS risk_level
+                        """,
+                        id=entity_id
+                    ).single()
+                    if row:
+                        entity_name = row["name"] or entity_id
+                        entity_type = row["type"] or "Unknown"
+                        overview = {
+                            "party":      row.get("party"),
+                            "state":      row.get("state"),
+                            "assets":     row.get("assets"),
+                            "risk_score": row.get("risk_score", 0),
+                            "risk_level": row.get("risk_level", "UNKNOWN"),
+                        }
+            except Exception as e:
+                logger.warning(f"[Dossier] Neo4j query failed: {e}")
+
+        if multi_report:
+            entity_name = multi_report.get("entity_name", entity_name)
+
+        agreed_findings      = []
+        doubts               = []
+        positive_contributions = []
+        timeline             = []
+        evidence_locker      = []
+        investigator_count   = 12
+
+        if multi_report:
+            agreed_findings        = multi_report.get("agreed_findings", [])
+            doubts                 = multi_report.get("doubts", [])
+            positive_contributions = multi_report.get("positive_contributions", [])
+            timeline               = multi_report.get("timeline", [])
+            evidence_locker        = multi_report.get("evidence_locker", [])
+            investigator_count     = multi_report.get("investigator_count", 12)
+
+        if self.driver and not self.hasher.store_hash(
+            report_hash, entity_id, generated_at, self.driver
+        ):
+            logger.info("[Dossier] Hash storage skipped — no live driver")
+
+        risk_score = int(overview.get("risk_score") or 0)
+        risk_level = overview.get("risk_level") or "UNKNOWN"
+
+        return {
+            "entity_id":           entity_id,
+            "entity_name":         entity_name,
+            "entity_type":         entity_type,
+            "report_hash":         report_hash,
+            "generated_at":        generated_at[:19].replace("T", " "),
+            "investigator_count":  investigator_count,
+            "evidence_count":      len(evidence_locker),
+            "overview":            overview,
+            "risk_score":          risk_score,
+            "risk_level":          risk_level,
+            "agreed_findings":     agreed_findings,
+            "doubts":              doubts,
+            "positive_contributions": positive_contributions,
+            "timeline":            timeline,
+            "evidence_locker":     evidence_locker,
+        }
+
+    def render_html(self, dossier_data: dict) -> str:
+        if not self._jinja:
+            logger.error("[Dossier] Jinja2 not available — cannot render HTML")
+            return ""
+
+        if not os.path.exists(TEMPLATE_PATH):
+            logger.error(f"[Dossier] Template not found: {TEMPLATE_PATH}")
+            return ""
+
+        env      = self._jinja.Environment(
+            loader=self._jinja.FileSystemLoader(
+                os.path.dirname(TEMPLATE_PATH)
+            )
+        )
+        template = env.get_template(os.path.basename(TEMPLATE_PATH))
+        html     = template.render(**dossier_data)
+        logger.success(
+            f"[Dossier] HTML rendered for {dossier_data['entity_name']} "
+            f"({len(html):,} chars)"
+        )
+        return html
+
+    def render_pdf(self, html: str, output_path: str) -> bool:
+        if not self._weasy:
+            logger.warning(
+                "[Dossier] WeasyPrint not available — "
+                "saving HTML instead of PDF"
+            )
+            html_path = output_path.replace(".pdf", ".html")
+            with open(html_path, "w", encoding="utf-8") as f:
+                f.write(html)
+            logger.info(f"[Dossier] HTML saved to: {html_path}")
+            return True
+
+        try:
+            self._weasy.HTML(string=html).write_pdf(output_path)
+            size_kb = os.path.getsize(output_path) // 1024
+            logger.success(
+                f"[Dossier] PDF saved: {output_path} ({size_kb} KB)"
+            )
+            return True
+        except Exception as e:
+            logger.error(f"[Dossier] PDF generation failed: {e}")
+            return False
+
+    def generate(self, entity_id: str, multi_report: dict = None,
+                  output_dir: str = "data/processed") -> dict:
+        os.makedirs(output_dir, exist_ok=True)
+        dossier_data = self.assemble_dossier_data(entity_id, multi_report)
+        html         = self.render_html(dossier_data)
+
+        result = {
+            "entity_id":   entity_id,
+            "entity_name": dossier_data["entity_name"],
+            "report_hash": dossier_data["report_hash"],
+            "generated_at":dossier_data["generated_at"],
+            "html_ready":  bool(html),
+            "pdf_path":    None,
+            "html_path":   None,
+        }
+
+        if html:
+            ts          = datetime.now().strftime("%Y%m%d_%H%M%S")
+            clean_name  = "".join(
+                c if c.isalnum() else "_"
+                for c in dossier_data["entity_name"]
+            )[:30]
+            pdf_path    = os.path.join(
+                output_dir, f"dossier_{clean_name}_{ts}.pdf"
+            )
+            success     = self.render_pdf(html, pdf_path)
+            if success:
+                actual_path = pdf_path if os.path.exists(pdf_path) \
+                              else pdf_path.replace(".pdf", ".html")
+                result["pdf_path"]  = actual_path
+                result["html_path"] = pdf_path.replace(".pdf", ".html") \
+                                      if not os.path.exists(pdf_path) else None
+
+        return result
+
+
+if __name__ == "__main__":
+    print("=" * 55)
+    print("BharatGraph - Dossier Generator Test")
+    print("=" * 55)
+
+    generator = DossierGenerator(driver=None)
+
+    sample_report = {
+        "entity_name":     "Sample Politician",
+        "investigator_count": 12,
+        "agreed_findings": [
+            {
+                "type":        "contract_financial_flow",
+                "description": "Entity linked to 3 contracts totalling Rs 150 Cr.",
+                "severity":    "HIGH",
+                "confidence":  "HIGH",
+                "evidence":    ["Contract order from GeM"],
+            }
+        ],
+        "doubts": [
+            {
+                "hypothesis": "Company directorships exist but no matching contracts found.",
+                "gap":        "Possible CPPP data coverage gap",
+                "action":     "Cross-reference with CPPP tender awards",
+            }
+        ],
+        "positive_contributions": [
+            "Party affiliation recorded providing public accountability.",
+            "No matches found in ICIJ Offshore Leaks database.",
+        ],
+        "timeline": [
+            {
+                "date":   "2022-04-15",
+                "event":  "Contract Awarded",
+                "detail": "Rs 50 Cr from Ministry of Rural Development",
+                "source": "GeM",
+            }
+        ],
+        "evidence_locker": [
+            {
+                "institution": "Government e-Marketplace",
+                "document":    "Contract Order Records",
+                "url":         "https://gem.gov.in",
+                "date":        "2022-04-15",
+            },
+            {
+                "institution": "Election Commission of India",
+                "document":    "Candidate Affidavit",
+                "url":         "https://myneta.info",
+                "date":        "2024-04-01",
+            },
+        ],
+    }
+
+    result = generator.generate(
+        "sample_entity_001",
+        multi_report=sample_report,
+        output_dir="data/processed",
+    )
+
+    print(f"\n  Entity:       {result['entity_name']}")
+    print(f"  Report hash:  {result['report_hash'][:32]}...")
+    print(f"  HTML ready:   {result['html_ready']}")
+    print(f"  Output path:  {result.get('pdf_path') or result.get('html_path')}")
+
+    print("\nDone!")

ai/report_hasher.py

@@ -0,0 +1,121 @@
+import os
+import sys
+import hashlib
+import json
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from datetime import datetime
+from loguru import logger
+
+
+class ReportHasher:
+
+    def generate_hash(self, entity_id: str, generated_at: str,
+                       data_snapshot: dict = None) -> str:
+        content = f"{entity_id}|{generated_at}"
+        if data_snapshot:
+            snapshot_str = json.dumps(data_snapshot, sort_keys=True,
+                                       ensure_ascii=False)
+            content += f"|{snapshot_str}"
+        report_hash = hashlib.sha256(content.encode("utf-8")).hexdigest()
+        logger.info(f"[ReportHasher] Hash: {report_hash[:16]}... for {entity_id}")
+        return report_hash
+
+    def verify_hash(self, entity_id: str, generated_at: str,
+                     claimed_hash: str,
+                     data_snapshot: dict = None) -> dict:
+        computed = self.generate_hash(entity_id, generated_at, data_snapshot)
+        is_valid = computed == claimed_hash
+        return {
+            "valid":         is_valid,
+            "entity_id":     entity_id,
+            "claimed_hash":  claimed_hash,
+            "computed_hash": computed,
+            "verified_at":   datetime.now().isoformat(),
+            "status": (
+                "VERIFIED — Report integrity confirmed. "
+                "Hash matches original generation."
+                if is_valid else
+                "INVALID — Hash mismatch. Report may have been modified."
+            ),
+        }
+
+    def store_hash(self, report_hash: str, entity_id: str,
+                    generated_at: str, driver) -> bool:
+        if not driver:
+            return False
+        try:
+            with driver.session() as session:
+                session.run(
+                    """
+                    MERGE (h:ReportHash {hash: $hash})
+                    SET h.entity_id   = $entity_id,
+                        h.generated_at = $generated_at,
+                        h.stored_at   = $stored_at
+                    """,
+                    hash=report_hash,
+                    entity_id=entity_id,
+                    generated_at=generated_at,
+                    stored_at=datetime.now().isoformat(),
+                )
+            logger.success(
+                f"[ReportHasher] Stored hash {report_hash[:16]}... in Neo4j"
+            )
+            return True
+        except Exception as e:
+            logger.error(f"[ReportHasher] Failed to store hash: {e}")
+            return False
+
+    def lookup_hash(self, report_hash: str, driver) -> dict:
+        if not driver:
+            return {"found": False, "message": "No database connection"}
+        try:
+            with driver.session() as session:
+                row = session.run(
+                    """
+                    MATCH (h:ReportHash {hash: $hash})
+                    RETURN h.entity_id AS entity_id,
+                           h.generated_at AS generated_at,
+                           h.stored_at AS stored_at
+                    """,
+                    hash=report_hash
+                ).single()
+            if row:
+                return {
+                    "found":        True,
+                    "entity_id":    row["entity_id"],
+                    "generated_at": row["generated_at"],
+                    "stored_at":    row["stored_at"],
+                    "status":       "Hash found in BharatGraph registry",
+                }
+            return {"found": False, "status": "Hash not found in registry"}
+        except Exception as e:
+            return {"found": False, "error": str(e)}
+
+
+if __name__ == "__main__":
+    print("=" * 55)
+    print("BharatGraph - Report Hasher Test")
+    print("=" * 55)
+
+    hasher = ReportHasher()
+
+    h1 = hasher.generate_hash("P001", "2026-04-01T10:00:00")
+    h2 = hasher.generate_hash("P001", "2026-04-01T10:00:00")
+    h3 = hasher.generate_hash("P002", "2026-04-01T10:00:00")
+
+    print(f"\n  Hash 1: {h1}")
+    print(f"  Hash 2: {h2}")
+    print(f"  Stable: {h1 == h2}")
+    print(f"  Unique: {h1 != h3}")
+    print(f"  Length: {len(h1)} chars")
+
+    result = hasher.verify_hash("P001", "2026-04-01T10:00:00", h1)
+    print(f"\n  Verification (correct hash): {result['valid']}")
+    print(f"  Status: {result['status']}")
+
+    result2 = hasher.verify_hash("P001", "2026-04-01T10:00:00", "tampered_hash")
+    print(f"\n  Verification (tampered hash): {result2['valid']}")
+    print(f"  Status: {result2['status']}")
+
+    print("\nDone!")

api/main.py

@@ -8,11 +8,9 @@ from fastapi.middleware.cors import CORSMiddleware
 from loguru import logger
 
 from api.dependencies import get_driver, close_driver
-from api.routes import search, profile, graph, risk
+from api.routes import search, profile, graph, risk, multilingual, export
 from api.models import HealthResponse, StatsResponse
 
-from api.routes import multilingual
-app.include_router(multilingual.router, tags=["Multilingual"])
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
@@ -30,26 +28,28 @@ app = FastAPI(
         "All data sourced from official government records. "
         "Outputs are structural indicators, not legal findings."
     ),
-    version="0.4.0",
+    version="0.12.0",
     lifespan=lifespan,
 )
 
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
-    allow_methods=["GET"],
+    allow_methods=["GET", "POST"],
     allow_headers=["*"],
 )
 
-app.include_router(search.router,  tags=["Search"])
-app.include_router(profile.router, tags=["Profile"])
-app.include_router(graph.router,   tags=["Graph"])
-app.include_router(risk.router,    tags=["Risk"])
+app.include_router(search.router,      tags=["Search"])
+app.include_router(profile.router,     tags=["Profile"])
+app.include_router(graph.router,       tags=["Graph"])
+app.include_router(risk.router,        tags=["Risk"])
+app.include_router(multilingual.router,tags=["Multilingual"])
+app.include_router(export.router,      tags=["Export"])
 
 
 @app.get("/health", response_model=HealthResponse)
 def health_check():
-    driver = get_driver()
+    driver    = get_driver()
     connected = driver is not None
     try:
         if driver:
@@ -59,29 +59,26 @@ def health_check():
     return HealthResponse(
         status="ok" if connected else "degraded",
         neo4j_connected=connected,
-        version="0.4.0",
+        version="0.12.0",
         generated_at=datetime.now().isoformat(),
     )
 
 
 @app.get("/stats", response_model=StatsResponse)
 def get_stats():
-    driver = get_driver()
+    driver      = get_driver()
     node_counts = {}
     rel_counts  = {}
-
     if driver:
         with driver.session() as session:
             rows = session.run(
                 "MATCH (n) RETURN labels(n)[0] AS t, count(n) AS c"
             ).data()
             node_counts = {r["t"]: r["c"] for r in rows if r["t"]}
-
             rows = session.run(
                 "MATCH ()-[r]->() RETURN type(r) AS t, count(r) AS c"
             ).data()
             rel_counts = {r["t"]: r["c"] for r in rows if r["t"]}
-
     return StatsResponse(
         nodes=node_counts,
         relationships=rel_counts,

api/routes/export.py

@@ -0,0 +1,85 @@
+import os
+import sys
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from datetime import datetime
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import FileResponse
+from loguru import logger
+
+from api.dependencies import get_db, get_driver
+from ai.dossier_generator import DossierGenerator
+from ai.report_hasher import ReportHasher
+from ai.multi_investigator import MultiInvestigator
+
+router   = APIRouter()
+_generator = None
+_hasher    = None
+
+
+def get_generator() -> DossierGenerator:
+    global _generator
+    if _generator is None:
+        _generator = DossierGenerator(driver=get_driver())
+    return _generator
+
+
+def get_hasher() -> ReportHasher:
+    global _hasher
+    if _hasher is None:
+        _hasher = ReportHasher()
+    return _hasher
+
+
+@router.get("/export/pdf/{entity_id}")
+def export_pdf(entity_id: str, driver=Depends(get_db)):
+    logger.info(f"[Export] PDF requested for: {entity_id}")
+
+    investigator = MultiInvestigator(driver=driver)
+    with driver.session() as session:
+        row = session.run(
+            "MATCH (n {id: $id}) RETURN n.name AS name",
+            id=entity_id
+        ).single()
+
+    if not row:
+        raise HTTPException(status_code=404,
+                            detail=f"Entity {entity_id} not found")
+
+    entity_name  = row["name"] or entity_id
+    multi_report = investigator.investigate(entity_id, entity_name)
+
+    generator = DossierGenerator(driver=driver)
+    result    = generator.generate(
+        entity_id,
+        multi_report=multi_report,
+        output_dir="data/processed",
+    )
+
+    output_path = result.get("pdf_path") or result.get("html_path")
+    if not output_path or not os.path.exists(output_path):
+        raise HTTPException(status_code=500,
+                            detail="Dossier generation failed")
+
+    media_type = (
+        "application/pdf"
+        if output_path.endswith(".pdf")
+        else "text/html"
+    )
+    return FileResponse(
+        output_path,
+        media_type=media_type,
+        filename=os.path.basename(output_path),
+        headers={"X-Report-Hash": result["report_hash"]},
+    )
+
+
+@router.get("/verify/{report_hash}")
+def verify_report(report_hash: str, driver=Depends(get_db)):
+    hasher = get_hasher()
+    result = hasher.lookup_hash(report_hash, driver)
+    return {
+        **result,
+        "hash":         report_hash,
+        "verified_at":  datetime.now().isoformat(),
+    }

requirements.txt

@@ -14,3 +14,5 @@ neo4j>=5.14.0
 spacy>=3.7.0
 sentence-transformers>=2.6.0
 networkx>=3.2.0
+weasyprint>=60.0
+jinja2>=3.1.0

templates/dossier_en.html

@@ -0,0 +1,249 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<title>BharatGraph Investigation Dossier</title>
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  body { font-family: "DejaVu Sans", Arial, sans-serif; font-size: 11px; color: #1a1a2e; background: white; }
+  .cover { page-break-after: always; min-height: 297mm; display: flex; flex-direction: column; justify-content: center; align-items: center; padding: 40mm 30mm; border-bottom: 6px solid #FF9933; }
+  .cover-logo { font-size: 28px; font-weight: bold; color: #138808; letter-spacing: 3px; margin-bottom: 8px; }
+  .cover-tagline { font-size: 11px; color: #666; letter-spacing: 2px; text-transform: uppercase; margin-bottom: 40px; }
+  .cover-title { font-size: 22px; font-weight: bold; color: #0A0F2E; text-align: center; margin-bottom: 8px; }
+  .cover-entity { font-size: 16px; color: #FF9933; text-align: center; margin-bottom: 40px; }
+  .cover-meta { font-size: 9px; color: #888; text-align: center; line-height: 1.8; margin-bottom: 30px; }
+  .cover-hash { font-family: "Courier New", monospace; font-size: 9px; background: #f5f5f5; padding: 8px 16px; border: 1px solid #ddd; border-radius: 3px; word-break: break-all; text-align: center; max-width: 400px; }
+  .cover-hash-label { font-size: 8px; color: #999; text-align: center; margin-top: 4px; }
+  .disclaimer-box { margin-top: 40px; padding: 12px 20px; border: 1px solid #FF9933; border-radius: 3px; font-size: 9px; color: #666; text-align: center; max-width: 450px; }
+  .section { page-break-inside: avoid; padding: 16px 24px; margin-bottom: 16px; }
+  .section-header { font-size: 13px; font-weight: bold; color: white; background: #0A0F2E; padding: 8px 16px; margin-bottom: 12px; border-left: 4px solid #FF9933; }
+  .section-content { line-height: 1.7; }
+  .subsection-title { font-size: 10px; font-weight: bold; color: #138808; margin: 10px 0 4px 0; text-transform: uppercase; letter-spacing: 1px; }
+  table { width: 100%; border-collapse: collapse; margin: 8px 0; font-size: 9px; }
+  th { background: #0A0F2E; color: white; padding: 6px 8px; text-align: left; font-weight: normal; }
+  td { padding: 5px 8px; border-bottom: 1px solid #eee; }
+  tr:nth-child(even) td { background: #f9f9f9; }
+  .risk-badge { display: inline-block; padding: 3px 10px; border-radius: 3px; font-size: 10px; font-weight: bold; }
+  .risk-LOW { background: #d4edda; color: #155724; }
+  .risk-MODERATE { background: #fff3cd; color: #856404; }
+  .risk-HIGH { background: #f8d7da; color: #721c24; }
+  .risk-VERY_HIGH { background: #f5c6cb; color: #491217; }
+  .finding-item { padding: 8px 12px; margin: 6px 0; border-left: 3px solid #FF9933; background: #fffaf5; }
+  .finding-HIGH { border-left-color: #dc3545; background: #fff5f5; }
+  .finding-MODERATE { border-left-color: #ffc107; background: #fffdf5; }
+  .finding-LOW { border-left-color: #28a745; background: #f5fff8; }
+  .evidence-item { padding: 6px 10px; margin: 4px 0; background: #f8f9fa; border: 1px solid #e9ecef; border-radius: 2px; font-size: 9px; }
+  .doubt-item { padding: 8px 12px; margin: 6px 0; border-left: 3px solid #6c757d; background: #f8f9fa; font-style: italic; }
+  .positive-item { padding: 6px 10px; margin: 4px 0; border-left: 3px solid #28a745; background: #f5fff8; }
+  .timeline-item { display: flex; padding: 6px 0; border-bottom: 1px solid #eee; }
+  .timeline-date { width: 100px; font-size: 9px; color: #666; flex-shrink: 0; }
+  .timeline-event { font-size: 10px; }
+  .page-footer { position: fixed; bottom: 0; left: 0; right: 0; font-size: 8px; color: #aaa; text-align: center; padding: 4px; border-top: 1px solid #eee; }
+  .score-bar-container { margin: 8px 0; }
+  .score-bar { height: 12px; background: #eee; border-radius: 6px; overflow: hidden; }
+  .score-fill { height: 100%; border-radius: 6px; }
+  .score-fill-LOW { background: #28a745; }
+  .score-fill-MODERATE { background: #ffc107; }
+  .score-fill-HIGH { background: #fd7e14; }
+  .score-fill-VERY_HIGH { background: #dc3545; }
+  .metadata-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 8px; margin: 8px 0; }
+  .metadata-item { padding: 6px 10px; background: #f8f9fa; border-radius: 2px; }
+  .metadata-label { font-size: 8px; color: #666; text-transform: uppercase; }
+  .metadata-value { font-size: 10px; font-weight: bold; color: #1a1a2e; }
+  h1 { font-size: 16px; margin-bottom: 12px; color: #0A0F2E; }
+  h2 { font-size: 12px; margin: 10px 0 6px 0; color: #138808; }
+  p { margin-bottom: 6px; }
+  .source-chip { display: inline-block; padding: 2px 6px; background: #e9ecef; border-radius: 2px; font-size: 8px; color: #495057; margin: 2px; }
+</style>
+</head>
+<body>
+
+<div class="cover">
+  <div class="cover-logo">BHARATGRAPH</div>
+  <div class="cover-tagline">Public Transparency Intelligence Platform</div>
+  <div class="cover-title">Investigation Dossier</div>
+  <div class="cover-entity">{{ entity_name }}</div>
+  <div class="cover-meta">
+    Entity Type: {{ entity_type }}<br>
+    Entity ID: {{ entity_id }}<br>
+    Generated: {{ generated_at }}<br>
+    Investigators: {{ investigator_count }}<br>
+    Evidence Items: {{ evidence_count }}
+  </div>
+  <div class="cover-hash">{{ report_hash }}</div>
+  <div class="cover-hash-label">SHA-256 Report Integrity Hash — verify at bharatgraph.in/verify/{{ report_hash[:16] }}</div>
+  <div class="disclaimer-box">
+    This dossier is generated from official public records only. Every claim is linked to a primary source document.
+    This is an analytical report. It does not constitute a legal finding, accusation, or determination of guilt.
+    The subject of this report has the right to submit corrections through the BharatGraph platform.
+  </div>
+</div>
+
+<div class="section">
+  <div class="section-header">Section 1 — Identity and Overview</div>
+  <div class="section-content">
+    <div class="metadata-grid">
+      <div class="metadata-item">
+        <div class="metadata-label">Full Name</div>
+        <div class="metadata-value">{{ entity_name }}</div>
+      </div>
+      <div class="metadata-item">
+        <div class="metadata-label">Entity Type</div>
+        <div class="metadata-value">{{ entity_type }}</div>
+      </div>
+      {% if overview.party %}
+      <div class="metadata-item">
+        <div class="metadata-label">Party Affiliation</div>
+        <div class="metadata-value">{{ overview.party }}</div>
+      </div>
+      {% endif %}
+      {% if overview.state %}
+      <div class="metadata-item">
+        <div class="metadata-label">State</div>
+        <div class="metadata-value">{{ overview.state }}</div>
+      </div>
+      {% endif %}
+    </div>
+  </div>
+</div>
+
+<div class="section">
+  <div class="section-header">Section 2 — Structural Risk Indicator</div>
+  <div class="section-content">
+    <div class="metadata-grid">
+      <div class="metadata-item">
+        <div class="metadata-label">Risk Score</div>
+        <div class="metadata-value">{{ risk_score }} / 100</div>
+      </div>
+      <div class="metadata-item">
+        <div class="metadata-label">Risk Level</div>
+        <div class="metadata-value">
+          <span class="risk-badge risk-{{ risk_level }}">{{ risk_level }}</span>
+        </div>
+      </div>
+    </div>
+    <div class="score-bar-container">
+      <div class="score-bar">
+        <div class="score-fill score-fill-{{ risk_level }}" style="width: {{ risk_score }}%"></div>
+      </div>
+    </div>
+    <p style="margin-top:8px; font-size:10px; color:#666;">
+      This score is derived from structural patterns in official data.
+      It is an analytical indicator, not a legal determination.
+    </p>
+  </div>
+</div>
+
+<div class="section">
+  <div class="section-header">Section 3 — Analytical Findings</div>
+  <div class="section-content">
+    {% if agreed_findings %}
+    <div class="subsection-title">Agreed Findings (confirmed by multiple investigators)</div>
+    {% for finding in agreed_findings %}
+    <div class="finding-item finding-{{ finding.severity }}">
+      <strong>[{{ finding.severity }}]</strong> {{ finding.description }}
+      {% if finding.evidence %}
+      <div style="margin-top:4px;">
+        {% for e in finding.evidence[:2] %}
+        <span class="source-chip">{{ e }}</span>
+        {% endfor %}
+      </div>
+      {% endif %}
+    </div>
+    {% endfor %}
+    {% else %}
+    <p>No findings confirmed by multiple investigators in current dataset.</p>
+    {% endif %}
+  </div>
+</div>
+
+<div class="section">
+  <div class="section-header">Section 4 — Doubts and Unexplained Patterns</div>
+  <div class="section-content">
+    {% if doubts %}
+    {% for doubt in doubts %}
+    <div class="doubt-item">
+      <strong>Hypothesis:</strong> {{ doubt.hypothesis }}<br>
+      <strong>Data Gap:</strong> {{ doubt.gap }}<br>
+      <strong>Recommended Action:</strong> {{ doubt.action }}
+    </div>
+    {% endfor %}
+    {% else %}
+    <p>No unexplained patterns identified in current dataset.</p>
+    {% endif %}
+  </div>
+</div>
+
+<div class="section">
+  <div class="section-header">Section 5 — Positive Contributions</div>
+  <div class="section-content">
+    {% if positive_contributions %}
+    {% for item in positive_contributions[:10] %}
+    <div class="positive-item">{{ item }}</div>
+    {% endfor %}
+    {% else %}
+    <p>Insufficient data to identify positive contributions.</p>
+    {% endif %}
+  </div>
+</div>
+
+<div class="section">
+  <div class="section-header">Section 6 — Timeline of Events</div>
+  <div class="section-content">
+    {% if timeline %}
+    {% for event in timeline[:20] %}
+    <div class="timeline-item">
+      <div class="timeline-date">{{ event.date }}</div>
+      <div class="timeline-event">
+        <strong>{{ event.event }}</strong> — {{ event.detail }}
+        <span class="source-chip">{{ event.source }}</span>
+      </div>
+    </div>
+    {% endfor %}
+    {% else %}
+    <p>No timeline events reconstructed from available data.</p>
+    {% endif %}
+  </div>
+</div>
+
+<div class="section">
+  <div class="section-header">Section 7 — Evidence Locker</div>
+  <div class="section-content">
+    <p style="margin-bottom:8px; font-size:9px; color:#666;">
+      All {{ evidence_count }} primary source documents referenced in this report.
+    </p>
+    {% for evidence in evidence_locker %}
+    <div class="evidence-item">
+      <strong>{{ evidence.institution }}</strong> — {{ evidence.document }}
+      {% if evidence.url %}| <a href="{{ evidence.url }}">{{ evidence.url }}</a>{% endif %}
+      {% if evidence.date %}| Date: {{ evidence.date }}{% endif %}
+    </div>
+    {% endfor %}
+  </div>
+</div>
+
+<div class="section">
+  <div class="section-header">Section 8 — Methodology and Data Sources</div>
+  <div class="section-content">
+    <p>This dossier was generated by the BharatGraph Multi-Investigator AI Engine.
+    {{ investigator_count }} specialist investigators analysed this entity in parallel,
+    each from an independent analytical angle. Every finding is backed by a primary
+    source document. No claims are made without evidence.</p>
+    <p style="margin-top:8px;">Data sources used in this analysis include official Indian government
+    records (ECI affidavits, MCA filings, GeM contracts, CAG audit reports, PIB press
+    releases, parliamentary records) and international datasets (OpenSanctions,
+    ICIJ Offshore Leaks, Wikidata).</p>
+    <p style="margin-top:8px; font-weight:bold; color:#dc3545;">
+    LEGAL DISCLAIMER: This report is generated from publicly available official records.
+    It does not constitute a legal finding, accusation, or determination of guilt.
+    The subject of this report has the right to submit corrections at bharatgraph.in.
+    </p>
+  </div>
+</div>
+
+<div class="page-footer">
+  BharatGraph Public Transparency Platform | Report Hash: {{ report_hash[:32] }}... | Generated: {{ generated_at }}
+</div>
+
+</body>
+</html>