Aurelius improvement pass: domain-aware recs, finance/research surfaces, 2D graph

CLAUDE.md

@@ -8,7 +8,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 # Start the backend (from the repo root)
 uvicorn main:app --reload --port 8000
 
-# Frontend is a static page (index.html / styles.css / app.js / graph3d.js).
+# Frontend is a static page (index.html / styles.css / app.js / graph2d.js).
 # Serve it next to the backend:
 python -m http.server 8081     # app.js auto-detects localhost backends
 
@@ -42,8 +42,7 @@ core/              the engine — knows NOTHING about any specific dataset
   llm.py           OPTIONAL Gemini layer — narrates evidence; never required
 adapters/          one file per dataset; registration on import
   wikipedia.py     live — links/linkshere, disambiguation redirect
-  openalex.py      live — citations
-  github.py        live — dependency manifests (forward-only)
+  openalex.py      live — citations; DOI/arXiv resolve; paper metadata
   finance.py       ingested — typed financial knowledge graph
   news.py          ingested — entity/article co-mention graph
   biomed.py        ingested — Hetionet
@@ -160,7 +159,7 @@ Update graph → Index**, each stage a plain function in `pipeline.py`.
 
 Graph output lands in the shared store under source "news" (entities +
 capped freshest article nodes, `co_mentioned`/`mentions` edges), so the
-navigator/discover/3D UI work on it unchanged. **News is `hidden = True`**
+navigator/discover/graph UI work on it unchanged. **News is `hidden = True`**
 (core/source.py) — registered and queryable but excluded from the
 standalone source picker, because it's consumed as an overlay *inside*
 Finance (the News/Discussion toggles call `/api/news/entity`), not
@@ -168,21 +167,50 @@ browsed on its own.
 
 ### Finance product surface (server.py)
 
-Three endpoints beyond search power the Finance explorer UI:
+The Finance module leads with a **Company Profile** (the primary surface),
+graph secondary. Endpoints beyond search:
+- `/api/company` — one company's full dossier aggregated in a single call:
+  price series + key facts (sector, CEO, HQ, ETF count) and every typed
+  edge grouped into researcher buckets (peers = rivals + sector members,
+  suppliers/customers, correlated `co_moves` with corr, macro exposure,
+  ETF/investor ownership). Powers the `#profile-panel`.
 - `/api/node` — one resolved node's stored features (price series, kind,
   sector). Company/macro nodes store ~120 daily closes normalized to 100
-  at the window start (`_series_features` in ingest/finance.py), so the
-  Compare panel can overlay two price lines and compute their correlation
-  client-side.
+  at the window start (`_series_features` in ingest/finance.py).
 - `/api/exposure` — weighted 1- and 2-hop propagation over the typed
   edges ("if X moves, who's affected?"); every result carries the
   strongest chain as evidence. Skips the country hub (adds noise).
-- `/api/neighbors` — returns each node's `kind` for the 3D view's
+- `/api/neighbors` — returns each node's `kind` for the graph view's
   kind-based coloring and progressive click-to-expand.
-
-The frontend Compare panel (app.js) fuses `/api/relate` + `/api/node`:
-connection strength, plain-language "why connected" evidence, an SVG
-price chart with computed correlation, and a hand-off to the pathfinder.
+- `/api/suggest` — domain-aware autocomplete (see below).
+
+The Compare panel (app.js) fuses `/api/relate` + `/api/node`: connection
+strength, plain-language "why connected" evidence, an SVG price chart with
+computed correlation, and a hand-off to the pathfinder.
+
+### Research product surface — Citation Explorer (server.py)
+
+The Research (OpenAlex) module leads with a **Citation Explorer**, not the
+old connect-two-papers pathfinding:
+- `/api/paper?q=` — resolve a paper (title, DOI, arXiv id or URL) and
+  return its metadata (authors/year/venue/citation-count/abstract) plus
+  `references` (works it cites) and `citations` (works citing it), each a
+  metadata card. Citing works are sorted most-cited-first.
+- `POST /api/paper/upload` — resolve a paper from an uploaded PDF: `pypdf`
+  extracts a DOI / arXiv id / title from the first pages, then the same
+  assembly runs. Size-capped + rate-limited; CORS allows POST for this.
+The `#paper-panel` renders the dossier and "Build citation graph" seeds
+the 2D graph (paper centre, references + citations, directed `cites`
+edges); clicking any paper node expands BOTH citation directions.
+
+### Domain-aware recommendations (`/api/suggest`)
+
+Autocomplete draws from the ACTIVE source's own vocabulary via
+`GraphSource.suggest()` — companies/tickers for finance, papers for
+research, diseases/genes for biology, articles for Wikipedia — instead of
+the old frontend-hardcoded Wikipedia opensearch. Store-backed sources
+answer from `GraphStore.suggest_titles` (prefix-ranked); live sources
+override (Wikipedia opensearch, OpenAlex works search).
 
 ### Optional Gemini layer (core/llm.py)
 
@@ -232,31 +260,38 @@ on small graphs a node recurs dozens of times per 8192-pair batch, the
 summed `np.add.at` updates act like a huge effective learning rate, and
 the matrices diverge to float32 overflow without it.
 
-### Frontend: index.html + styles.css + app.js + graph3d.js
+### Frontend: index.html + styles.css + app.js + graph2d.js
 
 Single non-module scripts — handlers referenced by inline `onclick=` must
 stay plain function declarations (they live on `window` implicitly; note
 `let` top-level bindings are NOT reachable as `window.x` from console).
 
-- `graph3d.js` — the 3D explorer (`window.GV`), built on `3d-force-graph`
-  (+ a standalone three.js UMD loaded first because `three-spritetext`
-  needs a global `THREE`). Reads the same `nodes`/`edges` state the WS
-  handlers maintain; app.js `render()` just calls `GV.sync(...)`. Features:
-  small node/link geometry, damped orbit controls, auto-`zoomToFit` that
-  backs off when the user grabs the camera (resumed by `GV.fit()`), label
-  LOD (sprites only on endpoints/centre/path), view filters
-  (all/explored/path via `ctx.filter`), post-found dimming, click-to-expand
-  (`opts.onExpand`), edge tooltips from `edge.display`. Falls back to the
-  2D D3 renderer if the CDN libs fail.
+- `graph2d.js` — the 2D graph explorer (`window.GV`), an HTML-canvas +
+  d3-force renderer (replaced the old WebGL/three.js `graph3d.js`). Runs
+  the force sim directly over the SAME node objects app.js keeps in
+  `nodes`, so the WS flow is unchanged; app.js `render()` just calls
+  `GV.sync(nodes, edges, ctx)`. Features: curved (quadratic-bezier) edges,
+  kind-based colour + gentle clustering, label LOD, focus mode (click a
+  node → spotlight its neighbourhood), progressive click-to-expand
+  (`opts.onExpand`), edge tooltips from `edge.display`, and an auto-fit
+  camera that FOLLOWS the graph as it grows and backs off when the user
+  grabs it (resume with `GV.fit()`). **The auto-fit eases `transform` with
+  a cheap per-frame lerp — never spawn d3 zoom transitions in the rAF loop;
+  stacking them once pegged the main thread.** Labels use `n.title || n.id`
+  (papers carry an opaque `W…` id, so title is required).
 - `app.js` — `AC_BACKEND` auto-detects localhost vs the HF Spaces URL;
-  multi-source picker from `/api/sources`; `expandNodeFromGraph()` calls
-  `/api/neighbors` (progressive expansion, caps + dedup);
-  `setGraphFilter`/`fitGraphView` drive the `#graph-controls` bar;
-  `nodeUrl()` gates external links to Wikipedia-source paths only.
+  multi-source picker from `/api/sources`; domain-aware autocomplete via
+  `/api/suggest`; the Finance **Company Profile** panel (`/api/company`)
+  and Research **Citation Explorer** panel (`/api/paper`, `/api/paper/upload`)
+  are the primary per-domain surfaces, with the graph as a secondary
+  explorer. `expandNodeFromGraph()` calls `/api/neighbors` (or, for papers,
+  pulls both citation directions); `setGraphFilter`/`fitGraphView` drive
+  the `#graph-controls` bar; `nodeUrl()` gates external links to
+  Wikipedia-source paths only.
 - Discover panel opens with a plain-language explanation of hidden
   connections and every result carries a "Why: …" evidence line.
-- `vercel.json` CSP must keep `https://cdn.jsdelivr.net` in `script-src`
-  and `worker-src 'self' blob:` for the 3D libs.
+- `vercel.json` CSP only needs `https://cdnjs.cloudflare.com` in
+  `script-src` (d3); the 3D libs and their `worker-src blob:` are gone.
 
 ## Key constants (config.py)
 

README.md

@@ -15,18 +15,19 @@ Aurelius is a general-purpose **graph intelligence engine**: pick two things
 in any connected dataset and it walks the real links between them, ranking
 every step by meaning — on-device embeddings and graph search, with an
 **optional** Gemini layer that narrates the results in plain English —
-while the live search animates as an interactive 3D graph. The AI layer is
+while the live search animates as an interactive 2D graph. The AI layer is
 purely additive: with no key the app runs fully, and every AI panel falls
 back to a small notice with the standard result still shown.
 
 It started as a Wikipedia path-finder. Today every dataset is a plug-in
-**adapter** behind one protocol, so the same engine navigates:
+**adapter** behind one protocol, and each domain leads with a purpose-built
+research surface — a **company profile** for finance, a **citation
+explorer** for papers — with the graph as a secondary explorer:
 
 | Source | Mode | Graph |
 |---|---|---|
 | Wikipedia | live | article links (fetched on demand) |
-| Research papers (OpenAlex) | live | citations |
-| GitHub | live | dependency manifests + same-owner repos |
+| Research papers (OpenAlex) | live | citations — explore any paper's references & citing works (by title, DOI, arXiv id or uploaded PDF) |
 | **Finance** (Yahoo Finance) | ingested | companies, ETFs, sectors, executives, countries & macro indicators with typed edges: supply chains, ownership, competition, holdings, and *computed* return correlations |
 | **News** (News Intelligence) | ingested | entities + articles from live coverage, co-mention relationships, evolving stories |
 | Biomedical (Hetionet) | ingested | genes–compounds–diseases |
@@ -44,7 +45,7 @@ embeddings, story grouping, and ranked search — exposed at `/api/news/*`
 for any domain module to consume.
 
 The frontend is a single static page (`index.html` / `styles.css` /
-`app.js` / `graph3d.js`) deployed on Vercel. The backend is this FastAPI
+`app.js` / `graph2d.js`) deployed on Vercel. The backend is this FastAPI
 service: an in-process `sentence-transformers` model plus the
 source-agnostic navigator, streamed to the browser over a WebSocket.
 

adapters/__init__.py

@@ -2,16 +2,15 @@
 GraphSource implementation with core.source.
 
 Importing this package registers every available adapter. Adapters that
-need ingested data (biomed, news, finance, github) register themselves
-regardless; they answer with a helpful error until an ingest run has
-populated the store.
+need ingested data (biomed, news, finance) register themselves regardless;
+they answer with a helpful error until an ingest run has populated the
+store.
 """
 
 from core.source import get_source, list_sources, register  # noqa: F401
 
 from . import wikipedia   # noqa: F401  (live)
 from . import openalex    # noqa: F401  (live)
-from . import github      # noqa: F401  (live crawl + optional ingest)
 from . import biomed      # noqa: F401  (ingested — Hetionet)
 from . import news        # noqa: F401  (ingested — GDELT/NewsAPI)
 from . import finance     # noqa: F401  (ingested — Yahoo Finance)

adapters/github.py

@@ -1,156 +0,0 @@
-"""Aurelius adapter — GitHub (live mode): the repository dependency graph.
-
-Nodes are repositories; edges are "depends on / relates to" links derived
-from a repo's dependency manifests and its owner's other repos. The demo
-use-case is impact analysis and ecosystem navigation: connect two repos,
-or discover() adjacent projects two hops out that you don't directly
-depend on.
-
-id = "owner/repo" (GitHub's own canonical id); title = the same.
-Backlinks (who-depends-on-me) are not available from the REST API without
-a full crawl, so supports_backlinks=False → the navigator runs forward-
-only for this source (direct-hit meeting only, no goal zone).
-
-Set GITHUB_TOKEN to lift the anonymous 60 req/hr limit to 5000/hr.
-"""
-
-from __future__ import annotations
-
-import re
-from typing import Optional
-
-import httpx
-
-from config import GITHUB_API, GITHUB_TOKEN, CONTACT_EMAIL
-from core.source import GraphSource, register
-from core.types import Edge, NodeInfo, NodeRef
-
-_HEADERS = {"User-Agent": f"Aurelius/1.0 ({CONTACT_EMAIL})",
-            "Accept": "application/vnd.github+json"}
-if GITHUB_TOKEN:
-    _HEADERS["Authorization"] = f"Bearer {GITHUB_TOKEN}"
-
-# owner/repo references inside dependency manifests and READMEs.
-_REPO_RE = re.compile(r"github\.com/([A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+)")
-# common manifest paths worth scanning for dependency edges
-_MANIFESTS = ("package.json", "requirements.txt", "pyproject.toml",
-              "go.mod", "Cargo.toml")
-
-
-class GitHubSource(GraphSource):
-    name = "github"
-    description = "GitHub — repositories linked by dependencies and authorship."
-    edge_types = ("depends_on", "same_owner")
-    supports_backlinks = False   # who-depends-on-me needs a full crawl
-
-    def __init__(self):
-        self._client: Optional[httpx.AsyncClient] = None
-        self._info_cache: dict[str, NodeInfo] = {}
-
-    def _http(self) -> httpx.AsyncClient:
-        if self._client is None or self._client.is_closed:
-            self._client = httpx.AsyncClient(headers=_HEADERS,
-                                             follow_redirects=True,
-                                             timeout=httpx.Timeout(25.0))
-        return self._client
-
-    async def _get(self, path: str, params: dict | None = None):
-        try:
-            r = await self._http().get(f"{GITHUB_API}{path}", params=params or {})
-            if r.status_code != 200:
-                return None
-            return r.json()
-        except Exception as e:
-            print(f"[github] {e}")
-            return None
-
-    def _ref(self, full_name: str, desc: str = "") -> NodeRef:
-        n = NodeRef(self.name, full_name.lower(), full_name)
-        if desc:
-            self._info_cache[n.id] = NodeInfo(
-                text=f"{full_name}. {desc}", summary=desc[:220])
-        return n
-
-    async def resolve(self, query: str) -> Optional[NodeRef]:
-        q = query.strip()
-        m = _REPO_RE.search(q)
-        if m:
-            q = m.group(1)
-        if "/" in q and " " not in q:
-            data = await self._get(f"/repos/{q}")
-            if data and data.get("full_name"):
-                return self._ref(data["full_name"], data.get("description") or "")
-        data = await self._get("/search/repositories",
-                               {"q": q, "sort": "stars", "per_page": 1})
-        items = (data or {}).get("items", [])
-        if not items:
-            return None
-        return self._ref(items[0]["full_name"], items[0].get("description") or "")
-
-    async def _manifest_repo_refs(self, full_name: str) -> set[str]:
-        found: set[str] = set()
-        for fname in _MANIFESTS:
-            data = await self._get(f"/repos/{full_name}/contents/{fname}")
-            if not data or "content" not in data:
-                continue
-            import base64
-            try:
-                text = base64.b64decode(data["content"]).decode("utf-8", "ignore")
-            except Exception:
-                continue
-            for m in _REPO_RE.finditer(text):
-                found.add(m.group(1))
-        return found
-
-    async def neighbors(self, n: NodeRef, *,
-                        hunt_id: str | None = None,
-                        priority_ids: set[str] | None = None) -> list[Edge]:
-        full_name = self._info_cache.get(n.id) and n.title or n.title
-        edges: list[Edge] = []
-        seen: set[str] = set()
-
-        # 1. Dependency edges from manifests.
-        for repo in await self._manifest_repo_refs(n.title):
-            key = repo.lower()
-            if key == n.id or key in seen:
-                continue
-            seen.add(key)
-            edges.append(Edge(src=n, dst=self._ref(repo), type="depends_on"))
-
-        # 2. Same-owner edges (the owner's other popular repos) — keeps the
-        #    graph connected when a repo has no parseable manifest.
-        owner = n.title.split("/")[0]
-        data = await self._get(f"/users/{owner}/repos",
-                               {"sort": "stars", "per_page": 30})
-        for repo in data or []:
-            fn = repo.get("full_name", "")
-            key = fn.lower()
-            if not fn or key == n.id or key in seen:
-                continue
-            seen.add(key)
-            edges.append(Edge(src=n,
-                              dst=self._ref(fn, repo.get("description") or ""),
-                              type="same_owner", weight=0.5))
-        return edges
-
-    async def node_info(self, n: NodeRef, rich: bool = False) -> NodeInfo:
-        if n.id in self._info_cache:
-            return self._info_cache[n.id]
-        data = await self._get(f"/repos/{n.title}")
-        if data:
-            desc = data.get("description") or ""
-            topics = " ".join(data.get("topics", []) or [])
-            text = f"{n.title}. {desc} {topics}".strip()
-            info = NodeInfo(text=text, summary=desc[:220])
-            self._info_cache[n.id] = info
-            return info
-        return NodeInfo(text=n.title)
-
-    async def node_infos(self, ns: list[NodeRef]) -> list[NodeInfo]:
-        return [self._info_cache.get(n.id, NodeInfo(text=n.title)) for n in ns]
-
-    async def sample_pair(self) -> Optional[tuple[str, str]]:
-        return ("pytorch/pytorch", "huggingface/transformers")
-
-
-register(GitHubSource())

adapters/openalex.py

@@ -14,6 +14,7 @@ incoming citations (cited_by). Both are real directed edges.
 from __future__ import annotations
 
 import asyncio
+import re
 from typing import Optional
 
 import httpx
@@ -23,7 +24,11 @@ from core.source import GraphSource, register
 from core.types import Edge, NodeInfo, NodeRef
 
 _UA = {"User-Agent": f"Aurelius/1.0 (mailto:{CONTACT_EMAIL})"}
-_SELECT = "id,display_name,publication_year,abstract_inverted_index,referenced_works"
+_SELECT = ("id,display_name,publication_year,cited_by_count,authorships,"
+           "primary_location,abstract_inverted_index,referenced_works")
+
+_DOI_RE   = re.compile(r"(10\.\d{4,9}/[^\s\"'<>]+)", re.IGNORECASE)
+_ARXIV_RE = re.compile(r"arxiv[:/]\s*(\d{4}\.\d{4,5})(v\d+)?", re.IGNORECASE)
 
 
 def _short_id(oa_id: str) -> str:
@@ -31,6 +36,18 @@ def _short_id(oa_id: str) -> str:
     return oa_id.rsplit("/", 1)[-1]
 
 
+def _authors(work: dict, cap: int = 3) -> list[str]:
+    names = [a.get("author", {}).get("display_name", "")
+             for a in (work.get("authorships") or [])]
+    return [n for n in names if n][:cap]
+
+
+def _venue(work: dict) -> str:
+    loc = work.get("primary_location") or {}
+    src = loc.get("source") or {}
+    return src.get("display_name", "") or ""
+
+
 def _deinvert_abstract(inv: dict | None, cap: int = 60) -> str:
     """OpenAlex ships abstracts as an inverted index {word: [positions]};
     reconstruct the first `cap` words for embedding text."""
@@ -80,26 +97,43 @@ class OpenAlexSource(GraphSource):
         sid = _short_id(work.get("id", ""))
         title = work.get("display_name") or sid
         yr = work.get("publication_year")
+        authors = _authors(work)
+        venue = _venue(work)
+        cited = work.get("cited_by_count") or 0
         abstract = _deinvert_abstract(work.get("abstract_inverted_index"))
         text = f"{title}." + (f" ({yr})." if yr else "")
         if abstract:
             text += f" {abstract}"
-        self._info_cache[sid] = NodeInfo(text=text,
-                                         summary=abstract[:220],
-                                         features={"year": yr or 0})
+        self._info_cache[sid] = NodeInfo(
+            text=text, summary=abstract[:280],
+            features={"year": yr or 0, "authors": authors, "venue": venue,
+                      "cited_by_count": cited, "kind": "paper"})
 
     async def resolve(self, query: str) -> Optional[NodeRef]:
         q = query.strip()
-        # Direct id?
+        # Direct OpenAlex id?
         if q.upper().startswith("W") and q[1:].isdigit():
             data = await self._get(f"/works/{q.upper()}", {"select": _SELECT})
             if data.get("id"):
                 self._stash_info(data)
                 return self._ref(data)
-        # Otherwise full-text search, most-cited first.
+        # DOI (bare or as a doi.org URL)?
+        m = _DOI_RE.search(q)
+        if m:
+            data = await self._get(f"/works/doi:{m.group(1)}", {"select": _SELECT})
+            if data.get("id"):
+                self._stash_info(data)
+                return self._ref(data)
+        # arXiv id (arXiv:2301.12345 or an arxiv.org/abs/... URL)?
+        am = _ARXIV_RE.search(q)
+        if am:
+            q = f"arXiv:{am.group(1)}"
+        # Otherwise full-text search by RELEVANCE (default sort). Sorting by
+        # citation count here is wrong for a title lookup — it returns the
+        # most-cited paper that loosely matches the words, not the paper the
+        # user named.
         data = await self._get("/works", {
-            "search": q, "per-page": 1, "select": _SELECT,
-            "sort": "cited_by_count:desc"})
+            "search": q, "per-page": 1, "select": _SELECT})
         results = data.get("results", [])
         if not results:
             return None
@@ -146,6 +180,27 @@ class OpenAlexSource(GraphSource):
     async def node_infos(self, ns: list[NodeRef]) -> list[NodeInfo]:
         return [self._info_cache.get(n.id, NodeInfo(text=n.title)) for n in ns]
 
+    async def suggest(self, query: str, limit: int = 8) -> list[dict]:
+        q = query.strip()
+        if len(q) < 3:
+            return []
+        data = await self._get("/works", {
+            "search": q, "per-page": min(limit, 25),
+            "select": "id,display_name,publication_year,authorships"})
+        out = []
+        for w in data.get("results", []):
+            sid = _short_id(w.get("id", ""))
+            yr = w.get("publication_year")
+            auths = w.get("authorships") or []
+            first = (auths[0].get("author", {}).get("display_name", "")
+                     if auths else "")
+            if first and len(auths) > 1:
+                first += " et al."
+            sub = " · ".join(x for x in [first, str(yr) if yr else ""] if x)
+            out.append({"id": sid, "title": w.get("display_name") or sid,
+                        "kind": "paper", "subtitle": sub or None})
+        return out
+
     async def sample_pair(self) -> Optional[tuple[str, str]]:
         return ("attention is all you need", "ImageNet classification")
 

adapters/wikipedia.py

@@ -305,6 +305,23 @@ class WikipediaSource(GraphSource):
                                 summary=sd))
         return out
 
+    # ── recommendations ──────────────────────────────────────────────────
+    async def suggest(self, query: str, limit: int = 8) -> list[dict]:
+        q = query.strip()
+        if len(q) < 2:
+            return []
+        data = await self._get({"action": "opensearch", "search": q,
+                                "limit": limit, "namespace": 0,
+                                "format": "json", "utf8": 1})
+        titles = data[1] if isinstance(data, list) and len(data) > 1 else []
+        descs  = data[2] if isinstance(data, list) and len(data) > 2 else []
+        out = []
+        for i, t in enumerate(titles):
+            sub = (descs[i] if i < len(descs) else "") or ""
+            out.append({"id": t, "title": t, "kind": "article",
+                        "subtitle": sub[:80] or None})
+        return out
+
     # ── niceties ─────────────────────────────────────────────────────────
     async def edge_display(self, src: NodeRef, dst: NodeRef) -> Optional[str]:
         """Visible text of the wikilink on src pointing at dst, when piped

app.js

@@ -4,8 +4,6 @@ let nodes = {};
 let edges = [];
 let centreNode = null;
 let pathNodes = new Set();
-let simulation = null;
-let svgEl, gEl;
 let width, height;
 let running = false;
 let _searchGen = 0;
@@ -138,6 +136,15 @@ function updateSourceUI() {
   const cmpFab = document.getElementById('compare-fab');
   if (cmpFab) cmpFab.style.display =
     (currentSource === 'finance' || currentSource === 'biomed') ? '' : 'none';
+  // Company Profile is a finance-only surface.
+  const profFab = document.getElementById('profile-fab');
+  if (profFab) profFab.style.display = isFinance ? '' : 'none';
+  if (!isFinance) toggleProfile(false);
+  // Citation Explorer is the research-papers surface.
+  const isPapers = currentSource === 'openalex';
+  const paperFab = document.getElementById('paper-fab');
+  if (paperFab) paperFab.style.display = isPapers ? '' : 'none';
+  if (!isPapers) togglePaper(false);
 }
 
 function renderLensPicker() {
@@ -316,7 +323,6 @@ const _isLocalHost = ['localhost', '127.0.0.1'].includes(location.hostname);
 const AC_BACKEND = _isLocalHost ? 'http://localhost:8000'
                                 : 'https://mvali77-aurelius.hf.space';
 const AC_BACKEND_WS = AC_BACKEND.replace(/^http/, 'ws');
-const WIKI_OPENSEARCH = 'https://en.wikipedia.org/w/api.php';
 
 // ════════════════════════════════════════════════════════════════════════════
 // Multi-source: load the registered adapters and let the user pick one.
@@ -345,7 +351,7 @@ function renderSourcePickers() {
 
 function sourceLabel(name) {
   const map = {
-    wikipedia: 'Wikipedia', openalex: 'Research Papers', github: 'GitHub',
+    wikipedia: 'Wikipedia', openalex: 'Research Papers',
     biomed: 'Biology', news: 'News', finance: 'Finance',
   };
   return map[name] || name;
@@ -356,19 +362,47 @@ const EXAMPLE_PAIRS = {
   wikipedia: [['Nagpur', 'Mars'], ['Cleopatra', 'Bitcoin'], ['Jazz', 'Quantum mechanics']],
   finance: [['NVDA', 'Ford'], ['Tim Cook', 'Crude Oil'], ['Berkshire Hathaway', 'Apple']],
   biomed: [['Levodopa', "Alzheimer's disease"], ['BRCA1', 'Apoptosis'], ['Tamoxifen', 'DNA repair']],
-  openalex: [['Attention is all you need', 'ImageNet']],
-  github: [['facebook/react', 'vercel/next.js']],
+  // Research papers lead with the citation explorer (hero CTA), not
+  // connect-two-papers pathfinding — so no A→B example pairs here.
 };
 
 function renderExampleChips() {
   const box = document.getElementById('hero-examples');
   if (!box) return;
   const pairs = EXAMPLE_PAIRS[currentSource] || [];
-  if (!pairs.length) { box.innerHTML = ''; return; }
-  box.innerHTML = '<span class="hero-ex-label">Try</span>'
-    + pairs.map(([a, b]) =>
-      `<button class="hero-ex-chip" onclick="runExample('${a.replace(/'/g, "\\'")}','${b.replace(/'/g, "\\'")}')">`
-      + `${escHtml(a)} <span>&rarr;</span> ${escHtml(b)}</button>`).join('');
+  // Finance and Research lead with a dedicated research surface, not
+  // pathfinding: a prominent CTA opens it straight from the landing.
+  let cta = '';
+  if (currentSource === 'finance') {
+    cta = `<button class="hero-research-cta" onclick="heroResearchCompany()">
+      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M4 20V11l5-3v12M13 20V6l5-3v17M3 20h18"/></svg>
+      Research a company</button>`;
+  } else if (currentSource === 'openalex') {
+    cta = `<button class="hero-research-cta" onclick="heroExplorePaper()">
+      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M6 3h9l4 4v14H6z"/><path d="M15 3v4h4"/><line x1="9" y1="12" x2="16" y2="12"/><line x1="9" y1="16" x2="14" y2="16"/></svg>
+      Explore a paper's citations</button>`;
+  }
+  if (!pairs.length && !cta) { box.innerHTML = ''; return; }
+  const tryLabel = cta ? 'or trace a link' : 'Try';
+  box.innerHTML = cta
+    + (pairs.length ? `<span class="hero-ex-label">${tryLabel}</span>`
+      + pairs.map(([a, b]) =>
+        `<button class="hero-ex-chip" onclick="runExample('${a.replace(/'/g, "\\'")}','${b.replace(/'/g, "\\'")}')">`
+        + `${escHtml(a)} <span>&rarr;</span> ${escHtml(b)}</button>`).join('') : '');
+}
+
+// Finance landing → jump straight to the company research surface.
+function heroResearchCompany() {
+  const seed = (document.getElementById('hero-inp-start').value || '').trim();
+  dismissHero(seed, '');
+  setTimeout(() => { if (seed) openProfile(seed); else toggleProfile(true); }, 260);
+}
+
+// Research landing → jump straight to the citation explorer.
+function heroExplorePaper() {
+  const seed = (document.getElementById('hero-inp-start').value || '').trim();
+  dismissHero(seed, '');
+  setTimeout(() => { if (seed) openPaper(seed); else togglePaper(true); }, 260);
 }
 
 function runExample(a, b) {
@@ -617,6 +651,412 @@ function compareToPath(a, b) {
   startSearch();
 }
 
+// ════════════════════════════════════════════════════════════════════════════
+// Company Profile — the primary finance research surface (/api/company).
+// A single company's dossier: price, key facts, peers, supply chain,
+// correlations, ownership, and the news moving it — the graph is secondary.
+// ════════════════════════════════════════════════════════════════════════════
+const PROFILE_QUICK = ['NVDA', 'AAPL', 'JPM', 'XOM', 'TSLA', 'BRK-B'];
+let _profileCurrent = null;
+
+function toggleProfile(open) {
+  const panel = document.getElementById('profile-panel');
+  if (!panel) return;
+  const fab = document.getElementById('profile-fab');
+  const show = open === undefined ? !panel.classList.contains('open') : open;
+  panel.classList.toggle('open', show);
+  panel.setAttribute('aria-hidden', show ? 'false' : 'true');
+  if (fab) fab.classList.toggle('hidden', show);
+  if (show) {
+    renderProfileEmptyChips();
+    const inp = document.getElementById('profile-input');
+    // seed with the last-focused / centre company when the box is empty
+    if (inp && !inp.value && centreNode) inp.value = centreNode;
+    if (inp && !_profileCurrent) inp.focus();
+  }
+}
+
+function renderProfileEmptyChips() {
+  const box = document.getElementById('profile-empty-chips');
+  if (!box) return;
+  box.innerHTML = PROFILE_QUICK.map(t =>
+    `<button class="prof-chip" onclick="openProfile('${t}')">${escHtml(t)}</button>`).join('');
+}
+
+async function openProfile(query) {
+  query = (query || '').trim();
+  if (!query) return;
+  toggleProfile(true);
+  const body = document.getElementById('profile-body');
+  const inp = document.getElementById('profile-input');
+  if (inp) inp.value = query;
+  if (body) body.innerHTML = '<div class="prof-loading"><span class="prof-spinner"></span>Building the profile…</div>';
+  try {
+    const data = await fetch(`${AC_BACKEND}/api/company?q=${encodeURIComponent(query)}`).then(r => r.json());
+    if (data.error) {
+      if (body) body.innerHTML = `<div class="prof-msg">${escHtml(data.error)}</div>`;
+      return;
+    }
+    _profileCurrent = data;
+    renderProfile(data);
+  } catch (e) {
+    if (body) body.innerHTML = '<div class="prof-msg">Could not reach the backend.</div>';
+  }
+}
+
+// single-series normalized price chart with an area fill
+function _profileChartSVG(series, changePct) {
+  if (!Array.isArray(series) || series.length < 2) return '';
+  const W = 560, H = 150, pad = 8;
+  const lo = Math.min(...series), hi = Math.max(...series);
+  const span = hi - lo || 1;
+  const up = (changePct || 0) >= 0;
+  const stroke = up ? '#4aab79' : '#d66a6a';
+  const step = (W - 2 * pad) / (series.length - 1);
+  const xy = series.map((v, i) =>
+    [pad + i * step, H - pad - (v - lo) / span * (H - 2 * pad)]);
+  const line = xy.map(p => `${p[0].toFixed(1)},${p[1].toFixed(1)}`).join(' ');
+  const area = `${pad},${H - pad} ${line} ${(W - pad).toFixed(1)},${H - pad}`;
+  return `<svg class="prof-chart" viewBox="0 0 ${W} ${H}" preserveAspectRatio="none" role="img" aria-label="Price chart">
+    <defs><linearGradient id="prof-grad" x1="0" y1="0" x2="0" y2="1">
+      <stop offset="0%" stop-color="${stroke}" stop-opacity="0.28"/>
+      <stop offset="100%" stop-color="${stroke}" stop-opacity="0"/>
+    </linearGradient></defs>
+    <polygon fill="url(#prof-grad)" points="${area}"/>
+    <polyline fill="none" stroke="${stroke}" stroke-width="2" stroke-linejoin="round" stroke-linecap="round" points="${line}"/>
+  </svg>`;
+}
+
+function _fmtChange(pct) {
+  if (typeof pct !== 'number' || !isFinite(pct)) return '';
+  const cls = pct >= 0 ? 'up' : 'down';
+  return `<span class="prof-chg ${cls}">${pct >= 0 ? '▲' : '▼'} ${Math.abs(pct)}%</span>`;
+}
+
+// a horizontal list of related-company cards (peers/suppliers/…)
+function _profileCards(items, opts = {}) {
+  if (!Array.isArray(items) || !items.length) return '';
+  return `<div class="prof-cards">` + items.map(c => {
+    const t = escHtml(c.title || c.id);
+    const meta = [];
+    if (opts.showCorr && typeof c.corr === 'number') meta.push(`corr ${c.corr}`);
+    else if (c.sector) meta.push(escHtml(c.sector));
+    const chg = (opts.showChange && typeof c.change_pct === 'number') ? _fmtChange(c.change_pct) : '';
+    return `<button class="prof-card" onclick="openProfile('${(c.id || '').replace(/'/g, "\\'")}')" title="Open ${t}">
+      <span class="prof-card-name">${t}</span>
+      <span class="prof-card-meta">${meta.join(' · ')} ${chg}</span>
+    </button>`;
+  }).join('') + `</div>`;
+}
+
+function _profileSection(title, hint, html) {
+  if (!html) return '';
+  return `<div class="prof-section">
+    <div class="prof-sec-head">${escHtml(title)}${hint ? `<span class="prof-sec-hint">${escHtml(hint)}</span>` : ''}</div>
+    ${html}
+  </div>`;
+}
+
+function renderProfile(d) {
+  const body = document.getElementById('profile-body');
+  if (!body) return;
+  const facts = [];
+  if (d.sector) facts.push(`<span class="prof-fact"><i>Sector</i>${escHtml(d.sector)}</span>`);
+  if (d.ceo && d.ceo.title) facts.push(`<span class="prof-fact"><i>CEO</i>${escHtml(d.ceo.title)}</span>`);
+  if (d.country) facts.push(`<span class="prof-fact"><i>HQ</i>${escHtml(d.country)}</span>`);
+  if (d.etfs && d.etfs.length) facts.push(`<span class="prof-fact"><i>In ETFs</i>${d.etfs.length}</span>`);
+
+  const price = (typeof d.last_price === 'number')
+    ? `<div class="prof-price">$${d.last_price} ${_fmtChange(d.change_pct)}
+        <span class="prof-price-note">last close · ${Array.isArray(d.series) ? d.series.length : 0}-day window</span></div>`
+    : '';
+
+  const kindBadge = d.kind ? `<span class="prof-kind">${escHtml(d.kind)}</span>` : '';
+
+  body.innerHTML = `
+    <div class="prof-title-row">
+      <h2 class="prof-title">${escHtml(d.title || d.id)}</h2>${kindBadge}
+    </div>
+    ${price}
+    ${facts.length ? `<div class="prof-facts">${facts.join('')}</div>` : ''}
+    ${d.summary ? `<p class="prof-summary">${escHtml(d.summary)}</p>` : ''}
+    ${Array.isArray(d.series) && d.series.length ? `<div class="prof-chart-wrap">${_profileChartSVG(d.series, d.change_pct)}</div>` : ''}
+
+    ${_profileSection('Peers', 'rivals & sector', _profileCards(d.peers, { showChange: true }))}
+    ${_profileSection('Suppliers', 'depends on', _profileCards(d.suppliers, { showChange: true }))}
+    ${_profileSection('Customers', 'sells to / powers', _profileCards(d.customers, { showChange: true }))}
+    ${_profileSection('Moves with', 'return correlation', _profileCards(d.correlated, { showCorr: true }))}
+    ${_profileSection('Macro exposure', 'correlated indicators', _profileCards(d.macro, { showCorr: true }))}
+    ${_profileSection('Ownership', 'ETFs & investors', _profileCards([...(d.etfs || []), ...(d.investors || [])]))}
+
+    <div class="prof-news" id="prof-news"><div class="prof-sec-head">In the news<span class="prof-sec-hint">latest coverage</span></div><div class="prof-news-body"><span class="prof-spinner"></span></div></div>
+
+    <div class="prof-actions">
+      <button class="prof-act primary" onclick="profileExploreGraph('${(d.id || '').replace(/'/g, "\\'")}')">Explore in graph</button>
+      <button class="prof-act" onclick="profileCompare('${(d.id || '').replace(/'/g, "\\'")}')">Compare…</button>
+    </div>`;
+
+  loadProfileNews(d.title || d.id);
+}
+
+// News for the profiled company (reuses the News Intelligence entity feed).
+async function loadProfileNews(name) {
+  const box = document.querySelector('#prof-news .prof-news-body');
+  if (!box) return;
+  try {
+    const data = await fetch(`${AC_BACKEND}/api/news/entity?name=${encodeURIComponent(name)}&k=5`).then(r => r.json());
+    const items = (data && data.results) || [];
+    if (!items.length) { box.innerHTML = '<div class="prof-msg small">No recent coverage indexed. Open the graph view and toggle News to refresh the feed.</div>'; return; }
+    box.innerHTML = items.map(a => {
+      const s = a.sentiment_label || 'neutral';
+      const when = a.published ? String(a.published).slice(0, 10) : '';
+      return `<a class="prof-news-item" href="${escHtml(a.url || '#')}" target="_blank" rel="noopener">
+        <span class="prof-news-dot prof-${s}" title="${s} tone"></span>
+        <span class="prof-news-txt">
+          <span class="prof-news-title">${escHtml(a.title || 'Untitled')}</span>
+          <span class="prof-news-src">${escHtml(a.source || '')}${when ? ' · ' + escHtml(when) : ''}</span>
+        </span>
+      </a>`;
+    }).join('');
+  } catch (e) {
+    box.innerHTML = '<div class="prof-msg small">Couldn\'t load news.</div>';
+  }
+}
+
+function profileExploreGraph(id) {
+  if (!id) return;
+  toggleProfile(false);
+  // seed the graph with this company and expand it
+  if (!nodes[id]) {
+    nodes[id] = { id, g: 0, h: 0, f: 0, state: 'centre',
+      kind: 'company', expanded: false,
+      x: width / 2, y: height / 2, vx: 0, vy: 0 };
+  }
+  centreNode = id;
+  render();
+  expandNodeFromGraph(id);
+}
+
+function profileCompare(id) {
+  toggleProfile(false);
+  toggleCompare(true);
+  const a = document.getElementById('cmp-a');
+  if (a) a.value = id;
+  const b = document.getElementById('cmp-b');
+  if (b) b.focus();
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// Citation Explorer — the primary research-papers surface (/api/paper).
+// Give it a paper (title, DOI, arXiv id or URL) and it shows the works it
+// cites and the works citing it, then builds an interactive citation graph
+// you expand on demand. Replaces the old connect-two-papers pathfinding.
+// ═══════════════════════════════════��════════════════════════════════════════
+const PAPER_QUICK = ['Attention is all you need', 'AlphaFold', 'ImageNet',
+                     'BERT language model', 'CRISPR gene editing'];
+let _paperCurrent = null;
+
+function togglePaper(open) {
+  const panel = document.getElementById('paper-panel');
+  if (!panel) return;
+  const fab = document.getElementById('paper-fab');
+  const show = open === undefined ? !panel.classList.contains('open') : open;
+  panel.classList.toggle('open', show);
+  panel.setAttribute('aria-hidden', show ? 'false' : 'true');
+  if (fab) fab.classList.toggle('hidden', show);
+  if (show) {
+    renderPaperEmptyChips();
+    const inp = document.getElementById('paper-input');
+    if (inp && !_paperCurrent) inp.focus();
+  }
+}
+
+function renderPaperEmptyChips() {
+  const box = document.getElementById('paper-empty-chips');
+  if (!box) return;
+  box.innerHTML = PAPER_QUICK.map(t =>
+    `<button class="prof-chip" onclick="openPaper('${t.replace(/'/g, "\\'")}')">${escHtml(t)}</button>`).join('');
+}
+
+async function openPaper(query) {
+  query = (query || '').trim();
+  if (!query) return;
+  togglePaper(true);
+  const body = document.getElementById('paper-body');
+  const inp = document.getElementById('paper-input');
+  if (inp) inp.value = query;
+  if (body) body.innerHTML = '<div class="prof-loading"><span class="prof-spinner"></span>Fetching citations…</div>';
+  try {
+    const data = await fetch(`${AC_BACKEND}/api/paper?q=${encodeURIComponent(query)}`).then(r => r.json());
+    if (data.error) { if (body) body.innerHTML = `<div class="prof-msg">${escHtml(data.error)}</div>`; return; }
+    _paperCurrent = data;
+    renderPaper(data);
+  } catch (e) {
+    if (body) body.innerHTML = '<div class="prof-msg">Could not reach the backend.</div>';
+  }
+}
+
+// Upload a PDF → backend extracts its DOI/arXiv/title and returns the
+// citation dossier, which renders exactly like a searched paper.
+// Drag-and-drop a PDF anywhere on the citation panel.
+(function wirePaperDrop() {
+  const setup = () => {
+    const panel = document.getElementById('paper-panel');
+    if (!panel) return;
+    const stop = (e) => { e.preventDefault(); e.stopPropagation(); };
+    ['dragenter', 'dragover'].forEach(ev => panel.addEventListener(ev, (e) => {
+      stop(e); panel.classList.add('drag-over');
+    }));
+    ['dragleave', 'drop'].forEach(ev => panel.addEventListener(ev, (e) => {
+      stop(e); if (ev === 'dragleave' && panel.contains(e.relatedTarget)) return;
+      panel.classList.remove('drag-over');
+    }));
+    panel.addEventListener('drop', (e) => {
+      const f = e.dataTransfer && e.dataTransfer.files;
+      if (f && f.length) uploadPaperPdf(f);
+    });
+  };
+  if (document.readyState !== 'loading') setup();
+  else document.addEventListener('DOMContentLoaded', setup);
+})();
+
+async function uploadPaperPdf(files) {
+  const file = files && files[0];
+  if (!file) return;
+  togglePaper(true);
+  const body = document.getElementById('paper-body');
+  if (body) body.innerHTML = `<div class="prof-loading"><span class="prof-spinner"></span>Reading “${escHtml(file.name)}”…</div>`;
+  try {
+    const fd = new FormData();
+    fd.append('file', file);
+    const data = await fetch(`${AC_BACKEND}/api/paper/upload`, { method: 'POST', body: fd }).then(r => r.json());
+    if (data.error) { if (body) body.innerHTML = `<div class="prof-msg">${escHtml(data.error)}</div>`; return; }
+    _paperCurrent = data;
+    const inp = document.getElementById('paper-input');
+    if (inp) inp.value = data.title || '';
+    renderPaper(data);
+  } catch (e) {
+    if (body) body.innerHTML = '<div class="prof-msg">Could not upload the PDF.</div>';
+  }
+}
+
+function _paperMeta(c) {
+  const bits = [];
+  if (c.authors && c.authors.length) bits.push(escHtml(c.authors.join(', ') + (c.authors.length >= 3 ? ' et al.' : '')));
+  if (c.year) bits.push(c.year);
+  if (c.venue) bits.push(escHtml(c.venue));
+  return bits.join(' · ');
+}
+
+function _paperCards(items, badge) {
+  if (!Array.isArray(items) || !items.length)
+    return '<div class="prof-msg small">None found.</div>';
+  return `<div class="paper-list">` + items.map(c => {
+    const cb = c.cited_by_count ? `<span class="paper-cb" title="times cited">${_kfmt(c.cited_by_count)}×</span>` : '';
+    return `<button class="paper-item" onclick="openPaper('${(c.id || '').replace(/'/g, "\\'")}')" title="Open this paper">
+      <span class="paper-item-main">
+        <span class="paper-item-title">${escHtml(c.title || c.id)}</span>
+        <span class="paper-item-meta">${_paperMeta(c) || '&nbsp;'}</span>
+      </span>
+      ${cb}
+    </button>`;
+  }).join('') + `</div>`;
+}
+
+function _kfmt(n) {
+  if (n >= 1000) return (n / 1000).toFixed(n >= 10000 ? 0 : 1) + 'k';
+  return String(n);
+}
+
+function renderPaper(d) {
+  const body = document.getElementById('paper-body');
+  if (!body) return;
+  const meta = [];
+  if (d.authors && d.authors.length) meta.push(escHtml(d.authors.join(', ') + (d.authors.length >= 3 ? ' et al.' : '')));
+  if (d.year) meta.push(d.year);
+  if (d.venue) meta.push(escHtml(d.venue));
+
+  body.innerHTML = `
+    <div class="prof-title-row"><h2 class="prof-title">${escHtml(d.title || d.id)}</h2></div>
+    ${meta.length ? `<div class="paper-byline">${meta.join(' · ')}</div>` : ''}
+    <div class="paper-stats">
+      <span class="paper-stat"><b>${_kfmt(d.cited_by_count || 0)}</b> citations</span>
+      <span class="paper-stat"><b>${d.n_references || 0}</b> references</span>
+      <span class="paper-stat"><b>${d.n_citations || 0}</b> citing here</span>
+    </div>
+    ${d.abstract ? `<p class="prof-summary paper-abstract">${escHtml(d.abstract)}</p>` : ''}
+
+    <div class="prof-actions" style="margin-top:16px">
+      <button class="prof-act primary" onclick="paperBuildGraph()">Build citation graph</button>
+    </div>
+
+    ${_profileSection('References', 'papers this cites', _paperCards(d.references))}
+    ${_profileSection('Cited by', 'influential papers citing this', _paperCards(d.citations))}`;
+}
+
+// Seed the 2D graph with the paper at the centre, its references (papers it
+// cites) and citations (papers citing it), then hand off to the explorer.
+function paperBuildGraph() {
+  const d = _paperCurrent;
+  if (!d) return;
+  togglePaper(false);
+  nodes = {}; edges = []; expandedNodes.clear();
+  const cx = width / 2, cy = height / 2;
+  nodes[d.id] = { id: d.id, title: d.title, g: 0, h: 0, f: 0,
+    state: 'centre', kind: 'paper', expanded: true, x: cx, y: cy, vx: 0, vy: 0 };
+  centreNode = d.id;
+  const place = (arr, sign) => (arr || []).forEach((c, i) => {
+    if (!c.id || nodes[c.id]) return;
+    const ang = (i / Math.max(1, arr.length)) * Math.PI + (sign > 0 ? 0 : Math.PI);
+    nodes[c.id] = { id: c.id, title: c.title, g: 1, h: 0, f: 1,
+      state: 'open', kind: 'paper', expanded: true,
+      x: cx + Math.cos(ang) * 160 + (Math.random() - .5) * 40,
+      y: cy + sign * 120 + (Math.random() - .5) * 40, vx: 0, vy: 0 };
+  });
+  place(d.references, -1);   // things it cites, above
+  place(d.citations, 1);     // things citing it, below
+  // directed edges: paper → reference (cites); citation → paper (cites)
+  (d.references || []).forEach(c => { if (nodes[c.id]) edges.push({ from: d.id, to: c.id, isPath: false, type: 'cites', display: 'cites' }); });
+  (d.citations || []).forEach(c => { if (nodes[c.id]) edges.push({ from: c.id, to: d.id, isPath: false, type: 'cites', display: 'cited by' }); });
+  expandedNodes.add(d.id);
+  render();
+  if (window.GV) window.GV.fit();
+  setStatus(`Citation graph for "${d.title}" — click any paper to expand its citations.`);
+}
+
+// Expand a paper node in the graph: pull both its references and citations.
+async function expandPaperNode(id) {
+  if (running || !nodes[id] || expandedNodes.has(id)) return;
+  setStatus(`Expanding citations for "${truncate(id, 40)}"…`);
+  try {
+    const d = await fetch(`${AC_BACKEND}/api/paper?q=${encodeURIComponent(id)}&refs=12&cites=12`).then(r => r.json());
+    if (d.error) { setStatus(d.error); return; }
+    expandedNodes.add(id);
+    const base = nodes[id] || { x: width / 2, y: height / 2 };
+    if (d.title && nodes[id]) nodes[id].title = d.title;
+    let added = 0;
+    const add = (c, sign, from, to, disp) => {
+      if (!c.id) return;
+      if (!nodes[c.id]) {
+        nodes[c.id] = { id: c.id, title: c.title, g: null, h: null, f: null,
+          state: 'open', kind: 'paper', expanded: true,
+          x: (base.x || width / 2) + (Math.random() - .5) * 120,
+          y: (base.y || height / 2) + sign * 80 + (Math.random() - .5) * 60,
+          vx: 0, vy: 0 };
+        added++;
+      }
+      if (!edges.find(e => e.from === from && e.to === to))
+        edges.push({ from, to, isPath: false, type: 'cites', display: disp });
+    };
+    (d.references || []).forEach(c => add(c, -1, id, c.id, 'cites'));
+    (d.citations || []).forEach(c => add(c, 1, c.id, id, 'cited by'));
+    render();
+    setStatus(`Expanded "${truncate(d.title || id, 40)}": +${added} papers. ${d.n_references} references, ${d.n_citations} citing.`);
+  } catch (e) {
+    setStatus('Could not expand — backend unreachable.');
+  }
+}
+
 // ════════════════════════════════════════════════════════════════════════════
 // News / Reddit overlays — fold live coverage onto the focused company.
 // ════════════════════════════════════════════════════════════════════════════
@@ -700,11 +1140,11 @@ function renderOverlay(data, query) {
 }
 
 /**
- * Debounced fetch directly to Wikipedia's opensearch API. Called on every
- * keystroke in a hero input field, but the actual network request is
- * delayed by AC_DEBOUNCE_MS so rapid typing doesn't spam the API. No
- * backend involved — CORS-enabled, instant, and accurate for any article
- * (not limited to a curated seed list).
+ * Debounced, domain-aware autocomplete. Called on every keystroke in a
+ * hero input, but the network request is delayed by AC_DEBOUNCE_MS so
+ * rapid typing doesn't spam the backend. Suggestions come from the active
+ * source's own vocabulary via /api/suggest (companies for finance, papers
+ * for research, articles for Wikipedia, …).
  */
 function triggerAutocomplete(fieldName) {
   const inputId = fieldName === 'start' ? 'hero-inp-start' : 'hero-inp-end';
@@ -719,14 +1159,17 @@ function triggerAutocomplete(fieldName) {
 
   acDebounceTimers[fieldName] = setTimeout(async () => {
     try {
+      // Domain-aware: suggestions come from whichever source is active
+      // (companies/tickers for finance, papers for research, diseases for
+      // biology, articles for Wikipedia) via the backend /api/suggest —
+      // no longer hardcoded to Wikipedia's opensearch.
       const params = new URLSearchParams({
-        action: 'opensearch', search: query, limit: '5',
-        namespace: '0', format: 'json', origin: '*',
+        source: currentSource, q: query, limit: '7',
       });
-      const res = await fetch(`${WIKI_OPENSEARCH}?${params}`);
+      const res = await fetch(`${AC_BACKEND}/api/suggest?${params}`);
       if (!res.ok) { closeAcDropdown(fieldName); return; }
       const data = await res.json();
-      const suggestions = Array.isArray(data) && data.length > 1 ? data[1] : [];
+      const suggestions = Array.isArray(data.suggestions) ? data.suggestions : [];
 
       // The user may have kept typing while this request was in flight —
       // if the field no longer matches what we searched for, drop the
@@ -746,6 +1189,24 @@ function triggerAutocomplete(fieldName) {
   }, AC_DEBOUNCE_MS);
 }
 
+// Per-kind glyph for the suggestion dropdown — a small visual cue that the
+// recommendation is domain-appropriate (a paper vs a company vs a gene).
+function _acKindIcon(kind) {
+  const P = 'stroke="currentColor" stroke-width="1.5" fill="none" stroke-linecap="round" stroke-linejoin="round"';
+  const wrap = (inner) => `<svg class="ac-icon" viewBox="0 0 16 16" width="14" height="14" ${P}>${inner}</svg>`;
+  switch (kind) {
+    case 'company':   return wrap('<path d="M3 14V4l5-2v12M8 14V6l5 2v6M2 14h12"/><path d="M5 6h0M5 9h0M10 9h0M10 11h0"/>');
+    case 'etf':       return wrap('<circle cx="8" cy="8" r="6"/><path d="M8 2v6l4 2"/>');
+    case 'sector':    return wrap('<rect x="2" y="9" width="3" height="5"/><rect x="6.5" y="5" width="3" height="9"/><rect x="11" y="2" width="3" height="12"/>');
+    case 'executive':
+    case 'person':    return wrap('<circle cx="8" cy="5" r="2.5"/><path d="M3.5 14a4.5 4.5 0 0 1 9 0"/>');
+    case 'country':   return wrap('<circle cx="8" cy="8" r="6"/><path d="M2 8h12M8 2c2 2.5 2 9.5 0 12M8 2c-2 2.5-2 9.5 0 12"/>');
+    case 'macro':     return wrap('<path d="M2 12l4-4 3 3 5-6"/><path d="M14 5v3h-3"/>');
+    case 'paper':     return wrap('<path d="M4 2h5l3 3v9H4z"/><path d="M9 2v3h3"/><line x1="6" y1="8" x2="10" y2="8"/><line x1="6" y1="11" x2="9" y2="11"/>');
+    default:          return wrap('<path d="M4 2h6l3 3v9H4V2z"/><path d="M10 2v3h3"/><line x1="6" y1="7" x2="11" y2="7"/><line x1="6" y1="10" x2="10" y2="10"/>');
+  }
+}
+
 /**
  * Escape a string for safe interpolation into innerHTML. Article titles come
  * from the Wikipedia API and can't currently contain "<"/">" (MediaWiki
@@ -773,17 +1234,24 @@ function renderAcDropdown(fieldName) {
     return;
   }
 
-  dropdown.innerHTML = items.map((title, i) => `
+  dropdown.innerHTML = items.map((item, i) => {
+    // Backend suggestions are objects {title, subtitle, kind}; keep a
+    // string fallback so nothing breaks if an older payload appears.
+    const title = typeof item === 'string' ? item : (item.title || '');
+    const subtitle = typeof item === 'string' ? '' : (item.subtitle || '');
+    const kind = typeof item === 'string' ? '' : (item.kind || '');
+    return `
     <div class="ac-item${i === acActiveIndex[fieldName] ? ' ac-active' : ''}"
          data-idx="${i}" data-title="${escHtml(title)}">
-      <svg class="ac-icon" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" width="14" height="14"><path d="M4 2h6l3 3v9H4V2z"/><path d="M10 2v3h3"/><line x1="6" y1="7" x2="11" y2="7"/><line x1="6" y1="10" x2="10" y2="10"/></svg>${escHtml(title)}
-    </div>
-  `).join('');
+      ${_acKindIcon(kind)}
+      <span class="ac-text">
+        <span class="ac-title">${escHtml(title)}</span>
+        ${subtitle ? `<span class="ac-sub">${escHtml(subtitle)}</span>` : ''}
+      </span>
+    </div>`;
+  }).join('');
   dropdown.classList.add('visible');
-  // BUGFIX: previously used inline onclick="selectAcSuggestion('${fieldName}', ${JSON.stringify(title)})"
-  // which broke because JSON.stringify's double-quotes collided with the outer HTML
-  // attribute's double-quotes, corrupting the attribute and silently failing on click.
-  // Event delegation with data-title avoids the quote-collision entirely.
+  // Event delegation with data-title avoids inline-onclick quote-collision.
   dropdown.querySelectorAll('.ac-item').forEach(el => {
     el.addEventListener('click', () => selectAcSuggestion(fieldName, el.dataset.title));
   });
@@ -799,8 +1267,11 @@ function closeAcDropdown(fieldName) {
   acActiveIndex[fieldName] = -1;
 }
 
-/** Called when the user clicks (or presses Enter on) a suggestion row. */
-function selectAcSuggestion(fieldName, title) {
+/** Called when the user clicks (or presses Enter on) a suggestion row.
+ * Accepts either a plain title string (click path) or a suggestion object
+ * (keyboard path). */
+function selectAcSuggestion(fieldName, item) {
+  const title = typeof item === 'string' ? item : (item && item.title) || '';
   const inputId = fieldName === 'start' ? 'hero-inp-start' : 'hero-inp-end';
   document.getElementById(inputId).value = title;
   closeAcDropdown(fieldName);
@@ -932,20 +1403,19 @@ function _syncMobileHandles() {
 
   // Collapsing/expanding either bar resizes #canvas-wrap via CSS transition,
   // but that's an internal layout change, not a viewport resize — it never
-  // fires the `resize` listener that normally keeps the d3 force simulation
-  // centered. Re-measure once the 0.32s transition (styles.css) finishes, or
-  // the graph stays centered on the stale pre-toggle canvas size.
+  // fires the window `resize` the canvas renderer listens for. Nudge one
+  // once the 0.32s transition (styles.css) finishes so the graph reframes
+  // on the new canvas size.
   setTimeout(_resyncCanvasSize, 340);
 }
 
 function _resyncCanvasSize() {
-  if (!simulation) return;
   const cw = document.getElementById('canvas-wrap');
   if (!cw) return;
   width = cw.clientWidth;
   height = cw.clientHeight;
-  simulation.force('center', d3.forceCenter(width / 2, height / 2));
-  simulation.alpha(0.3).restart();
+  // graph2d.js listens for window resize; dispatch one so it re-measures.
+  window.dispatchEvent(new Event('resize'));
 }
 
 // ── Search ────────────────────────────────────────────────────────────────────
@@ -1068,23 +1538,21 @@ function resetAll(showHero = true) {
     resetHeroDisplay();
   }
 
-  initSVG();
+  initGraph();
 }
 
-// ── Renderer selection: 3D (WebGL) when available, else 2D SVG fallback ──────
-// use3D is decided once on first init. When true, all the D3-specific
-// functions below (render/ticked/panToNode/drag) delegate to the GV 3D
-// controller in graph3d.js; the WebSocket message handlers are unchanged
-// because they only ever touch the shared `nodes`/`edges` state + render().
-let use3D = false;
-let _gv3dReady = false;
+// ── Renderer (2D canvas via graph2d.js) ──────────────────────────────────────
+// The WebSocket message handlers only ever touch the shared `nodes`/`edges`
+// state and call render(); render() hands that state to the canvas
+// controller (window.GV) in graph2d.js.
+let _gvReady = false;
 
 function _graphCtx() {
   return { pathNodes, foundPath, centreNode, filter: graphFilter,
            lens: _lensTypes(), running };
 }
 
-// ── Graph view filters + fit (3D explorer controls) ──────────────────────────
+// ── Graph view filters + fit (explorer controls) ─────────────────────────────
 function setGraphFilter(mode) {
   graphFilter = mode;
   document.querySelectorAll('#graph-controls .gc-btn[data-filter]').forEach(b =>
@@ -1093,7 +1561,7 @@ function setGraphFilter(mode) {
 }
 
 function fitGraphView() {
-  if (use3D && window.GV) window.GV.fit();
+  if (window.GV) window.GV.fit();
 }
 
 // ── Progressive expansion: click a node → pull its real neighbors in ─────────
@@ -1101,6 +1569,9 @@ function fitGraphView() {
 // the stream). Every edge carries its relationship type + evidence string,
 // which the 3D view surfaces as an edge tooltip.
 async function expandNodeFromGraph(id) {
+  // Research papers expand in BOTH citation directions (references +
+  // citing works) via the citation-explorer path.
+  if (currentSource === 'openalex') return expandPaperNode(id);
   if (running || !nodes[id] || expandedNodes.has(id)) return;
   setStatus(`Expanding "${id}"…`);
   try {
@@ -1152,256 +1623,29 @@ async function expandNodeFromGraph(id) {
 }
 
 // ── Init graph ──────────────────────────────────────────────────────────────
-function initSVG() {
-  width = document.getElementById('canvas-wrap').clientWidth;
-  height = document.getElementById('canvas-wrap').clientHeight;
-
-  const el3d = document.getElementById('graph3d');
-  const svgNode = document.getElementById('graph');
-  use3D = !!(window.GV && window.GV.available() && el3d);
-
+function initGraph() {
+  const wrap = document.getElementById('canvas-wrap');
+  width = wrap.clientWidth;
+  height = wrap.clientHeight;
+  const el = document.getElementById('graph-canvas');
   const gcBar = document.getElementById('graph-controls');
-  if (use3D) {
-    if (svgNode) svgNode.style.display = 'none';
-    el3d.style.display = 'block';
-    if (!_gv3dReady) _gv3dReady = window.GV.init(el3d, { onExpand: expandNodeFromGraph });
-    if (_gv3dReady) {
-      window.GV.reset();
-      if (gcBar) gcBar.style.display = 'flex';
-      renderLensPicker();
-      return;
-    }
-    use3D = false;   // init failed — fall through to SVG
-  }
-  if (gcBar) gcBar.style.display = 'none';
-  if (el3d) el3d.style.display = 'none';
-  if (svgNode) svgNode.style.display = 'block';
-
-  svgEl = d3.select('#graph');
-  svgEl.selectAll('*').remove();
-
-  // Define glow filter
-  const defs = svgEl.append('defs');
-  const glow = defs.append('filter')
-    .attr('id', 'glow')
-    .attr('x', '-30%')
-    .attr('y', '-30%')
-    .attr('width', '160%')
-    .attr('height', '160%');
-  glow.append('feGaussianBlur')
-    .attr('stdDeviation', '6')
-    .attr('result', 'blur');
-  glow.append('feMerge')
-    .append('feMergeNode').attr('in', 'blur');
-  glow.select('feMerge')
-    .append('feMergeNode').attr('in', 'SourceGraphic');
-
-  const zoom = d3.zoom()
-    .scaleExtent([0.2, 4])
-    .on('zoom', e => gEl.attr('transform', e.transform));
-  svgEl.call(zoom);
-
-  gEl = svgEl.append('g').attr('id', 'main-g');
-  gEl.append('g').attr('id', 'edge-layer');
-  gEl.append('g').attr('id', 'node-layer');
-  gEl.append('g').attr('id', 'label-layer');
-
-  simulation = d3.forceSimulation()
-    .force('link', d3.forceLink().id(d => d.id).distance(120).strength(0.4))
-    // distanceMax caps how far the mutual-repulsion force reaches between any
-    // two nodes. Without it, a long-running search (up to 60 expansions, 25
-    // new nodes per step) keeps accumulating cumulative repulsion across the
-    // WHOLE graph — every node keeps pushing every other node apart forever,
-    // so the cluster's total footprint grows without bound as more nodes
-    // appear, even though the camera's own zoom level never changes. That
-    // unbounded sprawl is what reads as "the page automatically zooms out" —
-    // capping the repulsion's reach keeps the graph's footprint roughly
-    // stable once nodes are a few hundred px apart, instead of ballooning.
-    .force('charge', d3.forceManyBody().strength(-300).distanceMax(420))
-    .force('center', d3.forceCenter(width / 2, height / 2))
-    .force('collide', d3.forceCollide(44))
-    .alphaDecay(0.02)
-    .on('tick', ticked);
-}
-
-// ── D3 tick ───────────────────────────────────────────────────────────────────
-function ticked() {
-  d3.selectAll('.edge-line')
-    .attr('x1', d => (nodes[d.from] || {}).x || 0)
-    .attr('y1', d => (nodes[d.from] || {}).y || 0)
-    .attr('x2', d => (nodes[d.to] || {}).x || 0)
-    .attr('y2', d => (nodes[d.to] || {}).y || 0);
-
-  d3.selectAll('.node-circle')
-    .attr('cx', d => d.x)
-    .attr('cy', d => d.y);
-
-  d3.selectAll('.node-label-el')
-    .attr('x', d => d.x)
-    .attr('y', d => d.y + nodeRadius(d) + 15);
-}
-
-function nodeRadius(d) {
-  if (d.state === 'centre') return 22;
-  if (d.state === 'target') return 18;
-  if (pathNodes.has(d.id)) return 15;
-  return 12;
-}
-
-function nodeColor(d) {
-  const s = getComputedStyle(document.documentElement);
-  if (d.state === 'centre') return s.getPropertyValue('--node-centre').trim();
-  if (d.state === 'target') return s.getPropertyValue('--node-target').trim();
-  if (d.state === 'closed') return '#374151';
-  if (d.state === 'gated') return '#4b2020';
-  if (pathNodes.has(d.id)) return foundPath.length ? '#34d399' : s.getPropertyValue('--node-path').trim();
-  return s.getPropertyValue('--node-open').trim();
-}
-
-function edgeColor(d) {
-  if (d.isPath) return foundPath.length ? 'rgba(52,211,153,0.9)' : 'rgba(249,115,22,0.85)';
-  const fromNode = nodes[d.from];
-  if (fromNode && fromNode.state === 'closed') return 'rgba(124,106,247,0.18)';
-  return 'rgba(124,106,247,0.38)';
-}
-function edgeWidth(d) { return d.isPath ? 3 : 1.2; }
-
-// ── Render ────────────────────────────────────────────────────────────────────
-function render() {
-  if (use3D) { window.GV.sync(nodes, edges, _graphCtx()); return; }
-
-  const nodeArr = Object.values(nodes);
-
-  const edgeSel = d3.select('#edge-layer')
-    .selectAll('.edge-line')
-    .data(edges, d => d.from + '→' + d.to);
-
-  edgeSel.enter().append('line')
-    .attr('class', 'edge-line')
-    .attr('stroke-opacity', 0)
-    .attr('stroke-linecap', 'round')
-    .transition().duration(400)
-    .attr('stroke-opacity', 1);
-
-  edgeSel.exit().remove();
-
-  d3.selectAll('.edge-line')
-    .attr('stroke', edgeColor)
-    .attr('stroke-width', edgeWidth)
-    .attr('class', d => d.isPath && foundPath.length ? 'edge-line edge-path-found' : 'edge-line');
-
-  const circSel = d3.select('#node-layer')
-    .selectAll('.node-circle')
-    .data(nodeArr, d => d.id);
-
-  circSel.enter().append('circle')
-    .attr('class', 'node-circle')
-    .attr('r', 0)
-    .attr('fill', nodeColor)
-    .attr('stroke', '#0a0a0f')
-    .attr('stroke-width', 2.5)
-    .style('cursor', 'pointer')
-    .on('mouseover', onNodeHover)
-    .on('mouseout', onNodeOut)
-    .on('click', onNodeClick)
-    .call(d3.drag()
-      .on('start', dragStart)
-      .on('drag', dragged)
-      .on('end', dragEnd))
-    .transition().duration(350)
-    .attr('r', nodeRadius);
-
-  d3.selectAll('.node-circle')
-    .attr('class', 'node-circle')
-    .attr('fill', nodeColor)
-    .style('filter', d => {
-      if (d.state === 'centre' || d.state === 'target' || pathNodes.has(d.id)) {
-        return 'url(#glow)';
-      }
-      return 'none';
-    })
-    .transition().duration(200)
-    .attr('r', nodeRadius);
-
-  circSel.exit().transition().duration(200).attr('r', 0).remove();
-
-  const lblSel = d3.select('#label-layer')
-    .selectAll('.node-label-el')
-    .data(nodeArr, d => d.id);
-
-  lblSel.enter().append('text')
-    .attr('class', d => 'node-label-el ' + (d.state === 'centre' ? 'centre-label' : 'node-label'))
-    .attr('opacity', 0)
-    .transition().duration(400)
-    .attr('opacity', d => {
-      if (d.state === 'centre' || d.state === 'target') return 1;
-      if (pathNodes.has(d.id)) return 0.9;
-      return 0.45;
-    });
-
-  d3.selectAll('.node-label-el')
-    .text(d => truncate(d.id, d.state === 'centre' ? 24 : 18))
-    .attr('class', d => 'node-label-el ' + (d.state === 'centre' ? 'centre-label' : 'node-label'))
-    .attr('fill', d =>
-      d.state === 'centre' ? 'var(--text)' :
-        d.state === 'target' ? 'var(--green)' : 'var(--text2)')
-    .transition().duration(300)
-    .attr('opacity', d => {
-      if (d.state === 'centre' || d.state === 'target') return 1;
-      if (pathNodes.has(d.id)) return 0.9;
-      return 0.42;
-    });
 
-  lblSel.exit().remove();
+  if (!_gvReady) _gvReady = window.GV.init(el, { onExpand: expandNodeFromGraph });
+  if (_gvReady) window.GV.reset();
+  if (gcBar) gcBar.style.display = 'flex';
+  renderLensPicker();
+}
 
-  simulation.nodes(nodeArr);
-  simulation.force('link').links(edges.map(e => ({
-    source: e.from, target: e.to, isPath: e.isPath
-  })));
-  simulation.alpha(0.3).restart();
+// ── Render: hand the shared state to the canvas controller ───────────────────
+function render() {
+  if (window.GV) window.GV.sync(nodes, edges, _graphCtx());
 }
 
-// ── Pan/fly to node ─────────────────────────────────────────────────────────
+// ── Pan/fly to a node (after a search; the auto-follow owns the camera
+// while a search is streaming, so we don't fight it mid-run) ─────────────────
 function panToNode(nodeId) {
-  if (use3D) {
-    // While a search is streaming, the auto-tracker owns the camera (it
-    // keeps the whole growing graph framed and zooms out as it grows);
-    // flying to every expanded node would fight it. Explicit clicks after
-    // the search still fly to the node via GV.focus.
-    if (!running) window.GV.focus(nodeId);
-    return;
-  }
-  const n = nodes[nodeId];
-  if (!n || !n.x) return;
-  const cw = document.getElementById('canvas-wrap').clientWidth;
-  const ch = document.getElementById('canvas-wrap').clientHeight;
-  const t = d3.zoomTransform(svgEl.node());
-  const tx = cw / 2 - t.k * n.x;
-  const ty = ch / 2 - t.k * n.y;
-  svgEl.transition().duration(600).ease(d3.easeCubicInOut)
-    .call(d3.zoom().transform, d3.zoomIdentity.translate(tx, ty).scale(t.k));
-}
-
-// ── Drag ──────────────────────────────────────────────────────────────────────
-function dragStart(e, d) { if (!e.active) simulation.alphaTarget(0.3).restart(); d.fx = d.x; d.fy = d.y; }
-function dragged(e, d) { d.fx = e.x; d.fy = e.y; }
-function dragEnd(e, d) { if (!e.active) simulation.alphaTarget(0); d.fx = null; d.fy = null; }
-
-// ── Tooltip ───────────────────────────────────────────────────────────────────
-function onNodeHover(e, d) {
-  const tip = document.getElementById('tooltip');
-  document.getElementById('tt-title').textContent = d.id;
-  const scores = [];
-  if (d.g != null) scores.push(`g(n) = ${d.g}  hops from start`);
-  if (d.h != null) scores.push(`h(n) = ${d.h}  heuristic`);
-  if (d.f != null) scores.push(`f(n) = ${d.f}  total`);
-  document.getElementById('tt-scores').innerHTML = scores.join('<br>');
-  tip.style.left = (e.pageX + 14) + 'px';
-  tip.style.top = (e.pageY - 32) + 'px';
-  tip.classList.add('visible');
-}
-function onNodeOut() { document.getElementById('tooltip').classList.remove('visible'); }
-function onNodeClick(e, d) { panToNode(d.id); }
+  if (!running && window.GV) window.GV.focus(nodeId);
+}
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 function truncate(s, n) { return s.length > n ? s.slice(0, n - 1) + '…' : s; }
@@ -1566,11 +1810,8 @@ function handleMessage(msg) {
       addLog(`Expanding: ${msg.id}  f=${msg.f}`, 'highlight');
       if (msg.stats) _updateStats(msg.stats);
       render();
-      // 2D only: follow the current centre node. In 3D the auto-tracker
-      // owns the camera — and this delayed call must never reach GV.focus,
-      // or a `found` landing inside the 200ms window flips `running` false
-      // and the stray focus() disables auto-framing mid-glide.
-      if (!use3D) setTimeout(() => panToNode(msg.id), 200);
+      // The canvas auto-follow keeps the whole growing graph framed while
+      // the search streams, so we don't fly to each centre node here.
       break;
     }
 
@@ -1658,10 +1899,13 @@ function handleMessage(msg) {
       showPathBanner(path);
       addLog(`✓ Found! ${path.join(' → ')}  (${msg.total_hops} hops, ${msg.steps} steps)`, 'success');
       setStatus(`Done! Path found in ${msg.total_hops} hops.`);
-      render();
-      document.getElementById('btn-search').disabled = false;
+      // Set the found/running state BEFORE render() so the canvas captures
+      // the found context (green path, dimmed cloud) on this sync — the
+      // renderer reads _graphCtx() once per sync, not per animation frame.
       running = false;
       foundPath = path;
+      render();
+      document.getElementById('btn-search').disabled = false;
       _hidePauseBtn();
       document.getElementById('btn-export').classList.add('visible');
       if (msg.stats) _updateStats(msg.stats);
@@ -1774,14 +2018,13 @@ function logoClick() {
 
 // ── Boot ──────────────────────────────────────────────────────────────────────
 window.addEventListener('load', () => {
-  initSVG();
+  initGraph();
   // Focus first hero input
   document.getElementById('hero-inp-start').focus();
 
   window.addEventListener('resize', () => {
     width = document.getElementById('canvas-wrap').clientWidth;
     height = document.getElementById('canvas-wrap').clientHeight;
-    if (simulation) simulation.force('center', d3.forceCenter(width / 2, height / 2));
   });
 
   // NEW: wire vector-search autocomplete onto the two hero inputs. This is
@@ -1796,20 +2039,10 @@ window.addEventListener('load', () => {
 });
 
 function animatePath(path, steps, hops, displayTexts) {
-  const delay = 160;
-  path.forEach((nodeId, i) => {
-    setTimeout(() => {
-      d3.selectAll('.node-circle')
-        .filter(d => d.id === nodeId)
-        .transition().duration(120)
-        .attr('r', d => nodeRadius(d) * 1.7)
-        .attr('fill', '#34d399')
-        .transition().duration(260)
-        .attr('r', d => nodeRadius(d))
-        .attr('fill', nodeColor);
-    }, i * delay);
-  });
-  setTimeout(() => openSuccessModal(path, steps, hops, displayTexts), path.length * delay + 480);
+  // The canvas renderer already recolours the found path and dims the
+  // cloud; frame the whole route, then present the result.
+  if (window.GV) window.GV.fit();
+  setTimeout(() => openSuccessModal(path, steps, hops, displayTexts), 900);
 }
 
 function openSuccessModal(path, steps, hops, displayTexts) {

config.py

@@ -133,8 +133,6 @@ AURELIUS_DB         = Path(os.getenv("AURELIUS_DB", str(_THIS_DIR / "data" / "au
 # pool" is explicitly faster with a mailto.
 CONTACT_EMAIL       = os.getenv("AURELIUS_CONTACT", "murtaza.vali.ug25@plaksha.edu.in")
 OPENALEX_API        = "https://api.openalex.org"
-GITHUB_API          = "https://api.github.com"
-GITHUB_TOKEN        = os.getenv("GITHUB_TOKEN", "")          # optional, raises rate limits
 NEWSAPI_KEY         = os.getenv("NEWSAPI_KEY", "")           # optional; GDELT fallback when absent
 # News Intelligence scheduled refresh: minutes between pipeline runs.
 # 0 (default) = off — refresh manually via /api/news/refresh or the CLI.
@@ -165,6 +163,6 @@ N2V_NEGATIVES       = 5
 # to text, per source. Text dominates for encyclopedic sources; structure
 # carries sources whose node text is thin (tickers, genes, file paths).
 FUSION_ALPHA = {
-    "wikipedia": 0.3, "openalex": 0.5, "github": 0.8,
+    "wikipedia": 0.3, "openalex": 0.5,
     "biomed": 0.8, "news": 0.5, "finance": 0.8,
 }

core/source.py

@@ -9,9 +9,9 @@ Two adapter modes:
   live      — neighbors/backlinks fetched from an upstream API per call
               (Wikipedia's links/linkshere, OpenAlex's refs/cited-by).
   ingested  — the graph was written into core.store by an ingest run;
-              the adapter answers from the store (biomed, news, finance,
-              github after crawl). StoreBackedSource below is the shared
-              implementation for this mode.
+              the adapter answers from the store (biomed, news, finance).
+              StoreBackedSource below is the shared implementation for
+              this mode.
 """
 
 from __future__ import annotations
@@ -70,6 +70,18 @@ class GraphSource(abc.ABC):
         with every candidate."""
         return [await self.node_info(n) for n in ns]
 
+    # ── recommendations ──────────────────────────────────────────────────
+    async def suggest(self, query: str, limit: int = 8) -> list[dict]:
+        """Type-ahead suggestions for the search box, drawn from THIS
+        source's own vocabulary — the fix for the old Wikipedia-only
+        autocomplete. Each item is
+            {id, title, kind?, subtitle?}
+        where `kind` groups results (company/paper/disease/…) and
+        `subtitle` is a short human hint. Default: no suggestions (a live
+        source with nothing cheap to offer simply returns []); adapters
+        override with a domain-appropriate lookup."""
+        return []
+
     # ── niceties (optional) ──────────────────────────────────────────────
     async def edge_display(self, src: NodeRef, dst: NodeRef) -> Optional[str]:
         """Human-facing rendering of an edge (Wikipedia: the piped link

core/store.py

@@ -14,7 +14,7 @@ Embeddings are stored as float32 BLOBs. Two vector columns per node:
   struct_emb — node2vec over the stored edge list (representation.py)
 
 StoreBackedSource at the bottom is the shared GraphSource implementation
-for every ingested-mode adapter (biomed, news, finance, github): subclass,
+for every ingested-mode adapter (biomed, news, finance): subclass,
 set name/description/edge_types, done.
 """
 
@@ -158,6 +158,32 @@ class GraphStore:
                 (source, f"%{q}%", limit)).fetchall()
         return [{"id": r[0], "title": r[1]} for r in rows]
 
+    def suggest_titles(self, source: str, query: str,
+                       limit: int = 8) -> list[dict]:
+        """Type-ahead lookup: prefix matches (on title or id) rank ahead of
+        mid-string matches, shortest title first. Carries features so the
+        UI can label each hit by kind. The ingested-mode counterpart to
+        Wikipedia's opensearch."""
+        q = query.strip()
+        if not q:
+            return []
+        sub = f"%{q}%"
+        prefix = f"{q}%"
+        with self._lock:
+            rows = self._conn.execute(
+                """SELECT id, title, features FROM nodes
+                   WHERE source=? AND (title LIKE ? COLLATE NOCASE
+                                    OR id    LIKE ? COLLATE NOCASE)
+                   ORDER BY
+                     CASE WHEN title LIKE ? COLLATE NOCASE THEN 0
+                          WHEN id    LIKE ? COLLATE NOCASE THEN 1
+                          ELSE 2 END,
+                     LENGTH(title)
+                   LIMIT ?""",
+                (source, sub, sub, prefix, prefix, limit)).fetchall()
+        return [{"id": r[0], "title": r[1],
+                 "features": json.loads(r[2] or "{}")} for r in rows]
+
     def neighbors(self, source: str, id: str) -> list[tuple[str, str, float]]:
         """→ [(dst_id, type, weight)]"""
         with self._lock:
@@ -358,6 +384,33 @@ class StoreBackedSource(GraphSource):
     async def node_infos(self, ns: list[NodeRef]) -> list[NodeInfo]:
         return [await self.node_info(n) for n in ns]
 
+    # ── recommendations ──────────────────────────────────────────────────
+    async def suggest(self, query: str, limit: int = 8) -> list[dict]:
+        if not self.ingested():
+            return []
+        out: list[dict] = []
+        for r in self.store.suggest_titles(self.name, query, limit):
+            feats = r.get("features") or {}
+            out.append({
+                "id": r["id"], "title": r["title"],
+                "kind": feats.get("kind"),
+                "subtitle": self.suggest_subtitle(r["id"], r["title"], feats),
+            })
+        return out
+
+    def suggest_subtitle(self, node_id: str, title: str,
+                         features: dict) -> Optional[str]:
+        """Short hint shown under a suggestion. Default: the node kind
+        (and the id when it differs from the title, e.g. a ticker).
+        Adapters override for richer hints."""
+        kind = features.get("kind")
+        label = kind.replace("_", " ") if kind else None
+        show_id = (node_id and node_id != title and len(node_id) <= 8
+                   and node_id.lower() not in title.lower())
+        if show_id:
+            return f"{node_id} · {label}" if label else node_id
+        return label
+
     # ── edge evidence ────────────────────────────────────────────────────
     def format_edge(self, typ: str, weight: float) -> str:
         """Human phrase for a typed edge. Adapters override for domain

core/types.py

@@ -15,9 +15,9 @@ from dataclasses import dataclass, field
 class NodeRef:
     """A node in some source graph.
 
-    source : adapter name ("wikipedia", "openalex", "github", ...)
+    source : adapter name ("wikipedia", "openalex", "finance", ...)
     id     : stable unique id within that source (Wikipedia: the canonical
-             title; OpenAlex: the work id "W2100837269"; GitHub: "owner/repo";
+             title; OpenAlex: the work id "W2100837269";
              Hetionet: "Gene::5468"; finance: the ticker).
     title  : human-readable label for display and text embedding.
     """

graph2d.js

@@ -0,0 +1,619 @@
+/* Aurelius — 2D graph explorer (HTML canvas + d3-force).
+ *
+ * Replaces the old WebGL/three.js renderer. A canvas draws hundreds of
+ * nodes smoothly; d3-force lays them out; d3-zoom drives pan/zoom. The
+ * design goals, borrowed from Obsidian / Kumu / Observable graph views:
+ *
+ *   · minimalist ink-on-dark palette — the found path is the only thing
+ *     that shouts; the exploration cloud recedes to faint context
+ *   · curved edges (quadratic beziers) so parallel links don't overlap
+ *   · gentle kind-based clustering (typed sources group by what nodes ARE)
+ *   · progressive expansion — click a node to pull its real neighbours in
+ *   · focus mode — click a node to spotlight its neighbourhood, dim the rest
+ *   · auto-fit that follows the graph as it grows and backs off the instant
+ *     the user grabs the camera (resume with GV.fit())
+ *   · label level-of-detail — text only on important / hovered nodes
+ *
+ * It runs the simulation directly over the SAME node objects app.js keeps
+ * in its `nodes` map (positions live on those objects), so the WebSocket
+ * flow is unchanged. One global, GV, matching the old renderer's surface:
+ *   GV.available()             always true (canvas is universal)
+ *   GV.init(el, opts)          build the renderer; opts.onExpand(id)
+ *   GV.sync(nodes, edges, ctx) reconcile with current state
+ *   GV.focus(id)               ease the camera to a node
+ *   GV.fit()                   frame everything + resume auto-follow
+ *   GV.reset()                 clear the graph
+ */
+
+(function () {
+  'use strict';
+
+  const PALETTE = {
+    centre: '#e2a45c', target: '#4aab79', start: '#e4b254',
+    open: '#c99a4e', closed: '#5f5a4a', gated: '#7a3b3b',
+    pathLive: '#e0864a', pathFound: '#5cd6a0',
+    dim: 'rgba(150,140,110,0.28)',
+    ring: '#0c0b08',
+    link: 'rgba(201,158,90,0.22)',
+    linkDim: 'rgba(140,124,84,0.09)',
+    linkPath: 'rgba(224,134,74,0.9)',
+    linkPathFound: 'rgba(92,214,160,0.95)',
+    label: '#c8bd98', labelDim: 'rgba(150,140,110,0.5)',
+    labelKey: '#efe9d6',
+  };
+
+  // Node kind → colour: typed graphs (finance/biology/news) cluster and
+  // colour by what a node IS, not just its search state.
+  const KIND_COLORS = {
+    company: '#c98a2e', etf: '#8b7cf7', sector: '#4aab79',
+    executive: '#e0995c', country: '#5b8dd6', macro: '#d65b8d',
+    person: '#e0995c', organization: '#8b7cf7', place: '#5b8dd6',
+    gene: '#4aab79', protein: '#8b7cf7', disease: '#d65b8d',
+    drug: '#c98a2e', pathway: '#5b8dd6',
+    article: '#8a86a8', paper: '#8a86a8', entity: '#c98a2e',
+  };
+
+  let canvas = null, g = null, container = null;
+  let sim = null, onExpand = null;
+  let dpr = 1, width = 0, height = 0;
+  let zoomBehavior = null, transform = null;    // d3.zoomIdentity at init
+  let nodesArr = [], linksArr = [];
+  const nodeById = new Map();
+  let lastCtx = {};
+  let hoverNode = null, hoverEdge = null, focusId = null;
+  let userNav = false, lastCount = -1, fitCooldown = 0;
+  let raf = 0, fitTarget = null;   // desired transform we ease toward
+
+  // ── helpers ──────────────────────────────────────────────────────────
+  // Display name: prefer a human title (papers carry an opaque id like
+  // "W2100837269"); Wikipedia/finance nodes fall back to the id, which IS
+  // their title.
+  const nameOf = (n) => n.title || n.id;
+  const found = (c) => !!(c && c.foundPath && c.foundPath.length);
+  const onPath = (id, c) => !!(c && c.pathNodes && c.pathNodes.has(id));
+  const isKey = (n, c) => n.state === 'centre' || n.state === 'target' ||
+    n.state === 'start' || onPath(n.id, c);
+
+  function nodeColor(n, c) {
+    if (n.state === 'centre') return PALETTE.centre;
+    if (n.state === 'target') return PALETTE.target;
+    if (n.state === 'start') return PALETTE.start;
+    if (onPath(n.id, c)) return found(c) ? PALETTE.pathFound : PALETTE.pathLive;
+    if ((n.state === 'open') && (n.kind || n.expanded)) {
+      return KIND_COLORS[n.kind] || PALETTE.open;
+    }
+    if (found(c)) return PALETTE.dim;
+    if (n.state === 'closed') return PALETTE.closed;
+    if (n.state === 'gated') return PALETTE.gated;
+    return PALETTE.open;
+  }
+
+  function nodeRadius(n, c) {
+    if (n.state === 'centre') return 11;
+    if (n.state === 'target' || n.state === 'start') return 9.5;
+    if (onPath(n.id, c)) return 7.5;
+    if (n.kind || n.expanded) return 5.5;
+    return 4.2;
+  }
+
+  function labelWorthy(n, c) {
+    return isKey(n, c) || n === hoverNode ||
+      (focusId && (n.id === focusId || isNeighborOfFocus(n.id)));
+  }
+
+  function passesFilter(n, c) {
+    const f = (c && c.filter) || 'all';
+    if (isKey(n, c)) return true;
+    if (f === 'all') return true;
+    if (f === 'path') return false;
+    if (f === 'explored') return n.state !== 'open';
+    return true;
+  }
+
+  // ── focus mode neighbourhood ───────────────────���─────────────────────
+  let focusNeighbors = new Set();
+  function recomputeFocusNeighbors() {
+    focusNeighbors = new Set();
+    if (!focusId) return;
+    for (const l of linksArr) {
+      const s = l.source.id || l.source, t = l.target.id || l.target;
+      if (s === focusId) focusNeighbors.add(t);
+      else if (t === focusId) focusNeighbors.add(s);
+    }
+  }
+  const isNeighborOfFocus = (id) => focusNeighbors.has(id);
+  function dimmedByFocus(id) {
+    return focusId && id !== focusId && !focusNeighbors.has(id);
+  }
+
+  // ── clustering anchors (typed sources group by kind) ─────────────────
+  const kindAnchors = new Map();
+  function anchorFor(kind) {
+    if (!kind) return null;
+    if (!kindAnchors.has(kind)) {
+      // deterministic angle from the kind string so a kind keeps its side
+      let h = 0;
+      for (let i = 0; i < kind.length; i++) h = (h * 31 + kind.charCodeAt(i)) | 0;
+      const ang = (Math.abs(h) % 360) * Math.PI / 180;
+      kindAnchors.set(kind, { x: Math.cos(ang), y: Math.sin(ang) });
+    }
+    return kindAnchors.get(kind);
+  }
+
+  // ── canvas plumbing ──────────────────────────────────────────────────
+  function resize() {
+    if (!container || !canvas) return;
+    width = container.clientWidth || 800;
+    height = container.clientHeight || 600;
+    dpr = Math.min(window.devicePixelRatio || 1, 2);
+    canvas.width = Math.round(width * dpr);
+    canvas.height = Math.round(height * dpr);
+    canvas.style.width = width + 'px';
+    canvas.style.height = height + 'px';
+    draw();
+  }
+
+  function kick() {
+    // Single rAF loop drives everything: it eases the camera toward
+    // `fitTarget` with a cheap lerp (NO d3 transitions — those stacked up
+    // and pegged the main thread), re-frames on a throttle while the layout
+    // is warm, and self-stops once the sim is cool AND the camera arrived.
+    if (raf) return;
+    const step = () => {
+      // periodically recompute the follow target while warm (unless the
+      // user grabbed the camera)
+      if (!userNav && sim && sim.alpha() > 0.02 && Date.now() >= fitCooldown) {
+        fitCooldown = Date.now() + 450;
+        fitTarget = computeFitTarget();
+      }
+      let easing = false;
+      if (fitTarget) {
+        const cur = transform;
+        const k = cur.k + (fitTarget.k - cur.k) * 0.16;
+        const x = cur.x + (fitTarget.x - cur.x) * 0.16;
+        const y = cur.y + (fitTarget.y - cur.y) * 0.16;
+        if (Math.abs(k - fitTarget.k) < 1e-3 &&
+            Math.abs(x - fitTarget.x) < 0.5 && Math.abs(y - fitTarget.y) < 0.5) {
+          applyTransform(fitTarget); fitTarget = null;
+        } else {
+          applyTransform(d3.zoomIdentity.translate(x, y).scale(k));
+          easing = true;
+        }
+      }
+      draw();
+      const warm = sim && sim.alpha() > 0.004;
+      if (warm || easing) raf = requestAnimationFrame(step);
+      else raf = 0;
+    };
+    raf = requestAnimationFrame(step);
+  }
+
+  // set the zoom transform instantly, keeping d3-zoom's internal state in
+  // sync so the next user gesture doesn't jump. Programmatic (no sourceEvent)
+  // so the zoom handler won't flag it as user navigation.
+  function applyTransform(t) {
+    transform = t;
+    if (zoomBehavior) d3.select(canvas).property('__zoom', t);
+  }
+
+  // ── draw ─────────────────────────────────────────────────────────────
+  function draw() {
+    if (!g) return;
+    g.save();
+    g.setTransform(dpr, 0, 0, dpr, 0, 0);
+    g.clearRect(0, 0, width, height);
+    const t = transform;
+    g.translate(t.x, t.y);
+    g.scale(t.k, t.k);
+
+    const c = lastCtx;
+    const isFound = found(c);
+    const now = performance.now();
+
+    // edges first
+    g.lineCap = 'round';
+    for (const l of linksArr) {
+      const a = l.source, b = l.target;
+      if (a.x == null || b.x == null) continue;
+      const path = !!l.isPath;
+      const dim = dimmedByFocus(a.id) && dimmedByFocus(b.id);
+      let col;
+      if (path) col = (isFound ? PALETTE.linkPathFound : PALETTE.linkPath);
+      else col = (isFound || dim) ? PALETTE.linkDim : PALETTE.link;
+      g.strokeStyle = col;
+      g.lineWidth = (path ? 2.4 : 1) / t.k;
+      // curved edge: perpendicular offset at the midpoint
+      const mx = (a.x + b.x) / 2, my = (a.y + b.y) / 2;
+      const dx = b.x - a.x, dy = b.y - a.y;
+      const curve = path ? 0 : 0.12;
+      const cx = mx - dy * curve, cy = my + dx * curve;
+      g.beginPath();
+      g.moveTo(a.x, a.y);
+      g.quadraticCurveTo(cx, cy, b.x, b.y);
+      g.stroke();
+    }
+
+    // nodes
+    for (const n of nodesArr) {
+      if (n.x == null) continue;
+      const r = nodeRadius(n, c);
+      const appear = n.__appear ? Math.min(1, (now - n.__appear) / 380) : 1;
+      const rr = r * (0.4 + 0.6 * appear);
+      let col = nodeColor(n, c);
+      let alpha = 1;
+      if (dimmedByFocus(n.id)) alpha = 0.22;
+      else if (isFound && !onPath(n.id, c) && !isKey(n, c)) alpha = 0.5;
+      g.globalAlpha = alpha * appear;
+      // subtle glow for key nodes
+      if (isKey(n, c) || n === hoverNode) {
+        g.shadowColor = col;
+        g.shadowBlur = 14 / Math.sqrt(t.k);
+      } else {
+        g.shadowBlur = 0;
+      }
+      g.beginPath();
+      g.arc(n.x, n.y, rr, 0, 2 * Math.PI);
+      g.fillStyle = col;
+      g.fill();
+      g.shadowBlur = 0;
+      // ring
+      g.lineWidth = 1.6 / t.k;
+      g.strokeStyle = PALETTE.ring;
+      g.stroke();
+      if (n === hoverNode) {
+        g.beginPath();
+        g.arc(n.x, n.y, rr + 3 / t.k, 0, 2 * Math.PI);
+        g.strokeStyle = 'rgba(240,232,210,0.7)';
+        g.lineWidth = 1.4 / t.k;
+        g.stroke();
+      }
+    }
+    g.globalAlpha = 1;
+
+    // labels (LOD) — only key / hovered / focused nodes, and only when
+    // zoomed in enough to be readable
+    const showAll = t.k > 1.35;
+    g.font = `500 ${12 / t.k}px Outfit, system-ui, sans-serif`;
+    g.textAlign = 'center';
+    g.textBaseline = 'top';
+    for (const n of nodesArr) {
+      if (n.x == null) continue;
+      const key = isKey(n, c);
+      if (!key && !showAll && n !== hoverNode &&
+          !(focusId && (n.id === focusId || focusNeighbors.has(n.id)))) continue;
+      if (dimmedByFocus(n.id)) continue;
+      const r = nodeRadius(n, c);
+      const label = truncate(nameOf(n), key ? 30 : 22);
+      g.globalAlpha = key || n === hoverNode ? 1 : 0.75;
+      g.fillStyle = n.state === 'target' ? PALETTE.target
+        : (n.state === 'centre' || n.state === 'start') ? PALETTE.labelKey
+        : PALETTE.label;
+      // legibility: dark pill behind key labels
+      if (key || n === hoverNode) {
+        const w = g.measureText(label).width;
+        g.globalAlpha = 0.55;
+        g.fillStyle = 'rgba(8,7,5,0.72)';
+        roundRect(g, n.x - w / 2 - 5 / t.k, n.y + r + 3 / t.k,
+          w + 10 / t.k, 16 / t.k, 4 / t.k);
+        g.fill();
+        g.globalAlpha = 1;
+        g.fillStyle = n.state === 'target' ? PALETTE.target : PALETTE.labelKey;
+      }
+      g.fillText(label, n.x, n.y + r + 5 / t.k);
+    }
+    g.globalAlpha = 1;
+
+    // edge tooltip label on hover
+    if (hoverEdge && hoverEdge.display) {
+      const a = hoverEdge.source, b = hoverEdge.target;
+      if (a.x != null && b.x != null) {
+        const mx = (a.x + b.x) / 2, my = (a.y + b.y) / 2;
+        g.font = `500 ${11 / t.k}px Outfit, system-ui, sans-serif`;
+        const w = g.measureText(hoverEdge.display).width;
+        g.fillStyle = 'rgba(8,7,5,0.85)';
+        roundRect(g, mx - w / 2 - 6 / t.k, my - 9 / t.k,
+          w + 12 / t.k, 18 / t.k, 4 / t.k);
+        g.fill();
+        g.fillStyle = '#e8dcbc';
+        g.textBaseline = 'middle';
+        g.fillText(hoverEdge.display, mx, my);
+        g.textBaseline = 'top';
+      }
+    }
+
+    g.restore();
+  }
+
+  function roundRect(ctx, x, y, w, h, r) {
+    ctx.beginPath();
+    ctx.moveTo(x + r, y);
+    ctx.arcTo(x + w, y, x + w, y + h, r);
+    ctx.arcTo(x + w, y + h, x, y + h, r);
+    ctx.arcTo(x, y + h, x, y, r);
+    ctx.arcTo(x, y, x + w, y, r);
+    ctx.closePath();
+  }
+
+  // ── hit testing ──────────────────────────────────────────────────────
+  function nodeAt(sx, sy) {
+    const [wx, wy] = transform.invert([sx, sy]);
+    let best = null, bestD = Infinity;
+    for (const n of nodesArr) {
+      if (n.x == null) continue;
+      const r = nodeRadius(n, lastCtx) + 4;
+      const d = (n.x - wx) ** 2 + (n.y - wy) ** 2;
+      if (d < r * r && d < bestD) { best = n; bestD = d; }
+    }
+    return best;
+  }
+
+  function edgeAt(sx, sy) {
+    const [wx, wy] = transform.invert([sx, sy]);
+    const tol = 6 / transform.k;
+    let best = null, bestD = tol * tol;
+    for (const l of linksArr) {
+      const a = l.source, b = l.target;
+      if (a.x == null || b.x == null || !l.display) continue;
+      const d = distToSeg(wx, wy, a.x, a.y, b.x, b.y);
+      if (d < bestD) { best = l; bestD = d; }
+    }
+    return best;
+  }
+
+  function distToSeg(px, py, x1, y1, x2, y2) {
+    const dx = x2 - x1, dy = y2 - y1;
+    const l2 = dx * dx + dy * dy || 1;
+    let t = ((px - x1) * dx + (py - y1) * dy) / l2;
+    t = Math.max(0, Math.min(1, t));
+    const cx = x1 + t * dx, cy = y1 + t * dy;
+    return (px - cx) ** 2 + (py - cy) ** 2;
+  }
+
+  // ── auto-fit ─────────────────────────────────────────────────────────
+  function bbox() {
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity, n = 0;
+    for (const nd of nodesArr) {
+      if (nd.x == null) continue;
+      minX = Math.min(minX, nd.x); maxX = Math.max(maxX, nd.x);
+      minY = Math.min(minY, nd.y); maxY = Math.max(maxY, nd.y); n++;
+    }
+    if (!n) return null;
+    return { minX, minY, maxX, maxY };
+  }
+
+  // desired transform that frames the whole graph (does NOT apply it — the
+  // rAF loop eases `transform` toward it)
+  function computeFitTarget() {
+    const bb = bbox();
+    if (!bb) return null;
+    const pad = 90;
+    const w = (bb.maxX - bb.minX) || 1, h = (bb.maxY - bb.minY) || 1;
+    const k = Math.max(0.15, Math.min(1.6,
+      Math.min((width - pad) / w, (height - pad) / h)));
+    const cx = (bb.minX + bb.maxX) / 2, cy = (bb.minY + bb.maxY) / 2;
+    return d3.zoomIdentity.translate(width / 2 - k * cx, height / 2 - k * cy).scale(k);
+  }
+
+  function scheduleFit() {
+    if (userNav) return;
+    fitCooldown = Date.now() + 450;
+    fitTarget = computeFitTarget();
+    kick();
+  }
+
+  // ── the GV surface ───────────────────────────────────────────────────
+  const GV = {
+    available() { return typeof d3 !== 'undefined'; },
+
+    init(el, opts) {
+      if (!this.available()) return false;
+      container = el;
+      onExpand = (opts && opts.onExpand) || null;
+      transform = d3.zoomIdentity;
+
+      canvas = document.createElement('canvas');
+      canvas.style.display = 'block';
+      canvas.style.width = '100%';
+      canvas.style.height = '100%';
+      canvas.style.cursor = 'grab';
+      el.innerHTML = '';
+      el.appendChild(canvas);
+      g = canvas.getContext('2d');
+
+      zoomBehavior = d3.zoom()
+        .scaleExtent([0.08, 5])
+        .on('start', (e) => {
+          if (e.sourceEvent) { userNav = true; fitTarget = null; }
+          canvas.style.cursor = 'grabbing';
+        })
+        .on('zoom', (e) => {
+          // a genuine user gesture (wheel/drag) pauses auto-follow
+          if (e.sourceEvent) { userNav = true; fitTarget = null; }
+          transform = e.transform;
+          draw();
+        })
+        .on('end', () => { canvas.style.cursor = 'grab'; });
+      d3.select(canvas).call(zoomBehavior)
+        .on('dblclick.zoom', null);
+
+      // pointer interactions
+      canvas.addEventListener('mousemove', onMove);
+      canvas.addEventListener('mouseleave', () => {
+        hoverNode = null; hoverEdge = null; hideTip(); draw();
+      });
+      canvas.addEventListener('click', onClick);
+
+      sim = d3.forceSimulation(nodesArr)
+        .force('link', d3.forceLink(linksArr).id(d => d.id)
+          .distance(l => l.isPath ? 64 : 92).strength(0.3))
+        .force('charge', d3.forceManyBody().strength(-240).distanceMax(520))
+        .force('collide', d3.forceCollide(d => nodeRadius(d, lastCtx) + 10))
+        .force('cluster', clusterForce(0.05))
+        .force('x', d3.forceX(() => centerWorld().x).strength(0.02))
+        .force('y', d3.forceY(() => centerWorld().y).strength(0.02))
+        .alphaDecay(0.025)
+        .velocityDecay(0.4)
+        .on('tick', () => { kick(); })
+        .stop();
+
+      window.addEventListener('resize', resize);
+      resize();
+      window.__aureliusGraph = { GV, sim };
+      return true;
+    },
+
+    sync(nodesObj, edgesArr, c) {
+      if (!sim) return;
+      lastCtx = c || {};
+      const lens = lastCtx.lens || null;
+
+      const visible = Object.values(nodesObj).filter(n => passesFilter(n, lastCtx));
+      const visSet = new Set(visible.map(n => n.id));
+
+      // links: honour the relationship lens; path edges always survive
+      const connected = new Set();
+      linksArr = [];
+      for (const e of edgesArr) {
+        if (!visSet.has(e.from) || !visSet.has(e.to)) continue;
+        if (lens && !e.isPath && (!e.type || !lens.has(e.type))) continue;
+        linksArr.push({ source: e.from, target: e.to, isPath: !!e.isPath,
+          type: e.type, display: e.display });
+        connected.add(e.from); connected.add(e.to);
+      }
+
+      // nodes: a lens hides the nodes it orphans, except anchors
+      const now = performance.now();
+      nodesArr.length = 0;
+      nodeById.clear();
+      for (const n of visible) {
+        if (lens && !isKey(n, lastCtx) && !connected.has(n.id)) continue;
+        if (n.__appear == null) n.__appear = now;   // fade-in stamp
+        nodesArr.push(n);
+        nodeById.set(n.id, n);
+      }
+
+      sim.nodes(nodesArr);
+      sim.force('link').links(linksArr);
+      recomputeFocusNeighbors();
+
+      // reheat so new nodes settle; harder when the graph changed size
+      const changed = nodesArr.length !== lastCount;
+      sim.alpha(changed ? 0.6 : 0.3).restart();
+      kick();
+      if (changed) { lastCount = nodesArr.length; scheduleFit(); }
+    },
+
+    focus(id) {
+      const n = nodeById.get(id);
+      if (!n || n.x == null) return;
+      userNav = true;                 // taking the camera; auto-follow yields
+      const k = Math.max(transform.k, 1.1);
+      fitTarget = d3.zoomIdentity
+        .translate(width / 2 - k * n.x, height / 2 - k * n.y).scale(k);
+      kick();
+    },
+
+    fit() {
+      userNav = false;
+      focusId = null;
+      recomputeFocusNeighbors();
+      fitCooldown = 0;
+      fitTarget = computeFitTarget();
+      kick();
+    },
+
+    reset() {
+      userNav = false; lastCount = -1; focusId = null; hoverNode = null;
+      hoverEdge = null; focusNeighbors = new Set(); fitTarget = null;
+      nodesArr.length = 0; linksArr = []; nodeById.clear();
+      if (sim) { sim.nodes([]); sim.force('link').links([]); sim.stop(); }
+      if (raf) { cancelAnimationFrame(raf); raf = 0; }
+      if (g) { g.setTransform(dpr, 0, 0, dpr, 0, 0); g.clearRect(0, 0, width, height); }
+    },
+
+    graph() { return { sim, nodesArr, linksArr }; },
+  };
+
+  // gentle pull of each node toward its kind's anchor direction
+  function clusterForce(strength) {
+    let nodes = [];
+    function force(alpha) {
+      const cw = centerWorld();
+      const spread = Math.min(width, height) * 0.32;
+      for (const n of nodes) {
+        const a = anchorFor(n.kind);
+        if (!a || onPath(n.id, lastCtx) || n.state === 'centre') continue;
+        n.vx += (cw.x + a.x * spread - n.x) * strength * alpha;
+        n.vy += (cw.y + a.y * spread - n.y) * strength * alpha;
+      }
+    }
+    force.initialize = (n) => { nodes = n; };
+    return force;
+  }
+
+  // world-space centre = screen centre un-projected (keeps layout stable
+  // under zoom/pan instead of snapping to a fixed origin)
+  function centerWorld() {
+    if (!transform) return { x: width / 2, y: height / 2 };
+    const [x, y] = transform.invert([width / 2, height / 2]);
+    return { x, y };
+  }
+
+  // ── pointer handlers ─────────────────────────────────────────────────
+  function onMove(e) {
+    const rect = canvas.getBoundingClientRect();
+    const sx = e.clientX - rect.left, sy = e.clientY - rect.top;
+    const n = nodeAt(sx, sy);
+    const prevN = hoverNode, prevE = hoverEdge;
+    hoverNode = n;
+    hoverEdge = n ? null : edgeAt(sx, sy);
+    canvas.style.cursor = n ? 'pointer' : 'grab';
+    if (n) showNodeTip(n, e.clientX, e.clientY); else hideTip();
+    if (n !== prevN || hoverEdge !== prevE) draw();
+  }
+
+  function onClick(e) {
+    const rect = canvas.getBoundingClientRect();
+    const n = nodeAt(e.clientX - rect.left, e.clientY - rect.top);
+    if (!n) {                       // click empty space clears focus
+      if (focusId) { focusId = null; recomputeFocusNeighbors(); draw(); }
+      return;
+    }
+    // toggle focus spotlight on the node's neighbourhood
+    focusId = (focusId === n.id) ? null : n.id;
+    recomputeFocusNeighbors();
+    GV.focus(n.id);
+    draw();
+    if (onExpand && !lastCtx.running) onExpand(n.id);
+  }
+
+  // reuse the app's existing tooltip element
+  function showNodeTip(n, px, py) {
+    const tip = document.getElementById('tooltip');
+    if (!tip) return;
+    const title = document.getElementById('tt-title');
+    const scores = document.getElementById('tt-scores');
+    if (title) title.textContent = nameOf(n);
+    if (scores) {
+      const rows = [];
+      if (n.kind) rows.push(cap(n.kind));
+      if (n.g != null) rows.push(`g = ${n.g} · hops from start`);
+      if (n.h != null) rows.push(`h = ${n.h} · heuristic`);
+      if (n.f != null) rows.push(`f = ${n.f} · total`);
+      if (onExpand && !lastCtx.running) rows.push('click to expand');
+      scores.innerHTML = rows.join('<br>');
+    }
+    tip.style.left = (px + 14) + 'px';
+    tip.style.top = (py - 32) + 'px';
+    tip.classList.add('visible');
+  }
+  function hideTip() {
+    const tip = document.getElementById('tooltip');
+    if (tip) tip.classList.remove('visible');
+  }
+
+  function truncate(s, n) { s = String(s); return s.length > n ? s.slice(0, n - 1) + '…' : s; }
+  function cap(s) { return String(s).replace(/_/g, ' ').replace(/^\w/, c => c.toUpperCase()); }
+
+  window.GV = GV;
+})();

graph3d.js

@@ -1,403 +0,0 @@
-/* Aurelius — 3D graph explorer (WebGL, three.js via 3d-force-graph).
- *
- * v2 redesign: from "giant static ball" to an exploration tool.
- *   · smaller nodes/links with more inter-node air (weak charge, longer
- *     link distance, small relSize)
- *   · inertial orbit controls (damping) — zoom/pan/rotate glide
- *   · auto-fit follows the graph while a search grows, but backs off the
- *     moment the user grabs the camera (and resumes via GV.fit())
- *   · label level-of-detail: floating text only on structurally important
- *     nodes (endpoints, centre, path); everything else is a small sphere
- *     with a hover tooltip
- *   · view filters (all / explored / path) applied at sync time, so the
- *     exploration cloud can be collapsed after a path is found
- *   · post-found dimming: once a path exists, non-path nodes fade back
- *   · click-to-expand: clicking a node asks the host app to fetch its
- *     neighbors (/api/neighbors) and animate them in — progressive
- *     expansion instead of one monolithic render
- *   · edge tooltips carry the relationship evidence ("supplies",
- *     "co-moves (corr 0.72)") when the source provides it
- *
- * It reads the same `nodes` (object keyed by id) and `edges` (array of
- * {from,to,isPath,type,display}) state the app.js message handlers keep,
- * so the WebSocket flow never changed. Exposes one global, GV:
- *   GV.init(el, opts)           build the scene; opts.onExpand(id) is the
- *                               click-to-expand callback
- *   GV.sync(nodes, edges, ctx)  reconcile with current state
- *                               (ctx: pathNodes, foundPath, centreNode,
- *                                filter, running)
- *   GV.focus(id)                fly the camera to a node
- *   GV.fit()                    frame everything + resume auto-follow
- *   GV.reset()                  clear the graph
- *   GV.available()              true if the 3D libs loaded
- *
- * Degrades gracefully: if the CDN libs are unavailable, available() is
- * false and app.js keeps the 2D SVG renderer.
- */
-
-(function () {
-  // Minimal palette: one warm accent for the path, everything else recedes
-  // into low-alpha neutrals so the found route is the only thing that
-  // shouts. Cloud nodes/links are deliberately faint context, not content.
-  const PALETTE = {
-    centre: '#e2a45c', target: '#4aab79', start: '#e4b254',
-    closed: 'rgba(150,138,104,0.45)', open: 'rgba(201,158,90,0.55)',
-    pathLive: '#e0864a', pathFound: '#5cd6a0', gated: 'rgba(75,32,32,0.5)',
-    dimNode: 'rgba(110,100,74,0.22)',
-    link: 'rgba(201,158,90,0.18)',
-    linkDim: 'rgba(120,104,64,0.07)',
-    linkPath: 'rgba(224,134,74,0.85)',
-    linkPathFound: 'rgba(92,214,160,0.9)',
-  };
-
-  // Node-kind palette — visual clustering for typed graphs: expanded
-  // finance/news nodes are colored by what they ARE, not just their
-  // search state.
-  const KIND_COLORS = {
-    company: '#c98a2e', etf: '#8b7cf7', sector: '#4aab79',
-    executive: '#e0995c', country: '#5b8dd6', macro: '#d65b8d',
-    person: '#e0995c', organization: '#8b7cf7', place: '#5b8dd6',
-    article: '#8a86a8', entity: '#c98a2e',
-  };
-
-  let Graph = null;
-  let container = null;
-  let SpriteText = (typeof window !== 'undefined') ? window.SpriteText : null;
-  let lastFocus = 0;
-  let onExpand = null;
-  let userNav = false;        // user grabbed the camera → stop auto-fitting
-  let fitTimer = null;
-  let lastCount = 0;
-
-  function found(ctx) { return !!(ctx.foundPath && ctx.foundPath.length); }
-  function onPath(n, ctx) { return ctx.pathNodes && ctx.pathNodes.has(n.id); }
-
-  function colorFor(n, ctx) {
-    if (n.state === 'centre') return PALETTE.centre;
-    if (n.state === 'target') return PALETTE.target;
-    if (n.state === 'start') return PALETTE.start;
-    if (onPath(n, ctx)) return found(ctx) ? PALETTE.pathFound : PALETTE.pathLive;
-    // progressively-expanded nodes stay bright (colored by kind when the
-    // source types its nodes) even after the search cloud dims
-    if (n.state === 'open' && (n.kind || n.expanded)) {
-      return KIND_COLORS[n.kind] || PALETTE.open;
-    }
-    // once the path is found, the exploration cloud recedes
-    if (found(ctx)) return PALETTE.dimNode;
-    if (n.state === 'closed') return PALETTE.closed;
-    if (n.state === 'gated') return PALETTE.gated;
-    return PALETTE.open;
-  }
-
-  function sizeFor(n, ctx) {
-    if (n.state === 'centre') return 3.2;
-    if (n.state === 'target' || n.state === 'start') return 2.8;
-    if (onPath(n, ctx)) return 2.2;
-    return 0.7;
-  }
-
-  function labelWorthy(n, ctx) {
-    return n.state === 'centre' || n.state === 'target' ||
-      n.state === 'start' || onPath(n, ctx);
-  }
-
-  function passesFilter(n, ctx) {
-    const f = ctx.filter || 'all';
-    if (f === 'all') return true;
-    if (labelWorthy(n, ctx)) return true;             // key nodes always visible
-    if (f === 'path') return false;
-    if (f === 'explored') return n.state !== 'open';  // hide the candidate cloud
-    return true;
-  }
-
-  // Continuous auto-framing: while the force layout is moving (nodes
-  // streaming in, simulation settling), keep re-framing the camera on a
-  // throttle so the whole graph stays centered and in frame — it zooms out
-  // automatically as the graph grows and re-centers as it drifts. The
-  // moment the user grabs the camera, tracking stops (GV.fit() resumes it).
-  //
-  // Framing is computed manually from graphData() positions and applied
-  // via cameraPosition(): the library's own zoomToFit/getGraphBbox is
-  // unreliable here (it reported a ±3-unit bbox for a ±120-unit layout and
-  // never moved the camera — the original "tiny graph lost in the corner"
-  // bug). cameraPosition() also plays well with damped orbit controls
-  // because it updates the controls' target.
-  let lastFitAt = 0;
-  const FIT_EVERY_MS = 900;
-
-  // Own camera animation: a persistent damper loop that exponentially
-  // eases the camera toward the current goal with instant ms=0
-  // cameraPosition steps. The library's animated moves (zoomToFit /
-  // cameraPosition with a duration) depend on its rAF render loop, which
-  // browsers throttle away in background tabs — and its getGraphBbox is
-  // also plain wrong here (reported a ±3-unit bbox for a ±120-unit
-  // layout), which was the original "tiny graph lost in the corner" bug.
-  // A setInterval damper is immune to rAF throttling; in hidden tabs it
-  // snaps instead of gliding, which is what you want anyway.
-  let camGoal = null;   // { pos: {x,y,z}, look: {x,y,z} }
-  let camDamper = null;
-
-  function animateCameraTo(pos, lookAt) {
-    camGoal = { pos, look: lookAt };
-  }
-
-  function startCamDamper() {
-    if (camDamper) return;
-    camDamper = setInterval(() => {
-      if (!Graph || !camGoal) return;
-      const cur = Graph.cameraPosition();
-      const ctl = Graph.controls();
-      const curLook = (ctl && ctl.target)
-        ? { x: ctl.target.x, y: ctl.target.y, z: ctl.target.z }
-        : { x: 0, y: 0, z: 0 };
-      const k = document.hidden ? 1 : 0.16;   // glide when visible, snap when not
-      const g = camGoal;
-      const nx = cur.x + (g.pos.x - cur.x) * k;
-      const ny = cur.y + (g.pos.y - cur.y) * k;
-      const nz = cur.z + (g.pos.z - cur.z) * k;
-      const lx = curLook.x + (g.look.x - curLook.x) * k;
-      const ly = curLook.y + (g.look.y - curLook.y) * k;
-      const lz = curLook.z + (g.look.z - curLook.z) * k;
-      Graph.cameraPosition({ x: nx, y: ny, z: nz }, { x: lx, y: ly, z: lz }, 0);
-      if (Math.hypot(g.pos.x - nx, g.pos.y - ny, g.pos.z - nz) < 1 &&
-          Math.hypot(g.look.x - lx, g.look.y - ly, g.look.z - lz) < 1) {
-        camGoal = null;   // arrived
-      }
-    }, 50);
-  }
-
-  function frameGraph(ms) {
-    if (!Graph) return;
-    const nodes = Graph.graphData().nodes.filter(n => n.x != null);
-    if (nodes.length < 1) return;
-    let cx = 0, cy = 0, cz = 0;
-    nodes.forEach(n => { cx += n.x; cy += n.y; cz += n.z; });
-    cx /= nodes.length; cy /= nodes.length; cz /= nodes.length;
-    let r = 0;
-    nodes.forEach(n => {
-      r = Math.max(r, Math.hypot(n.x - cx, n.y - cy, n.z - cz));
-    });
-    const cam = Graph.camera();
-    const fov = ((cam && cam.fov) || 50) * Math.PI / 180;
-    // distance that fits radius r in the vertical fov, +18% breathing room,
-    // clamped so tiny graphs don't fill the screen with two giant spheres
-    const dist = Math.max(120, (r + 14) / Math.tan(fov / 2) * 1.18);
-    const cur = Graph.cameraPosition();
-    let dx = cur.x - cx, dy = cur.y - cy, dz = cur.z - cz;
-    const len = Math.hypot(dx, dy, dz) || 1;
-    dx /= len; dy /= len; dz /= len;
-    animateCameraTo(
-      { x: cx + dx * dist, y: cy + dy * dist, z: cz + dz * dist },
-      { x: cx, y: cy, z: cz });
-  }
-
-  function tickFit() {
-    if (userNav || !Graph) return;
-    const now = Date.now();
-    if (now - lastFitAt < FIT_EVERY_MS) return;
-    lastFitAt = now;
-    frameGraph(650);
-  }
-
-  function scheduleFit() {
-    if (userNav || !Graph) return;
-    clearTimeout(fitTimer);
-    fitTimer = setTimeout(() => {
-      if (!userNav && Graph) frameGraph(700);
-    }, 450);
-  }
-
-  const GV = {
-    available() { return typeof window.ForceGraph3D === 'function'; },
-
-    init(el, opts) {
-      if (!this.available()) return false;
-      container = el;
-      onExpand = (opts && opts.onExpand) || null;
-
-      Graph = window.ForceGraph3D({ controlType: 'orbit' })(el)
-        .backgroundColor('rgba(0,0,0,0)')        // CSS cosmic backdrop shows through
-        .showNavInfo(false)
-        .nodeRelSize(2.0)
-        .nodeVal(n => n.__size || 1.5)
-        .nodeColor(n => n.__color || PALETTE.open)
-        .nodeOpacity(0.9)
-        .nodeResolution(32)          // smooth spheres, no visible faceting
-        .linkColor(l => l.__color || PALETTE.link)
-        .linkWidth(l => l.__pathFound ? 1.1 : (l.isPath ? 0.9 : 0.14))
-        .linkOpacity(0.45)
-        .linkDirectionalParticles(l => l.isPath ? 1 : 0)
-        .linkDirectionalParticleWidth(0.8)
-        .linkDirectionalParticleSpeed(0.008)
-        .linkLabel(l => l.display
-          ? `<div class="gv-tip">${escapeHtml(srcId(l))} → ${escapeHtml(dstId(l))}`
-          + `<span>${escapeHtml(l.display)}</span></div>` : '')
-        .warmupTicks(24)
-        .cooldownTime(8000)
-        .d3VelocityDecay(0.32)
-        // Camera tracks the layout: refit on a throttle while the engine
-        // runs, plus one final settle-frame when it stops.
-        .onEngineTick(tickFit)
-        .onEngineStop(() => { if (!userNav) frameGraph(800); })
-        .onNodeClick(n => {
-          this.focus(n.id);
-          if (onExpand) onExpand(n.id);
-        })
-        .nodeLabel(n => `<div class="gv-tip">${escapeHtml(n.id)}${n.kind ? `<span>${escapeHtml(n.kind)}</span>` : ''}${n.f != null ? `<span>f=${n.f}</span>` : ''}${n.__expandable ? '<span>click to expand</span>' : ''}</div>`);
-
-      // Floating text sprites for the important nodes only (label LOD).
-      if (SpriteText) {
-        Graph.nodeThreeObjectExtend(true).nodeThreeObject(n => {
-          if (!n.__label) return null;
-          const s = new SpriteText(truncate(n.id, 24));
-          s.color = n.__labelColor || '#d8d0b8';
-          s.textHeight = n.state === 'centre' ? 2.4 : 2.1;
-          s.fontFace = 'Outfit, sans-serif';
-          s.backgroundColor = 'rgba(10,9,6,0.35)';
-          s.padding = 0.9;
-          s.borderRadius = 1.5;
-          s.position.y = (n.__size || 1.5) + 3.4;
-          return s;
-        });
-      }
-
-      // Space the layout: small nodes with air between them instead of one
-      // dense ball. A collision force sized to each node's radius stops
-      // spheres from overlapping; longer links + bounded repulsion keep the
-      // footprint stable as the graph grows.
-      const charge = Graph.d3Force('charge');
-      if (charge) charge.strength(-80).distanceMax(300);
-      const linkF = Graph.d3Force('link');
-      if (linkF) linkF.distance(l => (l.isPath ? 38 : 52));
-      // NOTE: do NOT add window.d3.forceCollide here — that's the 2D D3
-      // build (loaded for the SVG fallback); its collide only handles x/y
-      // and biases/breaks the 3D simulation. Short-range charge repulsion
-      // is what keeps the small spheres from overlapping.
-
-      // Inertial camera: zoom/rotate/pan glide instead of snapping, and
-      // any manual grab pauses the auto-follow until GV.fit().
-      const controls = Graph.controls();
-      if (controls) {
-        controls.enableDamping = true;
-        controls.dampingFactor = 0.08;
-        controls.rotateSpeed = 0.75;
-        controls.zoomSpeed = 0.9;
-        controls.panSpeed = 0.8;
-        if (controls.addEventListener) {
-          controls.addEventListener('start', () => {
-            userNav = true;
-            camGoal = null;   // user grabbed the camera — stop steering it
-          });
-        }
-      }
-
-      window.addEventListener('resize', () => {
-        if (Graph && container) {
-          Graph.width(container.clientWidth).height(container.clientHeight);
-        }
-      });
-      Graph.width(el.clientWidth).height(el.clientHeight);
-      startCamDamper();
-      window.__aureliusGraph = Graph;   // debug/inspection handle
-      return true;
-    },
-
-    graph() { return Graph; },
-
-    sync(nodesObj, edgesArr, ctx) {
-      if (!Graph) return;
-      ctx = ctx || {};
-      const gd = Graph.graphData();
-      const existing = new Map(gd.nodes.map(n => [n.id, n]));
-      const lens = ctx.lens || null;   // Set of edge types, or null = all
-
-      const candidates = Object.values(nodesObj).filter(n => passesFilter(n, ctx));
-      const candSet = new Set(candidates.map(n => n.id));
-
-      // Links first: the relationship lens decides which edges survive
-      // (path edges always do), and therefore which nodes stay connected.
-      const links = [];
-      const connected = new Set();
-      edgesArr.forEach(e => {
-        if (!candSet.has(e.from) || !candSet.has(e.to)) return;
-        if (lens && !e.isPath && (!e.type || !lens.has(e.type))) return;
-        const pathFound = e.isPath && found(ctx);
-        links.push({
-          source: e.from, target: e.to, isPath: e.isPath,
-          type: e.type, display: e.display,
-          __pathFound: pathFound,
-          __color: e.isPath
-            ? (pathFound ? PALETTE.linkPathFound : PALETTE.linkPath)
-            : (found(ctx) ? PALETTE.linkDim : PALETTE.link),
-        });
-        connected.add(e.from); connected.add(e.to);
-      });
-
-      const nodes = [];
-      for (const src of candidates) {
-        // A lens hides nodes it orphans — except the key ones (endpoints,
-        // path) that anchor the view.
-        if (lens && !labelWorthy(src, ctx) && !connected.has(src.id)) continue;
-        const n = existing.get(src.id) || { id: src.id };
-        n.state = src.state; n.g = src.g; n.h = src.h; n.f = src.f;
-        n.kind = src.kind || null; n.expanded = !!src.expanded;
-        n.__color = colorFor(src, ctx);
-        n.__size = sizeFor(src, ctx);
-        n.__label = labelWorthy(src, ctx);
-        n.__expandable = !!onExpand && !ctx.running;
-        n.__labelColor = src.state === 'target' ? PALETTE.target :
-          (src.state === 'centre' ? '#ede8d4' : '#b8ad8a');
-        nodes.push(n);
-      }
-
-      Graph.graphData({ nodes, links });
-      if (nodes.length !== lastCount) {
-        lastCount = nodes.length;
-        scheduleFit();
-      }
-    },
-
-    focus(id) {
-      if (!Graph) return;
-      const now = Date.now();
-      if (now - lastFocus < 300) return;   // debounce rapid expands
-      lastFocus = now;
-      const n = Graph.graphData().nodes.find(x => x.id === id);
-      if (!n || n.x == null) return;
-      userNav = true;             // focusing a node = taking the camera;
-                                  // the auto-tracker yields until Fit view
-      const dist = 70;
-      const r = Math.hypot(n.x, n.y, n.z) || 1;
-      const k = 1 + dist / r;
-      animateCameraTo(
-        { x: n.x * k, y: n.y * k, z: n.z * k },
-        { x: n.x, y: n.y, z: n.z });
-    },
-
-    fit() {
-      if (!Graph) return;
-      userNav = false;            // resume auto-follow
-      lastFitAt = Date.now();
-      frameGraph(700);
-    },
-
-    reset() {
-      userNav = false;
-      lastCount = 0;
-      camGoal = null;
-      clearTimeout(fitTimer);
-      if (Graph) Graph.graphData({ nodes: [], links: [] });
-    },
-  };
-
-  function srcId(l) { return typeof l.source === 'object' ? l.source.id : l.source; }
-  function dstId(l) { return typeof l.target === 'object' ? l.target.id : l.target; }
-  function truncate(s, n) { return s.length > n ? s.slice(0, n - 1) + '…' : s; }
-  function escapeHtml(s) {
-    return String(s).replace(/[&<>"']/g, c => ({
-      '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;',
-    }[c]));
-  }
-
-  window.GV = GV;
-})();

index.html

@@ -7,14 +7,8 @@
   <title>Aurelius</title>
   <link rel="icon" type="image/png"
     href="data:image/png;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/4gHYSUNDX1BST0ZJTEUAAQEAAAHIAAAAAAQwAABtbnRyUkdCIFhZWiAH4AABAAEAAAAAAABhY3NwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA9tYAAQAAAADTLQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlkZXNjAAAA8AAAACRyWFlaAAABFAAAABRnWFlaAAABKAAAABRiWFlaAAABPAAAABR3dHB0AAABUAAAABRyVFJDAAABZAAAAChnVFJDAAABZAAAAChiVFJDAAABZAAAAChjcHJ0AAABjAAAADxtbHVjAAAAAAAAAAEAAAAMZW5VUwAAAAgAAAAcAHMAUgBHAEJYWVogAAAAAAAAb6IAADj1AAADkFhZWiAAAAAAAABimQAAt4UAABjaWFlaIAAAAAAAACSgAAAPhAAAts9YWVogAAAAAAAA9tYAAQAAAADTLXBhcmEAAAAAAAQAAAACZmYAAPKnAAANWQAAE9AAAApbAAAAAAAAAABtbHVjAAAAAAAAAAEAAAAMZW5VUwAAACAAAAAcAEcAbwBvAGcAbABlACAASQBuAGMALgAgADIAMAAxADb/2wBDAAUDBAQEAwUEBAQFBQUGBwwIBwcHBw8LCwkMEQ8SEhEPERETFhwXExQaFRERGCEYGh0dHx8fExciJCIeJBweHx7/2wBDAQUFBQcGBw4ICA4eFBEUHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh7/wAARCAH0AfQDASIAAhEBAxEB/8QAHQABAAICAwEBAAAAAAAAAAAAAAYHBAgBAwUCCf/EAEsQAAIBAwIEAwQGBwQHBwUBAAABAgMEBQYRByExQRJRYQgTcYEUIjKRobEVI0JSksHTM1Vi8SRjcnWisvAXNEZTgsLRFjVDs9Lh/8QAGwEBAAIDAQEAAAAAAAAAAAAAAAEDAgQFBgf/xAAuEQEAAgIBAgMHBQEAAwAAAAAAAQIDEQQFMRMhQQYSUXGBobEyM1Jh0SIVkfD/2gAMAwEAAhEDEQA/ANMgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALS4Q8HsrrSMMpkZzx2E35Vdv1tfb/AMtNbbf4ny9GVZs1MNJvknUQuwYMnIvGPHG5lVoN49L8N9FadtoUrHT1jUqRW30i5pRq1ZPz8Uk9vlsj2rrT+BvKLo3eExtxSa2cKtrCa2+aOHb2j48W1WszD0FPZfkzXc2iJaBA2q4i8BNPZehWu9MJYjIbNxpbv6NN+TXN…[truncated base64 icon]">
+  <!-- d3 powers the 2D canvas graph (force layout + zoom) in graph2d.js -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/d3/7.8.5/d3.min.js"></script>
-  <!-- Immersive 3D graph (WebGL via three.js). A standalone THREE UMD is
-       loaded first so three-spritetext (floating node labels) can find its
-       peer; 3d-force-graph bundles its own three for rendering. graph3d.js
-       degrades to the 2D D3 renderer if any of these fail to load. -->
-  <script src="https://cdn.jsdelivr.net/npm/three@0.160.0/build/three.min.js"></script>
-  <script src="https://cdn.jsdelivr.net/npm/three-spritetext@1.8.2/dist/three-spritetext.min.js"></script>
-  <script src="https://cdn.jsdelivr.net/npm/3d-force-graph@1.73.4/dist/3d-force-graph.min.js"></script>
   <link rel="preconnect" href="https://fonts.googleapis.com">
   <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
   <link
@@ -87,8 +81,9 @@
     <div id="hero-title" style="font-family: Cinzel">Aurelius</div>
     <div id="hero-tagline" class="hero-reveal">Navigate the Knowledge Graph</div>
     <div id="hero-rest" class="hero-reveal">
-      <div id="hero-sub">Find the hidden path between any two things in a giant network of ideas.<br>Watch Aurelius
-        navigate the graph — Wikipedia, research papers, code, biology, news, or markets — in real time.</div>
+      <div id="hero-sub">A research engine for connected knowledge. Explore a company, a paper's citations,
+        or the hidden path between any two ideas<br>across Wikipedia, research papers, finance, and biology
+        — every connection backed by real evidence.</div>
 
       <div id="hero-source-row">
         <span class="hero-source-label">Explore</span>
@@ -201,11 +196,9 @@
     <!-- Graph -->
     <div id="canvas-wrap">
       <div id="cosmos"></div>
-      <div id="graph3d"></div>
-      <svg id="graph"></svg>
+      <div id="graph-canvas"></div>
 
-      <!-- 3D explorer controls: view filters + camera fit. Hidden when the
-           2D SVG fallback renderer is active (app.js initSVG). -->
+      <!-- Explorer controls: view filters + camera fit. -->
       <div id="graph-controls">
         <button class="gc-btn active" data-filter="all" onclick="setGraphFilter('all')"
           title="Show every node the search touched">All</button>
@@ -301,6 +294,77 @@
           <circle cx="11" cy="11" r="7"/><line x1="16" y1="16" x2="21" y2="21"/><path d="M11 8v6M8 11h6"/>
         </svg>
       </button>
+
+      <!-- Company Profile panel — the primary finance surface. A dossier
+           for one company: price, key facts, peers, supply chain,
+           correlations and ownership, with the graph as a secondary
+           explorer. Shown only on the finance source. -->
+      <div id="profile-panel" aria-hidden="true">
+        <div class="prof-head">
+          <div class="prof-input-row">
+            <svg class="prof-search-ic" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round"><circle cx="7" cy="7" r="5"/><line x1="11" y1="11" x2="15" y2="15"/></svg>
+            <input id="profile-input" type="text" placeholder="Research a company — ticker or name" autocomplete="off"
+              onkeydown="if(event.key==='Enter')openProfile(this.value)" />
+            <button id="profile-run" onclick="openProfile(document.getElementById('profile-input').value)">Go</button>
+          </div>
+          <button class="prof-close" onclick="toggleProfile(false)" aria-label="Close">
+            <svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"><line x1="3" y1="3" x2="13" y2="13"/><line x1="13" y1="3" x2="3" y2="13"/></svg>
+          </button>
+        </div>
+        <div id="profile-body">
+          <div class="prof-empty">
+            <svg viewBox="0 0 48 48" fill="none" stroke="currentColor" stroke-width="1.4" stroke-linecap="round" stroke-linejoin="round">
+              <path d="M6 40V22l8-4v22M18 40V14l8-4v30M30 40V20l8-4v24M4 40h40"/>
+            </svg>
+            <p>Search any company to see its price, peers, supply chain, correlations, ownership and the news moving it — all in one place.</p>
+            <div class="prof-empty-chips" id="profile-empty-chips"></div>
+          </div>
+        </div>
+      </div>
+      <button id="profile-fab" onclick="toggleProfile(true)" title="Research a company">
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round">
+          <path d="M4 20V11l5-3v12M13 20V6l5-3v17M3 20h18"/>
+        </svg>
+        <span>Research</span>
+      </button>
+
+      <!-- Citation Explorer panel — the primary research-papers surface.
+           A paper's dossier: metadata, the works it cites and the works
+           citing it, with a "build citation graph" hand-off. Shown only on
+           the research (OpenAlex) source. -->
+      <div id="paper-panel" aria-hidden="true">
+        <div class="prof-head">
+          <div class="prof-input-row">
+            <svg class="prof-search-ic" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round"><circle cx="7" cy="7" r="5"/><line x1="11" y1="11" x2="15" y2="15"/></svg>
+            <input id="paper-input" type="text" placeholder="Paper title, DOI, or arXiv id" autocomplete="off"
+              onkeydown="if(event.key==='Enter')openPaper(this.value)" />
+            <button id="paper-run" onclick="openPaper(document.getElementById('paper-input').value)">Go</button>
+          </div>
+          <button class="prof-close" onclick="togglePaper(false)" aria-label="Close">
+            <svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"><line x1="3" y1="3" x2="13" y2="13"/><line x1="13" y1="3" x2="3" y2="13"/></svg>
+          </button>
+        </div>
+        <div id="paper-body">
+          <div class="prof-empty">
+            <svg viewBox="0 0 48 48" fill="none" stroke="currentColor" stroke-width="1.4" stroke-linecap="round" stroke-linejoin="round">
+              <path d="M14 6h16l6 6v30H14z"/><path d="M30 6v6h6"/><line x1="19" y1="22" x2="31" y2="22"/><line x1="19" y1="28" x2="31" y2="28"/><line x1="19" y1="34" x2="26" y2="34"/>
+            </svg>
+            <p>Give it a paper — by title, DOI, or arXiv id — to see what it cites, what cites it, and build an interactive citation graph you can expand.</p>
+            <div class="prof-empty-chips" id="paper-empty-chips"></div>
+            <label class="paper-drop" id="paper-drop">
+              <input type="file" accept="application/pdf" onchange="uploadPaperPdf(this.files)" hidden />
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round"><path d="M12 16V4M12 4l-4 4M12 4l4 4"/><path d="M4 16v3a1 1 0 0 0 1 1h14a1 1 0 0 0 1-1v-3"/></svg>
+              <span>or drop / choose a PDF</span>
+            </label>
+          </div>
+        </div>
+      </div>
+      <button id="paper-fab" onclick="togglePaper(true)" title="Explore a paper's citations">
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round">
+          <path d="M6 3h9l4 4v14H6z"/><path d="M15 3v4h4"/><line x1="9" y1="12" x2="16" y2="12"/><line x1="9" y1="16" x2="14" y2="16"/>
+        </svg>
+        <span>Citations</span>
+      </button>
     </div>
 
     <!-- Mobile-only: toggles the panel below open/closed. Lives OUTSIDE
@@ -464,8 +528,8 @@
 
       <p class="about-prose">Named after the Stoic emperor who wrote that every idea connects to the next. Aurelius
         makes those connections visible in any network of knowledge: pick two things, and it walks the real links
-        between them, ranking every step by meaning. It started on Wikipedia; today the same engine navigates
-        research-paper citations, code repositories, biomedical networks, live news coverage, and financial markets,
+        between them, ranking every step by meaning. It started on Wikipedia; today the same engine powers a
+        company research workspace, a paper citation explorer, biomedical networks and live news coverage,
         and can surface connections that no direct link records at all.</p>
 
       <hr class="about-divider" />
@@ -568,7 +632,7 @@
         <div class="about-compare-cell accent">Aims at the goal from both ends</div>
 
         <div class="about-compare-cell">Built for one dataset</div>
-        <div class="about-compare-cell accent">Same engine on Wikipedia, papers, code, biology, news &amp; markets</div>
+        <div class="about-compare-cell accent">Same engine on Wikipedia, papers, finance, biology &amp; news</div>
 
         <div class="about-compare-cell">Only finds what's directly linked</div>
         <div class="about-compare-cell accent">Discovers hidden connections with no direct link at all</div>
@@ -613,37 +677,38 @@
         <div class="onboarding-step">
           <div class="onboarding-icon">1</div>
           <div>
-            <strong>Pick a universe, then two things in it</strong>
-            <p>Wikipedia, research papers, GitHub, finance, or live news; choose a source, type a From and a
-              To (or hit Random).</p>
+            <strong>Pick a world to research</strong>
+            <p>Wikipedia, research papers, finance, or biology. Each has its own workspace — a company
+              profile, a paper's citations — plus the pathfinder that ties any two things together.</p>
           </div>
         </div>
         <div class="onboarding-step">
           <div class="onboarding-icon">2</div>
           <div>
-            <strong>Watch it navigate in real time</strong>
-            <p>Aurelius walks real connections toward your target from both ends, ranking every step by
+            <strong>Dive into one thing, or connect two</strong>
+            <p>Research a company (price, peers, supply chain, news) or a paper's citation tree; or type
+              a From and a To and watch Aurelius walk the real links between them, ranking every step by
               meaning. It never invents a link.</p>
           </div>
         </div>
         <div class="onboarding-step">
           <div class="onboarding-icon">3</div>
           <div>
-            <strong>Then explore</strong>
-            <p>Click any node to expand its real neighbours, filter the view down to the path, and open
-              Discover to surface connections with no direct link at all.</p>
+            <strong>Explore the graph</strong>
+            <p>Click any node to expand its real neighbours, focus on its neighbourhood, filter the view,
+              and open Discover to surface connections with no direct link at all.</p>
           </div>
         </div>
       </div>
       <p class="onboarding-tip">
-        Tip: try the Finance source with two companies from different industries; the route between them is
-        real supply chains, ownership and market co-movement.
+        Tip: in Finance, hit <strong>Research a company</strong> and search a ticker like NVDA — you'll see
+        its peers, suppliers, correlations and news before you ever touch the graph.
       </p>
       <button class="modal-close-btn onboarding-go-btn" onclick="closeOnboarding()">Let's Go</button>
     </div>
   </div>
 
-  <script src="graph3d.js"></script>
+  <script src="graph2d.js"></script>
   <script src="app.js"></script>
 </body>
 

ingest/__init__.py

@@ -1,5 +1,5 @@
 """Aurelius ingestion — batch pipelines that fill core.store for
-ingested-mode adapters (biomed, news, finance, and optionally github).
+ingested-mode adapters (biomed, news, finance).
 
 Each domain module exposes `ingest(...)` that writes nodes + edges into
 the store. The shared `embed_and_fuse(source_name)` step (pipeline.py)

ingest/cli.py

@@ -24,7 +24,7 @@ from ingest.pipeline import embed_and_fuse
 async def _run(args):
     if args.source == "status":
         store = get_store()
-        for name in ("wikipedia", "openalex", "github",
+        for name in ("wikipedia", "openalex",
                      "biomed", "news", "finance"):
             n, e = store.node_count(name), store.edge_count(name)
             state = "ingested" if n else "live/empty"

mainpybackup.txt

@@ -1,799 +0,0 @@
-"""
-Aurelius — Wikipedia Rabbit-Hole Navigator Backend
-Architecture: embeddings + graph search only. No LLM, no external services.
-
-Per-expansion pipeline:
-  1. Fetch ALL links from article (paginated, up to MAX_FETCH)
-  2. Batch-embed ALL uncached links in one in-process sentence-transformers call
-  3. Score each candidate: cosine-to-target + frontier bonus + category bonus
-  4. Prune to top PRUNE_TOP_K, dropping anything below the raw-cosine floor
-  5. Push survivors to heap (greedy best-first: heap key = h only)
-
-The only external dependency at runtime is the Wikipedia API itself. The
-embedding model (sentence-transformers, all-MiniLM-L6-v2) is loaded once,
-in-process, at startup — no network calls, no LLM, no failure mode where
-the search degrades silently.
-"""
-
-import asyncio
-import heapq
-import json
-import math
-import random
-import re
-import sys
-import time
-from collections import defaultdict
-from pathlib import Path
-from typing import Optional
-from urllib.parse import unquote
-
-import httpx
-import numpy as np
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect
-from fastapi.middleware.cors import CORSMiddleware
-from sentence_transformers import SentenceTransformer
-
-# Windows redirects stdout to cp1252 when it's not an interactive console
-# (e.g. piped to a log file), which raises on the arrow/emoji characters
-# used in log lines below and would otherwise crash mid-search.
-try:
-    sys.stdout.reconfigure(encoding="utf-8")
-    sys.stderr.reconfigure(encoding="utf-8")
-except Exception:
-    pass
-
-app = FastAPI()
-app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
-
-# ── Embedding model: loaded once at startup, in-process ─────────────────────
-EMBED_MODEL_NAME = "all-MiniLM-L6-v2"
-_EMBED_MODEL: Optional[SentenceTransformer] = None
-
-@app.on_event("startup")
-async def _startup_embed_model():
-    global _EMBED_MODEL
-    print(f"[Embed] Loading sentence-transformers model '{EMBED_MODEL_NAME}'...")
-    _EMBED_MODEL = SentenceTransformer(EMBED_MODEL_NAME)
-    print(f"[Embed] Ready (dim={_EMBED_MODEL.get_embedding_dimension()})")
-
-WIKI_API = "https://en.wikipedia.org/w/api.php"
-
-MAX_FETCH          = 500   # max links fetched from Wikipedia (paginated)
-MAX_PAGES          = 6     # safety cap on pagination pages when hunting for a specific goal link
-MAX_HOPS           = 60    # search iteration limit
-TOP_DISPLAY        = 25    # max neighbours sent to frontend per step
-FRONTIER_DEPTH_2_K = 16    # how many depth-1 target neighbours to expand for depth-2 frontier
-
-EMBED_BATCH_SIZE   = 128   # in-process model batch size (no HTTP token limits to worry about)
-
-PRUNE_TOP_K        = 15    # keep this many candidates per expansion after scoring
-PRUNE_FLOOR        = 0.15  # hard floor on raw cosine-to-target; frontier members exempt
-
-FRONTIER_D1_BONUS  = 0.30  # candidate is a direct link of the target
-FRONTIER_D2_BONUS  = 0.10  # candidate is 2 hops from the target
-CAT_BONUS_WEIGHT   = 0.10  # max bonus for category-embedding alignment
-
-_THIS_DIR = Path(__file__).resolve().parent
-SEED_FILE = _THIS_DIR / "common_wiki_searches.txt"
-
-WIKI_HEADERS = {
-    "User-Agent": "Aurelius-WikiNavigator/6.0 (educational; contact@example.com)",
-    "Accept": "application/json",
-}
-
-def make_wiki_client() -> httpx.AsyncClient:
-    return httpx.AsyncClient(headers=WIKI_HEADERS, follow_redirects=True,
-                             timeout=httpx.Timeout(25.0))
-
-
-# ══════════════════════════════════════════════════════════════
-# SEARCH STATS
-# ══════════════════════════════════════════════════════════════
-
-class SearchStats:
-    def __init__(self):
-        self.t0            = time.time()
-        self.nodes_visited = 0
-        self.nodes_pruned  = 0
-        self.embed_calls   = 0
-
-    def elapsed(self) -> float:
-        return round(time.time() - self.t0, 1)
-
-    def to_dict(self) -> dict:
-        return {
-            "nodes_visited": self.nodes_visited,
-            "nodes_pruned":  self.nodes_pruned,
-            "embed_calls":   self.embed_calls,
-            "elapsed_s":     self.elapsed(),
-        }
-
-
-# ══════════════════════════════════════════════════════════════
-# SESSION CACHES  (reset each search)
-# ══════════════════════════════════════════════════════════════
-
-_emb_cache: dict[str, np.ndarray] = {}   # title → embedding vector
-_dead_ends: set[str]              = set() # articles with 0 links
-
-def reset_session_caches():
-    global _emb_cache, _dead_ends
-    _emb_cache = {}
-    _dead_ends = set()
-
-
-# ══════════════════════════════════════════════════════════════
-# VECTOR MATH
-# ══════════════════════════════════════════════════════════════
-
-def cosine_similarity(a, b) -> float:
-    if a is None or b is None:
-        return 0.0
-    a = np.asarray(a, dtype=np.float32)
-    b = np.asarray(b, dtype=np.float32)
-    if a.size == 0 or b.size == 0:
-        return 0.0
-    na = np.linalg.norm(a)
-    nb = np.linalg.norm(b)
-    if na == 0 or nb == 0:
-        return 0.0
-    return float(np.dot(a, b) / (na * nb))
-
-
-# ══════════════════════════════════════════════════════════════
-# EMBEDDING  (in-process sentence-transformers, no network calls)
-# ══════════════════════════════════════════════════════════════
-
-async def batch_embed(texts: list[str], stats: SearchStats) -> list[np.ndarray]:
-    """
-    Embed texts via the in-process sentence-transformers model.
-    Results are cached per title across the session. Runs the (CPU-bound,
-    synchronous) encode call in a thread executor so it never blocks the
-    event loop — keeps pause/resume and other WS traffic responsive.
-    """
-    if not texts or _EMBED_MODEL is None:
-        return [np.array([]) for _ in texts]
-
-    uncached_idx  = [i for i, t in enumerate(texts) if t not in _emb_cache]
-    uncached_text = [texts[i] for i in uncached_idx]
-    if uncached_text:
-        loop = asyncio.get_event_loop()
-        embs = await loop.run_in_executor(
-            None,
-            lambda: _EMBED_MODEL.encode(
-                uncached_text, convert_to_numpy=True,
-                batch_size=EMBED_BATCH_SIZE, show_progress_bar=False,
-            ),
-        )
-        stats.embed_calls += 1
-        for orig_i, emb in zip(uncached_idx, embs):
-            _emb_cache[texts[orig_i]] = emb
-
-    return [_emb_cache.get(t, np.array([])) for t in texts]
-
-
-async def wiki_get(client: httpx.AsyncClient, params: dict, retries: int = 3) -> dict:
-    for attempt in range(retries + 1):
-        try:
-            r = await client.get(WIKI_API, params=params)
-            if r.status_code == 429:
-                await asyncio.sleep(min(2 ** attempt, 8)); continue
-            if r.status_code != 200:
-                return {}
-            return r.json()
-        except httpx.TimeoutException:
-            if attempt < retries: await asyncio.sleep(1)
-        except Exception as e:
-            print(f"[wiki] {e}"); return {}
-    return {}
-
-def extract_title_from_url(query: str) -> Optional[str]:
-    """If query is a Wikipedia URL, extract and decode the article title; else None."""
-    m = re.search(r'wikipedia\.org/wiki/([^#?\s]+)', query.strip())
-    if not m:
-        return None
-    return unquote(m.group(1)).replace('_', ' ').strip()
-
-async def resolve_article_title(client: httpx.AsyncClient, query: str) -> Optional[str]:
-    query = query.strip()
-    url_t = extract_title_from_url(query)
-    if url_t: query = url_t
-
-    data = await wiki_get(client, {"action":"query","titles":query,
-                                   "redirects":1,"format":"json","utf8":1})
-    for pid, page in data.get("query",{}).get("pages",{}).items():
-        if pid != "-1":
-            print(f"[resolve] Exact ✓ '{page['title']}'")
-            return page["title"]
-
-    data = await wiki_get(client, {"action":"opensearch","search":query,
-                                   "limit":10,"namespace":0,"format":"json","utf8":1})
-    titles = data[1] if isinstance(data, list) and len(data) > 1 else []
-    if titles:
-        for t in titles:
-            if t.lower() == query.lower(): return t
-        return titles[0]
-
-    data = await wiki_get(client, {"action":"query","list":"search","srsearch":query,
-                                   "srlimit":5,"srprop":"title","format":"json","utf8":1})
-    results = data.get("query",{}).get("search",[])
-    if results:
-        return results[0]["title"]
-    return None
-
-_DATE_RE = re.compile(
-    r'^\d{1,2} \w+$|^\w+ \d{1,2}$|^\d{4}$|^\d{4} in '
-    r'|^\d{1,2}\w* century'
-    r'|^(January|February|March|April|May|June|July|August|'
-    r'September|October|November|December)$'
-    r'|^\d{4}[-–]\d{2,4}$', re.IGNORECASE
-)
-def _is_date(t: str) -> bool:
-    return bool(_DATE_RE.search(t))
-
-_JUNK_TITLES = frozenset({
-    "Wayback Machine", "OCLC", "Digital object identifier", "CrossRef",
-    "JSTOR", "PubMed", "PubMed Central", "Semantic Scholar", "ArXiv",
-    "Bibcode", "CiteSeerX", "S2CID", "Zbl", "MR", "PMC",
-})
-def _is_junk(t: str) -> bool:
-    """Bibliographic citation artifacts: dead ends with 1-3 links each."""
-    return t.endswith("(identifier)") or t in _JUNK_TITLES
-
-async def get_all_links(client: httpx.AsyncClient, title: str,
-                        end_title: str = "",
-                        target_neighbours: set | None = None) -> list[str]:
-    """
-    Fetch ALL links via pagination (up to MAX_FETCH).
-    Goal link is always included first if found.
-    Target neighbours always get priority slots.
-    Date/year stubs filtered unless list would be empty.
-
-    BUGFIX: when hunting for end_title, the old exit condition
-    (len(all_links) >= MAX_FETCH) stopped pagination after roughly the
-    first alphabetical page of a large article, so a goal link sorting
-    late in the alphabet (e.g. "Pakistan" on India's 1000+-link page)
-    was never found even though it's a direct 1-hop link. We now keep
-    paginating past MAX_FETCH while specifically searching for a goal,
-    bounded by MAX_PAGES as a safety cap. Calls with no end_title (e.g.
-    pre-seeding target neighbours) are unaffected — same stop condition
-    as before.
-    """
-    all_links:  list[str] = []
-    date_links: list[str] = []
-    goal_link:  str | None = None
-    end_lower = end_title.lower() if end_title else ""
-    params = {
-        "action": "query", "titles": title, "prop": "links",
-        "pllimit": 500, "plnamespace": 0, "format": "json", "utf8": 1,
-    }
-    pages_fetched = 0
-    while True:
-        data = await wiki_get(client, params)
-        pages_fetched += 1
-        for page in data.get("query", {}).get("pages", {}).values():
-            for link in page.get("links", []):
-                t = link["title"]
-                if end_lower and t.lower() == end_lower:
-                    goal_link = t; continue
-                if _is_junk(t):
-                    continue
-                if _is_date(t):
-                    date_links.append(t)
-                else:
-                    all_links.append(t)
-        cont = data.get("continue", {})
-        if "plcontinue" not in cont:
-            break
-        if goal_link:
-            break   # found it — no need to keep paginating
-        if end_lower:
-            # Actively hunting a specific goal: keep going past MAX_FETCH,
-            # bounded only by MAX_PAGES (safety cap on API calls).
-            if pages_fetched >= MAX_PAGES:
-                break
-        else:
-            # No specific goal (e.g. pre-seeding neighbours): original behavior.
-            if len(all_links) + len(date_links) >= MAX_FETCH:
-                break
-        params["plcontinue"] = cont["plcontinue"]
-
-    result: list[str] = []
-    if goal_link:
-        result.append(goal_link)
-
-    tn = target_neighbours or set()
-    bridges = [l for l in all_links if l in tn]
-    rest    = [l for l in all_links if l not in tn]
-    result += bridges
-    result += rest
-    if len(result) < 5:
-        result += date_links[:max(0, 5 - len(result))]
-
-    return result[:MAX_FETCH]
-
-async def get_backlinks(client: httpx.AsyncClient, title: str,
-                        limit: int = MAX_FETCH) -> list[str]:
-    """
-    Fetch articles that link TO `title` (Wikipedia prop=linkshere) — the
-    correct direction for a forward-search bridge set.
-
-    get_all_links() returns what `title` points to. That is NOT useful as
-    a "one hop from target" bridge set, because Wikipedia links are not
-    reciprocal: target -> A does not imply A -> target. A backlink (B ->
-    target) is a guaranteed bridge — if the forward search ever reaches B,
-    expanding it is certain to find `target` in B's own outbound links.
-    Using outbound links here was sending the search on real-but-useless
-    detours (e.g. the "Star Wars" article links to "Star Destroyer", which
-    in turn links to real-world "Capital ship"/"Destroyer" articles for
-    etymology — those score high on the old outbound-based frontier but
-    don't link back to anything Star Wars-related themselves).
-    """
-    all_links:  list[str] = []
-    date_links: list[str] = []
-    params = {
-        "action": "query", "titles": title, "prop": "linkshere",
-        "lhlimit": 500, "lhnamespace": 0, "format": "json", "utf8": 1,
-    }
-    pages_fetched = 0
-    while True:
-        data = await wiki_get(client, params)
-        pages_fetched += 1
-        for page in data.get("query", {}).get("pages", {}).values():
-            for link in page.get("linkshere", []):
-                t = link["title"]
-                if _is_junk(t):
-                    continue
-                if _is_date(t):
-                    date_links.append(t)
-                else:
-                    all_links.append(t)
-        cont = data.get("continue", {})
-        if "lhcontinue" not in cont:
-            break
-        if len(all_links) + len(date_links) >= limit or pages_fetched >= MAX_PAGES:
-            break
-        params["lhcontinue"] = cont["lhcontinue"]
-    return (all_links + date_links)[:limit]
-
-async def get_article_summary(client: httpx.AsyncClient, title: str) -> str:
-    data = await wiki_get(client, {"action":"query","titles":title,"prop":"extracts",
-                                   "exintro":True,"explaintext":True,
-                                   "exsentences":2,"format":"json","utf8":1})
-    for page in data.get("query",{}).get("pages",{}).values():
-        return page.get("extract","")[:220]
-    return ""
-
-async def get_target_categories(client: httpx.AsyncClient, title: str) -> list[str]:
-    """Fetch human-readable categories for the target article."""
-    data = await wiki_get(client, {
-        "action": "query", "titles": title, "prop": "categories",
-        "cllimit": 20, "clshow": "!hidden", "format": "json", "utf8": 1,
-    })
-    cats = []
-    for page in data.get("query", {}).get("pages", {}).values():
-        for c in page.get("categories", []):
-            # Strip "Category:" prefix
-            name = re.sub(r"^Category:", "", c["title"]).strip()
-            cats.append(name)
-    return cats
-
-
-def _load_seed_titles() -> list[str]:
-    """Read the curated topic list used by the Random button, one title per line."""
-    if not SEED_FILE.exists():
-        return []
-    with open(SEED_FILE, "r", encoding="utf-8") as f:
-        return [line.strip() for line in f if line.strip()]
-
-
-# ══════════════════════════════════════════════════════════════
-# SEARCH ENGINE — greedy best-first, embeddings + graph only
-# ══════════════════════════════════════════════════════════════
-
-class AStarNavigator:
-    def __init__(self, start: str, end: str, ws: WebSocket):
-        self.start   = start
-        self.end     = end
-        self.ws      = ws
-        self.stats   = SearchStats()
-        self._paused = False
-
-        self.g_score:   dict[str, float]         = defaultdict(lambda: math.inf)
-        self.came_from: dict[str, Optional[str]] = {}
-        self.h_cache:   dict[str, float]         = {}
-        self.open_heap: list[tuple]              = []
-        self.open_set:  set[str]                = set()
-        self.closed_set:set[str]                = set()
-
-        self.cats_target:        list[str]        = []
-        self.cat_embeddings:     list[np.ndarray]  = []
-        self._target_neighbours: set[str]         = set()
-        self._frontier: dict[str, int]           = {}  # title → distance from target (1 or 2)
-        self.target_embedding:   Optional[np.ndarray] = None
-        self._target_cosine:     dict[str, float]      = {}  # raw cosine-to-target, used by prune floor
-
-
-    async def send(self, event: str, data: dict):
-        try:
-            await self.ws.send_text(json.dumps({"event": event, **data}))
-        except Exception:
-            pass
-
-    def reconstruct_path(self, current: str) -> list[str]:
-        path = [current]
-        while current in self.came_from and self.came_from[current] is not None:
-            current = self.came_from[current]
-            path.append(current)
-        return list(reversed(path))
-
-    # ── CORE SCORING PIPELINE ─────────────────────────────────────────────────
-    async def _rank_candidates(self, candidates: list[str]) -> dict[str, float]:
-        """
-        score(candidate) =
-              cosine(candidate_emb, target_emb)              # primary signal
-            + 0.30 if candidate backlinks the target directly else 0
-            + 0.10 if candidate is one hop further out (depth-2) else 0
-            + 0.10 * max(cosine(candidate_emb, category_emb_i))
-
-        Raw target cosine is stashed in self._target_cosine for the prune
-        floor — bonuses should not be able to rescue a semantically
-        unrelated candidate, only break ties among related ones.
-        """
-        if not candidates:
-            return {}
-
-        need_embed = [t for t in candidates if t not in _emb_cache]
-        if need_embed:
-            await batch_embed(need_embed, self.stats)
-
-        combined: dict[str, float] = {}
-        for t in candidates:
-            emb = _emb_cache.get(t)
-            s_target = cosine_similarity(emb, self.target_embedding)
-            self._target_cosine[t] = s_target
-
-            fd = self._frontier.get(t)
-            frontier_bonus = FRONTIER_D1_BONUS if fd == 1 else FRONTIER_D2_BONUS if fd == 2 else 0.0
-
-            cat_bonus = 0.0
-            if self.cat_embeddings and emb is not None and emb.size:
-                cat_sim = max(cosine_similarity(emb, ce) for ce in self.cat_embeddings)
-                cat_bonus = cat_sim * CAT_BONUS_WEIGHT
-
-            combined[t] = min(0.99, s_target + frontier_bonus + cat_bonus)
-
-        return combined
-
-    async def _prune(self, pool: list[str],
-                     scores: dict[str, float]) -> tuple[list[str], int]:
-        """
-        Sort by combined score, keep the top PRUNE_TOP_K, then drop any of
-        those below the raw-cosine floor (frontier members exempt — being
-        one or two links from the target is itself strong evidence).
-        """
-        if not scores:
-            return pool, 0
-
-        ranked = sorted(pool, key=lambda t: -scores.get(t, 0.0))
-        top    = ranked[:PRUNE_TOP_K]
-
-        survivors: list[str] = []
-        for t in top:
-            raw = self._target_cosine.get(t, 0.0)
-            if t in self._frontier or raw >= PRUNE_FLOOR:
-                survivors.append(t)
-            else:
-                self.h_cache[t] = 0.95
-
-        pruned = len(pool) - len(survivors)
-        self.stats.nodes_pruned += pruned
-        print(f"[Prune] {pruned}/{len(pool)} pruned, {len(survivors)} kept")
-        return survivors, pruned
-
-    # ── RUN ───────────────────────────────────────────────────────────────────
-    async def run(self):
-        reset_session_caches()
-
-        async with make_wiki_client() as client:
-
-            # ── 1. Resolve titles ─────────────────────────────────────────
-            await self.send("status", {"message": f"Resolving '{self.start}'..."})
-            start_title = await resolve_article_title(client, self.start)
-            if not start_title:
-                await self.send("error", {"message": f"Cannot find: '{self.start}'"}); return
-
-            await self.send("status", {"message": f"Resolving '{self.end}'..."})
-            end_title = await resolve_article_title(client, self.end)
-            if not end_title:
-                await self.send("error", {"message": f"Cannot find: '{self.end}'"}); return
-
-            await self.send("resolved", {"start": start_title, "end": end_title})
-            self.end = end_title
-
-            # ── 2. Target embedding  ──────────────────────────────────────
-            await self.send("status", {"message": "Embedding target article..."})
-            te = await batch_embed([end_title], self.stats)
-            if te and te[0] is not None and te[0].size:
-                self.target_embedding = te[0]
-                _emb_cache[end_title] = te[0]
-                print(f"[Embed] Target dim={te[0].shape[0]}")
-
-            # ── 3. Target categories + their embeddings ───────────────────
-            await self.send("status", {"message": "Fetching target article categories..."})
-            self.cats_target = await get_target_categories(client, end_title)
-            print(f"[init] Target categories: {self.cats_target[:6]}")
-            if self.cats_target:
-                cat_embs = await batch_embed(self.cats_target, self.stats)
-                self.cat_embeddings = [e for e in cat_embs if e is not None and e.size]
-
-            # ── 4. Pre-seed: target frontier depth-1 ───────────────────────
-            # Backlinks (who links TO the target), not outbound links — see
-            # get_backlinks() docstring for why this direction matters.
-            await self.send("status", {"message": "Pre-loading target backlinks..."})
-            target_nb = await get_backlinks(client, end_title)
-            self._target_neighbours = set(target_nb)
-            for tn in self._target_neighbours:
-                self._frontier[tn] = 1
-            print(f"[init] Target has {len(self._target_neighbours)} backlinks")
-
-            # ── 4b. Bidirectional-style frontier: depth-2 expansion ────────
-            # For a sample of depth-1 bridges, fetch THEIR backlinks too:
-            # X -> A -> target, where A is a depth-1 bridge. Reaching X
-            # guarantees a path through A to the target.
-            await self.send("status", {"message": "Expanding target frontier (depth 2)..."})
-            d2_sample = [t for t in target_nb if not _is_date(t)][:FRONTIER_DEPTH_2_K]
-            d2_results = await asyncio.gather(
-                *[get_backlinks(client, nb_title) for nb_title in d2_sample]
-            )
-            d2_count = 0
-            for nb_links in d2_results:
-                for t in nb_links:
-                    if t not in self._frontier and not _is_date(t):
-                        self._frontier[t] = 2
-                        d2_count += 1
-            print(f"[Frontier] Total: {len(self._frontier)} "
-                  f"(depth-1: {len(self._target_neighbours)}, depth-2: {d2_count})")
-
-            # ── 5. Init search ────────────────────────────────────────────
-            self.g_score[start_title] = 0
-            se = await batch_embed([start_title], self.stats)
-            if se and se[0] is not None and se[0].size and self.target_embedding is not None:
-                h0 = max(0.01, 1.0 - cosine_similarity(se[0], self.target_embedding))
-            else:
-                h0 = 0.9
-            self.h_cache[start_title] = h0
-            heapq.heappush(self.open_heap, (h0, 0, start_title))
-            self.open_set.add(start_title)
-
-            summary = await get_article_summary(client, start_title)
-            await self.send("node_add", {
-                "id": start_title, "g": 0, "h": round(h0,3), "f": round(h0,3),
-                "summary": summary, "state": "open",
-                "is_start": True, "is_end": False,
-            })
-            await self.send("node_add", {
-                "id": end_title, "g": None, "h": 0.0, "f": None,
-                "summary": "", "state": "target",
-                "is_start": False, "is_end": True,
-            })
-
-            step = 0
-
-            # ── 6. Greedy best-first search loop ─────────────────────────
-            while self.open_heap and step < MAX_HOPS * 30:
-
-                while self._paused:
-                    await asyncio.sleep(0.3)
-
-                if not self.open_heap:
-                    break
-                h_curr, g_curr, current = heapq.heappop(self.open_heap)
-                f_curr = g_curr + h_curr  # for display only
-                self.open_set.discard(current)
-
-                if current in self.closed_set:
-                    continue
-
-                step += 1
-                self.stats.nodes_visited += 1
-
-                await self.send("expand_node", {
-                    "id":          current,
-                    "g":           g_curr,
-                    "h":           round(h_curr, 3),
-                    "f":           round(f_curr, 3),
-                    "path_so_far": self.reconstruct_path(current),
-                    "step":        step,
-                    "stats":       self.stats.to_dict(),
-                })
-
-                # Goal check
-                if current.lower() == end_title.lower():
-                    path = self.reconstruct_path(current)
-                    await self.send("found", {
-                        "path": path, "steps": step,
-                        "total_hops": len(path)-1,
-                        "stats": self.stats.to_dict(),
-                    })
-                    return
-
-                self.closed_set.add(current)
-                await self.send("node_state", {"id": current, "state": "closed"})
-
-                # ── Fetch ALL links ───────────────────────────────────────
-                await self.send("status", {"message": f"Fetching links: '{current}'..."})
-                neighbours = await get_all_links(
-                    client, current,
-                    end_title=end_title,
-                    target_neighbours=self._target_neighbours,
-                )
-                print(f"[Search] step {step}: '{current}' → {len(neighbours)} links")
-
-                if not neighbours:
-                    _dead_ends.add(current)
-                    continue
-
-                # Immediate win
-                if end_title in neighbours:
-                    self.came_from[end_title] = current
-                    self.g_score[end_title]   = g_curr + 1
-                    path = self.reconstruct_path(end_title)
-                    print(f"[Search] Direct hit: '{current}' → '{end_title}'")
-                    await self.send("found", {
-                        "path": path, "steps": step,
-                        "total_hops": len(path)-1,
-                        "stats": self.stats.to_dict(),
-                    })
-                    return
-
-                # Filter closed + dead-ends
-                candidates = [
-                    nb for nb in neighbours
-                    if nb not in self.closed_set and nb not in _dead_ends
-                ]
-
-                # ── Embed + score pipeline ────────────────────────────────
-                await self.send("status", {"message": f"Ranking links for '{current}'..."})
-                scores = await self._rank_candidates(candidates)
-
-                # ── Prune ─────────────────────────────────────────────────
-                pool = list(scores.keys())
-                survivors, _ = await self._prune(pool, scores)
-
-                # ── Push to heap ──────────────────────────────────────────
-                new_nodes = []
-                for nb in survivors:
-                    if nb in self.closed_set:
-                        continue
-                    sc      = scores.get(nb, 0.05)
-                    h_nb    = max(0.01, 1.0 - sc)
-                    self.h_cache[nb] = h_nb
-                    tent_g  = g_curr + 1
-                    if tent_g < self.g_score[nb]:
-                        self.came_from[nb] = current
-                        self.g_score[nb]   = tent_g
-                        # Greedy best-first: heap priority = h only (not g+h).
-                        # This commits to the most promising direction without
-                        # penalising depth — Wikipedia paths are short (3-7
-                        # hops) and depth is not a useful cost signal here.
-                        heapq.heappush(self.open_heap, (h_nb, tent_g, nb))
-                        self.open_set.add(nb)
-                        is_end = nb.lower() == end_title.lower()
-                        new_nodes.append({
-                            "id": nb, "g": tent_g,
-                            "h": round(h_nb, 3), "f": round(tent_g + h_nb, 3),
-                            "state": "target" if is_end else "open",
-                            "is_end": is_end, "parent": current,
-                        })
-
-                display_nodes = new_nodes[:TOP_DISPLAY]
-                display_edges = [{"from": current, "to": n["id"]} for n in display_nodes]
-                if display_nodes:
-                    await self.send("neighbours", {
-                        "centre": current,
-                        "nodes":  display_nodes,
-                        "edges":  display_edges,
-                    })
-                    await asyncio.sleep(0.01)
-
-            await self.send("not_found", {
-                "message": f"No path found within {MAX_HOPS} hops.",
-                "visited": list(self.closed_set),
-                "stats":   self.stats.to_dict(),
-            })
-
-
-# ══════════════════════════════════════════════════════════════
-# REST endpoints (autocomplete lives entirely on the frontend now —
-# it calls Wikipedia's opensearch API directly)
-# ══════════════════════════════════════════════════════════════
-
-@app.get("/api/random")
-async def api_random():
-    """
-    Powers the "Random" button on the start screen. Picks two distinct
-    topics from the curated seed list (common_wiki_searches.txt) — NOT a
-    fully random Wikipedia page — so the search always gets a
-    well-connected pair of articles to find a path between.
-    """
-    titles = _load_seed_titles()
-    if len(titles) < 2:
-        return {"start": "Google", "end": "Mohali"}
-    start, end = random.sample(titles, 2)
-    return {"start": start, "end": end}
-
-
-@app.get("/api/health")
-async def api_health():
-    """
-    Polled by the frontend's loading screen on first load. Since FastAPI
-    does not accept connections until the startup handler (which loads the
-    embedding model) finishes, a successful response here already implies
-    the model is ready — there is nothing further to check.
-    """
-    return {"status": "ready"}
-
-
-# ══════════════════════════════════════════════════════════════
-# WebSocket endpoint
-# ══════════════════════════════════════════════════════════════
-
-@app.websocket("/ws")
-async def websocket_endpoint(ws: WebSocket):
-    await ws.accept()
-    navigator: Optional[AStarNavigator] = None
-    try:
-        raw  = await ws.receive_text()
-        data = json.loads(raw)
-        if "control" in data:
-            return
-
-        start = data.get("start", "").strip()
-        end   = data.get("end",   "").strip()
-        print(f"\n{'='*60}\n[WS] '{start}' → '{end}'\n{'='*60}")
-        if not start or not end:
-            await ws.send_text(json.dumps({"event":"error","message":"Need start and end."}))
-            return
-
-        navigator = AStarNavigator(start, end, ws)
-
-        async def listen_controls():
-            while True:
-                try:
-                    msg  = await asyncio.wait_for(ws.receive_text(), timeout=0.5)
-                    ctrl = json.loads(msg)
-                    if navigator:
-                        if ctrl.get("control") == "pause":
-                            navigator._paused = True;  print("[WS] Paused")
-                        elif ctrl.get("control") == "resume":
-                            navigator._paused = False; print("[WS] Resumed")
-                except asyncio.TimeoutError:
-                    pass
-                except Exception:
-                    break
-
-        ctrl_task   = asyncio.create_task(listen_controls())
-        search_task = asyncio.create_task(navigator.run())
-        done, pending = await asyncio.wait(
-            [ctrl_task, search_task], return_when=asyncio.FIRST_COMPLETED
-        )
-        for t in pending:
-            t.cancel()
-
-    except WebSocketDisconnect:
-        print("[WS] disconnected")
-    except Exception as e:
-        print(f"[WS] {e}")
-        try:
-            await ws.send_text(json.dumps({"event":"error","message":str(e)}))
-        except Exception:
-            pass
-
-
-if __name__ == "__main__":
-    import uvicorn
-    print("\n🌐 Aurelius backend → http://localhost:8000")
-    print("   Open index.html in your browser\n")
-    uvicorn.run(app, host="0.0.0.0", port=8000, log_level="warning")

requirements.txt

@@ -3,3 +3,5 @@ uvicorn[standard]>=0.29
 httpx>=0.27
 numpy>=1.26
 sentence-transformers>=3.0
+python-multipart>=0.0.9   # FastAPI file uploads (/api/paper/upload)
+pypdf>=4.0                # PDF text extraction for the citation explorer

server.py

@@ -15,12 +15,15 @@ Endpoints
 """
 
 import asyncio
+import io
 import json
 import os
+import re
 import time
 from collections import defaultdict, deque
 
-from fastapi import FastAPI, Request, WebSocket, WebSocketDisconnect, Query
+from fastapi import (FastAPI, Request, WebSocket, WebSocketDisconnect, Query,
+                     UploadFile, File)
 from fastapi.middleware.cors import CORSMiddleware
 from starlette.middleware.base import BaseHTTPMiddleware
 
@@ -43,7 +46,7 @@ app = FastAPI(docs_url=None, redoc_url=None, openapi_url=None)
 app.add_middleware(
     CORSMiddleware,
     allow_origins=ALLOWED_ORIGINS,
-    allow_methods=["GET"],
+    allow_methods=["GET", "POST"],   # POST for the PDF citation upload
     allow_headers=["*"],
 )
 
@@ -244,6 +247,27 @@ async def api_neighbors(request_source: str = Query("wikipedia", alias="source")
             "neighbors": out}
 
 
+@app.get("/api/suggest")
+async def api_suggest(request_source: str = Query("wikipedia", alias="source"),
+                      q: str = Query(...), limit: int = Query(8)):
+    """Domain-aware type-ahead. Each source suggests from its OWN
+    vocabulary (companies/tickers for finance, papers for research,
+    diseases/genes for biology, articles for Wikipedia) instead of the
+    old hardcoded Wikipedia opensearch. Never errors the UI — returns an
+    empty list on any failure."""
+    src = _resolve_source(request_source)
+    if src is None:
+        return {"error": f"Unknown source '{request_source}'"}
+    if len(q) > MAX_QUERY_LEN:
+        return {"error": "Query too long."}
+    try:
+        items = await src.suggest(q.strip(), limit=max(1, min(limit, 15)))
+    except Exception as e:
+        print(f"[suggest] {src.name}: {e}")
+        items = []
+    return {"source": src.name, "suggestions": items}
+
+
 @app.get("/api/node")
 async def api_node(request_source: str = Query("wikipedia", alias="source"),
                    q: str = Query(...)):
@@ -312,6 +336,111 @@ def _compute_exposure(src, ref, k: int) -> list[dict]:
     return exposed
 
 
+def _fin_card(store, node_id: str) -> dict:
+    """Compact facts for a related finance node — enough to render a row
+    (name, ticker, kind, sector, last price, window change)."""
+    node = store.get_node("finance", node_id) or {}
+    f = node.get("features") or {}
+    return {
+        "id": node_id,
+        "title": node.get("title", node_id),
+        "kind": f.get("kind"),
+        "sector": f.get("sector"),
+        "last_price": f.get("last_price"),
+        "change_pct": f.get("window_change_pct"),
+    }
+
+
+@app.get("/api/company")
+async def api_company(q: str = Query(...),
+                      request_source: str = Query("finance", alias="source")):
+    """One company's full research profile, aggregated from the finance
+    graph in a single call: price series + key facts, and every typed
+    relationship grouped into the sections a researcher actually wants —
+    peers, supply chain, correlations, ownership, leadership. The graph
+    becomes a secondary explorer; THIS is the primary finance surface."""
+    src = _resolve_source(request_source)
+    if src is None or getattr(src, "ingested", None) is None:
+        return {"error": "Company profiles need an ingested finance source."}
+    if not src.ingested():
+        return {"error": "Finance data has not been ingested yet."}
+    if len(q) > MAX_QUERY_LEN:
+        return {"error": "Query too long."}
+    ref = await src.resolve(q)
+    if not ref:
+        return {"error": f"Cannot find: '{q}'"}
+    store = src.store
+    node = store.get_node("finance", ref.id) or {}
+    feats = node.get("features") or {}
+
+    # group the node's typed edges into researcher-facing buckets
+    buckets: dict[str, list[tuple[str, float]]] = {
+        "competes_with": [], "supplied_by": [], "supplies": [],
+        "co_moves": [], "macro_correlates": [], "held_by": [],
+        "stake_held_by": [],
+    }
+    ceo_id = country_id = sector_id = None
+    for dst, typ, w in store.neighbors("finance", ref.id):
+        if typ in buckets:
+            buckets[typ].append((dst, w))
+        elif typ == "led_by":
+            ceo_id = dst
+        elif typ == "based_in":
+            country_id = dst
+        elif typ == "sector_member":
+            sector_id = dst
+
+    def cards(items, with_corr=False, limit=12):
+        items = sorted(items, key=lambda kv: -kv[1])[:limit]
+        out = []
+        for did, w in items:
+            c = _fin_card(store, did)
+            if with_corr:
+                c["corr"] = round(w, 2)
+            out.append(c)
+        return out
+
+    # peers: direct rivals first, then same-sector members
+    peers = [d for d, _ in buckets["competes_with"]]
+    seen = set(peers) | {ref.id}
+    if sector_id:
+        for d, typ, _w in store.neighbors("finance", sector_id):
+            if typ == "has_member" and d not in seen:
+                peers.append(d); seen.add(d)
+    peer_cards = [_fin_card(store, p) for p in peers[:10]]
+
+    ceo = None
+    if ceo_id:
+        cnode = store.get_node("finance", ceo_id) or {}
+        ceo = {"id": ceo_id, "title": cnode.get("title", ceo_id),
+               "summary": cnode.get("summary", "")}
+    country = None
+    if country_id:
+        country = (store.get_node("finance", country_id) or {}).get(
+            "title", country_id).replace(" (Sector)", "")
+
+    return {
+        "id": ref.id,
+        "title": node.get("title", ref.id),
+        "kind": feats.get("kind"),
+        "sector": feats.get("sector"),
+        "summary": node.get("summary", ""),
+        "last_price": feats.get("last_price"),
+        "change_pct": feats.get("window_change_pct"),
+        "series": feats.get("series"),
+        "series_days": feats.get("series_days"),
+        "ceo": ceo,
+        "country": country,
+        "peers": peer_cards,
+        "suppliers": cards(buckets["supplied_by"]),
+        "customers": cards(buckets["supplies"]),
+        "correlated": cards(buckets["co_moves"], with_corr=True),
+        "macro": cards(buckets["macro_correlates"], with_corr=True),
+        "etfs": cards(buckets["held_by"]),
+        "investors": cards(buckets["stake_held_by"]),
+    }
+
+
 @app.get("/api/exposure")
 async def api_exposure(request_source: str = Query("finance", alias="source"),
                        q: str = Query(...), k: int = Query(10)):
@@ -333,6 +462,134 @@ async def api_exposure(request_source: str = Query("finance", alias="source"),
             "exposed": _compute_exposure(src, ref, k)}
 
 
+@app.get("/api/paper")
+async def api_paper(q: str = Query(...),
+                    request_source: str = Query("openalex", alias="source"),
+                    refs: int = Query(25), cites: int = Query(25)):
+    """A paper's citation dossier: its metadata plus the works it CITES
+    (references) and the works that CITE it (citations), each with authors,
+    year, venue and citation count — the seed for the citation explorer.
+    Replaces the old connect-two-papers pathfinding as the primary research
+    surface."""
+    src = _resolve_source(request_source)
+    if src is None:
+        return {"error": f"Unknown source '{request_source}'"}
+    if len(q) > MAX_QUERY_LEN:
+        return {"error": "Query too long."}
+    ref = await src.resolve(q)
+    if not ref:
+        return {"error": f"Couldn't find a paper matching '{q}'."}
+    return await _paper_payload(src, ref, refs, cites)
+
+
+async def _paper_payload(src, ref, refs: int, cites: int) -> dict:
+    info = await src.node_info(ref, rich=True)
+
+    def _card(nref, feats):
+        f = feats or {}
+        return {"id": nref.id, "title": nref.title,
+                "year": f.get("year") or None,
+                "authors": f.get("authors") or [],
+                "venue": f.get("venue") or "",
+                "cited_by_count": f.get("cited_by_count") or 0}
+
+    try:
+        out_edges = await src.neighbors(ref)
+    except Exception:
+        out_edges = []
+    in_edges = []
+    if src.supports_backlinks:
+        try:
+            in_edges = await src.back_neighbors(ref, limit=cites * 2)
+        except Exception:
+            in_edges = []
+
+    ref_nodes = [e.dst for e in out_edges][:max(1, min(refs, 60))]
+    cite_nodes = [e.src for e in in_edges][:max(1, min(cites, 60))]
+    ref_infos = await src.node_infos(ref_nodes) if ref_nodes else []
+    cite_infos = await src.node_infos(cite_nodes) if cite_nodes else []
+
+    references = [_card(n, i.features) for n, i in zip(ref_nodes, ref_infos)]
+    citations = [_card(n, i.features) for n, i in zip(cite_nodes, cite_infos)]
+    citations.sort(key=lambda c: -c["cited_by_count"])   # influential first
+
+    f = info.features or {}
+    return {
+        "source": src.name,
+        "id": ref.id, "title": ref.title,
+        "year": f.get("year") or None,
+        "authors": f.get("authors") or [],
+        "venue": f.get("venue") or "",
+        "cited_by_count": f.get("cited_by_count") or 0,
+        "abstract": info.summary or "",
+        "references": references,
+        "citations": citations,
+        "n_references": len(references),
+        "n_citations": len(citations),
+    }
+
+
+_PDF_DOI_RE   = re.compile(r"\b(10\.\d{4,9}/[-._;()/:a-z0-9]+)", re.IGNORECASE)
+_PDF_ARXIV_RE = re.compile(r"arXiv:\s*(\d{4}\.\d{4,5})", re.IGNORECASE)
+
+
+def _pdf_locator(data: bytes) -> str | None:
+    """Pull a resolvable identifier out of an uploaded PDF: a DOI or arXiv
+    id from the first few pages (where they almost always sit), else the
+    title guessed from the largest first-page line. OpenAlex resolves any
+    of these."""
+    try:
+        from pypdf import PdfReader
+        reader = PdfReader(io.BytesIO(data))
+        text = ""
+        for page in reader.pages[:3]:
+            text += "\n" + (page.extract_text() or "")
+    except Exception as e:
+        print(f"[paper] pdf parse failed: {e}")
+        return None
+    m = _PDF_DOI_RE.search(text)
+    if m:
+        return m.group(1).rstrip(".,;)")
+    m = _PDF_ARXIV_RE.search(text)
+    if m:
+        return f"arXiv:{m.group(1)}"
+    # Fallback: the first substantial line is usually the title.
+    for line in text.splitlines():
+        s = line.strip()
+        if len(s) >= 20 and any(ch.isalpha() for ch in s):
+            return s[:MAX_QUERY_LEN]
+    return None
+
+
+@app.post("/api/paper/upload")
+async def api_paper_upload(request: Request,
+                           file: UploadFile = File(...),
+                           request_source: str = Query("openalex", alias="source")):
+    """Resolve a paper from an uploaded PDF: extract its DOI / arXiv id /
+    title, then return the same citation dossier as /api/paper. Rate-limited
+    and size-capped like the other write-ish endpoints."""
+    ip = request.client.host if request.client else "unknown"
+    if not _rate_ok(ip):
+        return {"error": "Rate limit reached — slow down a moment."}
+    src = _resolve_source(request_source)
+    if src is None:
+        return {"error": f"Unknown source '{request_source}'"}
+    data = await file.read()
+    if not data:
+        return {"error": "Empty file."}
+    if len(data) > 15 * 1024 * 1024:
+        return {"error": "PDF too large (15 MB max)."}
+    locator = _pdf_locator(data)
+    if not locator:
+        return {"error": "Couldn't find a DOI, arXiv id or title in that PDF."}
+    ref = await src.resolve(locator)
+    if not ref:
+        return {"error": f"Found “{locator[:60]}” in the PDF but couldn't match a paper."}
+    payload = await _paper_payload(src, ref, 25, 25)
+    payload["matched_via"] = locator[:80]
+    return payload
+
+
 @app.get("/api/relate")
 async def api_relate(request_source: str = Query("wikipedia", alias="source"),
                      a: str = Query(...), b: str = Query(...)):

styles.css

@@ -833,10 +833,14 @@ body::before {
   background: var(--bg);
 }
 
-svg#graph {
+#graph-canvas {
+  position: absolute;
+  inset: 0;
   width: 100%;
   height: 100%;
+  z-index: 1;
 }
+#graph-canvas canvas { display: block; }
 
 /* ─── Tooltip ─── */
 #tooltip {
@@ -1167,8 +1171,40 @@ svg#graph {
 }
 
 .ac-item .ac-icon {
-  opacity: 0.38;
+  opacity: 0.42;
   flex-shrink: 0;
+  margin-top: 1px;
+  align-self: flex-start;
+}
+
+.ac-item .ac-text {
+  display: flex;
+  flex-direction: column;
+  gap: 1px;
+  min-width: 0;
+  flex: 1;
+}
+
+.ac-item .ac-title {
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.ac-item .ac-sub {
+  font-size: 11px;
+  font-weight: 400;
+  color: var(--text2);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  text-transform: capitalize;
+}
+
+.ac-item:hover .ac-sub,
+.ac-item.ac-active .ac-sub {
+  color: var(--accent2);
+  opacity: 0.75;
 }
 
 .input-wrap {
@@ -2470,34 +2506,6 @@ svg#graph {
   to   { transform: translate3d(-40px, -30px, 0) rotate(6deg); }
 }
 
-#graph3d {
-  position: absolute;
-  inset: 0;
-  z-index: 1;
-  display: none;
-}
-#graph3d canvas { display: block; }
-
-/* 3D node hover tooltip (injected by 3d-force-graph nodeLabel HTML) */
-.gv-tip {
-  font-family: 'Outfit', sans-serif;
-  font-size: 12px;
-  font-weight: 600;
-  color: var(--text);
-  background: rgba(13, 12, 8, 0.9);
-  border: 1px solid rgba(201, 138, 46, 0.4);
-  border-radius: 6px;
-  padding: 5px 9px;
-  box-shadow: 0 4px 18px rgba(0, 0, 0, 0.5);
-}
-.gv-tip span {
-  display: block;
-  font-family: 'DM Mono', monospace;
-  font-size: 10px;
-  color: var(--accent2);
-  margin-top: 2px;
-}
-
 /* ─── Source picker ─── */
 .source-picker {
   font-family: 'Outfit', sans-serif;
@@ -2797,6 +2805,29 @@ svg#graph {
   transform: translateY(-1px);
 }
 
+/* Finance landing CTA — the primary "research a company" action */
+.hero-research-cta {
+  display: inline-flex;
+  align-items: center;
+  gap: 9px;
+  font-family: 'Outfit', sans-serif;
+  font-size: 14px;
+  font-weight: 600;
+  color: #1a1206;
+  background: var(--accent);
+  border: 1px solid var(--accent);
+  border-radius: 999px;
+  padding: 9px 20px;
+  cursor: pointer;
+  box-shadow: 0 6px 20px rgba(201, 138, 46, 0.25);
+  transition: filter 0.15s, transform 0.15s, box-shadow 0.15s;
+  flex-basis: 100%;
+  justify-content: center;
+  max-width: 260px;
+}
+.hero-research-cta svg { width: 18px; height: 18px; }
+.hero-research-cta:hover { filter: brightness(1.07); transform: translateY(-1px); box-shadow: 0 8px 26px rgba(201, 138, 46, 0.35); }
+
 /* ── Compare panel + FAB ───────────────────────────────────────────────── */
 #compare-fab {
   position: absolute;
@@ -2952,6 +2983,213 @@ svg#graph {
 .ovl-item-title { font-size: 12.5px; color: var(--text); line-height: 1.4; }
 .ovl-item-meta { font-size: 10.5px; color: var(--text2); }
 
+/* ══════════════════════════════════════════════════════════
+   COMPANY PROFILE — primary finance research surface
+══════════════════════════════════════════════════════════ */
+#profile-fab, #paper-fab {
+  position: absolute;
+  bottom: 20px;
+  left: 82px;
+  z-index: 13;
+  height: 50px;
+  padding: 0 18px 0 15px;
+  border-radius: 25px;
+  border: 1px solid rgba(201, 138, 46, 0.45);
+  background: rgba(20, 18, 12, 0.85);
+  color: var(--accent2);
+  cursor: pointer;
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  font-family: 'Outfit', sans-serif;
+  font-size: 13.5px;
+  font-weight: 600;
+  letter-spacing: 0.2px;
+  backdrop-filter: blur(10px);
+  -webkit-backdrop-filter: blur(10px);
+  box-shadow: 0 6px 20px rgba(0, 0, 0, 0.4);
+  transition: transform 0.18s, background 0.18s, box-shadow 0.18s;
+}
+#profile-fab svg, #paper-fab svg { width: 20px; height: 20px; }
+#profile-fab:hover, #paper-fab:hover { transform: translateY(-2px); background: rgba(28, 24, 15, 0.94); box-shadow: 0 8px 26px rgba(0, 0, 0, 0.5); }
+#profile-fab.hidden, #paper-fab.hidden { opacity: 0; pointer-events: none; transform: scale(0.8); }
+
+#profile-panel, #paper-panel {
+  position: absolute;
+  top: 16px;
+  left: 16px;
+  bottom: 16px;
+  z-index: 15;
+  width: 420px;
+  max-width: calc(100% - 32px);
+  display: flex;
+  flex-direction: column;
+  background: rgba(15, 14, 10, 0.94);
+  border: 1px solid var(--border);
+  border-radius: 16px;
+  backdrop-filter: blur(18px);
+  -webkit-backdrop-filter: blur(18px);
+  box-shadow: 0 16px 50px rgba(0, 0, 0, 0.55);
+  opacity: 0;
+  transform: translateX(-16px) scale(0.99);
+  pointer-events: none;
+  transition: opacity 0.24s, transform 0.24s;
+  overflow: hidden;
+}
+#profile-panel.open, #paper-panel.open { opacity: 1; transform: none; pointer-events: auto; }
+#paper-body { overflow-y: auto; padding: 16px 16px 22px; flex: 1; }
+
+/* Citation explorer specifics */
+.paper-byline { font-size: 12.5px; color: var(--text2); margin-top: 8px; line-height: 1.5; }
+.paper-abstract { margin-top: 12px; max-height: 120px; overflow-y: auto; }
+.paper-stats { display: flex; gap: 16px; margin-top: 12px; flex-wrap: wrap; }
+.paper-stat { font-size: 12px; color: var(--text2); }
+.paper-stat b { color: var(--text); font-size: 14px; font-weight: 700; }
+.paper-list { display: flex; flex-direction: column; gap: 4px; }
+.paper-item {
+  display: flex; align-items: center; gap: 10px; text-align: left;
+  background: rgba(255, 255, 255, 0.03); border: 1px solid var(--border);
+  border-radius: 9px; padding: 9px 11px; cursor: pointer;
+  transition: background 0.14s, border-color 0.14s, transform 0.14s;
+}
+.paper-item:hover { background: rgba(201, 138, 46, 0.08); border-color: rgba(201, 138, 46, 0.35); transform: translateY(-1px); }
+.paper-item-main { display: flex; flex-direction: column; gap: 2px; min-width: 0; flex: 1; }
+.paper-item-title { font-size: 12.5px; font-weight: 600; color: var(--text); line-height: 1.35;
+  display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; overflow: hidden; }
+.paper-item-meta { font-size: 10.5px; color: var(--text2); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+.paper-cb { font-family: 'DM Mono', monospace; font-size: 11px; color: var(--accent2);
+  background: rgba(201, 138, 46, 0.1); border-radius: 5px; padding: 3px 7px; flex-shrink: 0; }
+.paper-drop {
+  display: inline-flex; align-items: center; gap: 8px; margin-top: 16px;
+  padding: 10px 16px; border-radius: 10px; cursor: pointer;
+  border: 1px dashed rgba(201, 138, 46, 0.4); color: var(--text2);
+  font-size: 12.5px; transition: border-color 0.15s, background 0.15s, color 0.15s;
+}
+.paper-drop:hover { border-color: rgba(201, 138, 46, 0.7); color: var(--accent2); background: rgba(201, 138, 46, 0.06); }
+.paper-drop svg { width: 17px; height: 17px; }
+#paper-panel.drag-over { border-color: var(--accent); box-shadow: 0 0 0 2px rgba(201, 138, 46, 0.4), 0 16px 50px rgba(0, 0, 0, 0.55); }
+#paper-panel.drag-over .paper-drop { border-color: var(--accent); color: var(--accent2); background: rgba(201, 138, 46, 0.1); }
+
+.prof-head {
+  display: flex; align-items: center; gap: 10px;
+  padding: 12px 12px 12px 14px;
+  border-bottom: 1px solid var(--border);
+  flex-shrink: 0;
+}
+.prof-input-row { position: relative; flex: 1; display: flex; align-items: center; }
+.prof-search-ic { position: absolute; left: 11px; width: 15px; height: 15px; color: var(--text2); pointer-events: none; }
+#profile-input {
+  flex: 1; width: 100%;
+  background: rgba(255, 255, 255, 0.04);
+  border: 1px solid var(--border-bright);
+  border-radius: 9px;
+  color: var(--text);
+  font-family: 'Outfit', sans-serif;
+  font-size: 13.5px;
+  padding: 9px 62px 9px 34px;
+  outline: none;
+  transition: border-color 0.16s;
+}
+#profile-input:focus { border-color: rgba(201, 138, 46, 0.55); }
+#profile-run {
+  position: absolute; right: 5px;
+  background: var(--accent); color: #1a1206;
+  border: none; border-radius: 7px;
+  font-family: 'Outfit', sans-serif; font-weight: 700; font-size: 12px;
+  padding: 6px 12px; cursor: pointer;
+  transition: filter 0.16s;
+}
+#profile-run:hover { filter: brightness(1.08); }
+.prof-close { background: none; border: none; color: var(--text2); cursor: pointer; width: 20px; height: 20px; padding: 0; flex-shrink: 0; }
+.prof-close svg { width: 15px; height: 15px; }
+
+#profile-body { overflow-y: auto; padding: 16px 16px 22px; flex: 1; }
+
+.prof-empty { text-align: center; padding: 34px 20px; color: var(--text2); }
+.prof-empty svg { width: 46px; height: 46px; color: rgba(201, 138, 46, 0.5); margin-bottom: 14px; }
+.prof-empty p { font-size: 13px; line-height: 1.6; max-width: 300px; margin: 0 auto 16px; }
+.prof-empty-chips { display: flex; flex-wrap: wrap; gap: 7px; justify-content: center; }
+.prof-chip {
+  background: rgba(201, 138, 46, 0.1); border: 1px solid rgba(201, 138, 46, 0.32);
+  color: var(--accent2); border-radius: 20px; padding: 5px 13px;
+  font-family: 'DM Mono', monospace; font-size: 12px; cursor: pointer;
+  transition: background 0.15s, transform 0.15s;
+}
+.prof-chip:hover { background: rgba(201, 138, 46, 0.2); transform: translateY(-1px); }
+
+.prof-loading, .prof-msg { color: var(--text2); font-size: 13px; padding: 24px 8px; text-align: center; line-height: 1.5; }
+.prof-msg.small { padding: 12px 4px; font-size: 12px; text-align: left; }
+.prof-loading { display: flex; align-items: center; justify-content: center; gap: 10px; }
+.prof-spinner {
+  width: 15px; height: 15px; border-radius: 50%;
+  border: 2px solid rgba(201, 138, 46, 0.25); border-top-color: var(--accent);
+  display: inline-block; animation: prof-spin 0.8s linear infinite;
+}
+@keyframes prof-spin { to { transform: rotate(360deg); } }
+
+.prof-title-row { display: flex; align-items: flex-start; gap: 10px; justify-content: space-between; }
+.prof-title { font-family: 'Outfit', sans-serif; font-size: 20px; font-weight: 700; color: var(--text); line-height: 1.2; margin: 0; }
+.prof-kind {
+  font-size: 10px; font-weight: 700; text-transform: uppercase; letter-spacing: 0.6px;
+  color: var(--accent2); background: rgba(201, 138, 46, 0.12);
+  border: 1px solid rgba(201, 138, 46, 0.3); border-radius: 5px; padding: 3px 7px;
+  flex-shrink: 0; margin-top: 3px;
+}
+.prof-price { font-family: 'Outfit', sans-serif; font-size: 24px; font-weight: 700; color: var(--text); margin-top: 10px; display: flex; align-items: baseline; gap: 10px; flex-wrap: wrap; }
+.prof-price-note { font-size: 11px; font-weight: 400; color: var(--text2); }
+.prof-chg { font-size: 14px; font-weight: 700; }
+.prof-chg.up { color: #4aab79; }
+.prof-chg.down { color: #d66a6a; }
+
+.prof-facts { display: flex; flex-wrap: wrap; gap: 8px; margin-top: 14px; }
+.prof-fact {
+  display: flex; flex-direction: column; gap: 2px;
+  background: rgba(255, 255, 255, 0.03); border: 1px solid var(--border);
+  border-radius: 8px; padding: 7px 11px; font-size: 12.5px; color: var(--text);
+}
+.prof-fact i { font-style: normal; font-size: 10px; text-transform: uppercase; letter-spacing: 0.4px; color: var(--text2); }
+.prof-summary { font-size: 12.5px; color: var(--text2); line-height: 1.6; margin-top: 13px; }
+
+.prof-chart-wrap { margin-top: 16px; background: rgba(255,255,255,0.02); border: 1px solid var(--border); border-radius: 10px; padding: 10px; }
+.prof-chart { width: 100%; height: 130px; display: block; }
+
+.prof-section { margin-top: 20px; }
+.prof-sec-head { font-size: 13px; font-weight: 700; color: var(--text); display: flex; align-items: baseline; gap: 8px; margin-bottom: 9px; }
+.prof-sec-hint { font-size: 10.5px; font-weight: 400; color: var(--text2); text-transform: uppercase; letter-spacing: 0.4px; }
+.prof-cards { display: flex; flex-wrap: wrap; gap: 7px; }
+.prof-card {
+  display: flex; flex-direction: column; gap: 2px; align-items: flex-start;
+  background: rgba(255, 255, 255, 0.03); border: 1px solid var(--border);
+  border-radius: 9px; padding: 8px 11px; cursor: pointer; text-align: left;
+  transition: background 0.14s, border-color 0.14s, transform 0.14s;
+  max-width: 100%;
+}
+.prof-card:hover { background: rgba(201, 138, 46, 0.08); border-color: rgba(201, 138, 46, 0.35); transform: translateY(-1px); }
+.prof-card-name { font-size: 12.5px; font-weight: 600; color: var(--text); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; max-width: 220px; }
+.prof-card-meta { font-size: 10.5px; color: var(--text2); display: flex; gap: 6px; align-items: center; }
+
+.prof-news { margin-top: 22px; }
+.prof-news-body { display: flex; flex-direction: column; gap: 2px; margin-top: 4px; }
+.prof-news-item { display: flex; gap: 9px; align-items: flex-start; padding: 8px 9px; border-radius: 8px; text-decoration: none; transition: background 0.14s; }
+.prof-news-item:hover { background: rgba(255, 255, 255, 0.04); }
+.prof-news-dot { width: 8px; height: 8px; border-radius: 50%; margin-top: 5px; flex-shrink: 0; background: #9a916f; }
+.prof-news-dot.prof-positive { background: #5cd6a0; }
+.prof-news-dot.prof-negative { background: #e0736a; }
+.prof-news-txt { display: flex; flex-direction: column; gap: 2px; min-width: 0; }
+.prof-news-title { font-size: 12.5px; color: var(--text); line-height: 1.4; }
+.prof-news-src { font-size: 10.5px; color: var(--text2); }
+
+.prof-actions { display: flex; gap: 9px; margin-top: 22px; }
+.prof-act {
+  flex: 1; padding: 10px; border-radius: 9px; cursor: pointer;
+  font-family: 'Outfit', sans-serif; font-size: 12.5px; font-weight: 600;
+  background: rgba(255, 255, 255, 0.04); border: 1px solid var(--border-bright); color: var(--text);
+  transition: background 0.15s, transform 0.15s;
+}
+.prof-act:hover { background: rgba(255, 255, 255, 0.08); transform: translateY(-1px); }
+.prof-act.primary { background: var(--accent); border-color: var(--accent); color: #1a1206; font-weight: 700; }
+.prof-act.primary:hover { filter: brightness(1.08); }
+
 @media (max-width: 560px) {
   #discover-panel { width: calc(100% - 24px); top: 12px; right: 12px; }
   #discover-fab { width: 44px; height: 44px; bottom: 14px; right: 14px; }
@@ -2959,6 +3197,8 @@ svg#graph {
   .gc-btn { font-size: 11px; padding: 4px 8px; }
   #compare-panel { width: calc(100% - 24px); left: 12px; bottom: 12px; }
   #compare-fab { width: 44px; height: 44px; bottom: 14px; left: 14px; }
+  #profile-fab, #paper-fab { bottom: 14px; left: 68px; height: 44px; font-size: 12.5px; }
+  #profile-panel, #paper-panel { width: calc(100% - 24px); top: 12px; left: 12px; bottom: 12px; }
   #overlay-drawer { width: 100%; max-height: 50%; border-top-left-radius: 14px; border-top-right-radius: 14px; }
   #hero-examples { gap: 6px; }
   .hero-ex-chip { font-size: 11.5px; padding: 4px 10px; }

vercel.json

@@ -6,7 +6,7 @@
       "headers": [
         {
           "key": "Content-Security-Policy",
-          "value": "default-src 'self'; script-src 'self' 'unsafe-inline' https://cdnjs.cloudflare.com https://cdn.jsdelivr.net; style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; font-src https://fonts.gstatic.com; img-src 'self' data:; connect-src 'self' https://mvali77-aurelius.hf.space wss://mvali77-aurelius.hf.space https://en.wikipedia.org; worker-src 'self' blob:; frame-ancestors 'none'; base-uri 'self'; form-action 'self'; object-src 'none'"
+          "value": "default-src 'self'; script-src 'self' 'unsafe-inline' https://cdnjs.cloudflare.com; style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; font-src https://fonts.gstatic.com; img-src 'self' data:; connect-src 'self' https://mvali77-aurelius.hf.space wss://mvali77-aurelius.hf.space; frame-ancestors 'none'; base-uri 'self'; form-action 'self'; object-src 'none'"
         },
         { "key": "X-Content-Type-Options", "value": "nosniff" },
         { "key": "X-Frame-Options", "value": "DENY" },