release: complete — Evidence Connection Map + Deep Investigation

6-layer recursive investigation engine.
Click any graph node to see WHY connected, source, and next leads.
Evidence panel slides in from right with Investigate Further button.
/investigate/{id} and /connection-map endpoints live.

ai/connection_mapper.py

@@ -0,0 +1,191 @@
+import os, sys
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from datetime import datetime
+from loguru import logger
+
+
+RELATIONSHIP_LABELS = {
+    "DIRECTOR_OF":    {"label":"director","strength":"strong","color":"#FF9933"},
+    "WON_CONTRACT":   {"label":"contract","strength":"strong","color":"#138808"},
+    "AWARDED_BY":     {"label":"awarded_by","strength":"strong","color":"#000080"},
+    "FLAGS":          {"label":"audit_flag","strength":"strong","color":"#DC3545"},
+    "MEMBER_OF":      {"label":"party","strength":"medium","color":"#6F42C1"},
+    "AUDITS":         {"label":"audits","strength":"strong","color":"#DC3545"},
+    "MENTIONED_IN":   {"label":"mentioned","strength":"weak","color":"#6C757D"},
+}
+
+
+class ConnectionMapper:
+
+    def __init__(self, driver=None):
+        self.driver = driver
+
+    def find_paths(self, entity_a: str, entity_b: str,
+                   max_hops: int = 5) -> dict:
+        logger.info(f"[ConnectionMapper] {entity_a} → {entity_b} (max {max_hops} hops)")
+
+        if not self.driver:
+            return {"status":"no_database","paths":[],"path_count":0}
+
+        with self.driver.session() as session:
+            rows = session.run(
+                """
+                MATCH path = shortestPath(
+                  (a {id:$a})-[*1..5]-(b {id:$b})
+                )
+                RETURN [n IN nodes(path) | {id:n.id, name:n.name,
+                        label:labels(n)[0]}] AS nodes,
+                       [r IN relationships(path) | type(r)] AS rels,
+                       length(path) AS hops
+                LIMIT 10
+                """,
+                a=entity_a, b=entity_b
+            ).data()
+
+        paths = []
+        for row in rows:
+            nodes = row.get("nodes", [])
+            rels  = row.get("rels", [])
+            hops  = row.get("hops", 0)
+
+            steps = []
+            for i, rel in enumerate(rels):
+                rel_meta = RELATIONSHIP_LABELS.get(rel, {
+                    "label": rel.lower(), "strength":"unknown","color":"#6C757D"
+                })
+                steps.append({
+                    "from":        nodes[i].get("name") or nodes[i].get("id"),
+                    "from_id":     nodes[i].get("id"),
+                    "from_type":   nodes[i].get("label"),
+                    "relationship":rel,
+                    "rel_label":   rel_meta["label"],
+                    "strength":    rel_meta["strength"],
+                    "color":       rel_meta["color"],
+                    "to":          nodes[i+1].get("name") or nodes[i+1].get("id"),
+                    "to_id":       nodes[i+1].get("id"),
+                    "to_type":     nodes[i+1].get("label"),
+                    "why":         self._explain_relationship(rel),
+                    "how":         "Graph shortest path algorithm (Neo4j)",
+                    "source":      self._get_source(rel),
+                })
+
+            confidence = "HIGH" if hops <= 2 else "MEDIUM" if hops <= 3 else "LOW"
+
+            paths.append({
+                "hops":         hops,
+                "confidence":   confidence,
+                "steps":        steps,
+                "path_summary": " → ".join(
+                    n.get("name") or n.get("id","?") for n in nodes
+                ),
+            })
+
+        logger.success(f"[ConnectionMapper] Found {len(paths)} paths")
+
+        return {
+            "entity_a":    entity_a,
+            "entity_b":    entity_b,
+            "path_count":  len(paths),
+            "paths":       paths,
+            "mapped_at":   datetime.now().isoformat(),
+        }
+
+    def get_node_evidence(self, entity_id: str) -> dict:
+        logger.info(f"[ConnectionMapper] Evidence for node {entity_id}")
+
+        if not self.driver:
+            return {"entity_id": entity_id, "edges": [], "status": "no_database"}
+
+        with self.driver.session() as session:
+            rows = session.run(
+                """
+                MATCH (n {id:$id})-[r]-(m)
+                RETURN type(r) AS rel, labels(m)[0] AS node_type,
+                       m.name AS name, m.id AS mid,
+                       m.state AS state
+                LIMIT 30
+                """,
+                id=entity_id
+            ).data()
+            entity_row = session.run(
+                "MATCH (n {id:$id}) RETURN n.name AS name, labels(n)[0] AS label, "
+                "n.risk_score AS score, n.risk_level AS level, n.state AS state,"
+                "n.party AS party",
+                id=entity_id
+            ).single()
+
+        edges = []
+        for row in rows:
+            rel      = row.get("rel","")
+            rel_meta = RELATIONSHIP_LABELS.get(rel, {
+                "label":rel.lower(),"strength":"unknown","color":"#6C757D"
+            })
+            edges.append({
+                "relationship": rel,
+                "rel_label":    rel_meta["label"],
+                "strength":     rel_meta["strength"],
+                "color":        rel_meta["color"],
+                "connected_to": row.get("name"),
+                "connected_id": row.get("mid"),
+                "node_type":    row.get("node_type"),
+                "why":          self._explain_relationship(rel),
+                "how":          "Official government record",
+                "source":       self._get_source(rel),
+                "next_leads":   self._suggest_leads(rel, row.get("node_type","")),
+            })
+
+        entity_info = {}
+        if entity_row:
+            entity_info = {
+                "name":       entity_row.get("name"),
+                "label":      entity_row.get("label"),
+                "risk_score": entity_row.get("score"),
+                "risk_level": entity_row.get("level"),
+                "state":      entity_row.get("state"),
+                "party":      entity_row.get("party"),
+            }
+
+        return {
+            "entity_id":   entity_id,
+            "entity_info": entity_info,
+            "edge_count":  len(edges),
+            "edges":       edges,
+            "fetched_at":  datetime.now().isoformat(),
+        }
+
+    def _explain_relationship(self, rel: str) -> str:
+        explanations = {
+            "DIRECTOR_OF":  "Entity holds directorship in this company per MCA21 filings.",
+            "WON_CONTRACT": "Company received government contract via GeM procurement.",
+            "AWARDED_BY":   "Contract was awarded by this ministry/department.",
+            "FLAGS":        "CAG audit report flagged this scheme or department.",
+            "MEMBER_OF":    "Entity is a registered member of this political party.",
+            "AUDITS":       "CAG conducted audit of this ministry.",
+            "MENTIONED_IN": "Entity is mentioned in this document.",
+        }
+        return explanations.get(rel, f"Relationship type: {rel}")
+
+    def _get_source(self, rel: str) -> str:
+        sources = {
+            "DIRECTOR_OF":  "Ministry of Corporate Affairs — MCA21",
+            "WON_CONTRACT": "Government e-Marketplace (GeM)",
+            "AWARDED_BY":   "Government e-Marketplace (GeM)",
+            "FLAGS":        "Comptroller and Auditor General (CAG)",
+            "MEMBER_OF":    "Election Commission of India",
+            "AUDITS":       "Comptroller and Auditor General (CAG)",
+        }
+        return sources.get(rel, "BharatGraph Knowledge Graph")
+
+    def _suggest_leads(self, rel: str, node_type: str) -> list:
+        leads = {
+            "DIRECTOR_OF":  ["Check other companies this director controls",
+                             "Look for contracts from ministries this entity oversees"],
+            "WON_CONTRACT": ["Check if company was incorporated recently",
+                             "Compare contract value vs company paid-up capital"],
+            "FLAGS":        ["Read full CAG report for specific irregularity amount",
+                             "Check if irregularity led to prosecution"],
+            "MEMBER_OF":    ["Check donation records from this party",
+                             "Check policy changes benefiting entity after joining party"],
+        }
+        return leads.get(rel, ["Expand graph one more hop", "Check timeline alignment"])

ai/deep_investigator.py

@@ -0,0 +1,213 @@
+import os, sys
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from datetime import datetime
+from loguru import logger
+
+
+LAYER_NAMES = [
+    "direct_evidence",
+    "relationship_expansion",
+    "pattern_investigation",
+    "timeline_investigation",
+    "network_influence",
+    "evidence_validation",
+]
+
+
+class DeepInvestigator:
+
+    def __init__(self, driver=None):
+        self.driver = driver
+
+    def investigate(self, entity_id: str, entity_name: str = "") -> dict:
+        logger.info(f"[DeepInvestigator] 6-layer analysis: {entity_name or entity_id}")
+
+        if not self.driver:
+            return {
+                "entity_id":   entity_id,
+                "entity_name": entity_name,
+                "layers":      [],
+                "total_items": 0,
+                "status":      "no_database",
+                "investigated_at": datetime.now().isoformat(),
+            }
+
+        layers = []
+        with self.driver.session() as session:
+            if not entity_name:
+                row = session.run(
+                    "MATCH (n {id:$id}) RETURN n.name AS name",
+                    id=entity_id
+                ).single()
+                entity_name = (row["name"] if row else entity_id) or entity_id
+
+            for i, fn in enumerate([
+                lambda s: self._layer_1_direct(entity_id, s),
+                lambda s: self._layer_2_expansion(entity_id, s),
+                lambda s: self._layer_3_patterns(entity_id, s),
+                lambda s: self._layer_4_timeline(entity_id, s),
+                lambda s: self._layer_5_influence(entity_id, s),
+                lambda s: self._layer_6_validation(entity_id, entity_name, s),
+            ], 1):
+                try:
+                    result = fn(session)
+                    layers.append(result)
+                    logger.info(f"[DeepInvestigator] Layer {i}: {result.get('count',0)} items")
+                except Exception as e:
+                    logger.warning(f"[DeepInvestigator] Layer {i} failed: {e}")
+                    layers.append({"layer": i, "name": LAYER_NAMES[i-1],
+                                   "count": 0, "error": str(e)})
+
+        total = sum(l.get("count", 0) for l in layers)
+        logger.success(f"[DeepInvestigator] Complete: {total} items across 6 layers")
+
+        return {
+            "entity_id":       entity_id,
+            "entity_name":     entity_name,
+            "layer_count":     len(layers),
+            "total_items":     total,
+            "layers":          layers,
+            "investigated_at": datetime.now().isoformat(),
+        }
+
+    def _layer_1_direct(self, entity_id: str, session) -> dict:
+        rows = session.run(
+            """
+            MATCH (n {id:$id})-[r]-(m)
+            RETURN type(r) AS rel, labels(m)[0] AS node_type,
+                   m.name AS name, m.id AS mid
+            LIMIT 50
+            """,
+            id=entity_id
+        ).data()
+        items = [{"type":"direct_relationship","relationship":r.get("rel"),
+                  "connected_to":r.get("name"),"node_type":r.get("node_type"),
+                  "node_id":r.get("mid"),
+                  "why":"Directly linked in knowledge graph",
+                  "how":"Graph traversal — single hop",
+                  "confidence":"HIGH","source":"Neo4j graph database"}
+                 for r in rows]
+        return {"layer":1,"name":"Direct Evidence","count":len(items),"items":items}
+
+    def _layer_2_expansion(self, entity_id: str, session) -> dict:
+        rows = session.run(
+            """
+            MATCH (n {id:$id})-[:DIRECTOR_OF]->(:Company)<-[:DIRECTOR_OF]-(p)
+            WHERE p.id <> $id
+            RETURN p.name AS shared_person, p.id AS pid,
+                   labels(p)[0] AS ptype
+            LIMIT 20
+            """,
+            id=entity_id
+        ).data()
+        items = [{"type":"shared_directorship",
+                  "connected_to":r.get("shared_person"),
+                  "node_id":r.get("pid"),
+                  "why":"Shares company directorship with target entity",
+                  "how":"Two-hop graph traversal via shared company",
+                  "confidence":"HIGH","source":"MCA21 Director Records"}
+                 for r in rows]
+        return {"layer":2,"name":"Relationship Expansion","count":len(items),"items":items}
+
+    def _layer_3_patterns(self, entity_id: str, session) -> dict:
+        rows = session.run(
+            """
+            MATCH (n {id:$id})-[:DIRECTOR_OF]->(c:Company)
+                  -[:WON_CONTRACT]->(ct:Contract)
+            WITH ct.buyer_org AS buyer, count(ct) AS cnt,
+                 sum(ct.amount_crore) AS total
+            WHERE cnt >= 2
+            RETURN buyer, cnt, total
+            ORDER BY cnt DESC LIMIT 10
+            """,
+            id=entity_id
+        ).data()
+        items = [{"type":"contract_concentration",
+                  "buyer":r.get("buyer"),
+                  "contract_count":r.get("cnt"),
+                  "total_crore":r.get("total"),
+                  "why":f"Repeated contracts ({r.get('cnt')}) from same buyer",
+                  "how":"Pattern analysis — frequency count",
+                  "confidence":"HIGH","source":"GeM Procurement Data"}
+                 for r in rows]
+        return {"layer":3,"name":"Pattern Investigation","count":len(items),"items":items}
+
+    def _layer_4_timeline(self, entity_id: str, session) -> dict:
+        rows = session.run(
+            """
+            MATCH (n {id:$id})-[:DIRECTOR_OF|WON_CONTRACT*1..2]->(ct:Contract)
+            RETURN ct.order_date AS date, ct.amount_crore AS amount,
+                   ct.buyer_org AS buyer, ct.order_id AS contract_id
+            ORDER BY ct.order_date LIMIT 30
+            """,
+            id=entity_id
+        ).data()
+        items = [{"type":"timeline_event","date":r.get("date"),
+                  "event":"Contract Awarded",
+                  "amount_crore":r.get("amount"),
+                  "buyer":r.get("buyer"),
+                  "why":"Temporal sequence event in entity history",
+                  "how":"Timeline reconstruction from contract dates",
+                  "confidence":"HIGH","source":"GeM"}
+                 for r in rows if r.get("date")]
+        return {"layer":4,"name":"Timeline Investigation","count":len(items),"items":items}
+
+    def _layer_5_influence(self, entity_id: str, session) -> dict:
+        row = session.run(
+            """
+            MATCH (n {id:$id})
+            RETURN n.betweenness_centrality AS bc, n.pagerank AS pr
+            """,
+            id=entity_id
+        ).single()
+        items = []
+        if row:
+            bc = row.get("bc") or 0
+            if bc > 0.05:
+                items.append({
+                    "type":"network_gatekeeper",
+                    "metric":"betweenness_centrality",
+                    "value":round(bc, 4),
+                    "why":f"Betweenness centrality {bc:.4f} — entity connects clusters",
+                    "how":"NetworkX betweenness_centrality algorithm",
+                    "confidence":"HIGH","source":"Graph Analytics",
+                })
+        return {"layer":5,"name":"Network Influence","count":len(items),"items":items}
+
+    def _layer_6_validation(self, entity_id: str, entity_name: str,
+                              session) -> dict:
+        items = []
+        row = session.run(
+            "MATCH (n:Politician {id:$id}) RETURN n.state AS state",
+            id=entity_id
+        ).single()
+        if row and row.get("state"):
+            sebi = session.run(
+                """
+                MATCH (s:RegulatoryOrder)
+                WHERE toLower(s.title) CONTAINS toLower($name)
+                  AND s.state IS NOT NULL AND s.state <> $state
+                RETURN s.state AS sebi_state, s.title AS title LIMIT 1
+                """,
+                name=entity_name, state=row["state"]
+            ).single()
+            if sebi:
+                items.append({
+                    "type":"conflicting_disclosure",
+                    "why":"State differs between MCA and regulatory filing",
+                    "how":"Cross-source contradiction detection",
+                    "confidence":"MEDIUM","source":"MCA vs SEBI",
+                })
+        return {"layer":6,"name":"Evidence Validation","count":len(items),"items":items}
+
+
+if __name__ == "__main__":
+    print("=" * 55)
+    print("BharatGraph — Deep Investigator Test (offline)")
+    print("=" * 55)
+    d = DeepInvestigator(driver=None)
+    r = d.investigate("test_001", "Test Entity")
+    print(f"  Status: {r.get('status')}")
+    print(f"  Layers: {r.get('layer_count', 0)}")
+    print("\nDone!")

api/main.py

@@ -8,7 +8,7 @@ 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, multilingual, export, admin
+from api.routes import search, profile, graph, risk, multilingual, export, admin, investigation
 from api.models import HealthResponse, StatsResponse
 
 
@@ -48,7 +48,8 @@ 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.include_router(admin.router,      tags=["Admin"])
+app.include_router(admin.router,         tags=["Admin"])
+app.include_router(investigation.router, tags=["Investigation"])
 
 
 @app.get("/health", response_model=HealthResponse)

api/routes/investigation.py

@@ -0,0 +1,44 @@
+import os, sys
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from datetime import datetime
+from typing import Optional
+from fastapi import APIRouter, Depends, Query
+from loguru import logger
+
+from api.dependencies import get_db
+from ai.deep_investigator import DeepInvestigator
+from ai.connection_mapper import ConnectionMapper
+
+router = APIRouter()
+
+
+@router.get("/investigate/{entity_id}")
+def deep_investigate(entity_id: str, driver=Depends(get_db)):
+    logger.info(f"[Investigation] Deep investigate: {entity_id}")
+    investigator = DeepInvestigator(driver=driver)
+    with driver.session() as session:
+        row = session.run(
+            "MATCH (n {id:$id}) RETURN n.name AS name",
+            id=entity_id
+        ).single()
+    name = (row["name"] if row else entity_id) or entity_id
+    return investigator.investigate(entity_id, name)
+
+
+@router.get("/connection-map")
+def connection_map(
+    a: str = Query(..., description="Entity A ID"),
+    b: str = Query(..., description="Entity B ID"),
+    driver=Depends(get_db),
+):
+    logger.info(f"[Investigation] Connection map: {a} → {b}")
+    mapper = ConnectionMapper(driver=driver)
+    return mapper.find_paths(a, b)
+
+
+@router.get("/node-evidence/{entity_id}")
+def node_evidence(entity_id: str, driver=Depends(get_db)):
+    logger.info(f"[Investigation] Node evidence: {entity_id}")
+    mapper = ConnectionMapper(driver=driver)
+    return mapper.get_node_evidence(entity_id)

frontend/index.html

@@ -119,6 +119,7 @@
   <script src="js/api.js"></script>
   <script src="js/components.js"></script>
   <script src="js/graph.js"></script>
+  <script src="js/evidence_panel.js"></script>
   <script src="js/app.js"></script>
   <script>
     Api.health().then(() => {

frontend/js/api.js

@@ -53,6 +53,8 @@ const Api = {
 
   verifyHash: (hash) => Api._request(`/verify/${hash}`),
 
+  nodeEvidence: (entityId) => Api._request(`/node-evidence/${entityId}`),
+
   createFeedSocket: () => {
     const wsUrl = API_BASE.replace(/^http/, "ws") + "/ws/feed";
     return new WebSocket(wsUrl);

frontend/js/evidence_panel.js

@@ -0,0 +1,181 @@
+const EvidencePanel = {
+  _visible: false,
+  _container: null,
+
+  init: () => {
+    const panel = document.createElement("div");
+    panel.id = "evidence-panel";
+    panel.style.cssText = `
+      position: fixed; top: 0; right: -420px; width: 400px; height: 100vh;
+      background: var(--bg-secondary); border-left: 1px solid var(--border-color);
+      box-shadow: -4px 0 24px rgba(0,0,0,0.3); z-index: 500;
+      overflow-y: auto; transition: right 0.3s ease; padding: 0;
+    `;
+    document.body.appendChild(panel);
+    EvidencePanel._container = panel;
+
+    const overlay = document.createElement("div");
+    overlay.id = "evidence-overlay";
+    overlay.style.cssText = `
+      position:fixed;inset:0;background:rgba(0,0,0,0.4);
+      z-index:499;display:none;
+    `;
+    overlay.addEventListener("click", EvidencePanel.close);
+    document.body.appendChild(overlay);
+  },
+
+  open: async (entityId, entityName) => {
+    if (!EvidencePanel._container) EvidencePanel.init();
+    EvidencePanel._container.innerHTML = `
+      <div style="padding:20px">
+        <div style="display:flex;justify-content:space-between;align-items:center;margin-bottom:16px">
+          <span style="font-size:11px;font-weight:600;letter-spacing:.1em;
+                       text-transform:uppercase;color:var(--color-saffron)">
+            Evidence Panel
+          </span>
+          <button onclick="EvidencePanel.close()"
+                  style="background:none;border:none;color:var(--text-muted);
+                         font-size:20px;cursor:pointer;line-height:1">×</button>
+        </div>
+        <h2 style="font-size:18px;font-weight:700;color:var(--text-primary);margin-bottom:4px">
+          ${entityName || entityId}
+        </h2>
+        <div style="font-size:12px;color:var(--text-muted);margin-bottom:20px">
+          Entity ID: ${entityId}
+        </div>
+        <div id="panel-content">
+          <div class="spinner" style="margin:40px auto"></div>
+        </div>
+      </div>
+    `;
+    EvidencePanel._container.style.right = "0";
+    document.getElementById("evidence-overlay").style.display = "block";
+    EvidencePanel._visible = true;
+
+    try {
+      const data = await Api.nodeEvidence(entityId);
+      EvidencePanel._render(data, entityId);
+    } catch (err) {
+      document.getElementById("panel-content").innerHTML = `
+        <p style="color:var(--color-risk-very-high);font-size:13px">
+          Could not load evidence. Ensure API is running.
+        </p>`;
+    }
+  },
+
+  _render: (data, entityId) => {
+    const info   = data.entity_info || {};
+    const edges  = data.edges || [];
+    const el     = document.getElementById("panel-content");
+    if (!el) return;
+
+    const riskColour = {
+      "LOW":"var(--color-risk-low)","MODERATE":"#856404",
+      "HIGH":"var(--color-risk-high)","VERY_HIGH":"var(--color-risk-very-high)"
+    }[info.risk_level] || "var(--text-muted)";
+
+    el.innerHTML = `
+      ${info.risk_score != null ? `
+      <div style="padding:12px;background:var(--bg-tertiary);border-radius:8px;margin-bottom:16px">
+        <div style="font-size:11px;text-transform:uppercase;letter-spacing:.08em;
+                    color:var(--text-muted);margin-bottom:6px">Structural Risk</div>
+        <div style="display:flex;align-items:center;gap:8px">
+          <div style="flex:1;height:6px;background:var(--bg-primary);border-radius:3px;overflow:hidden">
+            <div style="width:${info.risk_score}%;height:100%;background:${riskColour};border-radius:3px"></div>
+          </div>
+          <span style="font-weight:700;font-size:13px;color:${riskColour}">
+            ${info.risk_score}/100
+          </span>
+        </div>
+      </div>` : ""}
+
+      <div style="margin-bottom:20px">
+        <div style="font-size:12px;font-weight:600;text-transform:uppercase;
+                    letter-spacing:.08em;color:var(--text-muted);margin-bottom:8px">
+          Connections (${edges.length})
+        </div>
+        ${edges.slice(0, 15).map(edge => `
+          <div style="padding:10px 12px;margin-bottom:8px;background:var(--bg-tertiary);
+                      border-radius:6px;border-left:3px solid ${edge.color || '#666'}">
+            <div style="display:flex;align-items:center;gap:6px;margin-bottom:4px">
+              <span style="font-size:10px;font-weight:600;text-transform:uppercase;
+                           color:${edge.color};letter-spacing:.06em">${edge.rel_label}</span>
+              <span style="font-size:10px;color:var(--text-muted)">
+                ${edge.strength === "strong" ? "●" : edge.strength === "medium" ? "◐" : "○"}
+                ${edge.strength}
+              </span>
+            </div>
+            <div style="font-size:13px;font-weight:500;color:var(--text-primary);margin-bottom:2px">
+              ${edge.connected_to || edge.connected_id}
+            </div>
+            <div style="font-size:11px;color:var(--text-secondary);margin-bottom:4px">
+              <strong>WHY:</strong> ${edge.why}
+            </div>
+            <div style="font-size:10px;color:var(--text-muted)">
+              <strong>SOURCE:</strong> ${edge.source}
+            </div>
+            ${edge.next_leads && edge.next_leads.length ? `
+            <div style="margin-top:6px;padding-top:6px;border-top:1px solid var(--border-color)">
+              <div style="font-size:10px;color:var(--color-saffron);font-weight:600;margin-bottom:3px">
+                NEXT LEADS
+              </div>
+              ${edge.next_leads.map(l => `
+                <div style="font-size:10px;color:var(--text-muted);margin-bottom:2px">→ ${l}</div>
+              `).join("")}
+            </div>` : ""}
+          </div>
+        `).join("")}
+      </div>
+
+      <button onclick="EvidencePanel._investigate('${entityId}')"
+              class="btn btn--primary" style="width:100%;margin-bottom:8px">
+        Investigate Further (6 Layers)
+      </button>
+      <button onclick="Router.navigate('/entity/${entityId}');EvidencePanel.close();"
+              class="btn btn--secondary" style="width:100%">
+        Open Full Dossier
+      </button>
+    `;
+  },
+
+  _investigate: async (entityId) => {
+    const btn = document.querySelector("#panel-content .btn--primary");
+    if (btn) { btn.textContent = "Investigating..."; btn.disabled = true; }
+    try {
+      const data = await Api._request(`/investigate/${entityId}`);
+      const el   = document.getElementById("panel-content");
+      if (!el) return;
+      const total = data.total_items || 0;
+      el.innerHTML += `
+        <div style="margin-top:16px;padding:12px;background:var(--bg-tertiary);
+                    border-radius:8px;border:1px solid var(--color-saffron)">
+          <div style="font-size:11px;font-weight:600;color:var(--color-saffron);
+                      margin-bottom:8px">6-LAYER INVESTIGATION COMPLETE</div>
+          ${(data.layers || []).map(l => `
+            <div style="display:flex;justify-content:space-between;
+                        font-size:11px;margin-bottom:4px">
+              <span style="color:var(--text-secondary)">Layer ${l.layer}: ${l.name}</span>
+              <span style="color:var(--text-primary);font-weight:600">${l.count} items</span>
+            </div>
+          `).join("")}
+          <div style="margin-top:6px;padding-top:6px;border-top:1px solid var(--border-color);
+                      font-size:12px;font-weight:600;color:var(--text-primary)">
+            Total: ${total} investigative items
+          </div>
+        </div>
+      `;
+    } catch (err) {
+      if (btn) { btn.textContent = "Investigate Further"; btn.disabled = false; }
+    }
+  },
+
+  close: () => {
+    if (EvidencePanel._container)
+      EvidencePanel._container.style.right = "-420px";
+    const overlay = document.getElementById("evidence-overlay");
+    if (overlay) overlay.style.display = "none";
+    EvidencePanel._visible = false;
+  },
+};
+
+window.EvidencePanel = EvidencePanel;

frontend/js/graph.js

@@ -108,9 +108,13 @@ const GraphRenderer = {
         })
       )
       .on("click", (event, d) => {
-        event.stopPropagation();
-        if (window.Router) Router.navigate(`/entity/${d.id}`);
-      });
+          event.stopPropagation();
+          if (window.EvidencePanel) {
+            EvidencePanel.open(d.id, d.name || d.id);
+          } else if (window.Router) {
+            Router.navigate(`/entity/${d.id}`);
+          }
+        })
 
     node.append("circle")
       .attr("r", 22)