Create self_learning_graph.py

dvnc_ai_v2_hf/self_learning_graph.py

@@ -0,0 +1,1729 @@
+import html
+import json
+import re
+import time
+import urllib.parse
+import xml.etree.ElementTree as ET
+from collections import Counter
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import gradio as gr
+import requests
+
+try:
+    import fitz  # PyMuPDF
+except Exception:
+    fitz = None
+
+
+SEARCH_MODES = ["topic", "title", "doi", "link", "paper_name", "autonomous_web"]
+SOURCE_OPTIONS = ["arxiv", "crossref", "openalex", "semantic_scholar", "europe_pmc"]
+DEFAULT_SOURCES = ["arxiv", "crossref", "openalex", "semantic_scholar", "europe_pmc"]
+PDF_PARSERS = ["pymupdf"]
+
+REQUEST_TIMEOUT = 25
+GRAPH_MAX_RESULTS = 12
+GRAPH_MAX_CONCEPTS = 12
+GRAPH_MAX_CLAIMS = 8
+GRAPH_MAX_EXPANSIONS = 6
+GRAPH_MAX_NODES = 500
+GRAPH_MAX_EDGES = 1600
+GRAPH_IFRAME_HEIGHT = 760
+MAX_ABSTRACT_CHARS = 4000
+MAX_RAW_TEXT_CHARS = 60000
+
+JOURNALS = [
+    {"name": "Nature", "url": "https://www.nature.com/search", "desc": "Flagship multidisciplinary research journal."},
+    {"name": "Science", "url": "https://www.science.org/search", "desc": "High-impact science journal and family."},
+    {"name": "Cell", "url": "https://www.cell.com/search", "desc": "Life sciences and translational biology."},
+    {"name": "The Lancet", "url": "https://www.thelancet.com/search", "desc": "Clinical and medical research."},
+    {"name": "IEEE Xplore", "url": "https://ieeexplore.ieee.org/search/searchresult.jsp", "desc": "Engineering, AI, signal processing, and systems."},
+]
+
+STOPWORDS = {
+    "a", "an", "and", "are", "as", "at", "be", "been", "being", "by", "can", "could",
+    "did", "do", "does", "for", "from", "had", "has", "have", "if", "in", "into", "is",
+    "it", "its", "may", "might", "of", "on", "or", "our", "such", "that", "the", "their",
+    "there", "these", "this", "those", "to", "using", "use", "used", "via", "was", "were",
+    "will", "with", "within", "without", "we", "they", "you", "your", "study", "paper",
+    "research", "results", "result", "method", "methods", "analysis", "approach", "based",
+    "new", "novel", "effect", "effects", "model", "models", "system", "systems", "show",
+    "shows", "shown", "however", "therefore", "also", "between", "across", "among", "et", "al",
+    "introduction", "discussion", "conclusion", "references", "figure", "table",
+}
+
+GRAPH_MEMORY: Dict[str, Any] = {
+    "papers": {},
+    "nodes": {},
+    "edges": [],
+    "queries": [],
+    "events": [],
+    "frontier": [],
+    "payloads": [],
+    "concept_counts": Counter(),
+    "claim_counts": Counter(),
+}
+
+
+# ----------------------------
+# Utility
+# ----------------------------
+
+def safe_text(x, default=""):
+    return html.escape(str(x if x is not None else default))
+
+
+def norm_text(x: Optional[str]) -> str:
+    return re.sub(r"\s+", " ", (x or "")).strip()
+
+
+def ensure_list(x):
+    return x if isinstance(x, list) else []
+
+
+def truncate_text(text: str, limit: int) -> str:
+    text = norm_text(text)
+    return text if len(text) <= limit else text[: limit - 1].rstrip() + "…"
+
+
+def slugify(text: str) -> str:
+    return re.sub(r"[^a-z0-9]+", "-", (text or "").lower()).strip("-")
+
+
+def normalize_doi(text: str) -> str:
+    text = (text or "").strip()
+    text = re.sub(r"^https?://(dx\.)?doi\.org/", "", text, flags=re.I)
+    return text.strip().rstrip("/")
+
+
+def detect_query_type(query: str) -> str:
+    q = (query or "").strip()
+    doi_pattern = r"^10\.\d{4,9}/[-._;()/:A-Z0-9]+$"
+    if re.match(doi_pattern, q, flags=re.I):
+        return "doi"
+    if q.startswith("http://") or q.startswith("https://"):
+        return "link"
+    return "topic"
+
+
+def tokenize(text: str) -> List[str]:
+    return [
+        t for t in re.findall(r"[A-Za-z][A-Za-z0-9\-/+]{2,}", (text or ""))
+        if t.lower() not in STOPWORDS
+    ]
+
+
+def text_overlap_score(a: str, b: str) -> float:
+    sa = {x.lower() for x in tokenize(a)}
+    sb = {x.lower() for x in tokenize(b)}
+    if not sa or not sb:
+        return 0.0
+    return len(sa & sb) / max(1, len(sa | sb))
+
+
+def compute_recency_bonus(year: str) -> float:
+    try:
+        y = int(str(year)[:4])
+    except Exception:
+        return 0.0
+    current = time.gmtime().tm_year
+    age = max(current - y, 0)
+    return max(0.0, 0.16 - age * 0.018)
+
+
+def clean_extracted_text(text: str) -> str:
+    text = text or ""
+    replacements = {
+        "\u00ad": "",
+        "\ufb01": "fi",
+        "\ufb02": "fl",
+        "\u2010": "-",
+        "\u2011": "-",
+        "\u2012": "-",
+        "\u2013": "-",
+        "\u2014": "-",
+        "\u2212": "-",
+        "\u00a0": " ",
+    }
+    for old, new in replacements.items():
+        text = text.replace(old, new)
+
+    text = re.sub(r"(\w)-\s*\n\s*(\w)", r"\1\2", text)
+    text = re.sub(r"([a-z])\n([a-z])", r"\1 \2", text)
+    text = re.sub(r"\bnjectable\b", "injectable", text, flags=re.I)
+    text = re.sub(r"\bfhydrogel\b", "hydrogel", text, flags=re.I)
+    text = re.sub(
+        r"(?i)\b([a-z])?(hydrogel|conductive|responsive|injectable|biomaterial|scaffold|cardiac|patch|repair)\b",
+        lambda m: m.group(2),
+        text,
+    )
+    text = re.sub(r"[ \t]+", " ", text)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text.strip()
+
+
+def paper_identity_key(paper: Dict[str, Any]) -> str:
+    return (
+        normalize_doi(paper.get("doi") or "")
+        or ((paper.get("external_ids") or {}).get("arxiv") or "")
+        or norm_text(paper.get("title", "")).lower()
+        or str(paper.get("id", ""))
+    )
+
+
+def unique_keep_order(items: List[str]) -> List[str]:
+    seen = set()
+    out = []
+    for item in items:
+        key = norm_text(item).lower()
+        if key and key not in seen:
+            seen.add(key)
+            out.append(norm_text(item))
+    return out
+
+
+# ----------------------------
+# Concept / claim extraction
+# ----------------------------
+
+def normalize_concept_label(phrase: str) -> str:
+    phrase = norm_text(phrase)
+    mapping = {"ph": "pH", "ai": "AI", "ml": "ML", "3d": "3D", "ecg": "ECG", "mri": "MRI"}
+    return " ".join(mapping.get(p.lower(), p) for p in phrase.split())
+
+
+def looks_like_bad_phrase(phrase: str) -> bool:
+    phrase = norm_text(phrase)
+    if not phrase or len(phrase) < 4 or len(phrase) > 90:
+        return True
+    parts = phrase.split()
+    if len(parts) > 6:
+        return True
+    for p in parts:
+        t = p.strip("-.,;:()[]{}")
+        if not t:
+            return True
+        if len(t) == 1 and t.lower() not in {"p", "h"}:
+            return True
+        if re.match(r"^[bcdfghjklmnpqrstvwxyz]{5,}$", t.lower()):
+            return True
+    return False
+
+
+def extract_concepts_from_text(text: str, max_terms: int = GRAPH_MAX_CONCEPTS) -> List[str]:
+    text = clean_extracted_text(text)
+    words = re.findall(r"[A-Za-z][A-Za-z0-9\-/+]{2,}", text)
+    phrases = []
+
+    for n in (3, 2, 1):
+        for i in range(len(words) - n + 1):
+            phrase = " ".join(words[i:i + n])
+            low = phrase.lower()
+            if any(tok in STOPWORDS for tok in low.split()):
+                continue
+            if looks_like_bad_phrase(low):
+                continue
+            phrases.append(low)
+
+    counts = Counter(phrases)
+    ranked = []
+    for phrase, count in counts.most_common(max_terms * 8):
+        score = float(count)
+        score += 0.25 * len(phrase.split())
+        if any(x in phrase for x in ["hydrogel", "conductive", "responsive", "injectable", "graph", "neural", "cardiac", "biomaterial"]):
+            score += 0.5
+        ranked.append((score, phrase))
+
+    out = []
+    seen = set()
+    for _, phrase in sorted(ranked, key=lambda x: x[0], reverse=True):
+        clean = normalize_concept_label(phrase)
+        low = clean.lower()
+        if low in seen:
+            continue
+        if any((low in s or s in low) and abs(len(low) - len(s)) <= 2 for s in seen):
+            continue
+        seen.add(low)
+        out.append(clean)
+        if len(out) >= max_terms:
+            break
+    return out
+
+
+def extract_claim_like_sentences(text: str, max_items: int = GRAPH_MAX_CLAIMS) -> List[str]:
+    text = clean_extracted_text(text)
+    sentences = [norm_text(s) for s in re.split(r"(?<=[\.\!\?])\s+", text) if norm_text(s)]
+    scored = []
+    for sentence in sentences:
+        if len(sentence) < 45 or len(sentence) > 320:
+            continue
+        lower = sentence.lower()
+        score = 0.0
+        if any(k in lower for k in ["improves", "reduces", "increases", "demonstrates", "shows", "reveals", "predicts", "achieves", "outperforms", "enables", "supports"]):
+            score += 2.0
+        if any(k in lower for k in ["significant", "associated", "correlated", "effective", "robust", "accurate", "validated", "statistically"]):
+            score += 1.0
+        score += min(len(tokenize(sentence)) / 18.0, 2.0)
+        scored.append((score, sentence))
+
+    out = []
+    seen = set()
+    for _, sentence in sorted(scored, key=lambda x: x[0], reverse=True):
+        key = sentence.lower()
+        if key not in seen:
+            seen.add(key)
+            out.append(sentence)
+        if len(out) >= max_items:
+            break
+    return out
+
+
+def extract_title_from_text(raw_text: str, fallback: str = "Uploaded PDF") -> str:
+    raw_text = clean_extracted_text(raw_text or "")
+    lines = [norm_text(x) for x in raw_text.splitlines() if norm_text(x)]
+    for line in lines[:18]:
+        if 8 <= len(line) <= 240 and not re.search(r"doi|http|www\.|@", line, flags=re.I):
+            return truncate_text(line.strip(" -:;"), 240)
+    return fallback
+
+
+def extract_references_from_text(text: str) -> List[Dict[str, str]]:
+    refs = []
+    seen = set()
+    doi_re = re.compile(r"10\.\d{4,9}/[-._;()/:A-Z0-9]+", re.I)
+
+    for line in [norm_text(x) for x in clean_extracted_text(text).splitlines() if norm_text(x)][-250:]:
+        doi_match = doi_re.search(line)
+        doi = normalize_doi(doi_match.group(0)) if doi_match else ""
+        title = line.replace(doi_match.group(0), "").strip(" .;,-") if doi_match else line
+        if len(title) < 12:
+            continue
+        key = (title.lower(), doi.lower())
+        if key in seen:
+            continue
+        seen.add(key)
+        refs.append({"title": truncate_text(title, 220), "doi": doi})
+        if len(refs) >= 40:
+            break
+    return refs
+
+
+# ----------------------------
+# Search sources
+# ----------------------------
+
+def parse_openalex_abstract(inverted_index) -> str:
+    if not inverted_index or not isinstance(inverted_index, dict):
+        return ""
+    pos_to_word = {}
+    for word, positions in inverted_index.items():
+        for pos in positions:
+            pos_to_word[pos] = word
+    return " ".join(pos_to_word[i] for i in sorted(pos_to_word)) if pos_to_word else ""
+
+
+def enrich_paper_semantics(query: str, paper: Dict[str, Any]) -> Dict[str, Any]:
+    paper = dict(paper)
+    title = clean_extracted_text(paper.get("title", ""))
+    abstract = clean_extracted_text(paper.get("abstract", "") or paper.get("summary", ""))
+    venue = clean_extracted_text(paper.get("venue", ""))
+
+    concepts = extract_concepts_from_text(" ".join([title, abstract, venue]), max_terms=GRAPH_MAX_CONCEPTS)
+    claims = extract_claim_like_sentences(abstract, max_items=GRAPH_MAX_CLAIMS)
+    rel = text_overlap_score(query, f"{title} {abstract}")
+    recency = compute_recency_bonus(paper.get("year"))
+    doi_bonus = 0.02 if paper.get("doi") else 0.0
+    oa_bonus = 0.03 if paper.get("open_access") else 0.0
+    learned_score = float(paper.get("score", 0)) + rel * 0.52 + recency + doi_bonus + oa_bonus + min(len(concepts), 8) * 0.012
+
+    paper["title"] = title or paper.get("title", "Untitled")
+    paper["abstract"] = abstract
+    paper["summary"] = truncate_text(abstract or paper.get("summary", ""), 520)
+    paper["venue"] = venue
+    paper["concepts"] = concepts[:GRAPH_MAX_CONCEPTS]
+    paper["claims"] = claims[:GRAPH_MAX_CLAIMS]
+    paper["relevance"] = round(rel, 4)
+    paper["learned_score"] = round(learned_score, 4)
+    return paper
+
+
+def dedupe_papers(items: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    seen = {}
+    for item in items:
+        key = paper_identity_key(item) or f"{item.get('source', 'src')}::{item.get('title', 'paper')}"
+        cur = seen.get(key)
+        cur_score = float(cur.get("learned_score", cur.get("score", 0))) if cur else -1
+        new_score = float(item.get("learned_score", item.get("score", 0)))
+        if cur is None or new_score > cur_score:
+            seen[key] = item
+    out = list(seen.values())
+    out.sort(key=lambda x: float(x.get("learned_score", x.get("score", 0))), reverse=True)
+    return out
+
+
+def search_arxiv(query: str, max_results: int = 8) -> List[Dict[str, Any]]:
+    encoded = urllib.parse.quote(query)
+    url = (
+        "http://export.arxiv.org/api/query?search_query=all:"
+        f"{encoded}&start=0&max_results={max_results}&sortBy=relevance&sortOrder=descending"
+    )
+    response = requests.get(url, timeout=REQUEST_TIMEOUT)
+    response.raise_for_status()
+    root = ET.fromstring(response.text)
+    ns = {"atom": "http://www.w3.org/2005/Atom"}
+
+    out = []
+    for entry in root.findall("atom:entry", ns):
+        title = clean_extracted_text(entry.findtext("atom:title", default="", namespaces=ns) or "")
+        summary = truncate_text(clean_extracted_text(entry.findtext("atom:summary", default="", namespaces=ns) or ""), MAX_ABSTRACT_CHARS)
+        published = entry.findtext("atom:published", default="", namespaces=ns) or ""
+        paper_id = entry.findtext("atom:id", default="", namespaces=ns) or ""
+        authors = [clean_extracted_text(a.findtext("atom:name", default="", namespaces=ns) or "") for a in entry.findall("atom:author", ns)]
+        pdf_url = ""
+        for link in entry.findall("atom:link", ns):
+            if link.attrib.get("title") == "pdf":
+                pdf_url = link.attrib.get("href", "")
+                break
+
+        out.append({
+            "id": paper_id or title,
+            "title": title,
+            "summary": summary,
+            "abstract": summary,
+            "published": published[:10],
+            "authors": [a for a in authors[:8] if a],
+            "authors_text": ", ".join([a for a in authors[:4] if a]) or "Unknown authors",
+            "url": paper_id,
+            "pdf": pdf_url,
+            "doi": "",
+            "venue": "arXiv",
+            "year": published[:4] if published else "",
+            "source": "arxiv",
+            "score": 0.76,
+            "open_access": True,
+            "external_ids": {"arxiv": (paper_id or "").split("/")[-1]},
+        })
+    return out
+
+
+def search_crossref(query: str, mode: str = "topic", max_results: int = 8) -> List[Dict[str, Any]]:
+    headers = {"User-Agent": "dvnc-ai-space/1.0"}
+    if mode == "doi":
+        url = f"https://api.crossref.org/works/{urllib.parse.quote(normalize_doi(query))}"
+        response = requests.get(url, headers=headers, timeout=REQUEST_TIMEOUT)
+        if response.status_code != 200:
+            return []
+        items = [response.json().get("message", {})]
+    else:
+        params = {"rows": max_results}
+        if mode in ("title", "paper_name"):
+            params["query.title"] = query
+        else:
+            params["query.bibliographic"] = query
+        response = requests.get("https://api.crossref.org/works", params=params, headers=headers, timeout=REQUEST_TIMEOUT)
+        response.raise_for_status()
+        items = response.json().get("message", {}).get("items", [])
+
+    out = []
+    for item in items:
+        authors = []
+        for a in item.get("author", []) or []:
+            name = " ".join(filter(None, [a.get("given"), a.get("family")])).strip()
+            if name:
+                authors.append(clean_extracted_text(name))
+
+        title = clean_extracted_text((item.get("title") or ["Untitled"])[0])
+        year = ""
+        for key in ["published-print", "published-online", "created"]:
+            if item.get(key, {}).get("date-parts"):
+                year = str(item[key]["date-parts"][0][0])
+                break
+        abstract = truncate_text(clean_extracted_text(re.sub("<.*?>", " ", item.get("abstract") or "")), MAX_ABSTRACT_CHARS)
+        doi = normalize_doi(item.get("DOI", ""))
+
+        out.append({
+            "id": doi or title,
+            "title": title,
+            "summary": truncate_text(abstract, 500),
+            "abstract": abstract,
+            "published": year,
+            "authors": authors,
+            "authors_text": ", ".join(authors[:4]) if authors else "Unknown authors",
+            "url": item.get("URL", ""),
+            "pdf": "",
+            "doi": doi,
+            "venue": clean_extracted_text((item.get("container-title") or [""])[0]),
+            "year": year,
+            "source": "crossref",
+            "score": 0.72,
+            "open_access": None,
+            "external_ids": {"crossref": doi} if doi else {},
+        })
+    return out
+
+
+def search_openalex(query: str, mode: str = "topic", max_results: int = 8) -> List[Dict[str, Any]]:
+    params = {"per-page": max_results}
+    if mode == "doi":
+        doi = normalize_doi(query)
+        params["filter"] = f"doi:https://doi.org/{doi}"
+    else:
+        params["search"] = query
+
+    response = requests.get("https://api.openalex.org/works", params=params, timeout=REQUEST_TIMEOUT)
+    if response.status_code != 200:
+        return []
+    items = response.json().get("results", [])
+
+    out = []
+    for item in items:
+        authors = []
+        for auth in item.get("authorships", [])[:8]:
+            author = auth.get("author") or {}
+            if author.get("display_name"):
+                authors.append(clean_extracted_text(author["display_name"]))
+        oa = item.get("open_access") or {}
+        doi = normalize_doi(item.get("doi") or "")
+        abstract = truncate_text(clean_extracted_text(parse_openalex_abstract(item.get("abstract_inverted_index"))), MAX_ABSTRACT_CHARS)
+
+        out.append({
+            "id": item.get("id") or doi or item.get("title"),
+            "title": clean_extracted_text(item.get("title") or ""),
+            "summary": truncate_text(abstract, 500),
+            "abstract": abstract,
+            "published": str(item.get("publication_year") or ""),
+            "authors": authors,
+            "authors_text": ", ".join(authors[:4]) if authors else "Unknown authors",
+            "url": ((item.get("primary_location") or {}).get("landing_page_url") or item.get("id") or ""),
+            "pdf": oa.get("oa_url") or "",
+            "doi": doi,
+            "venue": clean_extracted_text((((item.get("primary_location") or {}).get("source") or {}).get("display_name") or "")),
+            "year": str(item.get("publication_year") or ""),
+            "source": "openalex",
+            "score": 0.80,
+            "open_access": oa.get("is_oa"),
+            "external_ids": item.get("ids") or {},
+        })
+    return out
+
+
+def search_semantic_scholar(query: str, mode: str = "topic", max_results: int = 8) -> List[Dict[str, Any]]:
+    fields = "title,authors,year,abstract,venue,externalIds,url,openAccessPdf"
+    if mode == "doi":
+        doi = normalize_doi(query)
+        url = f"https://api.semanticscholar.org/graph/v1/paper/DOI:{urllib.parse.quote(doi)}"
+        response = requests.get(url, params={"fields": fields}, timeout=REQUEST_TIMEOUT)
+        if response.status_code != 200:
+            return []
+        items = [response.json()]
+    else:
+        response = requests.get(
+            "https://api.semanticscholar.org/graph/v1/paper/search",
+            params={"query": query, "limit": max_results, "fields": fields},
+            timeout=REQUEST_TIMEOUT,
+        )
+        if response.status_code != 200:
+            return []
+        items = response.json().get("data", [])
+
+    out = []
+    for item in items:
+        external = item.get("externalIds") or {}
+        authors = [clean_extracted_text(a.get("name")) for a in item.get("authors", []) if a.get("name")]
+        abstract = truncate_text(clean_extracted_text(item.get("abstract", "")), MAX_ABSTRACT_CHARS)
+        out.append({
+            "id": external.get("CorpusId") or external.get("DOI") or item.get("title"),
+            "title": clean_extracted_text(item.get("title") or ""),
+            "summary": truncate_text(abstract, 500),
+            "abstract": abstract,
+            "published": str(item.get("year") or ""),
+            "authors": authors,
+            "authors_text": ", ".join(authors[:4]) if authors else "Unknown authors",
+            "url": item.get("url") or "",
+            "pdf": ((item.get("openAccessPdf") or {}).get("url") or ""),
+            "doi": normalize_doi(external.get("DOI", "")),
+            "venue": clean_extracted_text(item.get("venue") or ""),
+            "year": str(item.get("year") or ""),
+            "source": "semantic_scholar",
+            "score": 0.84,
+            "open_access": bool((item.get("openAccessPdf") or {}).get("url")),
+            "external_ids": external,
+        })
+    return out
+
+
+def search_europe_pmc(query: str, mode: str = "topic", max_results: int = 8) -> List[Dict[str, Any]]:
+    epmc_query = f'DOI:"{query}"' if mode == "doi" else query
+    params = {"query": epmc_query, "format": "json", "pageSize": max_results, "resultType": "core"}
+    response = requests.get("https://www.ebi.ac.uk/europepmc/webservices/rest/search", params=params, timeout=REQUEST_TIMEOUT)
+    if response.status_code != 200:
+        return []
+    items = response.json().get("resultList", {}).get("result", [])
+
+    out = []
+    for item in items:
+        author_string = item.get("authorString", "")
+        authors = [clean_extracted_text(x) for x in author_string.split(",")[:8] if norm_text(x)]
+        pmcid = item.get("pmcid", "")
+        pdf_url = f"https://europepmc.org/articles/{pmcid}?pdf=render" if pmcid else ""
+        landing_url = f"https://europepmc.org/article/PMC/{pmcid}" if pmcid else ""
+        abstract = truncate_text(clean_extracted_text(item.get("abstractText", "")), MAX_ABSTRACT_CHARS)
+        out.append({
+            "id": item.get("id") or item.get("doi") or item.get("title"),
+            "title": clean_extracted_text(item.get("title") or ""),
+            "summary": truncate_text(abstract, 500),
+            "abstract": abstract,
+            "published": str(item.get("pubYear") or ""),
+            "authors": authors,
+            "authors_text": ", ".join(authors[:4]) if authors else "Unknown authors",
+            "url": landing_url,
+            "pdf": pdf_url,
+            "doi": normalize_doi(item.get("doi", "")),
+            "venue": clean_extracted_text(item.get("journalTitle", "")),
+            "year": str(item.get("pubYear") or ""),
+            "source": "europe_pmc",
+            "score": 0.78,
+            "open_access": bool(pmcid),
+            "external_ids": {"pmid": item.get("pmid"), "pmcid": pmcid},
+        })
+    return out
+
+
+def resolve_link(query: str) -> List[Dict[str, Any]]:
+    url = (query or "").strip()
+    if not url:
+        return []
+    return [{
+        "id": url,
+        "title": Path(url.split("?")[0]).name or url,
+        "summary": "Direct link supplied.",
+        "abstract": "",
+        "published": "",
+        "authors": [],
+        "authors_text": "Unknown authors",
+        "url": url,
+        "pdf": url if url.lower().endswith(".pdf") else "",
+        "doi": "",
+        "venue": "Web Link",
+        "year": "",
+        "source": "link",
+        "score": 0.4,
+        "open_access": None,
+        "external_ids": {},
+    }]
+
+
+def discover_papers(query: str, mode: str, sources: List[str], max_results: int = 10) -> List[Dict[str, Any]]:
+    query = (query or "").strip()
+    if not query:
+        return []
+
+    mode = detect_query_type(query) if mode == "autonomous_web" else mode
+    selected_sources = ensure_list(sources) or DEFAULT_SOURCES
+    results = []
+
+    if mode == "link":
+        return dedupe_papers(resolve_link(query))
+
+    if "arxiv" in selected_sources and mode != "doi":
+        try:
+            results.extend(search_arxiv(query, max_results=min(max_results, 6)))
+        except Exception:
+            pass
+    if "crossref" in selected_sources:
+        try:
+            results.extend(search_crossref(query, mode=mode, max_results=min(max_results, 8)))
+        except Exception:
+            pass
+    if "openalex" in selected_sources:
+        try:
+            results.extend(search_openalex(query, mode=mode, max_results=min(max_results, 8)))
+        except Exception:
+            pass
+    if "semantic_scholar" in selected_sources:
+        try:
+            results.extend(search_semantic_scholar(query, mode=mode, max_results=min(max_results, 8)))
+        except Exception:
+            pass
+    if "europe_pmc" in selected_sources:
+        try:
+            results.extend(search_europe_pmc(query, mode=mode, max_results=min(max_results, 8)))
+        except Exception:
+            pass
+
+    papers = [enrich_paper_semantics(query, p) for p in dedupe_papers(results)]
+    papers.sort(key=lambda x: float(x.get("learned_score", x.get("score", 0))), reverse=True)
+    return papers[:max_results]
+
+
+# ----------------------------
+# Journal / paper HTML
+# ----------------------------
+
+def journal_query_links(query: str):
+    q = urllib.parse.quote_plus(query or "biomaterials cardiac repair")
+    rows = []
+    for journal in JOURNALS:
+        url = f"{journal['url']}?q={q}" if "?" not in journal["url"] else f"{journal['url']}&q={q}"
+        if "ieeexplore" in journal["url"]:
+            url = f"https://ieeexplore.ieee.org/search/searchresult.jsp?queryText={q}"
+        rows.append({"name": journal["name"], "desc": journal["desc"], "url": url})
+    return rows
+
+
+def build_journal_html(query):
+    rows = []
+    for journal in journal_query_links(query):
+        rows.append(
+            f"""
+            <a class="journal-card" href="{safe_text(journal['url'])}" target="_blank" rel="noopener noreferrer">
+              <div>
+                <h4>{safe_text(journal['name'])}</h4>
+                <p>{safe_text(journal['desc'])}</p>
+              </div>
+              <span>Open</span>
+            </a>
+            """
+        )
+    return """
+    <style>
+      .journal-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(240px,1fr));gap:12px}
+      .journal-card{display:flex;justify-content:space-between;gap:12px;padding:14px 16px;border-radius:14px;border:1px solid #dbe3f0;background:#f8fbff;text-decoration:none;color:#0f172a}
+      .journal-card h4{margin:0 0 4px;font-size:15px}
+      .journal-card p{margin:0;color:#475569;font-size:13px;line-height:1.45}
+      .journal-card span{align-self:center;font-size:12px;font-weight:700;color:#2563eb}
+    </style>
+    <div class="journal-grid">""" + "".join(rows) + "</div>"
+
+
+def paper_choice_value(index: int, paper: Dict[str, Any]) -> str:
+    doi = normalize_doi(paper.get("doi") or "")
+    title_slug = slugify(paper.get("title", ""))[:40]
+    return f"{index}|{doi}|{title_slug}"
+
+
+def paper_choice_label(index: int, paper: Dict[str, Any]) -> str:
+    score = round(float(paper.get("learned_score", paper.get("score", 0))), 3)
+    title = paper.get("title", "Untitled")
+    authors_text = paper.get("authors_text", "Unknown authors")[:90]
+    source = paper.get("source", "src")
+    return f"[{source}] {title} — {authors_text} — score {score}"
+
+
+def format_selection_choices(papers):
+    return [(paper_choice_label(i, paper), paper_choice_value(i, paper)) for i, paper in enumerate(papers)]
+
+
+def format_papers_html(papers):
+    if not papers:
+        return '<div class="panel papers-panel" style="padding:18px"><p>No papers found yet.</p></div>'
+
+    items = []
+    for i, paper in enumerate(papers, start=1):
+        summary = safe_text((paper.get("summary") or paper.get("abstract") or "")[:320])
+        doi_line = f'<span class="paper-badge doi-badge">{safe_text(paper.get("doi"))}</span>' if paper.get("doi") else ""
+        pdf_link = paper.get("pdf") or "#"
+        abs_link = paper.get("url") or "#"
+        concepts_text = ", ".join((paper.get("concepts") or [])[:5])
+
+        items.append(
+            f"""
+            <article class="paper-card">
+              <div class="paper-topline">
+                <span class="paper-badge">{safe_text(paper.get('source', 'paper'))}</span>
+                <span class="paper-badge alt">{safe_text(paper.get('published', '') or 'Paper')}</span>
+                {doi_line}
+              </div>
+              <h4>{i}. {safe_text(paper.get('title', 'Untitled'))}</h4>
+              <p>{summary or 'No abstract snippet available.'}</p>
+              <div class="paper-meta-stack">
+                <div><strong>Authors:</strong> {safe_text(paper.get('authors_text', 'Unknown authors'))}</div>
+                <div><strong>Venue:</strong> {safe_text(paper.get('venue', 'Unknown venue'))}</div>
+                <div><strong>Learned score:</strong> {safe_text(round(float(paper.get('learned_score', paper.get('score', 0))), 3))}</div>
+                <div><strong>Concepts:</strong> {safe_text(concepts_text or 'None extracted')}</div>
+              </div>
+              <div class="paper-links">
+                <a href="{safe_text(abs_link)}" target="_blank" rel="noopener noreferrer">Abstract</a>
+                <a href="{safe_text(pdf_link)}" target="_blank" rel="noopener noreferrer">PDF</a>
+              </div>
+            </article>
+            """
+        )
+    return '<div class="papers-grid">' + ''.join(items) + '</div>'
+
+
+def format_frontier_html(frontier):
+    if not frontier:
+        return '<div class="panel papers-panel" style="padding:18px"><p>No autonomous expansion candidates yet.</p></div>'
+    cards = []
+    for i, paper in enumerate(frontier[:12], start=1):
+        cards.append(
+            f"""
+            <article class="paper-card frontier-card">
+              <div class="paper-topline">
+                <span class="paper-badge">frontier</span>
+                <span class="paper-badge alt">{safe_text(paper.get('source', 'paper'))}</span>
+              </div>
+              <h4>{i}. {safe_text(paper.get('title', 'Untitled'))}</h4>
+              <p>{safe_text((paper.get('summary') or paper.get('abstract') or '')[:280])}</p>
+              <div class="paper-meta-stack">
+                <div><strong>Frontier score:</strong> {safe_text(paper.get('frontier_score', paper.get('learned_score', paper.get('score', 0))))}</div>
+                <div><strong>Concept overlap:</strong> {safe_text(paper.get('frontier_concept_overlap', 0))}</div>
+                <div><strong>Authors:</strong> {safe_text(paper.get('authors_text', 'Unknown authors'))}</div>
+              </div>
+            </article>
+            """
+        )
+    return '<div class="papers-grid">' + ''.join(cards) + '</div>'
+
+
+def uploaded_pdf_summary(file_obj):
+    if not file_obj:
+        return "No PDF uploaded yet."
+    path = getattr(file_obj, "name", None) or str(file_obj)
+    p = Path(path)
+    return f"Uploaded PDF ready for ingestion: {p.name}. Use Parse uploaded PDF to extract title, abstract, sections, references, concepts, and claims."
+
+
+# ----------------------------
+# 3D graph
+# ----------------------------
+
+def graph_kind_style(kind: str) -> Dict[str, Any]:
+    palette = {
+        "query": {"color": "#1f8ef1", "size": 14, "label": "Research topic"},
+        "paper": {"color": "#00c49a", "size": 10, "label": "Paper"},
+        "upload": {"color": "#ff9f43", "size": 11, "label": "Uploaded PDF"},
+        "concept": {"color": "#a66cff", "size": 8, "label": "Concept"},
+        "author": {"color": "#f368e0", "size": 7, "label": "Author"},
+        "claim": {"color": "#ff6b6b", "size": 8, "label": "Claim"},
+        "reference": {"color": "#6c757d", "size": 7, "label": "Reference"},
+        "frontier": {"color": "#ffd166", "size": 8, "label": "Frontier candidate"},
+    }
+    return palette.get(kind, {"color": "#9aa0a6", "size": 7, "label": kind.title()})
+
+
+def summarize_graph(nodes: List[Dict], edges: List[Dict]) -> Dict[str, Any]:
+    counts = Counter((n.get("kind") or n.get("type") or "unknown").lower() for n in nodes)
+    return {"nodes": len(nodes), "edges": len(edges), "counts": dict(counts)}
+
+
+def _prepare_3d_graph_data(nodes: List[Dict], edges: List[Dict], title: str) -> Dict[str, Any]:
+    node_out = []
+    for node in nodes:
+        kind = (node.get("kind") or node.get("type") or "paper").lower()
+        if kind == "topic":
+            kind = "query"
+        if kind == "uploadedpdf":
+            kind = "upload"
+        if kind == "frontierpaper":
+            kind = "frontier"
+        style = graph_kind_style(kind)
+        node_out.append({
+            "id": node.get("id"),
+            "label": truncate_text(node.get("label") or node.get("title") or node.get("id") or "node", 120),
+            "kind": kind,
+            "color": style["color"],
+            "val": style["size"],
+            "detail": {
+                "kind": style["label"],
+                "title": node.get("title") or node.get("label") or node.get("id"),
+                "venue": node.get("venue") or "",
+                "year": node.get("year") or "",
+                "doi": node.get("doi") or "",
+                "source": node.get("source") or "",
+                "authors_text": node.get("authors_text") or "",
+                "text": node.get("text") or "",
+            },
+        })
+    edge_out = []
+    for edge in edges:
+        edge_out.append({
+            "source": edge.get("source"),
+            "target": edge.get("target"),
+            "type": edge.get("type") or "RELATES_TO",
+            "label": edge.get("type") or "RELATES_TO",
+        })
+    return {"title": title, "nodes": node_out, "links": edge_out, "summary": summarize_graph(nodes, edges)}
+
+
+def build_learning_graph_html(nodes, edges, title="Self-Learning Knowledge Graph"):
+    if not nodes:
+        return """
+        <div class="panel brain-shell" style="overflow:auto; max-width:100%;">
+          <div class="brain-header">
+            <div>
+              <p class="eyebrow">Learning Graph</p>
+              <h3>Self-Learning Knowledge Graph</h3>
+            </div>
+          </div>
+          <div class="brain-stage learning-empty" style="min-height:420px; overflow:auto;">
+            <div class="empty-graph-copy">
+              <h4>No papers mapped yet</h4>
+              <p>Search papers, select candidates, or upload a PDF to grow the graph in an interactive 3D view.</p>
+            </div>
+          </div>
+        </div>
+        """
+
+    graph_data = _prepare_3d_graph_data(nodes, edges, title)
+    payload_json = json.dumps(graph_data, ensure_ascii=False)
+
+    iframe_html = f"""
+<!doctype html>
+<html>
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<style>
+  html, body {{ margin:0; height:100%; background:#0b1020; color:#eef2ff; font-family: Inter, ui-sans-serif, system-ui, sans-serif; overflow:hidden; }}
+  #wrap {{ position:relative; width:100%; height:100%; background:radial-gradient(circle at top, #18213c 0%, #0b1020 60%, #060910 100%); }}
+  #graph {{ position:absolute; inset:0; }}
+  .overlay {{
+    position:absolute; left:16px; top:16px; z-index:10; max-width:min(460px, calc(100% - 32px));
+    padding:14px 16px; border:1px solid rgba(255,255,255,.12); border-radius:16px;
+    background:rgba(10,14,28,.72); backdrop-filter: blur(14px); box-shadow:0 12px 28px rgba(0,0,0,.28);
+  }}
+  .overlay h3 {{ margin:0 0 6px; font-size:18px; line-height:1.2; }}
+  .overlay p {{ margin:0; font-size:13px; color:#cbd5e1; line-height:1.5; }}
+  .panel {{
+    position:absolute; right:16px; top:16px; z-index:10; width:min(360px, calc(100% - 32px));
+    max-height:calc(100% - 32px); overflow:auto; padding:14px 16px; border:1px solid rgba(255,255,255,.12);
+    border-radius:16px; background:rgba(10,14,28,.72); backdrop-filter: blur(14px); box-shadow:0 12px 28px rgba(0,0,0,.28);
+  }}
+  .panel h4 {{ margin:0 0 8px; font-size:14px; color:#f8fafc; }}
+  .panel p {{ margin:0; font-size:12px; color:#cbd5e1; line-height:1.5; }}
+  .panel dl {{ margin:12px 0 0; display:grid; grid-template-columns:auto 1fr; gap:6px 10px; font-size:12px; }}
+  .panel dt {{ color:#93c5fd; }}
+  .panel dd {{ margin:0; color:#e2e8f0; word-break:break-word; }}
+  .hint {{
+    position:absolute; left:16px; bottom:16px; z-index:10; padding:10px 12px; border-radius:12px;
+    font-size:12px; color:#dbeafe; background:rgba(15,23,42,.75); border:1px solid rgba(255,255,255,.08);
+  }}
+</style>
+<script src="https://unpkg.com/three@0.160.0/build/three.min.js"></script>
+<script src="https://unpkg.com/3d-force-graph"></script>
+</head>
+<body>
+<div id="wrap">
+  <div id="graph"></div>
+  <div class="overlay">
+    <h3></h3>
+    <p>Drag the background to orbit, scroll to zoom, right-drag to pan, and drag a node to move or pin it in 3D space.</p>
+  </div>
+  <div class="panel" id="panel">
+    <h4>Node details</h4>
+    <p>Click any node to inspect its label, type, venue, DOI, year, and source.</p>
+  </div>
+  <div class="hint">Interactive 3D graph: orbit, zoom, pan, drag nodes.</div>
+</div>
+<script>
+const payload = {payload_json};
+document.querySelector('.overlay h3').textContent = payload.title || 'Self-Learning Knowledge Graph';
+const panelEl = document.getElementById('panel');
+
+const Graph = ForceGraph3D()(document.getElementById('graph'))
+  .backgroundColor('#00000000')
+  .graphData(payload)
+  .nodeRelSize(6)
+  .nodeOpacity(1)
+  .nodeLabel(node => `<div style="padding:6px 8px"><strong>${{node.label}}</strong><br/>${{(node.detail || {{}}).kind || node.kind}}</div>`)
+  .linkWidth(link => ['ABOUT','UPLOADED_SOURCE','FRONTIER_CANDIDATE'].includes(link.type) ? 2.6 : 1.35)
+  .linkDirectionalParticles(link => ['ABOUT','FRONTIER_CANDIDATE'].includes(link.type) ? 2 : 0)
+  .linkDirectionalParticleWidth(2.2)
+  .cooldownTicks(140)
+  .d3VelocityDecay(0.24)
+  .d3Force('charge').strength(-180)
+  .nodeColor(node => node.color)
+  .nodeVal(node => node.val)
+  .onNodeClick(node => {{
+    const d = node.detail || {{}};
+    panelEl.innerHTML = `
+      <h4>Node details</h4>
+      <dl>
+        <dt>Label</dt><dd>${{node.label || ''}}</dd>
+        <dt>Type</dt><dd>${{d.kind || node.kind || ''}}</dd>
+        <dt>Venue</dt><dd>${{d.venue || '—'}}</dd>
+        <dt>Year</dt><dd>${{d.year || '—'}}</dd>
+        <dt>DOI</dt><dd>${{d.doi || '—'}}</dd>
+        <dt>Source</dt><dd>${{d.source || '—'}}</dd>
+        <dt>Authors</dt><dd>${{d.authors_text || '—'}}</dd>
+        <dt>Text</dt><dd>${{d.text || '—'}}</dd>
+      </dl>`;
+  }})
+  .onNodeDragEnd(node => {{
+    node.fx = node.x;
+    node.fy = node.y;
+    node.fz = node.z;
+  }});
+
+Graph.scene().add(new THREE.AmbientLight(0xffffff, 1.1));
+const dirLight = new THREE.DirectionalLight(0xffffff, 0.8);
+dirLight.position.set(120, 120, 120);
+Graph.scene().add(dirLight);
+Graph.cameraPosition({{ z: 210 }});
+</script>
+</body>
+</html>
+"""
+    return f"""
+    <div class="panel brain-shell" style="overflow:auto; max-width:100%;">
+      <iframe
+        title="{safe_text(title)}"
+        style="width:100%; height:{GRAPH_IFRAME_HEIGHT}px; border:0; border-radius:18px; overflow:auto; background:#0b1020;"
+        sandbox="allow-scripts allow-same-origin"
+        srcdoc="{html.escape(iframe_html, quote=True)}"
+      ></iframe>
+    </div>
+    """
+
+
+def build_learning_graph_state(query, papers, uploaded_name=None):
+    nodes = [{"id": "query", "label": query or "Research topic", "kind": "query"}]
+    edges = []
+
+    for i, paper in enumerate(papers[:6], start=1):
+        pid = f"paper_{i}"
+        nodes.append({
+            "id": pid,
+            "label": paper.get("title", f"Paper {i}"),
+            "kind": "paper",
+            "title": paper.get("title"),
+            "venue": paper.get("venue"),
+            "year": paper.get("year"),
+            "source": paper.get("source"),
+            "authors_text": paper.get("authors_text"),
+        })
+        edges.append({"source": "query", "target": pid, "type": "ABOUT"})
+        for concept in (paper.get("concepts") or [])[:3]:
+            cid = f"concept_{i}_{slugify(concept)[:30]}"
+            nodes.append({"id": cid, "label": concept, "kind": "concept"})
+            edges.append({"source": pid, "target": cid, "type": "MENTIONS"})
+
+    if uploaded_name:
+        nodes.append({"id": "upload", "label": uploaded_name, "kind": "upload"})
+        edges.append({"source": "query", "target": "upload", "type": "UPLOADED_SOURCE"})
+    return nodes, edges
+
+
+def graph_from_selected(query, selected_papers, uploaded_name=None, parsed_state=None, frontier=None):
+    nodes = [{"id": "query", "label": query or "Research topic", "kind": "query"}]
+    edges = []
+
+    for i, paper in enumerate(selected_papers[:8], start=1):
+        pid = f"paper_{i}"
+        nodes.append({
+            "id": pid,
+            "label": paper.get("title", f"Paper {i}"),
+            "kind": "paper",
+            "title": paper.get("title"),
+            "venue": paper.get("venue"),
+            "year": paper.get("year"),
+            "doi": paper.get("doi"),
+            "source": paper.get("source"),
+            "authors_text": paper.get("authors_text"),
+        })
+        edges.append({"source": "query", "target": pid, "type": "ABOUT"})
+
+        for author in paper.get("authors", [])[:3]:
+            aid = f"author_{i}_{slugify(author)[:30]}"
+            nodes.append({"id": aid, "label": author, "kind": "author"})
+            edges.append({"source": pid, "target": aid, "type": "WRITTEN_BY"})
+
+        for concept in (paper.get("concepts") or [])[:4]:
+            cid = f"concept_{i}_{slugify(concept)[:30]}"
+            nodes.append({"id": cid, "label": concept, "kind": "concept"})
+            edges.append({"source": pid, "target": cid, "type": "MENTIONS"})
+
+        for claim in (paper.get("claims") or [])[:2]:
+            cid = f"claim_{i}_{slugify(claim)[:30]}"
+            nodes.append({"id": cid, "label": truncate_text(claim, 82), "kind": "claim", "text": claim})
+            edges.append({"source": pid, "target": cid, "type": "ASSERTS"})
+
+    if uploaded_name:
+        nodes.append({"id": "upload", "label": uploaded_name, "kind": "upload", "title": uploaded_name})
+        edges.append({"source": "query", "target": "upload", "type": "UPLOADED_SOURCE"})
+        if parsed_state and isinstance(parsed_state, dict):
+            for concept in (parsed_state.get("concepts") or [])[:4]:
+                cid = f"upload_concept_{slugify(concept)[:30]}"
+                nodes.append({"id": cid, "label": concept, "kind": "concept"})
+                edges.append({"source": "upload", "target": cid, "type": "MENTIONS"})
+            for claim in (parsed_state.get("claims") or [])[:3]:
+                cid = f"upload_claim_{slugify(claim)[:30]}"
+                nodes.append({"id": cid, "label": truncate_text(claim, 82), "kind": "claim", "text": claim})
+                edges.append({"source": "upload", "target": cid, "type": "ASSERTS"})
+            for ref in (parsed_state.get("references") or [])[:6]:
+                if ref.get("title"):
+                    rid = f"ref_{slugify(ref.get('title'))[:30]}"
+                    nodes.append({"id": rid, "label": truncate_text(ref.get("title"), 82), "kind": "reference", "doi": ref.get("doi", "")})
+                    edges.append({"source": "upload", "target": rid, "type": "CITES"})
+
+    for j, fp in enumerate(ensure_list(frontier)[:6], start=1):
+        fid = f"frontier_{j}"
+        nodes.append({
+            "id": fid,
+            "label": fp.get("title", f"Frontier {j}"),
+            "kind": "frontier",
+            "title": fp.get("title"),
+            "source": fp.get("source"),
+            "authors_text": fp.get("authors_text"),
+            "year": fp.get("year"),
+            "doi": fp.get("doi"),
+        })
+        edges.append({"source": "query", "target": fid, "type": "FRONTIER_CANDIDATE"})
+
+    dedup_nodes = []
+    seen = set()
+    for node in nodes:
+        if node["id"] not in seen:
+            seen.add(node["id"])
+            dedup_nodes.append(node)
+    return dedup_nodes, edges
+
+
+# ----------------------------
+# PDF parsing
+# ----------------------------
+
+def parse_pdf_with_pymupdf(pdf_path: str) -> Dict[str, Any]:
+    if fitz is None:
+        raise RuntimeError("PyMuPDF not installed")
+
+    doc = fitz.open(pdf_path)
+    page_texts = [page.get_text("text") for page in doc[: min(len(doc), 10)]]
+    raw_text = truncate_text(clean_extracted_text("\n".join(page_texts).strip()), MAX_RAW_TEXT_CHARS)
+    first_page = clean_extracted_text("\n".join(page_texts[:2]))[:5000]
+
+    title = extract_title_from_text(first_page, fallback=Path(pdf_path).name)
+
+    abstract = ""
+    match = re.search(r"abstract\s*(.+?)(?:\n\s*\n|\n(?:1|i)[\.\s]|\nintroduction)", raw_text, re.I | re.S)
+    if match:
+        abstract = truncate_text(clean_extracted_text(match.group(1)), 2600)
+
+    sections = []
+    blocks = re.split(r"\n(?=[A-Z][A-Za-z\s]{2,40}\n)", raw_text)
+    for block in blocks[:10]:
+        lines = [norm_text(x) for x in block.splitlines() if norm_text(x)]
+        if not lines:
+            continue
+        heading = lines[0] if len(lines[0]) < 60 else "Section"
+        body = " ".join(lines[1:] if len(lines) > 1 else lines)
+        if len(body) > 80:
+            sections.append({"heading": clean_extracted_text(heading), "text": truncate_text(body, 4200)})
+
+    return {
+        "parser": "pymupdf",
+        "title": title,
+        "abstract": abstract,
+        "authors": [],
+        "sections": sections[:12] or ([{"heading": "Full Text", "text": raw_text[:12000]}] if raw_text else []),
+        "references": extract_references_from_text(raw_text),
+        "claims": extract_claim_like_sentences(raw_text, max_items=GRAPH_MAX_CLAIMS),
+        "concepts": extract_concepts_from_text(" ".join([title, abstract, raw_text[:18000]]), max_terms=GRAPH_MAX_CONCEPTS),
+        "raw_text": raw_text,
+        "parser_quality": "text-fallback-cleaned",
+    }
+
+
+def parse_uploaded_pdf(file_obj, parser_order=None):
+    if not file_obj:
+        return "### PDF parse status\n\nNo PDF uploaded yet.", {}
+
+    path = getattr(file_obj, "name", None) or str(file_obj)
+    parser_order = ensure_list(parser_order) or PDF_PARSERS
+    errors = []
+
+    for parser_name in parser_order:
+        try:
+            if parser_name == "pymupdf":
+                result = parse_pdf_with_pymupdf(path)
+            else:
+                continue
+
+            summary = (
+                f"### PDF parse status\n\n"
+                f"- Parser used: {result['parser']}\n"
+                f"- Parser quality: {result.get('parser_quality', 'unknown')}\n"
+                f"- Title: {result.get('title') or 'Unknown'}\n"
+                f"- Authors: {', '.join(result.get('authors')[:6]) if result.get('authors') else 'Unknown'}\n"
+                f"- Abstract found: {'Yes' if result.get('abstract') else 'No'}\n"
+                f"- Sections extracted: {len(result.get('sections') or [])}\n"
+                f"- References extracted: {len(result.get('references') or [])}\n"
+                f"- Concepts extracted: {len(result.get('concepts') or [])}\n"
+                f"- Claims extracted: {len(result.get('claims') or [])}\n"
+            )
+            return summary, result
+        except Exception as e:
+            errors.append(f"{parser_name}: {e}")
+
+    fail_summary = "### PDF parse status\n\n" + "\n".join([f"- {x}" for x in errors])
+    return fail_summary, {"parser": None, "errors": errors}
+
+
+def render_parse_result(parsed):
+    if not parsed or not isinstance(parsed, dict) or (not parsed.get("title") and not parsed.get("sections")):
+        return '<div class="panel" style="padding:18px"><p>No parsed document yet.</p></div>'
+
+    sections_html = []
+    for section in parsed.get("sections", [])[:8]:
+        sections_html.append(
+            f"""
+            <details class="agent-step">
+              <summary class="agent-summary">
+                <div class="agent-index">§</div>
+                <div class="agent-head">
+                  <h4>{safe_text(section.get('heading', 'Section'))}</h4>
+                  <span>section</span>
+                </div>
+              </summary>
+              <div class="agent-copy">
+                <p>{safe_text(section.get('text', '')[:2200])}</p>
+              </div>
+            </details>
+            """
+        )
+
+    refs = parsed.get("references", [])[:14]
+    refs_html = "".join(
+        f"<li>{safe_text(r.get('title') or 'Untitled')} {'· DOI ' + safe_text(r.get('doi')) if r.get('doi') else ''}</li>"
+        for r in refs
+    ) or "<li>No references extracted.</li>"
+
+    concepts = parsed.get("concepts", [])[:12]
+    claims = parsed.get("claims", [])[:8]
+    concepts_html = "".join(f"<li>{safe_text(x)}</li>" for x in concepts) or "<li>No concepts extracted.</li>"
+    claims_html = "".join(f"<li>{safe_text(x)}</li>" for x in claims) or "<li>No claims extracted.</li>"
+
+    title = safe_text(parsed.get("title") or "Parsed document")
+    abstract = safe_text((parsed.get("abstract") or "")[:2600]) or "No abstract extracted."
+    parser_name = safe_text(parsed.get("parser") or "unknown")
+    parser_quality = safe_text(parsed.get("parser_quality") or "unknown")
+
+    return f"""
+    <div class="panel" style="padding:18px">
+      <div class="brain-header">
+        <div>
+          <p class="eyebrow">PDF Parse</p>
+          <h3>{title}</h3>
+        </div>
+        <div class="brain-legend"><span><i class="dot dot-upload"></i> {parser_name} · {parser_quality}</span></div>
+      </div>
+      <div class="parse-grid">
+        <div class="parse-card">
+          <h4>Abstract</h4>
+          <p>{abstract}</p>
+        </div>
+        <div class="parse-card">
+          <h4>References</h4>
+          <ul class="ref-list">{refs_html}</ul>
+        </div>
+        <div class="parse-card">
+          <h4>Concepts</h4>
+          <ul class="ref-list">{concepts_html}</ul>
+        </div>
+        <div class="parse-card">
+          <h4>Claims</h4>
+          <ul class="ref-list">{claims_html}</ul>
+        </div>
+      </div>
+      <div class="timeline" style="margin-top:14px; max-height:560px; overflow:auto;">
+        {''.join(sections_html) if sections_html else '<div class="panel" style="padding:16px;"><p>No sections extracted.</p></div>'}
+      </div>
+    </div>
+    """
+
+
+# ----------------------------
+# Ingest payload / learning
+# ----------------------------
+
+def add_node(nodes_by_id: Dict[str, Dict], node_id: str, node_type: str, label: str = "", **attrs):
+    if not node_id:
+        return
+    current = nodes_by_id.get(node_id, {})
+    merged = {"id": node_id, "type": node_type, "label": label or current.get("label", node_id)}
+    merged.update(current)
+    for key, value in attrs.items():
+        if value not in [None, ""]:
+            merged[key] = value
+    nodes_by_id[node_id] = merged
+
+
+def add_edge(edges: List[Dict], source: str, target: str, edge_type: str, **attrs):
+    if not source or not target or source == target:
+        return
+    edge = {"source": source, "target": target, "type": edge_type}
+    for key, value in attrs.items():
+        if value not in [None, ""]:
+            edge[key] = value
+    edges.append(edge)
+
+
+def build_ingest_payload(query, selected_papers, parsed_pdf=None, frontier=None):
+    nodes_by_id = {}
+    edges = []
+
+    topic_id = "topic:query"
+    add_node(nodes_by_id, topic_id, "Topic", label=query or "Research topic", query=query or "")
+
+    for i, paper in enumerate(selected_papers, start=1):
+        paper_id = normalize_doi(paper.get("doi")) or ((paper.get("external_ids") or {}).get("arxiv")) or f"paper:{i}:{slugify(paper.get('title', 'paper'))[:40]}"
+        add_node(
+            nodes_by_id,
+            paper_id,
+            "Paper",
+            label=paper.get("title") or f"Paper {i}",
+            title=paper.get("title"),
+            year=paper.get("year"),
+            venue=paper.get("venue"),
+            doi=normalize_doi(paper.get("doi")),
+            source=paper.get("source"),
+            url=paper.get("url"),
+            pdf=paper.get("pdf"),
+            score=paper.get("score"),
+            learned_score=paper.get("learned_score", paper.get("score")),
+            open_access=paper.get("open_access"),
+            authors_text=paper.get("authors_text"),
+        )
+        add_edge(edges, topic_id, paper_id, "ABOUT", weight=paper.get("learned_score", paper.get("score", 0)))
+
+        for author in paper.get("authors", [])[:6]:
+            author_id = f"author:{slugify(author)[:64]}"
+            add_node(nodes_by_id, author_id, "Author", label=author, name=author)
+            add_edge(edges, paper_id, author_id, "WRITTEN_BY")
+
+        for concept in (paper.get("concepts") or [])[:8]:
+            concept_id = f"concept:{slugify(concept)[:72]}"
+            add_node(nodes_by_id, concept_id, "Concept", label=concept, name=concept)
+            add_edge(edges, paper_id, concept_id, "MENTIONS")
+
+        for claim in (paper.get("claims") or [])[:4]:
+            claim_id = f"claim:{slugify(claim)[:72]}"
+            add_node(nodes_by_id, claim_id, "Claim", label=claim[:140], text=claim)
+            add_edge(edges, paper_id, claim_id, "ASSERTS")
+
+    if parsed_pdf and isinstance(parsed_pdf, dict) and parsed_pdf.get("title"):
+        doc_id = "upload:pdf"
+        add_node(nodes_by_id, doc_id, "UploadedPDF", label=parsed_pdf.get("title"), title=parsed_pdf.get("title"), parser=parsed_pdf.get("parser"))
+        add_edge(edges, topic_id, doc_id, "UPLOADED_SOURCE")
+
+        for concept in (parsed_pdf.get("concepts") or [])[:8]:
+            concept_id = f"concept:{slugify(concept)[:72]}"
+            add_node(nodes_by_id, concept_id, "Concept", label=concept, name=concept)
+            add_edge(edges, doc_id, concept_id, "MENTIONS")
+
+        for claim in (parsed_pdf.get("claims") or [])[:6]:
+            claim_id = f"claim:{slugify(claim)[:72]}"
+            add_node(nodes_by_id, claim_id, "Claim", label=claim[:140], text=claim)
+            add_edge(edges, doc_id, claim_id, "ASSERTS")
+
+        for idx, ref in enumerate(parsed_pdf.get("references", [])[:20], start=1):
+            ref_title = ref.get("title") or f"Reference {idx}"
+            ref_doi = normalize_doi(ref.get("doi") or "")
+            ref_id = ref_doi or f"ref:{idx}:{slugify(ref_title)[:40]}"
+            add_node(nodes_by_id, ref_id, "Reference", label=ref_title, title=ref_title, doi=ref_doi)
+            add_edge(edges, doc_id, ref_id, "CITES")
+
+    for idx, item in enumerate(ensure_list(frontier)[:18], start=1):
+        fid = normalize_doi(item.get("doi")) or f"frontier:{idx}:{slugify(item.get('title', 'paper'))[:40]}"
+        add_node(
+            nodes_by_id,
+            fid,
+            "FrontierPaper",
+            label=item.get("title") or f"Frontier {idx}",
+            title=item.get("title"),
+            frontier_score=item.get("frontier_score"),
+            url=item.get("url"),
+            source=item.get("source"),
+            authors_text=item.get("authors_text"),
+            year=item.get("year"),
+            doi=item.get("doi"),
+        )
+        add_edge(edges, topic_id, fid, "FRONTIER_CANDIDATE", weight=item.get("frontier_score", item.get("learned_score", item.get("score", 0))))
+
+    return {"status": "ok", "nodes": list(nodes_by_id.values())[:GRAPH_MAX_NODES], "edges": edges[:GRAPH_MAX_EDGES]}
+
+
+def learn_from_payload(payload: Dict, query: str = "") -> Dict:
+    if not payload:
+        return GRAPH_MEMORY
+
+    GRAPH_MEMORY["queries"].append(query or "")
+    GRAPH_MEMORY["events"].append({
+        "ts": time.time(),
+        "query": query or "",
+        "nodes": len(payload.get("nodes", [])),
+        "edges": len(payload.get("edges", [])),
+    })
+    GRAPH_MEMORY["payloads"].append(payload)
+
+    for node in payload.get("nodes", []):
+        node_id = node.get("id")
+        if not node_id:
+            continue
+        GRAPH_MEMORY["nodes"][node_id] = node
+        node_type = (node.get("type") or "").lower()
+        if node_type in {"paper", "frontierpaper"}:
+            GRAPH_MEMORY["papers"][node_id] = node
+        if node_type == "concept" and node.get("label"):
+            GRAPH_MEMORY["concept_counts"][node["label"].lower()] += 1
+        if node_type == "claim" and node.get("label"):
+            GRAPH_MEMORY["claim_counts"][node["label"].lower()] += 1
+
+    GRAPH_MEMORY["edges"].extend(payload.get("edges", []))
+    GRAPH_MEMORY["edges"] = GRAPH_MEMORY["edges"][:GRAPH_MAX_EDGES]
+    return GRAPH_MEMORY
+
+
+def export_learning_state() -> str:
+    snapshot = {
+        "papers": list(GRAPH_MEMORY["papers"].values())[:60],
+        "nodes": list(GRAPH_MEMORY["nodes"].values())[:250],
+        "edges": GRAPH_MEMORY["edges"][:500],
+        "top_concepts": GRAPH_MEMORY["concept_counts"].most_common(24),
+        "top_claims": GRAPH_MEMORY["claim_counts"].most_common(24),
+        "queries": GRAPH_MEMORY["queries"][-20:],
+        "events": GRAPH_MEMORY["events"][-20:],
+        "frontier": GRAPH_MEMORY["frontier"][:24],
+    }
+    return json.dumps(snapshot, indent=2, ensure_ascii=False)
+
+
+# ----------------------------
+# Frontier expansion
+# ----------------------------
+
+def score_frontier_candidate(query: str, seed_concepts: List[str], paper: Dict[str, Any]) -> Dict[str, Any]:
+    title = paper.get("title", "")
+    abstract = paper.get("abstract", "") or paper.get("summary", "")
+    venue = paper.get("venue", "")
+    base_text = " ".join([title, abstract, venue])
+    rel = text_overlap_score(query, base_text)
+    concept_overlap = text_overlap_score(" ".join(seed_concepts), " ".join(paper.get("concepts") or [])) if seed_concepts else 0.0
+    recency = compute_recency_bonus(paper.get("year"))
+    doi_bonus = 0.02 if paper.get("doi") else 0.0
+    oa_bonus = 0.03 if paper.get("open_access") else 0.0
+    score = float(paper.get("learned_score", paper.get("score", 0))) + rel * 0.45 + concept_overlap * 0.22 + recency + doi_bonus + oa_bonus
+    paper["frontier_score"] = round(score, 4)
+    paper["frontier_relevance"] = round(rel, 4)
+    paper["frontier_concept_overlap"] = round(concept_overlap, 4)
+    return paper
+
+
+def propose_expansion_queries(query: str, papers: List[Dict], parsed_state: Optional[Dict] = None, limit: int = GRAPH_MAX_EXPANSIONS) -> List[str]:
+    concept_pool = []
+    venue_pool = []
+    for paper in papers[:8]:
+        concept_pool.extend((paper.get("concepts") or [])[:4])
+        if paper.get("venue"):
+            venue_pool.append(paper["venue"])
+    if parsed_state and isinstance(parsed_state, dict):
+        concept_pool.extend((parsed_state.get("concepts") or [])[:6])
+
+    ranked_concepts = [c for c, _ in Counter([norm_text(c).lower() for c in concept_pool if c]).most_common(limit * 2)]
+    expansions = [norm_text(query)] if query else []
+    for concept in ranked_concepts:
+        if concept:
+            expansions.append(f"{query} {concept}".strip())
+    for venue in unique_keep_order(venue_pool)[:2]:
+        if venue:
+            expansions.append(f"{query} {venue}".strip())
+    return unique_keep_order(expansions)[:limit]
+
+
+def frontier_expand(query: str, sources: List[str], selected_papers: List[Dict], parsed_state: Optional[Dict] = None, per_query: int = 4) -> List[Dict]:
+    seed_concepts = []
+    for p in selected_papers[:6]:
+        seed_concepts.extend((p.get("concepts") or [])[:4])
+    if parsed_state and isinstance(parsed_state, dict):
+        seed_concepts.extend((parsed_state.get("concepts") or [])[:6])
+
+    expansion_queries = propose_expansion_queries(query, selected_papers, parsed_state=parsed_state, limit=GRAPH_MAX_EXPANSIONS)
+    frontier = []
+    for eq in expansion_queries:
+        try:
+            items = discover_papers(eq, "topic", sources, max_results=per_query)
+            for item in items:
+                frontier.append(score_frontier_candidate(query or eq, seed_concepts, item))
+        except Exception:
+            continue
+
+    frontier = dedupe_papers(frontier)
+    frontier.sort(key=lambda x: float(x.get("frontier_score", x.get("learned_score", x.get("score", 0)))), reverse=True)
+    GRAPH_MEMORY["frontier"] = frontier[: GRAPH_MAX_EXPANSIONS * per_query]
+    return GRAPH_MEMORY["frontier"]
+
+
+def autonomous_expand_into_markdown(query, payload, parsed_state=None):
+    frontier = GRAPH_MEMORY.get("frontier") or []
+    lines = [
+        "### Autonomous expansion plan",
+        "",
+        f"- Seed query: {query or 'Research topic'}",
+        f"- Current nodes: {len(payload.get('nodes', [])) if isinstance(payload, dict) else 0}",
+        f"- Current edges: {len(payload.get('edges', [])) if isinstance(payload, dict) else 0}",
+        f"- Frontier candidates: {len(frontier)}",
+    ]
+
+    proposed = propose_expansion_queries(query or "", list(GRAPH_MEMORY.get("papers", {}).values())[:8], parsed_state=parsed_state, limit=GRAPH_MAX_EXPANSIONS)
+    if proposed:
+        lines.extend(["", "#### Proposed next queries", ""])
+        lines.extend([f"- {q}" for q in proposed])
+
+    if frontier:
+        lines.extend(["", "#### Top frontier papers", ""])
+        for item in frontier[:8]:
+            lines.append(
+                f"- {item.get('title', 'Untitled')} ({item.get('source', 'unknown')}) — frontier score {item.get('frontier_score', item.get('learned_score', item.get('score', 0)))}"
+            )
+    return "\n".join(lines)
+
+
+# ----------------------------
+# Selection / ingest
+# ----------------------------
+
+def resolve_selected_papers(selected_indices, papers_state):
+    papers = ensure_list(papers_state)
+    selected_indices = ensure_list(selected_indices)
+    selected = []
+    if not selected_indices:
+        return selected
+
+    value_map = {paper_choice_value(i, paper): paper for i, paper in enumerate(papers)}
+    label_map = {paper_choice_label(i, paper): paper for i, paper in enumerate(papers)}
+
+    for idx in selected_indices:
+        try:
+            if isinstance(idx, int):
+                if 0 <= idx < len(papers):
+                    selected.append(papers[idx])
+                continue
+            idx_str = str(idx)
+            if idx_str in value_map:
+                selected.append(value_map[idx_str])
+                continue
+            if idx_str.isdigit():
+                num = int(idx_str)
+                if 0 <= num < len(papers):
+                    selected.append(papers[num])
+                    continue
+            if "|" in idx_str:
+                left = idx_str.split("|", 1)[0]
+                if left.isdigit():
+                    num = int(left)
+                    if 0 <= num < len(papers):
+                        selected.append(papers[num])
+                        continue
+            if idx_str in label_map:
+                selected.append(label_map[idx_str])
+                continue
+        except Exception:
+            continue
+
+    out = []
+    seen = set()
+    for paper in selected:
+        key = paper_identity_key(paper)
+        if key not in seen:
+            seen.add(key)
+            out.append(paper)
+    return out
+
+
+def build_ingest_status_markdown(query_text: str, payload: Dict, selected: List[Dict], parsed_state: Optional[Dict], frontier: List[Dict]) -> str:
+    payload = payload or {"nodes": [], "edges": []}
+    nodes = payload.get("nodes", [])
+    edges = payload.get("edges", [])
+    counts = Counter((node.get("type") or "Unknown") for node in nodes)
+
+    node_lines = []
+    for idx, node in enumerate(nodes[:24], start=1):
+        label = node.get("label") or node.get("title") or node.get("id")
+        node_lines.append(f"- {idx}. [{node.get('type', 'Node')}] {label}")
+
+    edge_lines = []
+    for idx, edge in enumerate(edges[:30], start=1):
+        edge_lines.append(f"- {idx}. {edge.get('source')} --{edge.get('type', 'RELATES_TO')}--> {edge.get('target')}")
+
+    return "\n".join([
+        "### Graph ingest status",
+        "",
+        f"- Topic: {query_text}",
+        f"- Selected papers ingested: {len(selected)}",
+        f"- Uploaded PDF parsed: {'Yes' if parsed_state and isinstance(parsed_state, dict) and parsed_state.get('title') else 'No'}",
+        f"- Frontier candidates added: {len(frontier)}",
+        f"- Total nodes created: {len(nodes)}",
+        f"- Total edges created: {len(edges)}",
+        f"- Node breakdown: {', '.join([f'{k}={v}' for k, v in counts.items()]) if counts else 'None'}",
+        "",
+        "### Nodes",
+        *(node_lines or ["- None"]),
+        "",
+        "### Edges",
+        *(edge_lines or ["- None"]),
+    ])
+
+
+def ingest_selected_papers(query, selected_indices, papers_state, pdf_file, parsed_state):
+    papers = ensure_list(papers_state)
+    selected = resolve_selected_papers(selected_indices, papers)
+    uploaded_name = Path(getattr(pdf_file, "name", str(pdf_file))).name if pdf_file else None
+
+    if not selected and papers:
+        selected = papers[:3]
+
+    if not selected and parsed_state and isinstance(parsed_state, dict) and parsed_state.get("title"):
+        selected = []
+
+    if not selected and not (parsed_state and isinstance(parsed_state, dict) and parsed_state.get("title")):
+        graph_html = build_learning_graph_html([], [], "Self-Learning Knowledge Graph")
+        empty_payload = {"status": "empty", "nodes": [], "edges": []}
+        return (
+            graph_html,
+            "### Graph ingest status\n\n- No papers were selected and no parsed PDF is available.\n- Select papers or parse an uploaded PDF first.",
+            empty_payload,
+        )
+
+    query_text = norm_text(query or "")
+    if not query_text and isinstance(parsed_state, dict):
+        query_text = parsed_state.get("title") or "Research topic"
+    if not query_text:
+        query_text = "Research topic"
+
+    selected = [enrich_paper_semantics(query_text, paper) for paper in selected]
+    frontier = frontier_expand(query_text, DEFAULT_SOURCES, selected or papers[:3], parsed_state=parsed_state if isinstance(parsed_state, dict) else None, per_query=3)
+
+    graph_nodes, graph_edges = graph_from_selected(
+        query_text,
+        selected,
+        uploaded_name,
+        parsed_state if isinstance(parsed_state, dict) else None,
+        frontier=frontier,
+    )
+    graph_html = build_learning_graph_html(graph_nodes, graph_edges, "Selected Research Graph")
+
+    payload = build_ingest_payload(
+        query_text,
+        selected,
+        parsed_state if isinstance(parsed_state, dict) else None,
+        frontier=frontier,
+    )
+    learn_from_payload(payload, query=query_text)
+
+    status_md = build_ingest_status_markdown(
+        query_text,
+        payload,
+        selected,
+        parsed_state if isinstance(parsed_state, dict) else None,
+        frontier,
+    )
+
+    return graph_html, status_md, payload
+
+
+# ----------------------------
+# Discovery
+# ----------------------------
+
+def summarize_learning_state(query_text, papers, selected_sources):
+    concept_pool = []
+    for paper in papers[:8]:
+        concept_pool.extend((paper.get("concepts") or [])[:4])
+    top_concepts = [c for c, _ in Counter([c.lower() for c in concept_pool]).most_common(8)]
+    return (
+        "### Discovery results\n\n"
+        f"- Query: {query_text}\n"
+        f"- Sources: {', '.join(selected_sources)}\n"
+        f"- Candidates found: {len(papers)}\n"
+        f"- Top learned concepts: {', '.join(top_concepts) if top_concepts else 'None'}\n"
+        "- Select papers below, or leave selection empty to auto-ingest the top papers.\n"
+    )
+
+
+def run_paper_discovery(query, search_mode, sources, pdf_file):
+    query_text = norm_text(query or "")
+    selected_sources = ensure_list(sources) or DEFAULT_SOURCES
+
+    if not query_text and not pdf_file:
+        empty_graph = build_learning_graph_html([], [], "Self-Learning Knowledge Graph")
+        return (
+            empty_graph,
+            '<div class="panel papers-panel" style="padding:18px"><p>Enter a topic, title, DOI, link, or upload a PDF to start learning.</p></div>',
+            build_journal_html("biomaterials cardiac repair"),
+            "No PDF uploaded yet.",
+            gr.update(choices=[], value=[]),
+            [],
+            "### No discovery results yet.",
+        )
+
+    if not query_text and pdf_file:
+        uploaded_name = Path(getattr(pdf_file, "name", str(pdf_file))).name
+        graph_nodes, graph_edges = build_learning_graph_state("", [], uploaded_name)
+        return (
+            build_learning_graph_html(graph_nodes, graph_edges, "Uploaded PDF Waiting for Parse"),
+            '<div class="panel papers-panel" style="padding:18px"><p>No query yet. Parse the uploaded PDF or enter a research topic to begin discovery.</p></div>',
+            build_journal_html("biomaterials cardiac repair"),
+            uploaded_pdf_summary(pdf_file),
+            gr.update(choices=[], value=[]),
+            [],
+            "### Upload detected.\n\n- Parse the PDF to extract structure.\n- Or enter a topic to start discovery.",
+        )
+
+    uploaded_name = Path(getattr(pdf_file, "name", str(pdf_file))).name if pdf_file else None
+
+    try:
+        papers = discover_papers(query_text, search_mode, selected_sources, max_results=GRAPH_MAX_RESULTS)
+        graph_nodes, graph_edges = build_learning_graph_state(query_text, papers[:6], uploaded_name)
+        graph_html = build_learning_graph_html(graph_nodes, graph_edges, "Self-Learning Knowledge Graph")
+        papers_html = format_papers_html(papers)
+        journals_html = build_journal_html(query_text or "biomaterials cardiac repair")
+        pdf_summary = uploaded_pdf_summary(pdf_file)
+        choices = format_selection_choices(papers)
+        status_md = summarize_learning_state(query_text, papers, selected_sources)
+        return (
+            graph_html,
+            papers_html,
+            journals_html,
+            pdf_summary,
+            gr.update(choices=choices, value=[]),
+            papers,
+            status_md,
+        )
+    except Exception as e:
+        graph_nodes, graph_edges = build_learning_graph_state(query_text, [], uploaded_name)
+        error_html = f'<div class="panel papers-panel" style="padding:18px"><p>Paper search failed: {safe_text(str(e))}</p></div>'
+        return (
+            build_learning_graph_html(graph_nodes, graph_edges),
+            error_html,
+            build_journal_html(query_text or "biomaterials cardiac repair"),
+            uploaded_pdf_summary(pdf_file),
+            gr.update(choices=[], value=[]),
+            [],
+            f"### Discovery failed.\n\n- Error: {safe_text(str(e))}",
+        )
+
+
+__all__ = [
+    "SEARCH_MODES",
+    "SOURCE_OPTIONS",
+    "DEFAULT_SOURCES",
+    "PDF_PARSERS",
+    "GRAPH_MEMORY",
+    "discover_papers",
+    "run_paper_discovery",
+    "parse_uploaded_pdf",
+    "render_parse_result",
+    "ingest_selected_papers",
+    "build_ingest_payload",
+    "learn_from_payload",
+    "frontier_expand",
+    "autonomous_expand_into_markdown",
+    "export_learning_state",
+    "format_frontier_html",
+    "build_learning_graph_html",
+    "build_journal_html",
+    "safe_text",
+]