replication-radar 0.3.2__tar.gz → 0.3.3__tar.gz

replication_radar-0.3.3/DEMO.md

@@ -0,0 +1,125 @@
+# Replication Radar — MCP demo runbook
+
+A clean ~60-second screen recording showing the **verified-knowledge MCP** in an AI agent:
+the agent gives a *cited, verified* answer about a research claim instead of a confident,
+unchecked one. This is the "cite instead of hallucinate" moment — the AI-hackathon hook.
+
+The MCP is **read-only**: it answers *"has this claim been independently checked, and did it
+hold?"* It does **not** start replications (that's the FORRT template). Don't demo a "start a
+replication" flow with it.
+
+---
+
+## 1 · One-time setup (~5 minutes)
+
+**Install the MCP in an isolated environment** (so the path is stable for the client):
+
+```bash
+python3 -m venv ~/.venvs/radar
+~/.venvs/radar/bin/pip install replication-radar      # pulls in the `mcp` runtime too
+```
+
+**Smoke-test it works** (should print `True` then a number):
+
+```bash
+~/.venvs/radar/bin/python - <<'PY'
+from replication_radar.radar import replication_status, verified_claims
+print("replicated:", replication_status("10.1126/science.aax8591")["replicated"])
+print("verified claims in corpus:", verified_claims()["count"])
+PY
+```
+
+**Register it with Claude Desktop.** Edit
+`~/Library/Application Support/Claude/claude_desktop_config.json` (create it if missing) — use the
+**absolute** python path (Claude Desktop does not use your shell PATH):
+
+```json
+{
+  "mcpServers": {
+    "replication-radar": {
+      "command": "/Users/annef/.venvs/radar/bin/python",
+      "args": ["-m", "replication_radar.server"]
+    }
+  }
+}
+```
+
+Quit and reopen Claude Desktop. Click the tools/🔨 icon — you should see **replication-radar**
+with 4 tools: `radar`, `replication_status`, `find_independent_software`, `verified_claims`.
+
+**Optional — add the OpenAIRE / Alien Gateway MCP** alongside it (you/Jean have the connection).
+It makes the "two MCPs together" point explicit. If wiring it up is fiddly, **skip it** — the
+demo lands with just `replication-radar`.
+
+---
+
+## 2 · Pre-flight (right before recording)
+
+1. Ask: *"Which tools do you have from replication-radar?"* → it should list the 4. (Warms it up.)
+2. Do **one off-record dry run** of Beat 1 below — it warms the network/HTTP caches so the real
+   take is fast and identical.
+
+---
+
+## 3 · The recording — two beats
+
+### Beat 1 — the money shot: verify + cite (≈35 s)
+
+**Type this prompt:**
+
+> I want to cite the finding from Soroye et al. 2020 (Science, DOI 10.1126/science.aax8591) —
+> that projected per-species bumble-bee extirpation rankings are robust. Before I do: has that
+> claim actually been independently replicated, and did it hold? Give me something citable.
+
+**What to expect:** the agent calls **`replication_status("10.1126/science.aax8591")`** and gets
+back `replicated: true` with **5 independent verdicts** — 4 `confirms` (Validated) and 1
+`qualifies` (PartiallySupported) — each with a **signed Outcome nanopublication URL** and the
+replication's deposit DOI. The answer should say roughly: *"independently replicated 5×, 4
+confirmed, 1 qualifies it; here are the signed verdicts to cite,"* with links.
+
+**The point to land (caption or voiceover):** OpenAIRE/citation count would call this paper
+"settled"; the MCP shows it's been checked 5 times and hands you **signed, citable verdicts** —
+including the one that *qualifies* it. That's the difference between paraphrasing and citing.
+
+### Beat 2 — the discovery side (≈20 s, optional)
+
+**Type this prompt:**
+
+> What high-impact work on marine heatwaves and species distributions is worth replicating —
+> and what's already been checked?
+
+**What to expect:** the agent calls **`radar("marine heatwave species")`** and returns
+impact-ranked papers, each flagged **OPEN** (a replication opportunity) or **VERIFIED** (already
+checked, with the verdict).
+
+**The point to land:** the same layer also tells an agent *where the replication gaps are*.
+
+---
+
+## 4 · Recording tips
+
+- Resize the Claude window to a clean 1280×800-ish; hide other panels.
+- ~45–75 seconds total; no audio needed — burn in 2-3 short captions for the "point to land" lines.
+- Keep the tool-call expansion **visible** for a beat (it's proof the answer came from the MCP,
+  not the model's memory).
+- Export as MP4 or GIF for the submission.
+
+---
+
+## 5 · If the OpenAIRE MCP is set up too
+
+Add a one-line framing before Beat 1: *"Two MCPs are connected — OpenAIRE for the structural
+graph, replication-radar for the verification layer."* You don't need to force OpenAIRE to fire;
+its presence in the tools list is enough to make the pairing point. The verification answer from
+`replication-radar` is the star.
+
+---
+
+*Tools reference — what the agent can call:*
+
+| tool | answers |
+|---|---|
+| `replication_status(doi)` | Has this DOI been replicated, did it hold? Verdicts + signed nanopub links. |
+| `verified_claims()` | The whole verified-knowledge corpus (every claim with a verdict). |
+| `radar(topic)` | Impact-ranked replication targets in a field — OPEN vs VERIFIED. |
+| `find_independent_software(doi, topic)` | Reusable engines *not* authored by the original team. |

{replication_radar-0.3.2 → replication_radar-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: replication-radar
-Version: 0.3.2
+Version: 0.3.3
 Summary: MCP server that turns the OpenAIRE Graph into a ranked replication queue — impact-ranked targets and the Science Live verification overlay (retraction/supersession-aware).
 Project-URL: Homepage, https://github.com/ScienceLiveHub/replication-radar
 Project-URL: Repository, https://github.com/ScienceLiveHub/replication-radar

replication_radar-0.3.3/STORY.md

@@ -0,0 +1,130 @@
+# Replication Radar — adding the signals the OpenAIRE Graph can't hold
+
+*OpenAIRE AI Hackathon · Theme B (Build) · a Science Live contribution*
+**Live app: https://openaire-hackathon.netlify.app · how it works: /methodology.html · `pip install replication-radar`**
+
+## The question
+
+The OpenAIRE Graph is a network of **structural links** between research entities — papers,
+authors, institutions, funding. It can tell you how *visible* a paper is (citation influence,
+popularity, the BIP! classes C1–C5), but not what it *means*: it links documents to one another
+without representing the **claims** inside them, their level of evidence, their **epistemic
+status** (confirmed, contested, retracted, superseded), or the **semantic relations between
+results** — replication, contradiction, refinement, not just "cites".
+
+That gap matters more than ever in the age of LLMs. A model fed the Graph swallows everything
+equally: a result replicated fifty times reads the same as a single study on twelve mice or an
+unreviewed preprint. The difference between *recognising text patterns* and *understanding* is
+exactly this missing layer — verified, status-aware, traceable knowledge that a system can **cite
+instead of paraphrase**. OpenAIRE is the infrastructure best placed to start closing that gap at
+European scale.
+
+So we asked a concrete build question toward it: **can we add the two most actionable missing
+signals — is a claim *reliable* (independently checked, and did it hold) and is its *software*
+reusable — live, on top of the Graph, without changing it?** A heavily-cited paper looks
+identical, in the Graph today, to one nobody ever reproduced; a widely-used research tool has the
+same "0 citations, class C5" as an abandoned script. Both are signals the Graph structurally
+cannot hold.
+
+## The journey
+
+We started simply: rank papers by impact to find what's worth replicating. That worked, but it
+just re-served the Graph's one signal. The turn came when we tried to answer "has this been
+replicated?" — and realised the Graph *structurally cannot* hold that answer. A verification isn't
+a paper, gets no citations, and has no node in the Graph.
+
+But it does exist elsewhere. Science Live publishes replication outcomes as cryptographically
+signed **nanopublications** (the FORRT chain: Quote → Claim → Study → Outcome → CiTO). So the
+Radar pulls the verdict layer **live from the nanopub network** and overlays it on the Graph by
+DOI. Several corrections shaped the design along the way:
+
+- **Verification is author-agnostic.** We don't care *who* ran the replication, so the index is
+  built **by template, not by person** — querying every FORRT Outcome and CiTO on the network and
+  joining them on the nanopub trusty hash. Today that surfaces **31 independent, signed
+  replication outcomes across 21 papers**; as more people publish replications, they flow in
+  automatically.
+- **Enumeration has to be the right shape.** We verified empirically that walking the nanopub
+  graph outward from a paper *bleeds* into adjacent chains (it once pulled a lizard study into a
+  bumble-bee paper's replications) and *misses* disconnected ones, so we enumerate by the
+  **CiTO→DOI verdict-citation** instead — the set that is actually correct.
+- **Validity is part of the verdict.** A retracted or superseded outcome must not count. The
+  overlay filters any outcome retracted/invalidated/superseded **by its own signer**, via the
+  nanopub admin graph — only the original author can retract their own work.
+- **Reproduce ≠ replicate, and agreement matters.** We surface the FORRT distinction (materials
+  available = reproducible; tested by a different route = replicated) and an **agreement pattern**
+  — robustly-validated, validated, contested, refuted — computed from the verdict spread, so
+  "five replications that all agree" reads differently from "five that disagree".
+- **What, not just whether.** Each verdict carries the **claim it actually tested** — the atomic
+  AIDA statement, traversed Outcome → Study → Claim — so a card says not "Validated" but
+  *"Validated: ‘per-species extirpation rankings are sensitive to the grid resolution’"*.
+
+Then the software side. The Graph makes research software *findable* but not *assessable*. We
+first tried to *recommend* tooling and it failed badly (keyword-matching surfaced off-topic
+repos), so we pivoted from recommendation to **assessment**, and after checking that standard
+FAIR services (F-UJI, OSTrails) had no usable API, computed the **fair-software.eu** five
+recommendations ourselves, live, from the GitHub and Software Heritage APIs.
+
+Two disciplines run through all of it. **Everything is grounded** — every signal comes from a
+named, verifiable source, and is documented, signal by signal, in a **machine- and human-readable
+methodology page** (`methodology.json` + `/methodology.html`) that states where each label and
+score comes from and how it is computed. And everything runs **client-side** against public,
+CORS-enabled APIs — no backend, no keys — so the whole thing is a static site anyone can open,
+and it ships accessible (Lighthouse accessibility 100, colour-blind-safe, keyboard-operable).
+
+## The insight
+
+- **Nanopublications are the substrate the Graph is missing — and the AI hook.** The verdict
+  layer isn't scraped text; it's built from claim-level, cryptographically-signed assertions that
+  already carry what the Graph lacks: the claim, its epistemic relation (`cito:confirms` /
+  `disputes` / `qualifies`), and its provenance. So the Graph gains, for a paper, not "this
+  document exists" but "*this specific claim was independently checked → validated → here is the
+  signed verdict*". That is exactly what an LLM needs to **cite rather than hallucinate**. We
+  package it as an **MCP server** that an agent runs **next to the OpenAIRE/Alien MCP**: one gives
+  the structural graph, the other answers "has this been checked, and did it hold". Together they
+  are the first bricks of a graph of **verified knowledge**.
+- **Reliability and reusability are *different categories* of signal**, not better metrics. You
+  can't repair the citation axis into a truth axis or a reuse axis — you have to *add* them, and
+  you can add them *live*, on top of the Graph, without waiting for it to change.
+- **Verification is author-agnostic and network-wide.** Keying it on a template rather than a
+  person turns a personal portfolio into a community trust layer.
+- **Grounded-and-transparent is a discipline, not a nicety.** Every signal is sourced and
+  documented; the one feature we built on a guess (keyword tooling) we deleted — and the project
+  is stronger for it.
+
+## What others can reuse
+
+- **The live web app** — pure static, queries OpenAIRE + the nanopub network + GitHub/Software
+  Heritage from the browser. Fork it, point it elsewhere.
+- **An MCP server** (`pip install replication-radar`) exposing the same engine to any agent, to
+  run alongside the OpenAIRE MCP — the verified-knowledge layer for agentic workflows.
+- **A reproducible, author-agnostic, retraction-aware verdict-index method** — FORRT
+  Outcome/CiTO templates joined on the trusty hash, with the admin-graph validity guard. Any
+  replication network can be read this way.
+- **A machine-readable provenance & methodology spec** (`methodology.json`, CC-BY) — every
+  signal's source and formula, reusable as a transparency pattern for any composite-score tool.
+- **A grounded software-FAIR assessment** — the fair-software.eu recommendations + usage,
+  computed from GitHub + Software Heritage (no third-party scorer needed).
+- **A feasibility map of the open-science API landscape** — what's reachable and CORS-friendly
+  (OpenAIRE Graph API, the nanopub SPARQL + admin graph, GitHub/SWH/Zenodo) and what isn't
+  (F-UJI/OSTrails assessment APIs; per-paper relations from the public Graph API) — so the next
+  builder doesn't re-discover it.
+
+*A complementary facet by Jean Iaquinta uses the **OpenAIRE MCP's** citation-graph tools to trace
+the relationships around a verified paper — and shows the citation graph contains everything
+**except** the verification edge, which is exactly the gap the Radar fills.*
+
+## Honest limits
+
+Discovery recall is keyword-bound (OpenAIRE free-text terms are AND-ed); the verdict overlay is
+network-wide but only covers claims with a DOI a search can reach; FAIR-software runs only where a
+real repository resolves, and GitHub's unauthenticated rate limit caps how many it scores per hour
+(results are cached so repeated use stays stable); OpenAIRE's own subject classification is
+sometimes quirky and is shown faithfully, not corrected. None of this is hidden in the output. And
+we add only two of the missing layers — reliability and reusability; the fuller graph of *verified
+knowledge* (claim-level extraction at scale, temporal obsolescence, distinguishing hypothesis from
+result from interpretation) is the direction this points at, not something we finished.
+
+---
+
+*Materials are dual-licensed: **source code under MIT**, and this write-up together with the
+verdict index and methodology spec under **[CC-BY 4.0](https://creativecommons.org/licenses/by/4.0/)**.*

{replication_radar-0.3.2 → replication_radar-0.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "replication-radar"
-version = "0.3.2"
+version = "0.3.3"
 description = "MCP server that turns the OpenAIRE Graph into a ranked replication queue — impact-ranked targets and the Science Live verification overlay (retraction/supersession-aware)."
 readme = "README.md"
 requires-python = ">=3.10"

{replication_radar-0.3.2 → replication_radar-0.3.3}/site/app.js

@@ -4,6 +4,10 @@
 
 const API = "https://api.openaire.eu/graph/v1";
 const CLASS_SCORE = { C1: 1, C2: 0.8, C3: 0.6, C4: 0.4, C5: 0.2 };
+// Per-class tooltip text so EVERY class (not just C1/C5) explains itself on hover.
+const CLS_PCT = { C1: "top 0.01%", C2: "top 0.1%", C3: "top 1%", C4: "top 10%", C5: "the rest (outside the top 10%)" };
+const impactTip = (c) => `OpenAIRE BIP! citation-impact class — ${c} = ${CLS_PCT[c] || "—"} most-cited across all of science (C1 highest · C5 lowest)`;
+const impulseTip = (c) => `OpenAIRE BIP! impulse class — ${c} = ${CLS_PCT[c] || "—"} by recent citation momentum (C1 highest · C5 lowest)`;
 const EXAMPLES = ["species distribution", "marine heatwave", "bumble bee climate", "presence-only", "range maps scale"];
 
 let VERDICTS = {};      // doi -> [verifications]
@@ -63,26 +67,42 @@ const readinessFrom = (matScore, impactScore, momentum) => {
   const r = 0.45 * (matScore || 0) + 0.35 * impactScore + 0.20 * momentum;
   return Math.round(r * 100) / 100;
 };
-// Status taxonomy — "not replicated" is DISAMBIGUATED, not penalised.
+// Inline Lucide icons (monochrome, inherit currentColor → the app's navy/pink/grey palette).
+const svg = (p, s = 13) => `<svg class="ic" width="${s}" height="${s}" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.1" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">${p}</svg>`;
+const ICON = {
+  robust: svg('<path d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"/><path d="m9 12 2 2 4-4"/>'),
+  validated: svg('<circle cx="12" cy="12" r="10"/><path d="m9 12 2 2 4-4"/>'),
+  contested: svg('<path d="m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3"/><path d="M12 9v4"/><path d="M12 17h.01"/>'),
+  refuted: svg('<circle cx="12" cy="12" r="10"/><path d="m15 9-6 6"/><path d="m9 9 6 6"/>'),
+  reproducible: svg('<path d="m17 2 4 4-4 4"/><path d="M3 11v-1a4 4 0 0 1 4-4h14"/><path d="m7 22-4-4 4-4"/><path d="M21 13v1a4 4 0 0 1-4 4H3"/>'),
+  needs: svg('<circle cx="12" cy="12" r="10"/><path d="M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3"/><path d="M12 17h.01"/>'),
+  dormant: svg('<path d="M12 3a6 6 0 0 0 9 9 9 9 0 1 1-9-9Z"/>'),
+  check: svg('<path d="M20 6 9 17l-5-5"/>', 13),
+  x: svg('<path d="M18 6 6 18"/><path d="m6 6 12 12"/>', 13),
+  star: svg('<path d="M11.5 2.3a.5.5 0 0 1 .9 0l2.3 4.7a2.1 2.1 0 0 0 1.6 1.1l5.2.8a.5.5 0 0 1 .3.9l-3.7 3.6a2.1 2.1 0 0 0-.6 1.9l.9 5.1a.5.5 0 0 1-.8.6l-4.6-2.4a2.1 2.1 0 0 0-2 0L6.7 21.3a.5.5 0 0 1-.8-.6l.9-5.1a2.1 2.1 0 0 0-.6-1.9l-3.7-3.6a.5.5 0 0 1 .3-.9l5.2-.8a2.1 2.1 0 0 0 1.6-1.1z"/>', 13),
+  fork: svg('<circle cx="12" cy="18" r="3"/><circle cx="6" cy="6" r="3"/><circle cx="18" cy="6" r="3"/><path d="M18 9v2c0 .6-.4 1-1 1H7c-.6 0-1-.4-1-1V9"/><path d="M12 12v3"/>', 13),
+};
+// Status taxonomy — "not replicated" is DISAMBIGUATED, not penalised. (label = plain text; icon = SVG)
 const STATUS = {
-  robust:       { label: "✅ Robustly validated", cls: "st-val",   tip: "multiple independent replications, all confirmed — a settled, reliable result" },
-  validated:    { label: "✅ Validated",          cls: "st-val",   tip: "independently replicated and it held up" },
-  contested:    { label: "⚠️ Contested",          cls: "st-con",   tip: "independent replications DISAGREE (some confirm, some contradict/partial) — worth re-checking" },
-  refuted:      { label: "❌ Refuted",            cls: "st-con",   tip: "independent replication(s) contradicted it, none confirmed" },
-  reproducible: { label: "🔁 Reproducible",       cls: "st-ready", tip: "original code/data are available, so it can be RE-RUN (reproduced). Note: replication ≠ reproduction — replication tests the same claim with DIFFERENT data/methods (FORRT)." },
-  needs:        { label: "❔ Needs check",         cls: "st-needs", tip: "not yet replicated and OpenAIRE links no materials — unknown (not absent); resolve from the paper" },
-  dormant:      { label: "💤 Dormant",            cls: "st-dorm",  tip: "no verdict, older, low momentum, no materials surfaced — likely dormant" },
+  robust:       { label: "Robustly validated", icon: ICON.robust,       cls: "st-val",   tip: "multiple independent replications, all confirmed — a settled, reliable result" },
+  validated:    { label: "Validated",          icon: ICON.validated,    cls: "st-val",   tip: "independently replicated and it held up" },
+  contested:    { label: "Contested",          icon: ICON.contested,    cls: "st-con",   tip: "independent replications DISAGREE (some confirm, some contradict/partial) — worth re-checking" },
+  refuted:      { label: "Refuted",            icon: ICON.refuted,      cls: "st-ref",   tip: "independent replication(s) contradicted it, none confirmed" },
+  reproducible: { label: "Reproducible",       icon: ICON.reproducible, cls: "st-ready", tip: "original code/data are available, so it can be RE-RUN (reproduced). Note: replication ≠ reproduction — replication tests the same claim with DIFFERENT data/methods (FORRT)." },
+  needs:        { label: "Needs check",        icon: ICON.needs,        cls: "st-needs", tip: "not yet replicated and OpenAIRE links no materials — unknown (not absent); resolve from the paper" },
+  dormant:      { label: "Dormant",            icon: ICON.dormant,      cls: "st-dorm",  tip: "no verdict, older, low momentum, no materials surfaced — likely dormant" },
 };
-// Distinct replication OUTCOMES for a paper — one signed nanopub per independent replication
-// (deduped by outcome URI, since several replications target the same claim).
+// Distinct replication OUTCOMES for a paper — one SIGNED nanopub per independent replication
+// (deduped by outcome URI). A record with no outcome nanopub isn't a replication (e.g. a stale
+// non-verdict citation in the bundled fallback), so it's dropped — this keeps the count
+// (agreementOf) and the rendered chips (outcomeLinks) in agreement.
 const outcomesFor = (doi) => {
   const seen = new Set(), out = [];
-  (VERDICTS[doi] || []).forEach((v, i) => {
-    const key = v.outcome_np || `__${i}`;
-    if (seen.has(key)) return;
-    seen.add(key);
-    out.push({ np: v.outcome_np || null, verdict: v.verdict || "" });
-  });
+  for (const v of VERDICTS[doi] || []) {
+    if (!v.outcome_np || seen.has(v.outcome_np)) continue;
+    seen.add(v.outcome_np);
+    out.push({ np: v.outcome_np, verdict: v.verdict || "" });
+  }
   return out;
 };
 // Colour an outcome chip by its verdict so the agreement pattern is legible at a glance.
@@ -146,12 +166,21 @@ async function search(topic, type, size) {
 
 // resolve a single record by DOI (any type) — used for the original paper AND the
 // replication's own OpenAIRE node. OpenAIRE free-text matches the DOI string.
+// Session caches — re-scanning reuses successful lookups instead of re-hitting the APIs.
+// This is what makes repeated scans STABLE (and stops exhausting GitHub's 60/hour unauth
+// limit, which used to make FAIR badges flicker). Only successes are cached, so a transient
+// failure retries next time and the cache converges to complete.
+const _DOI = new Map(), _FAIR = new Map();
 async function fetchByDoi(doi) {
   if (!doi) return null;
+  if (_DOI.has(doi)) return _DOI.get(doi);
+  let res = null;
   try {
     const hits = (await (await fetch(`${API}/researchProducts?search=${encodeURIComponent(doi)}&pageSize=5`)).json()).results || [];
-    return hits.find((h) => doiOf(h) === doi.toLowerCase()) || hits[0] || null;
-  } catch (e) { return null; }
+    res = hits.find((h) => doiOf(h) === doi.toLowerCase()) || hits[0] || null;
+  } catch (e) { res = null; }
+  if (res) _DOI.set(doi, res);
+  return res;
 }
 
 // OpenAIRE richness we already receive but were hiding
@@ -181,6 +210,12 @@ async function githubFromZenodo(doi) {
 }
 
 async function assessSoftware(url) {
+  if (_FAIR.has(url)) return _FAIR.get(url);   // cached success → stable across scans, saves rate limit
+  const res = await _assessSoftware(url);
+  if (res) _FAIR.set(url, res);
+  return res;
+}
+async function _assessSoftware(url) {
   const g = parseGitHub(url);
   if (!g) return null;
   const base = `https://api.github.com/repos/${g.owner}/${g.repo}`;
@@ -223,15 +258,27 @@ const aidaText = (u) => { if (!u) return ""; try { return decodeURIComponent(u.r
 const claimType = (u) => (!u ? "" : u.replace(/.*\/terms\//, "").replace(/-FORRT-Claim$/, "").replace(/_/g, " "));
 const claimFor = (outcome_np) => CLAIMS[npHash(outcome_np)] || null;
 
-async function sparqlCsv(query) {
-  const r = await fetch(`${NP_SPARQL}?query=${encodeURIComponent(query)}`, { headers: { Accept: "text/csv" } });
-  if (!r.ok) throw new Error(`nanopub-query ${r.status}`);
-  const lines = (await r.text()).trim().split(/\r?\n/);
-  const head = lines.shift().split(",");
-  return lines.map((line) => {
-    const cells = (line.match(/("([^"]*)"|[^,]*)(,|$)/g) || []).map((c) => c.replace(/,$/, "").replace(/^"|"$/g, ""));
-    const o = {}; head.forEach((h, i) => (o[h] = cells[i])); return o;
-  });
+// The public nanopub-query endpoint 504s intermittently under load; one retry turns most of
+// those transient failures into success, so the app stays on the LIVE index instead of dropping
+// to the bundled snapshot (the source of the "random" differences).
+async function sparqlCsv(query, tries = 3) {
+  let lastErr;
+  for (let i = 0; i < tries; i++) {
+    try {
+      const r = await fetch(`${NP_SPARQL}?query=${encodeURIComponent(query)}`, { headers: { Accept: "text/csv" } });
+      if (!r.ok) throw new Error(`nanopub-query ${r.status}`);
+      const lines = (await r.text()).trim().split(/\r?\n/);
+      const head = lines.shift().split(",");
+      return lines.map((line) => {
+        const cells = (line.match(/("([^"]*)"|[^,]*)(,|$)/g) || []).map((c) => c.replace(/,$/, "").replace(/^"|"$/g, ""));
+        const o = {}; head.forEach((h, i) => (o[h] = cells[i])); return o;
+      });
+    } catch (e) {
+      lastErr = e;
+      if (i + 1 < tries) await new Promise((res) => setTimeout(res, 700 * (i + 1)));
+    }
+  }
+  throw lastErr;
 }
 
 async function buildIndexFromNetwork() {
@@ -479,17 +526,17 @@ function targetRow(t) {
     : `replication priority = 0.45·materials + 0.35·impact + 0.20·momentum  —  materials ${p.mat == null ? "unverified" : p.mat.toFixed(2)} · impact ${(p.impact || 0).toFixed(2)} · momentum ${(p.momentum || 0).toFixed(2)}`;
   const score = `<div class="score" title="${esc(scoreTitle)}"><span>${t.priority != null ? t.priority.toFixed(2) : "—"}</span><small>PRIORITY</small></div>`;
   const st = STATUS[t.statusKey] || STATUS.needs;
-  const badge = `<span class="badge ${st.cls}" title="${esc(st.tip)}">${st.label}</span>`
-    + (t.cls ? `<span class="badge cls" title="OpenAIRE BIP! impact class — C1 = top 0.01% most-cited globally, C5 = the rest">${t.cls}</span>` : "");
+  const badge = `<span class="badge ${st.cls}" title="${esc(st.tip)}">${st.icon}${st.label}</span>`
+    + (t.cls ? `<span class="badge cls" title="${esc(impactTip(t.cls))}">${t.cls}</span>` : "");
   // Materials badge ONLY when positively known. OpenAIRE rarely links code/data to a
   // paper, so 'unknown' is the norm in live search and would be noise on every row —
   // it's carried in the score breakdown tooltip, and resolved in the baked demo set.
-  const matMeta = (t.mat && t.mat.state === "rocrate") ? `<span class="badge mok" title="RO-Crate research object — code + data + provenance bundled">RO-Crate ✓</span>`
-    : (t.mat && t.mat.state === "code") ? `<span class="badge mok" title="code repository linked to this paper">code ✓</span>`
+  const matMeta = (t.mat && t.mat.state === "rocrate") ? `<span class="badge mok" title="RO-Crate research object — code + data + provenance bundled">${ICON.check}RO-Crate</span>`
+    : (t.mat && t.mat.state === "code") ? `<span class="badge mok" title="code repository linked to this paper">${ICON.check}code</span>`
     : "";
   const meta = `<div class="t-meta">`
     + (t.year ? `<span class="badge yr">${t.year}</span>` : "")
-    + (t.impl ? `<span class="badge imp" title="OpenAIRE BIP! impulse class — early citation momentum (C1 highest)">impulse ${t.impl}</span>` : "")
+    + (t.impl ? `<span class="badge imp" title="${esc(impulseTip(t.impl))}">impulse ${t.impl}</span>` : "")
     + matMeta + `</div>`;
   const link = t.doi ? `<a href="https://doi.org/${t.doi}" target="_blank" rel="noopener">${t.doi}</a>` : "";
   // what EXACTLY was replicated — the claim's AIDA statement (atomic sentence) + its FORRT type
@@ -498,12 +545,12 @@ function targetRow(t) {
     ? `<div class="tclaim"><span class="claimlbl">claim:</span> <span class="claimq">“${esc(cl.aida || cl.label)}”</span>${cl.type ? ` <span class="badge ctype" title="FORRT claim type">${esc(cl.type)}</span>` : ""}</div>` : "";
   const outs = t.status === "VERIFIED" ? outcomesFor(t.doi).filter((o) => o.np) : [];
   const verdictLink = (t.status === "VERIFIED")
-    ? `<div class="tverdict">independently checked by Science Live — <b>${esc(agreementOf(t.doi).why)}</b>${outcomeLinks(outs)}</div>` : "";
+    ? `<div class="tverdict">independently checked by <a href="https://sciencelive4all.org" target="_blank" rel="noopener">Science Live</a> — <b>${esc(agreementOf(t.doi).why)}</b>${outcomeLinks(outs)}</div>` : "";
   const resolvedNote = (t.mat && t.mat.resolved)
     ? `<div class="tresolved">↳ materials resolved from ${esc(t.mat.source || "the paper")} (not in OpenAIRE): <a href="${esc(t.mat.code || "")}" target="_blank" rel="noopener">code repo</a>${(t.mat.data && t.mat.data.length) ? ` · data: ${t.mat.data.map(esc).join(", ")}` : ""}</div>`
     : "";
   const fairNote = t.fair
-    ? `<div class="tfair">FAIR software <b>${t.fair.score}/5</b> · ⭐ ${t.fair.stars}${t.fair.swh ? " · in Software Heritage" : ""}</div>`
+    ? `<div class="tfair">FAIR software <b>${t.fair.score}/5</b> · ${ICON.star}${t.fair.stars}${t.fair.swh ? " · in Software Heritage" : ""}</div>`
     : "";
   // OPEN targets get a next step: discovery here → the FORRT template handles the nanopub chain.
   const replicateCTA = (t.status !== "VERIFIED")
@@ -566,16 +613,18 @@ function renderVerified(inField) {
   const matchCard = (v) => {
     const chips = [
       v.oa ? `<span class="ochip oa" title="Open-access route (OpenAIRE) — how the paper is free to read: gold/diamond = OA journal, hybrid = OA in a subscription journal, green = self-archived copy, bronze = free on the publisher site with no open licence">${esc(v.oa)} OA</span>` : "",
-      ...(v.fos || []).map((f) => `<span class="ochip">${esc(f).slice(0, 24)}</span>`),
-      ...(v.sdg || []).map((s) => `<span class="ochip sdg">${esc(s).slice(0, 22)}</span>`),
-      `<span class="ochip cites">${v.citations.toLocaleString()} cites</span>`,
+      ...(v.fos || []).map((f) => `<span class="ochip" title="Field of Science (OECD FOS scheme) — subject classification assigned by OpenAIRE">${esc(f).slice(0, 24)}</span>`),
+      ...(v.sdg || []).map((s) => { const m = /^(\d+)\./.exec(s); return m
+        ? `<a class="ochip sdg" href="https://sdgs.un.org/goals/goal${m[1]}" target="_blank" rel="noopener" title="UN Sustainable Development Goal ${m[1]} — assigned by OpenAIRE's SDG classifier (opens the UN definition)">${esc(s).slice(0, 22)}</a>`
+        : `<span class="ochip sdg" title="UN Sustainable Development Goal — assigned by OpenAIRE's SDG classifier">${esc(s).slice(0, 22)}</span>`; }),
+      `<span class="ochip cites" title="Citation count from the OpenAIRE Graph">${v.citations.toLocaleString()} cites</span>`,
     ].join("");
     let repl = "";
     if (v.repl) {
       const f = v.repl.fair;
       const fairBadge = f
-        ? `<div class="fairrecs"><b>FAIR software (${f.score}/5):</b> ${Object.entries(f.recs).map(([k, ok]) => `<span class="${ok ? "rok" : "rno"}">${ok ? "✓" : "✗"} ${k}</span>`).join("")}</div>
-        <div class="fairline">⭐ ${f.stars} stars · ${f.forks} forks · ${f.swh ? `<span class="swhok">in Software Heritage</span>` : `<span class="swhno">not yet in Software Heritage</span>`}</div>`
+        ? `<div class="fairrecs"><b>FAIR software (${f.score}/5):</b> ${Object.entries(f.recs).map(([k, ok]) => `<span class="${ok ? "rok" : "rno"}">${ok ? ICON.check : ICON.x}${k}</span>`).join("")}</div>
+        <div class="fairline">${ICON.star}${f.stars} stars · ${ICON.fork}${f.forks} forks · ${f.swh ? `<span class="swhok">in Software Heritage</span>` : `<span class="swhno">not yet in Software Heritage</span>`}</div>`
         : "";
       const nodeHref = v.repl.code && v.repl.code.includes("github") ? v.repl.code : v.repl.url;
       repl = `<div class="vrepl">↳ replication is an OpenAIRE node: <a href="${nodeHref}" target="_blank" rel="noopener">${esc(v.repl.title).slice(0, 44) || v.repl.doi}</a> <span class="ochip type">${esc(v.repl.type)}</span></div>${fairBadge}`;
@@ -591,14 +640,14 @@ function renderVerified(inField) {
       <span class="vt">${esc(v.title).slice(0, 82)}</span>
       <div class="ochips">${chips}</div>
       ${vClaimLine}
-      <div class="vline"><span class="vv ${partialOf(v) ? "partial" : ""}">${v.verdicts.join(", ")}</span> — independently checked by Science Live ${vouts.length ? outcomeLinks(vouts) : (v.cito_np ? `· <a href="${v.cito_np}" target="_blank" rel="noopener">verdict chain →</a>` : "")}</div>
+      <div class="vline"><span class="vv ${partialOf(v) ? "partial" : ""}">${v.verdicts.join(", ")}</span> — independently checked by <a href="https://sciencelive4all.org" target="_blank" rel="noopener">Science Live</a> ${vouts.length ? outcomeLinks(vouts) : (v.cito_np ? `· <a href="${v.cito_np}" target="_blank" rel="noopener">verdict chain →</a>` : "")}</div>
       ${repl}
     </li>`;
   };
   const fieldHtml = field.length
     ? `<ul class="vlist">${field.map(matchCard).join("")}</ul>`
     : `<p class="vnone">No Science Live verdict matching your search yet — every paper on the left is an <b>open</b> replication opportunity.</p>`;
-  const moreHtml = `<p class="vmore-stat">Verdicts are pulled <b>live</b> from the nanopub network (any signer), filtered for retracted/superseded versions. <a href="https://github.com/ScienceLiveHub/replication-radar/blob/main/src/replication_radar/data/verdicts.json" target="_blank" rel="noopener">offline fallback index →</a></p>`;
+  const moreHtml = `<p class="vmore-stat">Verdicts are read <b>live</b> from the nanopub network — any signer, retraction- and supersession-filtered. <a href="methodology.html">How this works →</a></p>`;
   el("verified").innerHTML = fieldHtml + moreHtml;
 }
 
@@ -654,7 +703,7 @@ async function run(topic, isExample) {
 }
 
 // ---------- wire up ----------
-el("chips").innerHTML = EXAMPLES.map((e) => `<span class="chip">${e}</span>`).join("");
+el("chips").innerHTML = EXAMPLES.map((e) => `<button type="button" class="chip">${e}</button>`).join("");
 el("chips").addEventListener("click", (e) => { if (e.target.classList.contains("chip")) { el("topic").value = e.target.textContent; run(e.target.textContent); } });
 el("go").addEventListener("click", () => run(el("topic").value));
 el("topic").addEventListener("keydown", (e) => { if (e.key === "Enter") run(el("topic").value); });

{replication_radar-0.3.2 → replication_radar-0.3.3}/site/index.html

@@ -12,7 +12,7 @@
     <div class="wrap">
       <h1>Replication&nbsp;Radar</h1>
       <p class="tag">What's worth replicating next — read straight off the OpenAIRE&nbsp;Graph.</p>
-      <p class="sub">Science Live × OpenAIRE · impact-ranked targets · the claim each makes · already-checked overlay</p>
+      <p class="sub">Science Live × OpenAIRE · impact-ranked targets · the claim each makes · already-checked overlay · <a href="methodology.html" style="color:#fff;text-decoration:underline">how it works &amp; where the data comes from</a></p>
     </div>
   </header>
 
@@ -23,7 +23,7 @@
       <div class="chips" id="chips"></div>
     </section>
 
-    <p id="status" class="status"></p>
+    <p id="status" class="status" role="status" aria-live="polite"></p>
 
     <section id="results" hidden>
       <div class="card chartcard">
@@ -48,8 +48,11 @@
 
   <footer>
     <div class="wrap">
-      <span>Live against <a href="https://graph.openaire.eu/">OpenAIRE Graph</a> · verdicts from <a href="https://sciencelive4all.org">Science Live</a> nanopublications</span>
-      <span><a href="https://github.com/ScienceLiveHub/replication-radar">code (MIT)</a> · <a href="https://pypi.org/project/replication-radar/">PyPI</a> · <a href="https://github.com/ScienceLiveHub/replication-radar/blob/main/STORY.md">story (CC-BY)</a></span>
+      <span class="svc">Want a claim replicated but can't run it yourself? <a href="https://vitenhub.no/replication-services" target="_blank" rel="noopener">Science Live offers replication as a service →</a></span>
+      <div class="foot-links">
+        <span>Live against <a href="https://graph.openaire.eu/">OpenAIRE Graph</a> · verdicts from <a href="https://sciencelive4all.org">Science Live</a> nanopublications</span>
+        <span><a href="methodology.html">methodology &amp; sources</a> · <a href="https://github.com/ScienceLiveHub/replication-radar">code (MIT)</a> · <a href="https://pypi.org/project/replication-radar/">PyPI</a> · <a href="https://github.com/ScienceLiveHub/replication-radar/blob/main/STORY.md">story (CC-BY)</a></span>
+      </div>
     </div>
   </footer>