updating backend for larger corpus

.dockerignore

@@ -0,0 +1,8 @@
+# .dockerignore
+backend/.venv
+backend/data
+frontend/node_modules
+frontend/dist
+.git
+.gitignore
+*.md

.gitignore

@@ -1,2 +1,11 @@
-
+# .gitignore
+backend/.venv/
+backend/data/
+backend/__pycache__/
+backend/**/__pycache__/
+backend/annotations_cache.sqlite
+frontend/node_modules/
+frontend/dist/
+.env
+*.pyc
 .DS_Store

Dockerfile

@@ -0,0 +1,28 @@
+FROM node:20-slim AS fe
+WORKDIR /fe
+COPY frontend/package*.json ./
+RUN npm ci
+COPY frontend/ ./
+RUN npm run build
+
+FROM python:3.11-slim
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
+WORKDIR /app
+
+COPY backend/pyproject.toml backend/uv.lock* ./backend/
+WORKDIR /app/backend
+RUN uv sync --no-dev || uv sync --no-dev --no-install-project
+RUN uv run python -m spacy download en_core_web_sm
+
+COPY backend/ /app/backend/
+COPY --from=fe /fe/dist /app/frontend/dist
+
+ENV PATHFINDER_STATIC_DIR=/app/frontend/dist \
+    ASTROPARSE_CORPUS_DIR=/data/corpus \
+    ASTROPARSE_FAISS_PATH=/data/astroparse_fp16.faiss \
+    HF_HOME=/data/hf_cache
+
+RUN mkdir -p /data && chmod 777 /data
+
+EXPOSE 7860
+CMD ["uv", "run", "--no-sync", "uvicorn", "astroparse_api.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -3,9 +3,8 @@ title: Pathfinder
 emoji: 🔎
 colorFrom: yellow
 colorTo: blue
-sdk: gradio
-sdk_version: 4.40.0
-app_file: app_gradio.py
+sdk: docker
+app_port: 7860
 pinned: true
 license: mit
 ---

backend/.env.example

@@ -0,0 +1,5 @@
+# backend/.env.example
+OPENAI_API_KEY=sk-...
+GITHUB_TOKEN=ghp_...
+GIST_ID=...
+PATHFINDER_CORPUS_REPO=kiyer/beacon_corpus

backend/astroparse_api/bootstrap.py

@@ -0,0 +1,28 @@
+# backend/astroparse_api/bootstrap.py — unchanged from Beacon, corpus pull is identical
+from __future__ import annotations
+
+import shutil
+import tempfile
+from pathlib import Path
+
+from huggingface_hub import snapshot_download  # noqa: F401 — re-exported so tests can patch
+
+
+def ensure_corpus(corpus_dir: Path, faiss_path: Path, repo_id: str) -> None:
+    if corpus_dir.is_dir() and faiss_path.is_file():
+        return
+
+    import astroparse_api.bootstrap as _self
+    _snapshot_download = _self.snapshot_download
+
+    with tempfile.TemporaryDirectory() as staging:
+        staging_path = Path(staging)
+        _snapshot_download(repo_id=repo_id, repo_type="dataset", local_dir=staging_path)
+
+        src_faiss = staging_path / "astroparse_fp16.faiss"
+        faiss_path.parent.mkdir(parents=True, exist_ok=True)
+        shutil.move(str(src_faiss), str(faiss_path))
+
+        src_corpus = staging_path / "corpus"
+        corpus_dir.parent.mkdir(parents=True, exist_ok=True)
+        shutil.move(str(src_corpus), str(corpus_dir))

backend/astroparse_api/jobs.py

@@ -0,0 +1,28 @@
+# backend/astroparse_api/jobs.py
+import asyncio
+import uuid
+from dataclasses import dataclass, field
+
+@dataclass
+class Job:
+    id: str = field(default_factory=lambda: uuid.uuid4().hex)
+    queue: asyncio.Queue = field(default_factory=asyncio.Queue)
+    done: bool = False
+
+class JobRegistry:
+    def __init__(self):
+        self._jobs: dict[str, Job] = {}
+
+    def create(self) -> Job:
+        job = Job()
+        self._jobs[job.id] = job
+        return job
+
+    def get(self, job_id: str) -> Job | None:
+        return self._jobs.get(job_id)
+
+async def emit(job: Job, event: str, data: dict):
+    await job.queue.put({"event": event, "data": data})
+    if event in ("result", "error", "blocked"):
+        job.done = True
+        await job.queue.put(None)

backend/astroparse_api/main.py

@@ -0,0 +1,141 @@
+# backend/astroparse_api/main.py
+import asyncio
+import json
+import os
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+from dotenv import load_dotenv
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel
+from sse_starlette.sse import EventSourceResponse
+
+from .bootstrap import ensure_corpus
+from .jobs import Job, JobRegistry, emit
+from .retrieve import Corpus
+from .search import check_moderation, log_query_to_gist, search_corpus, synthesize_answer, score_consensus
+
+load_dotenv(Path(__file__).resolve().parent.parent / ".env")
+
+_DEFAULT_DATA_DIR = Path(__file__).resolve().parent.parent / "data"
+_REPO_ROOT = Path(__file__).resolve().parent.parent.parent
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    if os.environ.get("ASTROPARSE_SKIP_CORPUS") != "1":
+        corpus_dir = Path(os.environ.get("ASTROPARSE_CORPUS_DIR", str(_DEFAULT_DATA_DIR / "corpus")))
+        faiss_path = Path(os.environ.get("ASTROPARSE_FAISS_PATH", str(_DEFAULT_DATA_DIR / "astroparse_fp16.faiss")))
+        corpus_repo = os.environ.get("PATHFINDER_CORPUS_REPO", "kiyer/beacon_corpus")
+        await asyncio.to_thread(ensure_corpus, corpus_dir, faiss_path, corpus_repo)
+        await asyncio.to_thread(get_corpus)
+    yield
+
+
+app = FastAPI(lifespan=lifespan)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[os.environ.get("PATHFINDER_DEV_ORIGIN", "http://localhost:5173")],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+registry = JobRegistry()
+_corpus: Corpus | None = None
+_umap_cache: list | None = None
+
+
+def get_corpus() -> Corpus:
+    global _corpus
+    if _corpus is None:
+        _corpus = Corpus.load()
+    return _corpus
+
+
+class SearchRequest(BaseModel):
+    query: str
+    top_k: int = 10
+    pool: int = 1000
+    answer_style: str = "Multi-paper"
+
+
+async def run_search_pipeline(job: Job, req: SearchRequest):
+    try:
+        async def stage(name, status, log=None):
+            await emit(job, "stage", {"name": name, "status": status, "log": log})
+
+        key = os.environ.get("OPENAI_API_KEY", "")
+
+        flagged = await asyncio.to_thread(check_moderation, req.query, key)
+        asyncio.create_task(log_query_to_gist(req.query, flagged))
+        if flagged:
+            await emit(job, "blocked", {
+                "message": "This query was flagged by content moderation. Try rephrasing your question."
+            })
+            return
+
+        await stage("intent", "active")
+        await stage("intent", "done", f"{req.answer_style.lower()} synthesis")
+
+        await stage("search", "active")
+        corpus = await asyncio.to_thread(get_corpus)
+        papers, abstracts = await asyncio.to_thread(
+            search_corpus, corpus, req.query, req.top_k, req.pool, key
+        )
+        await emit(job, "papers", {"papers": [p.model_dump() for p in papers]})
+        await stage("search", "done", f"{len(papers)} papers retrieved")
+
+        await stage("consensus", "active")
+        consensus = await score_consensus(req.query, abstracts, key)
+        await emit(job, "consensus", consensus)
+        await stage("consensus", "done", f"{len(abstracts)} abstracts \u2192 {consensus['label'].lower()}")
+
+        await stage("compose", "active")
+        async for chunk in synthesize_answer(req.query, papers, abstracts, req.answer_style, key):
+            await emit(job, "answer_token", {"text": chunk})
+        await stage("compose", "done", "gpt-4o-mini")
+
+        await emit(job, "result", {"done": True})
+    except Exception as e:  # noqa: BLE001 — job boundary
+        await emit(job, "error", {"message": str(e)[:300]})
+
+
+@app.post("/api/search", status_code=202)
+async def search_endpoint(req: SearchRequest):
+    job = registry.create()
+    asyncio.create_task(run_search_pipeline(job, req))
+    return {"jobId": job.id}
+
+
+@app.get("/api/jobs/{job_id}/events")
+async def job_events(job_id: str):
+    job = registry.get(job_id)
+    if job is None:
+        raise HTTPException(404, "unknown job")
+
+    async def gen():
+        while True:
+            item = await job.queue.get()
+            if item is None:
+                break
+            yield {"event": item["event"], "data": json.dumps(item["data"])}
+
+    return EventSourceResponse(gen())
+
+
+@app.get("/api/umap-sample")
+async def umap_sample(n: int = 4000):
+    """Background scatter for the embedding map. Cached in-process after the
+    first call since the corpus doesn't change at runtime."""
+    global _umap_cache
+    if _umap_cache is None:
+        corpus = await asyncio.to_thread(get_corpus)
+        _umap_cache = await asyncio.to_thread(corpus.umap_sample, n)
+    return {"points": _umap_cache}
+
+
+_static_dir = Path(os.environ.get("PATHFINDER_STATIC_DIR", str(_REPO_ROOT / "frontend" / "dist")))
+if _static_dir.is_dir():
+    app.mount("/", StaticFiles(directory=str(_static_dir), html=True), name="spa")

backend/astroparse_api/retrieve.py

@@ -0,0 +1,123 @@
+# backend/astroparse_api/retrieve.py
+import os
+import re
+from pathlib import Path
+
+import numpy as np
+
+_POS_TAGS = {"PROPN", "ADJ", "NOUN"}
+_nlp = None
+
+
+def _get_nlp():
+    global _nlp
+    if _nlp is None:
+        import spacy
+        _nlp = spacy.load("en_core_web_sm")
+    return _nlp
+
+
+def get_keywords(text: str) -> list[str]:
+    doc = _get_nlp()(text.lower())
+    return [t.text for t in doc if t.pos_ in _POS_TAGS and not t.is_stop and not t.is_punct]
+
+
+def keyword_weights(query_kws: list[str], candidate_kws: list[list[str]]) -> np.ndarray:
+    w = np.full(len(candidate_kws), 0.1)
+    for qk in query_kws:
+        qk = qk.lower()
+        for i, kws in enumerate(candidate_kws):
+            for k in kws:
+                if qk in k.lower():
+                    w[i] += 0.1
+    return w / w.max()
+
+
+from .schemas import LitPaper, Scores  # noqa: E402
+
+EMBED_MODEL = "text-embedding-3-small"
+_ARXIV_ID = re.compile(r"^\d{4}\.\d{4,5}$")
+_DEFAULT_DATA_DIR = Path(__file__).resolve().parent.parent / "data"
+
+
+class Corpus:
+    def __init__(self, dataset, index):
+        self.ds = dataset
+        self.index = index
+
+    @property
+    def arxiv_ids(self) -> set[str]:
+        if not hasattr(self, "_arxiv_ids"):
+            col = self.ds["arxiv_id"] if "arxiv_id" in self.ds.column_names else []
+            self._arxiv_ids = {x for x in col if x}
+        return self._arxiv_ids
+
+    @property
+    def bibcodes(self) -> set[str]:
+        if not hasattr(self, "_bibcodes"):
+            col = self.ds["bibcode"] if "bibcode" in self.ds.column_names else []
+            self._bibcodes = {x for x in col if x}
+        return self._bibcodes
+
+    @classmethod
+    def load(cls) -> "Corpus":
+        import faiss
+        from datasets import load_dataset
+
+        corpus_dir = Path(os.environ.get("ASTROPARSE_CORPUS_DIR", _DEFAULT_DATA_DIR / "corpus"))
+        faiss_path = Path(os.environ.get("ASTROPARSE_FAISS_PATH", _DEFAULT_DATA_DIR / "astroparse_fp16.faiss"))
+        if not corpus_dir.is_dir() or not faiss_path.is_file():
+            raise RuntimeError(f"compact corpus not found ({corpus_dir}, {faiss_path})")
+        ds = load_dataset("parquet", data_files=str(corpus_dir / "*.parquet"), split="train")
+        index = faiss.read_index(str(faiss_path), faiss.IO_FLAG_MMAP)
+        return cls(ds, index)
+
+    def search(self, query_embedding: np.ndarray, k: int = 1000):
+        q = np.asarray(query_embedding, dtype=np.float32).reshape(1, -1)
+        distances, indices = self.index.search(q, k)
+        sims = 1.0 / (np.asarray(distances[0]) + 1e-10)
+        return [int(i) for i in indices[0]], sims
+
+    def umap_sample(self, n: int = 4000) -> list[list[float]]:
+        """Random sample of (ux, uy) across the whole corpus, for the
+        embedding-map background scatter. Cached by the caller — this does
+        a fresh random draw each call."""
+        total = self.ds.num_rows
+        n = min(n, total)
+        rng = np.random.default_rng()
+        idx = rng.choice(total, size=n, replace=False)
+        rows = self.ds[idx.tolist()]
+        return [[float(x), float(y)] for x, y in zip(rows["umap_x"], rows["umap_y"])]
+
+
+def embed_batch(texts: list[str], api_key: str) -> list[np.ndarray]:
+    from openai import OpenAI
+
+    client = OpenAI(api_key=api_key)
+    out: list[np.ndarray] = []
+    for i in range(0, len(texts), 100):
+        data = client.embeddings.create(input=texts[i : i + 100], model=EMBED_MODEL).data
+        out += [np.array(d.embedding, dtype=np.float32) for d in data]
+    return out
+
+
+def _short_name(authors, year: int) -> str:
+    first = authors[0] if isinstance(authors, list) else str(authors).split(";")[0].split(" and ")[0]
+    last = first.split(",")[0].strip().split()[-1]
+    return f"{last}{str(year)[2:]}"
+
+
+def _lit_from_row(row: dict, embed_score: float, kw_score: float, rank: int) -> LitPaper:
+    date = row["date"]
+    year = date.year if hasattr(date, "year") else int(str(date)[:4])
+    authors = ", ".join(row["authors"]) if isinstance(row["authors"], list) else str(row["authors"])
+    arxiv_id = str(row.get("arxiv_id", ""))
+    arxiv = arxiv_id if _ARXIV_ID.match(arxiv_id) else ""
+    return LitPaper(
+        id=row["bibcode"], short=_short_name(row["authors"], year), title=row["title"],
+        authors=authors, year=year, journal="", bibcode=row["bibcode"], arxiv=arxiv,
+        cites=int(row.get("cites", 0) or 0),
+        ux=float(row.get("umap_x", 0.0) or 0.0), uy=float(row.get("umap_y", 0.0) or 0.0),
+        abstract=row["abstract"],
+        scores=Scores(embed=round(float(embed_score), 4), keywords=round(float(kw_score), 4), rank=rank),
+    )

backend/astroparse_api/schemas.py

@@ -0,0 +1,22 @@
+# backend/astroparse_api/schemas.py
+from pydantic import BaseModel
+
+class Scores(BaseModel):
+    embed: float
+    keywords: float
+    rank: int
+
+class LitPaper(BaseModel):
+    id: str
+    short: str
+    title: str
+    authors: str
+    year: int
+    journal: str
+    bibcode: str
+    arxiv: str
+    cites: int
+    ux: float
+    uy: float
+    abstract: str
+    scores: Scores

backend/astroparse_api/search.py

@@ -0,0 +1,106 @@
+# backend/astroparse_api/search.py
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime, timezone
+
+import httpx
+import numpy as np
+from openai import AsyncOpenAI, OpenAI
+
+from .retrieve import Corpus, get_keywords, keyword_weights, _lit_from_row
+
+
+def check_moderation(text: str, api_key: str) -> bool:
+    client = OpenAI(api_key=api_key)
+    result = client.moderations.create(input=text)
+    return result.results[0].flagged
+
+
+async def log_query_to_gist(query: str, flagged: bool) -> None:
+    token = os.environ.get("GITHUB_TOKEN")
+    gist_id = os.environ.get("GIST_ID")
+    if not (token and gist_id):
+        return
+    timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
+    line = f"\n{timestamp}: [mod flag: {flagged}] {query}\n"
+    headers = {"Authorization": f"token {token}", "Accept": "application/vnd.github.v3+json"}
+    try:
+        async with httpx.AsyncClient(timeout=5.0) as client:
+            resp = await client.get(f"https://api.github.com/gists/{gist_id}", headers=headers)
+            existing = resp.json()["files"]["log.txt"]["content"] if resp.status_code == 200 else ""
+            await client.patch(
+                f"https://api.github.com/gists/{gist_id}", headers=headers,
+                json={"description": "Logged Strings", "public": False,
+                      "files": {"log.txt": {"content": existing + line}}},
+            )
+    except Exception:
+        pass
+
+
+def search_corpus(corpus: Corpus, query: str, top_k: int, pool: int, api_key: str):
+    client = OpenAI(api_key=api_key)
+    emb = np.array(
+        client.embeddings.create(input=[query], model="text-embedding-3-small").data[0].embedding,
+        dtype=np.float32,
+    )
+    indices, sims = corpus.search(emb, k=pool)
+    rows = corpus.ds[indices]
+    kw = keyword_weights(get_keywords(query), rows["keywords"])
+    embed_norm = sims / sims.max()
+    combined = embed_norm * kw
+    order = np.argsort(combined)[::-1][:top_k]
+    papers = [
+        _lit_from_row({k: rows[k][j] for k in rows}, float(embed_norm[j]), float(kw[j]), rank)
+        for rank, j in enumerate(order, start=1)
+    ]
+    return papers, [p.abstract for p in papers]
+
+
+STYLE_PROMPTS = {
+    "Concise": "Answer in 1-2 sentences, citing papers inline as [Author+Year]. Be direct.",
+    "Multi-paper": "Answer in 2-3 short paragraphs synthesizing across papers, citing inline as [Author+Year].",
+    "Deep Research": (
+        "Break the question into 2-4 sub-questions. For each, write a short heading and a "
+        "grounded paragraph citing [Author+Year]. End with a 'Summary' paragraph noting where "
+        "the literature agrees and where it's still debated."
+    ),
+}
+
+
+async def synthesize_answer(query: str, papers, abstracts: list[str], style: str, api_key: str):
+    client = AsyncOpenAI(api_key=api_key)
+    context = "\n\n".join(f"[{p.short}] {p.title}\n{a}" for p, a in zip(papers, abstracts))
+    stream = await client.chat.completions.create(
+        model="gpt-4o-mini", stream=True,
+        messages=[
+            {"role": "system", "content": "You are an astronomy research assistant. Use only "
+             f"the provided abstracts. {STYLE_PROMPTS[style]}"},
+            {"role": "user", "content": f"Question: {query}\n\nAbstracts:\n{context}"},
+        ],
+    )
+    async for chunk in stream:
+        delta = chunk.choices[0].delta.content
+        if delta:
+            yield delta
+
+
+async def score_consensus(query: str, abstracts: list[str], api_key: str) -> dict:
+    client = AsyncOpenAI(api_key=api_key)
+    resp = await client.chat.completions.create(
+        model="gpt-4o-mini",
+        response_format={"type": "json_schema", "json_schema": {"name": "consensus", "schema": {
+            "type": "object",
+            "properties": {"label": {"type": "string"}, "explanation": {"type": "string"},
+                            "relevance_score": {"type": "number"}},
+            "required": ["label", "explanation", "relevance_score"],
+        }}},
+        messages=[
+            {"role": "system", "content": "Rate consensus between the query and abstracts. "
+             "label must be one of: Strong Agreement, Moderate Agreement, Weak Agreement, "
+             "No Clear Agreement, Weak Disagreement, Moderate Disagreement, Strong Disagreement."},
+            {"role": "user", "content": f"Query: {query}\n\n" + "\n\n".join(abstracts)},
+        ],
+    )
+    return json.loads(resp.choices[0].message.content)

backend/pyproject.toml

@@ -0,0 +1,22 @@
+# backend/pyproject.toml
+[project]
+name = "astroparse-api"
+version = "0.1.0"
+requires-python = ">=3.11"
+dependencies = [
+  "fastapi>=0.115",
+  "uvicorn[standard]>=0.30",
+  "sse-starlette>=2.1",
+  "openai>=1.40",
+  "httpx>=0.27",
+  "faiss-cpu>=1.8",
+  "datasets>=2.20",
+  "pyarrow>=17.0",
+  "numpy>=1.26",
+  "spacy>=3.7",
+  "huggingface_hub>=0.24",
+  "python-dotenv>=1.0",
+]
+
+[tool.uv]
+package = false

frontend/index.html

@@ -0,0 +1,16 @@
+<!-- frontend/index.html -->
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <link rel="preconnect" href="https://fonts.googleapis.com">
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+  <link href="https://fonts.googleapis.com/css2?family=Space+Grotesk:wght@400;500;600;700&family=IBM+Plex+Sans:wght@400;500;600&family=IBM+Plex+Mono:wght@400;500&display=swap" rel="stylesheet">
+  <title>Pathfinder</title>
+</head>
+<body>
+  <div id="root"></div>
+  <script type="module" src="/src/main.jsx"></script>
+</body>
+</html>

frontend/package.json

@@ -0,0 +1,9 @@
+// frontend/package.json
+{
+  "name": "pathfinder-frontend",
+  "private": true,
+  "type": "module",
+  "scripts": { "dev": "vite", "build": "vite build" },
+  "dependencies": { "react": "^18.3.0", "react-dom": "^18.3.0" },
+  "devDependencies": { "@vitejs/plugin-react": "^4.3.0", "vite": "^5.4.0" }
+}

frontend/src/App.jsx

@@ -0,0 +1,334 @@
+// frontend/src/App.jsx
+import React, { useState, useRef, useEffect, useCallback, useMemo } from 'react';
+import { LIGHT, DARK, PIPELINE, EXAMPLES } from './theme.js';
+import { runSearch, fetchUmapSample } from './api.js';
+
+function fmtAuthors(a) {
+  const list = a.split(', ');
+  return list.length > 3 ? `${list.slice(0, 3).join(', ')}, +${list.length - 3}` : a;
+}
+
+function linkifyAnswer(text, papers) {
+  const byShort = {};
+  papers.forEach((p) => { byShort[p.short] = p; });
+  return text.replace(/\[([^\]]+)\]/g, (m, short) => {
+    const p = byShort[short];
+    if (!p) return m;
+    return `<a href="https://arxiv.org/abs/${p.arxiv}" target="_blank" style="color:var(--goldtext); border-bottom:1px solid var(--goldborder);">(${short})</a>`;
+  });
+}
+
+export default function App() {
+  const [view, setView] = useState('home');
+  const [query, setQuery] = useState('');
+  const [theme, setTheme] = useState('light');
+  const [topK, setTopK] = useState(10);
+  const [answerStyle, setAnswerStyle] = useState('Multi-paper');
+  const [sort, setSort] = useState('relevance');
+  const [weights, setWeights] = useState({ keywords: true, recency: false, citations: false });
+  const [years, setYears] = useState({});
+  const [expanded, setExpanded] = useState({});
+  const [reasoningOpen, setReasoningOpen] = useState(false);
+  const [settingsOpen, setSettingsOpen] = useState(false);
+
+  const [phaseKeys, setPhaseKeys] = useState([]);
+  const [papers, setPapers] = useState([]);
+  const [answerHtml, setAnswerHtml] = useState('');
+  const [answerRaw, setAnswerRaw] = useState('');
+  const [consensus, setConsensus] = useState(null);
+  const [blockedMsg, setBlockedMsg] = useState('');
+  const [done, setDone] = useState(false);
+  const [umapBg, setUmapBg] = useState([]);
+
+  const mapCanvasRef = useRef(null);
+  const esRef = useRef(null);
+
+  useEffect(() => { fetchUmapSample().then(setUmapBg).catch(() => {}); }, []);
+
+  const V = theme === 'dark' ? DARK : LIGHT;
+  const themeVars = useMemo(
+    () => Object.fromEntries(Object.entries(V).map(([k, v]) => [k, v])),
+    [V]
+  );
+
+  const scored = useCallback(() => {
+    const recencyFactor = (y) => 0.55 + 0.45 * Math.min(1, Math.max(0, (y - 2013) / 10));
+    const citeFactor = (c) => 0.55 + 0.45 * Math.min(1, Math.log10(c + 1) / Math.log10(2000));
+    return papers.map((p) => {
+      let sc = p.scores.embed;
+      if (weights.keywords) sc *= (0.45 + 0.55 * p.scores.keywords);
+      if (weights.recency) sc *= recencyFactor(p.year);
+      if (weights.citations) sc *= citeFactor(p.cites);
+      return { ...p, score: sc };
+    });
+  }, [papers, weights]);
+
+  const displayed = useCallback(() => {
+    const anyYr = Object.values(years).some(Boolean);
+    let list = scored().filter((p) => !anyYr || years[p.year]);
+    list.sort((a, b) => sort === 'year' ? b.year - a.year : sort === 'cites' ? b.cites - a.cites : b.score - a.score);
+    const maxSc = Math.max(...list.map((p) => p.score), 0.0001);
+    list = list.slice(0, topK);
+    return list.map((p, i) => ({ ...p, rank: i + 1, rel: p.score / maxSc }));
+  }, [scored, years, sort, topK]);
+
+  const drawMap = useCallback(() => {
+    const cv = mapCanvasRef.current;
+    if (!cv) return;
+    const dark = theme === 'dark';
+    const ctx = cv.getContext('2d');
+    const W = cv.width, H = cv.height, pad = 14;
+    const allX = umapBg.map((p) => p[0]).concat(papers.map((p) => p.ux));
+    const allY = umapBg.map((p) => p[1]).concat(papers.map((p) => p.uy));
+    const minX = Math.min(...allX, 0), maxX = Math.max(...allX, 1);
+    const minY = Math.min(...allY, 0), maxY = Math.max(...allY, 1);
+    const px = (x) => pad + ((x - minX) / (maxX - minX || 1)) * (W - 2 * pad);
+    const py = (y) => pad + ((y - minY) / (maxY - minY || 1)) * (H - 2 * pad);
+
+    ctx.clearRect(0, 0, W, H);
+    ctx.fillStyle = dark ? 'rgba(233,236,247,0.055)' : 'rgba(20,22,30,0.09)';
+    umapBg.forEach(([x, y]) => { ctx.beginPath(); ctx.arc(px(x), py(y), 1.15, 0, 6.29); ctx.fill(); });
+
+    displayed().forEach((p) => {
+      const x = px(p.ux), y = py(p.uy);
+      ctx.beginPath(); ctx.arc(x, y, 8, 0, 6.29);
+      ctx.fillStyle = dark ? 'rgba(255,255,255,0.9)' : 'rgba(12,13,17,0.10)';
+      ctx.fill();
+      ctx.shadowColor = dark ? 'rgba(244,183,64,0.9)' : 'rgba(227,154,30,0.75)';
+      ctx.shadowBlur = 11;
+      ctx.beginPath(); ctx.arc(x, y, 3.6, 0, 6.29);
+      ctx.fillStyle = dark ? '#F4B740' : '#E39A1E';
+      ctx.fill(); ctx.shadowBlur = 0;
+    });
+  }, [umapBg, papers, displayed, theme]);
+
+  useEffect(() => { drawMap(); }, [drawMap]);
+
+  const onSubmit = async () => {
+    const q = query.trim() || EXAMPLES[0];
+    setQuery(q); setView('run'); setPhaseKeys([]); setPapers([]);
+    setAnswerHtml(''); setAnswerRaw(''); setConsensus(null); setBlockedMsg(''); setDone(false);
+
+    esRef.current = await runSearch(q, topK, answerStyle, {
+      onStage: (d) => { if (d.status === 'done') setPhaseKeys((prev) => [...prev, d.name]); },
+      onPapers: (ps) => setPapers(ps),
+      onAnswerToken: (t) => setAnswerRaw((prev) => prev + t),
+      onConsensus: (c) => setConsensus(c),
+      onBlocked: (d) => { setBlockedMsg(d.message); setView('home'); },
+      onDone: () => setDone(true),
+      onError: (d) => { setBlockedMsg(d.message || 'Something went wrong.'); setDone(true); },
+    });
+  };
+
+  useEffect(() => {
+    return () => esRef.current?.close();
+  }, []);
+
+  const phase = PIPELINE.findIndex((s) => !phaseKeys.includes(s.k));
+  const running = view === 'run' && !done && phase !== -1;
+  const showResults = view === 'run' && (done || papers.length > 0);
+  const shownPapers = displayed();
+
+  const yearCounts = {};
+  scored().forEach((p) => { yearCounts[p.year] = (yearCounts[p.year] || 0) + 1; });
+
+  return (
+    <div style={{ display: 'flex', minHeight: '100vh', color: 'var(--text)', background: 'var(--bg)', fontFamily: "'IBM Plex Sans', sans-serif", ...themeVars }}>
+      <div style={{ width: 66, flex: '0 0 66px', borderRight: '1px solid var(--line)', display: 'flex', flexDirection: 'column', alignItems: 'center', padding: '18px 0', gap: 20 }}>
+        <button onClick={() => setView('home')} title="Pathfinder home" style={{ width: 38, height: 38, background: 'none', border: 'none', cursor: 'pointer' }}>
+          <svg viewBox="0 0 24 24" width="26" height="26"><path d="M12 1 L13.7 9.6 L22.4 12 L13.7 14.4 L12 23 L10.3 14.4 L1.6 12 L10.3 9.6 Z" style={{ fill: 'var(--gold)' }} /></svg>
+        </button>
+      </div>
+
+      <div style={{ flex: 1, minWidth: 0, display: 'flex', flexDirection: 'column' }}>
+        <div style={{ height: 60, borderBottom: '1px solid var(--line)', display: 'flex', alignItems: 'center', gap: 14, padding: '0 26px' }}>
+          <span style={{ fontFamily: "'Space Grotesk', sans-serif", fontWeight: 600, fontSize: 18, color: 'var(--head)' }}>Pathfinder</span>
+          <div style={{ marginLeft: 'auto' }}>
+            <button onClick={() => setTheme((t) => t === 'light' ? 'dark' : 'light')} style={{ fontSize: 13 }}>
+              {theme === 'light' ? 'Dark mode' : 'Light mode'}
+            </button>
+          </div>
+        </div>
+
+        {view === 'home' && (
+          <div style={{ flex: 1, display: 'flex', flexDirection: 'column', alignItems: 'center', padding: '0 26px' }}>
+            <div style={{ width: '100%', maxWidth: 780, marginTop: '11vh' }}>
+              <h1 style={{ fontFamily: "'Space Grotesk', sans-serif", fontWeight: 700, fontSize: 48, lineHeight: 1.05, letterSpacing: '-1.6px', color: 'var(--head)' }}>
+                A beacon through the<br />astronomy literature.
+              </h1>
+              <p style={{ fontSize: 17, color: 'var(--muted)', maxWidth: 600 }}>
+                Ask a research question in plain language. Pathfinder embeds it, searches the corpus, weighs the results, and answers with the papers that ground it.
+              </p>
+
+              {blockedMsg && (
+                <div style={{ border: '1px solid var(--goldborder)', background: 'var(--goldsoft)', color: 'var(--goldtext)', borderRadius: 10, padding: '10px 14px', marginBottom: 16, fontSize: 14 }}>
+                  {blockedMsg}
+                </div>
+              )}
+
+              <div style={{ border: '1px solid var(--line2)', borderRadius: 16, background: 'var(--surface)', overflow: 'hidden' }}>
+                <textarea
+                  rows={2}
+                  value={query}
+                  onChange={(e) => setQuery(e.target.value)}
+                  onKeyDown={(e) => { if (e.key === 'Enter' && !e.shiftKey) { e.preventDefault(); onSubmit(); } }}
+                  placeholder="How does stellar feedback regulate star formation in dwarf galaxies?"
+                  style={{ width: '100%', border: 'none', outline: 'none', resize: 'none', background: 'transparent', color: 'var(--text)', fontSize: 17, padding: '20px 20px 8px' }}
+                />
+                <div style={{ display: 'flex', alignItems: 'center', gap: 10, padding: '10px 12px 12px', borderTop: '1px solid var(--linesoft)' }}>
+                  <span style={{ fontSize: '12.5px', color: 'var(--muted2)' }}>top-k {topK}</span>
+                  <button onClick={() => setTopK((k) => Math.max(3, k - 1))}>−</button>
+                  <button onClick={() => setTopK((k) => Math.min(20, k + 1))}>+</button>
+                  <select value={answerStyle} onChange={(e) => setAnswerStyle(e.target.value)} style={{ marginLeft: 8 }}>
+                    <option>Concise</option>
+                    <option>Multi-paper</option>
+                    <option>Deep Research</option>
+                  </select>
+                  <button onClick={onSubmit} style={{ marginLeft: 'auto', background: 'var(--gold)', color: 'var(--ongold)', border: 'none', padding: '10px 18px', borderRadius: 10, fontWeight: 600, cursor: 'pointer' }}>
+                    Run Pathfinder →
+                  </button>
+                </div>
+              </div>
+
+              <div style={{ display: 'flex', flexWrap: 'wrap', gap: 9, marginTop: 22 }}>
+                {EXAMPLES.map((q) => (
+                  <button key={q} onClick={() => { setQuery(q); }} style={{ textAlign: 'left', border: '1px solid var(--line)', background: 'var(--example)', color: 'var(--abstract)', padding: '9px 13px', borderRadius: 10, fontSize: 13, cursor: 'pointer' }}>
+                    {q}
+                  </button>
+                ))}
+              </div>
+            </div>
+          </div>
+        )}
+
+        {view === 'run' && running && (
+          <div style={{ maxWidth: 720, margin: '0 auto', padding: '48px 26px' }}>
+            <div style={{ fontSize: 18, color: 'var(--head)', marginBottom: 26 }}>{query}</div>
+            <div style={{ border: '1px solid var(--line)', borderRadius: 16, background: 'var(--card)', padding: '8px 6px' }}>
+              {PIPELINE.map((s, i) => (
+                <div key={s.k} style={{ display: 'flex', alignItems: 'center', gap: 13, padding: '12px 16px' }}>
+                  <span style={{ width: 20, textAlign: 'center' }}>
+                    {phaseKeys.includes(s.k) ? '✓' : i === phase ? '…' : '○'}
+                  </span>
+                  <span style={{ fontSize: '14.5px', color: i > phase ? 'var(--faint)' : 'var(--text)' }}>{s.label}</span>
+                </div>
+              ))}
+            </div>
+          </div>
+        )}
+
+        {showResults && (
+          <div style={{ display: 'flex', gap: 28, maxWidth: 1320, margin: '0 auto', padding: '26px 26px 80px' }}>
+            <div style={{ flex: 1, minWidth: 0 }}>
+              <div style={{ fontFamily: "'Space Grotesk', sans-serif", fontSize: 21, color: 'var(--head)', marginBottom: 18 }}>{query}</div>
+
+              <button onClick={() => setReasoningOpen((o) => !o)} style={{ marginBottom: 22, fontSize: '12.5px' }}>
+                Retrieved {shownPapers.length} papers · {PIPELINE.length} steps {reasoningOpen ? '▲' : '▼'}
+              </button>
+
+              <div style={{ border: '1px solid var(--answercardborder)', borderRadius: 16, background: 'var(--answercardbg)', padding: '24px 26px', marginBottom: 16 }}>
+                <div style={{ fontFamily: "'Space Grotesk', sans-serif", fontWeight: 600, fontSize: 15, color: 'var(--head)', marginBottom: 14 }}>
+                  Synthesized answer <span style={{ fontSize: 11, color: 'var(--muted2)', border: '1px solid var(--line2)', borderRadius: 999, padding: '2px 8px', marginLeft: 6 }}>{answerStyle}</span>
+                </div>
+                <div
+                  style={{ fontSize: '15.5px', lineHeight: 1.72, color: 'var(--answer)' }}
+                  dangerouslySetInnerHTML={{ __html: linkifyAnswer(answerRaw, papers) }}
+                />
+              </div>
+
+              {consensus && (
+                <div style={{ border: '1px solid var(--line)', borderRadius: 14, background: 'var(--card)', padding: '18px 20px', marginBottom: 14 }}>
+                  <div style={{ display: 'flex', gap: 10, marginBottom: 8 }}>
+                    <span style={{ fontSize: 12, color: 'var(--muted2)' }}>LITERATURE CONSENSUS</span>
+                    <span style={{ fontSize: '12.5px', fontWeight: 600, color: 'var(--green)', background: 'var(--greensoft)', padding: '3px 10px', borderRadius: 999 }}>{consensus.label}</span>
+                  </div>
+                  <div style={{ fontSize: '13.5px', color: 'var(--muted)' }}>{consensus.explanation}</div>
+                </div>
+              )}
+
+              <div style={{ display: 'flex', alignItems: 'baseline', gap: 10, margin: '26px 0 14px' }}>
+                <h2 style={{ fontFamily: "'Space Grotesk', sans-serif", fontSize: 16, color: 'var(--head)' }}>Retrieved papers</h2>
+                <span style={{ fontSize: '12.5px', color: 'var(--muted2)' }}>showing {shownPapers.length}</span>
+              </div>
+
+              {shownPapers.map((p) => {
+                const exp = !!expanded[p.bibcode];
+                const highly = p.rel > 0.94;
+                return (
+                  <div key={p.bibcode} style={{ border: '1px solid var(--line)', borderRadius: 14, background: 'var(--card)', padding: '18px 20px', marginBottom: 12 }}>
+                    <div style={{ display: 'flex', gap: 14 }}>
+                      <div style={{ fontSize: 12, color: 'var(--faint2)', minWidth: 20 }}>{String(p.rank).padStart(2, '0')}</div>
+                      <div style={{ flex: 1, minWidth: 0 }}>
+                        <div style={{ display: 'flex', gap: 10, marginBottom: 5 }}>
+                          <span style={{ fontSize: '11.5px', color: 'var(--goldtext)', background: 'var(--goldchip)', padding: '2px 8px', borderRadius: 6 }}>{p.short}</span>
+                          <span style={{ fontSize: '11.5px', fontWeight: 600, color: highly ? 'var(--green)' : 'var(--cyan)', background: highly ? 'var(--greensoft)' : 'var(--relevantbg)', padding: '2px 9px', borderRadius: 999 }}>
+                            {highly ? 'Highly relevant' : p.rel > 0.85 ? 'Relevant' : 'Related'}
+                          </span>
+                        </div>
+                        <a href={`https://arxiv.org/abs/${p.arxiv}`} target="_blank" rel="noreferrer" style={{ fontFamily: "'Space Grotesk', sans-serif", fontSize: '16.5px', color: 'var(--head)', display: 'block', marginBottom: 6 }}>
+                          {p.title}
+                        </a>
+                        <div style={{ fontSize: 13, color: 'var(--muted)' }}>{fmtAuthors(p.authors)}</div>
+                        <div style={{ fontSize: '12.5px', color: 'var(--faint)', marginBottom: 12 }}>
+                          {p.year} · {p.cites.toLocaleString()} citations
+                        </div>
+                        {exp && (
+                          <div style={{ fontSize: '13.5px', lineHeight: 1.62, color: 'var(--abstract)', borderLeft: '2px solid var(--goldborder)', paddingLeft: 14, marginBottom: 14 }}>
+                            {p.abstract}
+                          </div>
+                        )}
+                        <div style={{ display: 'flex', gap: 18 }}>
+                          <button onClick={() => setExpanded((e) => ({ ...e, [p.bibcode]: !exp }))} style={{ fontSize: 12 }}>
+                            {exp ? 'Hide abstract' : 'Show abstract'}
+                          </button>
+                          <a href={`https://ui.adsabs.harvard.edu/abs/${p.bibcode}`} target="_blank" rel="noreferrer" style={{ fontSize: 12, color: 'var(--cyan)' }}>ADS ↗</a>
+                          <a href={`https://arxiv.org/abs/${p.arxiv}`} target="_blank" rel="noreferrer" style={{ fontSize: 12, color: 'var(--cyan)' }}>arXiv ↗</a>
+                        </div>
+                      </div>
+                    </div>
+                  </div>
+                );
+              })}
+            </div>
+
+            <div style={{ width: 284, flexShrink: 0 }}>
+              <div style={{ border: '1px solid var(--line)', borderRadius: 14, background: 'var(--card2)', padding: 14, marginBottom: 16 }}>
+                <div style={{ fontSize: 13, fontWeight: 600, color: 'var(--head)', marginBottom: 10 }}>Embedding map</div>
+                <canvas ref={mapCanvasRef} width={512} height={440} style={{ width: '100%', height: 'auto', borderRadius: 8, background: 'var(--mapbg)' }} />
+              </div>
+
+              <div style={{ border: '1px solid var(--line)', borderRadius: 14, background: 'var(--card2)', padding: '15px 16px', marginBottom: 16 }}>
+                <div style={{ fontSize: 11, color: 'var(--muted2)', marginBottom: 11 }}>SORT BY</div>
+                {['relevance', 'year', 'cites'].map((k) => (
+                  <label key={k} style={{ display: 'flex', gap: 10, padding: '6px 0', cursor: 'pointer', fontSize: '13.5px', color: sort === k ? 'var(--head)' : 'var(--muted)' }}>
+                    <input type="radio" checked={sort === k} onChange={() => setSort(k)} /> {k}
+                  </label>
+                ))}
+              </div>
+
+              <div style={{ border: '1px solid var(--line)', borderRadius: 14, background: 'var(--card2)', padding: '15px 16px', marginBottom: 16 }}>
+                <div style={{ fontSize: 11, color: 'var(--muted2)', marginBottom: 6 }}>WEIGHT RANKING BY</div>
+                {[['keywords', 'Keywords'], ['recency', 'Recency'], ['citations', 'Citations']].map(([k, label]) => (
+                  <label key={k} style={{ display: 'flex', justifyContent: 'space-between', padding: '7px 0', cursor: 'pointer', fontSize: '13.5px' }}>
+                    {label}
+                    <input type="checkbox" checked={weights[k]} onChange={() => setWeights((w) => ({ ...w, [k]: !w[k] }))} />
+                  </label>
+                ))}
+              </div>
+
+              <div style={{ border: '1px solid var(--line)', borderRadius: 14, background: 'var(--card2)', padding: '15px 16px' }}>
+                <div style={{ fontSize: 11, color: 'var(--muted2)', marginBottom: 11 }}>YEAR</div>
+                {Object.keys(yearCounts).sort((a, b) => b - a).map((y) => (
+                  <label key={y} style={{ display: 'flex', gap: 10, padding: '5px 0', cursor: 'pointer', fontSize: '13.5px' }}>
+                    <input type="checkbox" checked={!!years[y]} onChange={() => setYears((yr) => ({ ...yr, [y]: !yr[y] }))} />
+                    {y} <span style={{ marginLeft: 'auto', color: 'var(--faint2)' }}>{yearCounts[y]}</span>
+                  </label>
+                ))}
+              </div>
+            </div>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}

frontend/src/api.js

@@ -0,0 +1,27 @@
+// frontend/src/api.js
+export async function runSearch(query, topK, answerStyle, handlers) {
+  const res = await fetch('/api/search', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ query, top_k: topK, answer_style: answerStyle }),
+  });
+  const { jobId } = await res.json();
+  const es = new EventSource(`/api/jobs/${jobId}/events`);
+
+  es.addEventListener('stage', (e) => handlers.onStage?.(JSON.parse(e.data)));
+  es.addEventListener('papers', (e) => handlers.onPapers?.(JSON.parse(e.data).papers));
+  es.addEventListener('answer_token', (e) => handlers.onAnswerToken?.(JSON.parse(e.data).text));
+  es.addEventListener('consensus', (e) => handlers.onConsensus?.(JSON.parse(e.data)));
+  es.addEventListener('blocked', (e) => { handlers.onBlocked?.(JSON.parse(e.data)); es.close(); });
+  es.addEventListener('result', () => { handlers.onDone?.(); es.close(); });
+  es.addEventListener('error', (e) => {
+    try { handlers.onError?.(JSON.parse(e.data)); } catch { handlers.onError?.({ message: 'connection lost' }); }
+    es.close();
+  });
+  return es;
+}
+
+export async function fetchUmapSample() {
+  const res = await fetch('/api/umap-sample');
+  return (await res.json()).points;
+}

frontend/src/main.jsx

@@ -0,0 +1,6 @@
+// frontend/src/main.jsx
+import React from 'react';
+import { createRoot } from 'react-dom/client';
+import App from './App.jsx';
+
+createRoot(document.getElementById('root')).render(<App />);

frontend/src/theme.js

@@ -0,0 +1,52 @@
+// frontend/src/theme.js — ported verbatim from the design doc
+export const LIGHT = {
+  '--bg': '#FBFBF8', '--grad1': 'rgba(227,154,30,0.07)', '--grad2': 'rgba(12,122,134,0.05)',
+  '--text': '#1C1E25', '--head': '#0B0C0F', '--muted': '#565A68', '--muted2': '#565A68',
+  '--faint': '#868B99', '--faint2': '#A6AAB5', '--ver': '#B4B8C2',
+  '--abstract': '#3A3F4C', '--answer': '#26292F',
+  '--line': '#EAEAE3', '--line2': '#E0DFD6', '--line3': '#D8D8CE', '--linesoft': '#EFEEE8',
+  '--card': '#FFFFFF', '--card2': '#FFFFFF', '--surface': '#FFFFFF', '--popover': '#FFFFFF',
+  '--inset': '#F4F3EE', '--avatar': '#EFEEE8', '--track': '#E4E3DB',
+  '--example': '#FFFFFF', '--reasonbg': '#F4F3EE',
+  '--gold': '#E39A1E', '--goldhover': '#f2ab34', '--goldtext': '#A9640A', '--goldsoft': 'rgba(227,154,30,0.14)',
+  '--goldchip': 'rgba(227,154,30,0.12)', '--goldborder': 'rgba(227,154,30,0.5)', '--goldbtnborder': 'rgba(227,154,30,0.6)',
+  '--goldfaint': 'rgba(227,154,30,0.3)', '--goldglow': 'rgba(227,154,30,0.6)', '--ongold': '#241800',
+  '--answercardborder': 'rgba(227,154,30,0.35)', '--answercardbg': 'linear-gradient(180deg, rgba(227,154,30,0.06), rgba(227,154,30,0.015))',
+  '--cyan': '#0C7A86', '--cyanhover': '#0A5C66', '--green': '#1C8A4E', '--greensoft': 'rgba(28,138,78,0.1)',
+  '--greenring': 'rgba(28,138,78,0.4)', '--relevantbg': 'rgba(12,122,134,0.1)', '--relatedbg': 'rgba(0,0,0,0.05)',
+  '--ringoff': '#CFCEC5', '--knoboff': '#B0B0A8', '--topbar': 'rgba(251,251,248,0.86)',
+  '--slash': '#C4C3BA', '--mapbg': '#FCFCFA', '--corpusdot': '#C7C6BD',
+};
+
+export const DARK = {
+  '--bg': '#0A0D17', '--grad1': 'rgba(244,183,64,0.06)', '--grad2': 'rgba(111,214,230,0.05)',
+  '--text': '#E9ECF7', '--head': '#F3F5FC', '--muted': '#9aa1bd', '--muted2': '#8991ae',
+  '--faint': '#626a88', '--faint2': '#4f587a', '--ver': '#3f4763',
+  '--abstract': '#b6bcd4', '--answer': '#dfe3f2',
+  '--line': 'rgba(233,236,247,0.08)', '--line2': 'rgba(233,236,247,0.14)', '--line3': 'rgba(233,236,247,0.16)', '--linesoft': 'rgba(233,236,247,0.06)',
+  '--card': '#0f1423', '--card2': '#0d1220', '--surface': '#101524', '--popover': '#12162a',
+  '--inset': '#0c1120', '--avatar': '#1a2135', '--track': '#1a2135',
+  '--example': '#0e1320', '--reasonbg': '#0d1220',
+  '--gold': '#F4B740', '--goldhover': '#ffca5e', '--goldtext': '#F4B740', '--goldsoft': 'rgba(244,183,64,0.16)',
+  '--goldchip': 'rgba(244,183,64,0.1)', '--goldborder': 'rgba(244,183,64,0.5)', '--goldbtnborder': 'rgba(244,183,64,0.55)',
+  '--goldfaint': 'rgba(244,183,64,0.25)', '--goldglow': '#F4B740', '--ongold': '#161200',
+  '--answercardborder': 'rgba(244,183,64,0.22)', '--answercardbg': 'linear-gradient(180deg, rgba(244,183,64,0.05), rgba(244,183,64,0.01))',
+  '--cyan': '#6fd6e6', '--cyanhover': '#9ee6f2', '--green': '#63cf87', '--greensoft': 'rgba(99,207,135,0.12)',
+  '--greenring': 'rgba(99,207,135,0.35)', '--relevantbg': 'rgba(111,214,230,0.1)', '--relatedbg': 'rgba(233,236,247,0.06)',
+  '--ringoff': 'rgba(233,236,247,0.2)', '--knoboff': '#5b6486', '--topbar': 'rgba(10,13,23,0.82)',
+  '--slash': '#3a4260', '--mapbg': '#0A0D17', '--corpusdot': '#39415f',
+};
+
+export const PIPELINE = [
+  { k: 'intent', label: 'Analyzing query intent' },
+  { k: 'search', label: 'Searching the corpus' },
+  { k: 'consensus', label: 'Evaluating consensus' },
+  { k: 'compose', label: 'Composing grounded answer' },
+];
+
+export const EXAMPLES = [
+  'How does stellar feedback regulate star formation in dwarf galaxies?',
+  'Evidence for and against primordial non-Gaussianity from galaxy surveys',
+  'Can strong-lensing time delays resolve the Hubble tension?',
+  'JWST detections of quenched galaxies at z > 4',
+];

frontend/vite.config.js

@@ -0,0 +1,8 @@
+// frontend/vite.config.js
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+  server: { proxy: { '/api': 'http://localhost:7860' } },
+});