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

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: replication-radar
-Version: 0.3.0
-Summary: MCP server that turns the OpenAIRE Graph into a ranked replication queue — impact-ranked targets, independent reusable tooling, and the Science Live verification overlay.
+Version: 0.3.2
+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
 Project-URL: Science Live, https://sciencelive4all.org

{replication_radar-0.3.0 → replication_radar-0.3.2}/docs/openaire-mcp.md

@@ -9,6 +9,15 @@
 > So MCP-backed features belong in the **`src/replication_radar` MCP server / agentic exploration**,
 > **not** in the browser app. The browser app stays on public CORS APIs (nanopub SPARQL + the
 > public OpenAIRE Graph REST API). Keep this split in mind when reading the "direction" column.
+>
+> **Confirmed (live `_debug.api_urls_called`, 2026-06-14):** the MCP queries the **same open
+> OpenAIRE Graph** as the app — `api.openaire.eu/graph/v2/researchProducts` (search) and
+> `api.openaire.eu/graph/v1/researchProducts/links` (relationships). There is **no private/fuller
+> dataset** behind the gateway; OAuth is access control, not a different graph. The app uses v1
+> search and does **not** call `/links` — that relationship endpoint (public, ~1.2M paper↔software
+> edges globally) is the one capability the app could adopt directly, no MCP needed. For
+> biodiversity/EO papers it returns only paper→paper `cites` (verified), so it does not close the
+> materials gap for this domain.
 
 Directions: **(i)** verified-knowledge graph (typed links between results) · **(ii)** CoARA
 (assess researchers/projects by output *diversity* + reproducibility + reuse, not citations) ·

{replication_radar-0.3.0 → replication_radar-0.3.2}/docs/readiness-scoring-plan.md

@@ -79,6 +79,11 @@ readiness = 0.45 * materials      // per-paper (2a); null→excluded & flagged,
 - **P1 · Status taxonomy (live):** compute & group by status; surface ⭐ Replication-ready.
 - **P2 · Curated demo enrichment (baked-to-static):** for the demo set resolve materials fully (repo
   from paper, FAIR, RO-Crate, citation-network "missing edge", transfer-headroom). See `app-ui.md` §8.
+  **▶ STARTED 2026-06-14** (`site/curated.json` + `app.js`): paper-resolved materials baked as just
+  the repo link (grounded, from the paper's Data/Code statement); app overrides materials, injects the
+  paper so it appears for its topic, and computes **FAIR live** via existing `assessSoftware()`.
+  **WiSDM lit**: `code ✓` + resolved-from-paper provenance + FAIR 3/5, readiness 0.4→0.49.
+  TODO: add Soroye/Bombus + a HEALPix-transfer entry; then the "missing edge" graph + transfer-headroom.
 - **P3 · Close the loop:** "Start a replication" → `forrt-replication-template` (scoped) → publish
   chain → re-search shows the paper flip to ✅ Validated.
 

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

@@ -1,7 +1,7 @@
 [project]
 name = "replication-radar"
-version = "0.3.0"
-description = "MCP server that turns the OpenAIRE Graph into a ranked replication queue — impact-ranked targets, independent reusable tooling, and the Science Live verification overlay."
+version = "0.3.2"
+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"
 license = { text = "MIT" }

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

@@ -7,8 +7,9 @@ const CLASS_SCORE = { C1: 1, C2: 0.8, C3: 0.6, C4: 0.4, C5: 0.2 };
 const EXAMPLES = ["species distribution", "marine heatwave", "bumble bee climate", "presence-only", "range maps scale"];
 
 let VERDICTS = {};      // doi -> [verifications]
+let CLAIMS = {};        // outcome-hash -> { label, aida, type } (what exactly was replicated)
 let VERIFIED = [];      // enriched: {doi, title, citations, verifications}
-let chart = null;
+let CURATED = {};       // doi -> paper-resolved materials (the links OpenAIRE lacks; from the paper)
 
 // ---------- OpenAIRE helpers (same shape as openaire.py) ----------
 const doiOf = (r) => {
@@ -56,11 +57,85 @@ const materialsOf = (r) => {
 // Transparent composite: materials is the largest term; when materials is UNKNOWN
 // (null) we DROP that term and renormalise the rest — never score a missing link as 0.
 const readinessFrom = (matScore, impactScore, momentum) => {
-  const r = matScore == null
-    ? (0.35 * impactScore + 0.20 * momentum) / 0.55
-    : (0.45 * matScore + 0.35 * impactScore + 0.20 * momentum);
+  // No renormalisation when materials are unknown: you can't even reproduce a paper whose
+  // code/data aren't surfaced, so the materials term simply contributes 0 (worth caps at 0.55).
+  // A paper WITH materials therefore always out-ranks an equally-cited one without.
+  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.
+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" },
+};
+// Distinct replication OUTCOMES for a paper — one signed nanopub per independent replication
+// (deduped by outcome URI, since several replications target the same claim).
+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 || "" });
+  });
+  return out;
+};
+// Colour an outcome chip by its verdict so the agreement pattern is legible at a glance.
+const verdictClass = (v) => /contradict|notsupport|refut/i.test(v) ? "v-con"
+  : /partial/i.test(v) ? "v-part"
+  : /validat|confirm|support/i.test(v) ? "v-ok" : "v-other";
+// Short, human verdict label for a chip (no arbitrary numbers — the verdict is the meaning).
+const verdictLabel = (v) => /contradict/i.test(v) ? "Contradicted"
+  : /notsupport/i.test(v) ? "Not supported"
+  : /partial/i.test(v) ? "Partial"
+  : /validat|confirm|support/i.test(v) ? "Validated" : (v || "outcome");
+// Each replication outcome is a verdict-labelled, colour-coded chip linking to its signed nanopub
+// — navy = confirmed, amber = partial, red = contradicted. No cryptic index numbers.
+const outcomeLinks = (outs) => {
+  if (!outs.length) return "";
+  const lead = outs.length === 1 ? "replication outcome:" : `${outs.length} replication outcomes:`;
+  return ` · ${lead} ` + outs.map((o) =>
+    `<a class="onp ${verdictClass(o.verdict)}" href="${o.np}" target="_blank" rel="noopener" title="${esc(o.verdict)} — open the signed nanopub">${verdictLabel(o.verdict)}</a>`).join(" ");
+};
+// Agreement pattern across the independent replication verdicts — many-agree ≠ disagree.
+const agreementOf = (doi) => {
+  const vs = outcomesFor(doi).map((o) => o.verdict);
+  const contra  = vs.filter((v) => /contradict|notsupport|refut/i.test(v)).length;
+  const partial = vs.filter((v) => /partial/i.test(v)).length;
+  const confirm = vs.filter((v) => /validat|confirm|support/i.test(v) && !/partial|contradict|notsupport|refut/i.test(v)).length;
+  const n = vs.length;
+  if (contra && (confirm || partial)) return { key: "contested", why: `${n} replications disagree — ${confirm} confirm · ${partial} partial · ${contra} contradict` };
+  if (contra)                         return { key: "refuted",   why: `contradicted by ${contra} replication${contra > 1 ? "s" : ""}` };
+  if (confirm >= 2 && !partial)       return { key: "robust",    why: `${confirm} independent replications, all confirmed` };
+  if (confirm)                        return { key: "validated", why: partial ? `confirmed (${n} replications, ${partial} partial)` : (n > 1 ? `confirmed (${n} replications)` : "confirmed once") };
+  if (partial)                        return { key: "validated", why: `partially supported (${partial} of ${n})` };
+  return { key: "validated", why: "independently checked" };
+};
+const statusOf = (t) => {
+  if (t.status === "VERIFIED") return agreementOf(t.doi).key;        // robust / validated / contested / refuted
+  if (t.mat && t.mat.score != null) return "reproducible";          // original materials present → can re-run
+  const old = t.year && (new Date().getFullYear() - t.year) >= 8;   // had time to be replicated
+  const hot = t.impl === "C1" || t.impl === "C2";                   // still gaining momentum
+  return (old && !hot) ? "dormant" : "needs";
+};
+// Replication PRIORITY (0..1) — how much this would benefit from (further) replication, so the
+// number and the order agree. OPEN = worth × feasible (the readiness already computed). VERIFIED =
+// impact modulated by the agreement: contested/unsettled rises, robustly-validated sinks (it's done).
+const VERDICT_WEIGHT = { robust: 0.2, validated: 0.4, contested: 0.95, refuted: 0.55 };
+const priorityOf = (t) => {
+  if (t.status !== "VERIFIED") {
+    // dormant = old, cold, no materials → low ACTIONABILITY, so it sinks below live targets
+    // however high its historic citation count, matching what the "💤 Dormant" badge signals.
+    return t.statusKey === "dormant" ? Math.round(t.readiness * 0.5 * 100) / 100 : t.readiness;
+  }
+  const imp = Math.max(CLASS_SCORE[t.infl] || 0.2, CLASS_SCORE[t.cls] || 0.2);
+  return Math.round(imp * (VERDICT_WEIGHT[t.statusKey] ?? 0.4) * 100) / 100;
+};
 
 async function search(topic, type, size) {
   const u = `${API}/researchProducts?search=${encodeURIComponent(topic)}&type=${type}&pageSize=${size}`;
@@ -135,9 +210,18 @@ const NP_SPARQL = "https://query.knowledgepixels.com/repo/full";
 const TPL_OUTCOME = "https://w3id.org/np/RA2zljn0Nw9SadppOyxZoh-_Rxosslrq-vYG-p9SttnJE";
 const TPL_CITO = "https://w3id.org/np/RA43F9EoOuzF0xoNUnCMNyFsfIqlsuWDdPHCnN0wCdCAw";
 const VERDICT_RELS = new Set(["confirms", "qualifies", "disputes", "critiques", "extends", "supports", "refutes"]);
+// CiTO relations that are METHOD/DATA/CREDIT provenance — they point to a SOURCE paper, not a
+// verdict on it. A verdict must never attach via these: a study that `usesMethodIn` Phillips 2009
+// and was Contradicted does NOT contradict Phillips 2009 (it reused its method). (lowercased compare)
+const NONVERDICT_RELS = new Set(["usesmethodin", "usesdatafrom", "citesasdatasource", "citesasevidence", "credits", "citesforinformation", "obtainsbackgroundfrom", "obtainssupportfrom", "citesasauthority", "citesasrelated", "citesassourcedocument", "includesquotationfrom", "sharesauthorinstitutionwith"]);
 const npHash = (u) => (u || "").replace(/.*\/np\//, "");
 const doiPart = (u) => (u || "").replace(/.*doi\.org\//, "").toLowerCase();
 const cleanRepo = (r) => (!r ? null : r.includes("doi.org/") ? doiPart(r) : /^10\./.test(r) ? r.toLowerCase() : r);
+// AIDA statement URI → the atomic claim sentence (mixed +/%20 encoding in the wild).
+const aidaText = (u) => { if (!u) return ""; try { return decodeURIComponent(u.replace(/.*\/aida\//, "").replace(/\+/g, " ")); } catch (e) { return ""; } };
+// e.g. ".../terms/model_performance-FORRT-Claim" → "model performance"
+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" } });
@@ -155,8 +239,28 @@ async function buildIndexFromNetwork() {
 SELECT DISTINCT ?outcome ?status ?repo WHERE { GRAPH ?g { ?outcome ntpl:wasCreatedFromTemplate <${TPL_OUTCOME}> . } ?outcome np:hasAssertion ?oa . GRAPH ?oa { ?oc slt:hasValidationStatus ?s . OPTIONAL { ?oc slt:hasOutcomeRepository ?repo . } } BIND(STRAFTER(STR(?s),"/terms/") AS ?status) }`;
   const QB = `PREFIX np: <http://www.nanopub.org/nschema#> PREFIX ntpl: <https://w3id.org/np/o/ntemplate/> PREFIX cito: <http://purl.org/spar/cito/>
 SELECT DISTINCT ?cito ?subj ?rel ?orig WHERE { GRAPH ?g { ?cito ntpl:wasCreatedFromTemplate <${TPL_CITO}> . } ?cito np:hasAssertion ?ca . GRAPH ?ca { ?subj ?rel ?orig . } FILTER(STRSTARTS(STR(?rel),STR(cito:))) FILTER(CONTAINS(STR(?orig),"doi.org/10.")) } LIMIT 3000`;
+  // QC: what exactly was replicated — traverse Outcome →isOutcomeOf→ Study →targetsClaim→ Claim,
+  // pulling the claim label, its AIDA statement (the atomic claim sentence), and its FORRT type.
+  const QC = `PREFIX np: <http://www.nanopub.org/nschema#> PREFIX ntpl: <https://w3id.org/np/o/ntemplate/> PREFIX slt: <https://w3id.org/sciencelive/o/terms/> PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+SELECT DISTINCT ?outcome ?claimLabel ?aida ?ctype WHERE { GRAPH ?og { ?outcome ntpl:wasCreatedFromTemplate <${TPL_OUTCOME}> . } ?outcome np:hasAssertion ?oa . GRAPH ?oa { ?oc slt:isOutcomeOf ?study . } GRAPH ?sg { ?study slt:targetsClaim ?claim . } GRAPH ?cg { ?claim rdfs:label ?claimLabel . } OPTIONAL { GRAPH ?cg { ?claim slt:asAidaStatement ?aida . } } OPTIONAL { GRAPH ?cg { ?claim a ?ctype . FILTER(CONTAINS(STR(?ctype),"-FORRT-Claim")) } } } LIMIT 500`;
+  // QV: validity guard — OUR Outcomes retracted / invalidated / superseded by a nanopub from the
+  // SAME creator (only the original author can retract their own work; a third-party `retracts`
+  // must not suppress someone else's). Disapproval is deliberately excluded — that's disagreement,
+  // not retraction. Anchored on the Outcome template alone to stay under the endpoint timeout.
+  const QV = `PREFIX ntpl: <https://w3id.org/np/o/ntemplate/> PREFIX npx: <http://purl.org/nanopub/x/> PREFIX dct: <http://purl.org/dc/terms/>
+SELECT DISTINCT ?np WHERE { GRAPH ?g { ?np ntpl:wasCreatedFromTemplate <${TPL_OUTCOME}> . } GRAPH ?supg { ?sup ?act ?np . } VALUES ?act { npx:retracts npx:invalidates npx:supersedes } GRAPH ?cg1 { ?sup dct:creator ?cc . } GRAPH ?cg2 { ?np dct:creator ?cc . } }`;
   const A = await sparqlCsv(QA);            // sequential: concurrent queries truncate the endpoint
   const B = await sparqlCsv(QB);
+  let invalid = new Set();
+  try { invalid = new Set((await sparqlCsv(QV)).map((r) => npHash(r.np))); }  // best-effort: never break verdicts
+  catch (e) { /* no guard this load */ }
+  CLAIMS = {};
+  try {                                     // claim enrichment is best-effort — never break verdicts
+    for (const r of await sparqlCsv(QC)) {
+      const h = npHash(r.outcome);
+      if (!CLAIMS[h]) CLAIMS[h] = { label: r.claimLabel || "", aida: aidaText(r.aida), type: claimType(r.ctype) };
+    }
+  } catch (e) { /* claims stay empty; cards still show verdict + why */ }
   const byHash = {};
   for (const r of B) {
     const h = npHash(r.subj);
@@ -164,9 +268,11 @@ SELECT DISTINCT ?cito ?subj ?rel ?orig WHERE { GRAPH ?g { ?cito ntpl:wasCreatedF
   }
   const V = {};
   for (const o of A) {
+    if (invalid.has(npHash(o.outcome))) continue;   // drop a superseded/retracted Outcome
     const cs = byHash[npHash(o.outcome)] || [];
     const verdictCitos = cs.filter((c) => VERDICT_RELS.has(c.rel) && !c.orig.startsWith("10.5281/"));
-    const targets = verdictCitos.length ? verdictCitos : cs.filter((c) => !c.orig.startsWith("10.5281/"));
+    const targets = verdictCitos.length ? verdictCitos
+      : cs.filter((c) => !NONVERDICT_RELS.has((c.rel || "").toLowerCase()) && !c.orig.startsWith("10.5281/"));
     for (const c of targets) {
       (V[c.orig] = V[c.orig] || []).push({
         verdict: o.status || "Published", cito: [c.rel], repo_doi: cleanRepo(o.repo),
@@ -206,6 +312,23 @@ async function loadVerdicts() {
   }));
 }
 
+// ---------- curated paper-resolved materials (the links OpenAIRE doesn't hold) ----------
+// curated.json carries only the repo/RO-Crate link, taken from each paper's Data/Code
+// statement (grounded). FAIR is still computed LIVE by assessSoftware() against the repo.
+async function loadCurated() {
+  try { CURATED = (await (await fetch("curated.json")).json()).resolved || {}; }
+  catch (e) { CURATED = {}; return; }
+  // enrich each with its OpenAIRE node (title / impact / year) so it can be injected + ranked
+  await Promise.all(Object.entries(CURATED).map(async ([doi, c]) => {
+    const rec = await fetchByDoi(doi);
+    if (rec) {
+      c.title = rec.mainTitle || doi; c.citations = impact(rec).citationCount || 0;
+      c.cls = impact(rec).citationClass; c.infl = impact(rec).influenceClass;
+      c.impl = impact(rec).impulseClass; c.year = yearOf(rec);
+    } else { c.title = c.title || doi; }
+  }));
+}
+
 // ---------- the radar ----------
 // OpenAIRE returns peer-review reports, comments, errata etc. as "publications" —
 // not replication targets. Drop them, and collapse versions/duplicates by title.
@@ -232,12 +355,12 @@ async function radar(topic) {
   const rank = (r) => [CLASS_SCORE[impact(r).influenceClass] || .2, CLASS_SCORE[impact(r).citationClass] || .2, (impact(r).citationCount || 0)];
   pubs.sort((a, b) => { const A = rank(a), B = rank(b); return (B[0] - A[0]) || (B[1] - A[1]) || (B[2] - A[2]); });
 
-  const sw = await search(topic, "software", 25);   // field-level reusable tooling (shown once, below)
-
   const targets = pubs.slice(0, 50).map((p) => {
     const doi = doiOf(p);
     const verified = doi && VERDICTS[doi];
-    const mat = materialsOf(p);                       // per-paper, grounded (unknown != absent)
+    let mat = materialsOf(p);                          // per-paper, grounded (unknown != absent)
+    const cur = doi && CURATED[doi];                   // paper-resolved materials override (P2)
+    if (cur) mat = { score: cur.state === "rocrate" ? 1.0 : 0.6, state: cur.state, code: cur.code || null, resolved: true, data: cur.data || [], source: cur.source || "the paper", lang: cur.lang };
     const impactScore = classScore(p), momentum = momentumScore(p);
     const readiness = readinessFrom(mat.score, impactScore, momentum);   // computed for ALL (incl. verified)
     return {
@@ -289,17 +412,6 @@ async function radar(topic) {
     .map((v) => ({ title: v.title, citations: v.citations, status: "VERIFIED" }));
   const chartItems = [...poolItems, ...extra].sort((a, b) => (b.citations || 0) - (a.citations || 0)).slice(0, 12);
 
-  // FIELD-LEVEL independent tooling — shown ONCE, not per paper (it isn't paper-specific).
-  // Reuse-ranked, de-duplicated, and we drop repos merely named after the query.
-  const slug = topic.toLowerCase().replace(/\s+/g, "-");
-  const seenT = new Set();
-  const tooling = sw
-    .filter((s) => reuse(s) >= 2 && !(s.mainTitle || "").toLowerCase().includes(slug))
-    .sort((a, b) => reuse(b) - reuse(a))
-    .map((s) => ({ title: s.mainTitle || "", link: s.codeRepositoryUrl || urlOf(s), swh: swh(s), swhUrl: swhUrlOf(s) }))
-    .filter((t) => { const k = t.link || t.title; if (!t.title || seenT.has(k)) return false; seenT.add(k); return true; })
-    .slice(0, 5);
-
   // Inject matched VERIFIED papers that OpenAIRE's keyword search didn't return, so
   // the paper you replicated always appears in the table (at its replicability rank).
   const have = new Set(targets.map((t) => t.doi));
@@ -307,21 +419,50 @@ async function radar(topic) {
     if (!v.doi || have.has(v.doi)) continue;
     const cs = Math.max(CLASS_SCORE[v.infl] || 0.2, CLASS_SCORE[v.cls] || 0.2);
     const momentum = CLASS_SCORE[v.impl] || 0.2;
-    const matScore = (v.repl && v.repl.code) ? 1.0 : (v.repo_doi ? 0.8 : null);   // its replication deposit
+    // verified: the materials score is about reproducing the ORIGINAL (unknown here) — NOT the
+    // replication's own repo. Keep that repo only so the FAIR badge can assess it.
     targets.push({
       title: v.title, doi: v.doi, citations: v.citations, cls: v.cls, infl: v.infl,
       year: v.year || null, impl: v.impl || null,
-      mat: { score: matScore, state: matScore == null ? "unknown" : "code", code: (v.repl && v.repl.code) || null },
-      parts: { mat: matScore, impact: cs, momentum },
+      mat: { score: null, state: "unknown", code: (v.repl && v.repl.code) || null },
+      parts: { mat: null, impact: cs, momentum },
       status: "VERIFIED",
-      readiness: readinessFrom(matScore, cs, momentum),
+      readiness: readinessFrom(null, cs, momentum),
       verification: [...new Set(v.verdicts)].join(", "),
       outcome_np: v.outcome_np,
     });
   }
-  targets.sort((a, b) => (b.readiness || 0) - (a.readiness || 0) || (b.citations || 0) - (a.citations || 0));
+  // Inject curated, paper-resolved candidates that match the field but OpenAIRE search missed,
+  // so the fully-resolved (materials-verified) papers always appear for their topic.
+  for (const [doi, c] of Object.entries(CURATED)) {
+    if (targets.some((t) => t.doi === doi)) continue;
+    const tw = new Set((c.title || "").toLowerCase().split(/\W+/));
+    if (!terms.some((t) => tw.has(t))) continue;       // only when it matches the search
+    const impactScore = Math.max(CLASS_SCORE[c.infl] || 0.2, CLASS_SCORE[c.cls] || 0.2);
+    const momentum = CLASS_SCORE[c.impl] || 0.2;
+    const matScore = c.state === "rocrate" ? 1.0 : 0.6;
+    targets.push({
+      title: c.title, doi, citations: c.citations || 0, cls: c.cls, infl: c.infl,
+      year: c.year || null, impl: c.impl || null,
+      mat: { score: matScore, state: c.state, code: c.code || null, resolved: true, data: c.data || [], source: c.source || "the paper", lang: c.lang },
+      parts: { mat: matScore, impact: impactScore, momentum },
+      status: VERDICTS[doi] ? "VERIFIED" : "OPEN",
+      readiness: readinessFrom(matScore, impactScore, momentum),
+      verification: VERDICTS[doi] ? [...new Set(VERDICTS[doi].map((v) => v.verdict))].join(", ") : null,
+      outcome_np: VERDICTS[doi] ? ((VERDICTS[doi].find((v) => v.outcome_np) || {}).outcome_np || null) : null,
+    });
+  }
+  targets.forEach((t) => { t.statusKey = statusOf(t); t.priority = priorityOf(t); });
+  // sort by replication PRIORITY — so the number and the order agree (contested/unchecked rise,
+  // robustly-validated sinks). No status-rank override.
+  targets.sort((a, b) => (b.priority || 0) - (a.priority || 0) || (b.citations || 0) - (a.citations || 0));
+
+  // FAIR computed LIVE (same assessSoftware the verified path uses) for paper-resolved repos
+  await Promise.all(targets.map(async (t) => {
+    if (t.mat && t.mat.resolved && t.mat.code && parseGitHub(t.mat.code)) t.fair = await assessSoftware(t.mat.code);
+  }));
 
-  return { topic, targets, inField, chartItems, tooling };
+  return { topic, targets, inField, chartItems };
 }
 
 // ---------- rendering ----------
@@ -329,55 +470,90 @@ const el = (id) => document.getElementById(id);
 const esc = (s) => (s || "").replace(/[&<>]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;" }[c]));
 
 const PER_PAGE = 10;
-let _targets = [], _tpage = 0;
+let _targets = [], _tpage = 0, _tfilter = new Set();
 
 function targetRow(t) {
   const p = t.parts || {};
-  const scoreTitle = `replicability = 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 unv = t.mat && t.mat.score == null ? `<small class="unv">mat ?</small>` : "";
-  const score = `<div class="score" title="${esc(scoreTitle)}"><span>${t.readiness != null ? t.readiness.toFixed(2) : "—"}</span><small>REPLIC.</small>${unv}</div>`;
-  const badge = t.status === "VERIFIED"
-    ? `<span class="badge verified">VERIFIED</span><span class="badge cls">${t.verification}</span>`
-    : `<span class="badge open">OPEN</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 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.state === "code" ? `<span class="badge mok" title="code repository linked to this paper">code ✓</span>`
-    : `<span class="badge munk" title="OpenAIRE holds no code/data link for this paper — unknown, NOT absent (needs checking)">materials ?</span>`;
+  const scoreTitle = t.status === "VERIFIED"
+    ? `replication priority — already checked: impact modulated by agreement (${t.statusKey}). A robustly-validated result sinks (it's settled); a contested one rises (worth re-checking).`
+    : `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>` : "");
+  // 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 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>` : "")
     + matMeta + `</div>`;
   const link = t.doi ? `<a href="https://doi.org/${t.doi}" target="_blank" rel="noopener">${t.doi}</a>` : "";
-  const verdictLink = (t.status === "VERIFIED" && t.outcome_np)
-    ? `<div class="tverdict">independently checked by Science Live · <a href="${t.outcome_np}" target="_blank" rel="noopener">replication outcome →</a></div>` : "";
+  // what EXACTLY was replicated — the claim's AIDA statement (atomic sentence) + its FORRT type
+  const cl = t.status === "VERIFIED" ? claimFor(t.outcome_np) : null;
+  const claimLine = (cl && (cl.aida || cl.label))
+    ? `<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>` : "";
+  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>`
+    : "";
+  // OPEN targets get a next step: discovery here → the FORRT template handles the nanopub chain.
+  const replicateCTA = (t.status !== "VERIFIED")
+    ? `<div class="treplicate"><a href="https://github.com/ScienceLiveHub/forrt-replication-template" target="_blank" rel="noopener" title="Start a replication from the FORRT template — it scaffolds the repo and the signed nanopub chain (Claim · Study · Outcome)">▷ Replicate this with the template →</a></div>`
+    : "";
   return `<div class="target ${t.status === "VERIFIED" ? "verified" : ""}">
     ${score}
-    <div class="t-main">${badge}<br><b>${esc(t.title)}</b>${meta}${verdictLink}</div>
+    <div class="t-main">${badge}<br><b>${esc(t.title)}</b>${meta}${claimLine}${verdictLink}${resolvedNote}${fairNote}${replicateCTA}</div>
     <div class="t-right">${t.citations.toLocaleString()} cites<br>${link}</div>
   </div>`;
 }
 
+const FILTER_ORDER = ["reproducible", "robust", "validated", "contested", "refuted", "needs", "dormant"];
+const visibleTargets = () => (_tfilter.size ? _targets.filter((t) => _tfilter.has(t.statusKey)) : _targets);
+
+function paintFilters() {
+  const counts = {};
+  for (const t of _targets) counts[t.statusKey] = (counts[t.statusKey] || 0) + 1;
+  const present = FILTER_ORDER.filter((k) => counts[k]);
+  if (present.length < 2) { el("tfilters").innerHTML = ""; return; }   // nothing to filter
+  const chip = (on, key, label, count) =>
+    `<button class="tfilter${on ? " on" : ""}" onclick="filterTargets(${key ? `'${key}'` : "null"})"${key ? ` title="${esc(STATUS[key].tip)}"` : ""}>${label} <span>${count}</span></button>`;
+  el("tfilters").innerHTML = chip(_tfilter.size === 0, null, "All", _targets.length)
+    + present.map((k) => chip(_tfilter.has(k), k, STATUS[k].label, counts[k])).join("");
+}
+
 function paintTargets() {
-  const pages = Math.max(1, Math.ceil(_targets.length / PER_PAGE));
+  paintFilters();
+  const list = visibleTargets();
+  const pages = Math.max(1, Math.ceil(list.length / PER_PAGE));
   if (_tpage >= pages) _tpage = pages - 1;
-  el("tcount").textContent = `${_targets.filter((t) => t.status === "OPEN").length} open · ${_targets.filter((t) => t.status === "VERIFIED").length} verified`;
-  el("targets").innerHTML = _targets.slice(_tpage * PER_PAGE, _tpage * PER_PAGE + PER_PAGE).map(targetRow).join("");
+  if (_tpage < 0) _tpage = 0;
+  el("tcount").textContent = `${_targets.length} candidate${_targets.length === 1 ? "" : "s"}`;
+  el("targets").innerHTML = list.length
+    ? list.slice(_tpage * PER_PAGE, _tpage * PER_PAGE + PER_PAGE).map(targetRow).join("")
+    : `<p class="hint" style="padding:10px 2px">No candidates in this category — <a href="#" onclick="filterTargets(null);return false">show all</a>.</p>`;
   el("tpager").innerHTML = pages > 1
     ? `<button ${_tpage === 0 ? "disabled" : ""} onclick="pageTargets(-1)">← Prev</button><span>Page ${_tpage + 1} of ${pages}</span><button ${_tpage >= pages - 1 ? "disabled" : ""} onclick="pageTargets(1)">Next →</button>`
     : "";
 }
 
-function renderTargets(targets) { _targets = targets; _tpage = 0; paintTargets(); }
+function renderTargets(targets) { _targets = targets; _tpage = 0; _tfilter.clear(); paintTargets(); }
 window.pageTargets = (d) => { _tpage += d; paintTargets(); el("targets").scrollIntoView({ behavior: "smooth", block: "start" }); };
+window.filterTargets = (k) => {
+  if (k === null) _tfilter.clear();
+  else if (_tfilter.has(k)) _tfilter.delete(k);
+  else _tfilter.add(k);
+  _tpage = 0; paintTargets();
+};
 
-function renderTooling(tooling) {
-  if (!tooling || !tooling.length) { el("fieldtools").innerHTML = ""; return; }
-  const items = tooling.map((t) =>
-    `${t.link ? `<a href="${t.link}" target="_blank" rel="noopener">${esc(t.title).slice(0, 40)}</a>` : esc(t.title).slice(0, 40)}${t.swh ? ` <a href="${t.swhUrl || t.link}" target="_blank" rel="noopener" class="swh" title="archived in Software Heritage">⬡</a>` : ""}`
-  ).join(" &nbsp;·&nbsp; ");
-  el("fieldtools").innerHTML = `<b>Independent reusable tooling in this area</b> — engines for replicating by a different route, not tied to any one paper below: ${items}`;
-}
 
 function renderVerified(inField) {
   const field = VERIFIED.filter((v) => inField.has(v.doi)).sort((a, b) => b.citations - a.citations);
@@ -389,7 +565,7 @@ function renderVerified(inField) {
   // rich card: the trust edge shown as TWO OpenAIRE nodes (original + replication)
   const matchCard = (v) => {
     const chips = [
-      v.oa ? `<span class="ochip oa">${esc(v.oa)} OA</span>` : "",
+      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>`,
@@ -406,54 +582,56 @@ function renderVerified(inField) {
     } else if (v.repo_doi) {
       repl = `<div class="vrepl muted">↳ replication deposit: <a href="${v.repo_doi.startsWith("http") ? esc(v.repo_doi) : "https://doi.org/" + esc(v.repo_doi)}" target="_blank" rel="noopener">${esc(v.repo_doi)}</a> <span class="ochip wait">awaiting OpenAIRE harvest</span></div>`;
     }
+    const vouts = outcomesFor(v.doi).filter((o) => o.np);
+    const vcl = claimFor(v.outcome_np);
+    const vClaimLine = (vcl && (vcl.aida || vcl.label))
+      ? `<div class="vclaim"><span class="claimlbl">claim replicated</span> <span class="claimq">“${esc(vcl.aida || vcl.label)}”</span>${vcl.type ? ` <span class="badge ctype" title="FORRT claim type">${esc(vcl.type)}</span>` : ""}</div>` : "";
     return `<li class="match">
       <span class="nodelabel">original paper · OpenAIRE</span>
       <span class="vt">${esc(v.title).slice(0, 82)}</span>
       <div class="ochips">${chips}</div>
-      <div class="vline"><span class="vv ${partialOf(v) ? "partial" : ""}">${v.verdicts.join(", ")}</span> — independently checked by Science Live ${v.outcome_np ? `· <a href="${v.outcome_np}" target="_blank" rel="noopener">replication outcome →</a>` : (v.cito_np ? `· <a href="${v.cito_np}" target="_blank" rel="noopener">verdict chain →</a>` : "")}</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>
       ${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 drawn from the Science Live verification index bundled with this Radar. <a href="https://github.com/ScienceLiveHub/replication-radar/blob/main/src/replication_radar/data/verdicts.json" target="_blank" rel="noopener">browse the index →</a></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>`;
   el("verified").innerHTML = fieldHtml + moreHtml;
 }
 
-function renderChart(items) {
-  const short = (s) => { s = s || ""; return s.length > 46 ? s.slice(0, 44) + "…" : s; };
-  if (chart) chart.destroy();
-  if (!items.length) { el("gap").parentElement.querySelector(".empty")?.remove(); return; }
-  chart = new Chart(el("gap"), {
-    type: "bar",
-    data: {
-      labels: items.map((i) => short(i.title)),
-      datasets: [{
-        data: items.map((i) => Math.max(1, i.citations || 0)),
-        backgroundColor: items.map((i) => (i.status === "VERIFIED" ? "#11875a" : "#e6007e")),
-        borderRadius: 5, barThickness: 16,
-      }],
-    },
-    options: {
-      indexAxis: "y",
-      maintainAspectRatio: false,
-      scales: {
-        x: { type: "logarithmic", title: { display: true, text: "citation impact (count, log)" }, grid: { color: "#eef2f9" } },
-        y: { ticks: { font: { size: 11 } }, grid: { display: false } },
-      },
-      plugins: {
-        legend: { display: false },
-        tooltip: { callbacks: {
-          title: (ti) => items[ti[0].dataIndex].title,   // full (untruncated) paper title on hover
-          label: (c) => `${items[c.dataIndex].status === "VERIFIED" ? "✓ already checked" : "open — worth replicating"} · ${items[c.dataIndex].citations.toLocaleString()} cites`,
-        } },
-      },
-    },
-  });
+// The replication-gap map: a status-composition bar over the ranked list (not a per-paper
+// citation chart — the insight is how MUCH of the field has been checked, not who's most cited).
+const GAP_ORDER = ["reproducible", "robust", "validated", "contested", "refuted", "needs", "dormant"];
+// Distinguishable by hue AND lightness — the two "unchecked" states (needs/dormant) were
+// previously near-identical light blue-greys; now a clear medium slate vs a light warm grey.
+// Platform chart colormap: chart-1 pink, chart-3 green, chart-4 orange, destructive red,
+// chart-5 slate + a light grey for the two "unchecked" states (which should recede).
+// reproducible = brand pink · robust/validated (confirmed) = navy + brighter blue · contested =
+// amber · refuted = red · the two unchecked states = DESATURATED neutral greys (no blue tint) so
+// the navy/blue "checked" segments read clearly apart from them.
+const GAP_COLOR = { reproducible: "#be2e78", robust: "#1f4d8f", validated: "#4a7bc0", contested: "#f59e09", refuted: "#ff6b6b", needs: "#9aa0a8", dormant: "#d7d9dc" };
+const CHECKED = new Set(["robust", "validated", "contested", "refuted"]);
+function renderChart() {
+  const counts = {};
+  for (const t of _targets) counts[t.statusKey] = (counts[t.statusKey] || 0) + 1;
+  const total = _targets.length;
+  if (!total) { el("gap").innerHTML = ""; return; }
+  const present = GAP_ORDER.filter((k) => counts[k]);
+  const checked = present.filter((k) => CHECKED.has(k)).reduce((s, k) => s + counts[k], 0);
+  const seg = present.map((k) =>
+    `<span class="gapseg" style="width:${(counts[k] / total * 100).toFixed(1)}%;background:${GAP_COLOR[k]}" title="${esc(STATUS[k].label)} — ${counts[k]}"></span>`).join("");
+  const key = present.map((k) =>
+    `<button class="gapkeyi" onclick="filterTargets('${k}')" title="filter the list to ${esc(STATUS[k].label)}"><i style="background:${GAP_COLOR[k]}"></i>${STATUS[k].label} <b>${counts[k]}</b></button>`).join("");
+  const head = checked === 0
+    ? `<b>0</b> of <b>${total}</b> independently checked — <span class="gapnone">the whole field is an open replication gap</span>`
+    : `<b>${checked}</b> of <b>${total}</b> independently checked — <span class="gapsub">the other ${total - checked} are the replication gap</span>`;
+  el("gap").innerHTML = `<div class="gaphead">${head}</div><div class="gapbar">${seg}</div><div class="gapkey">${key}</div>`;
 }
 
-async function run(topic) {
+async function run(topic, isExample) {
   topic = (topic || "").trim();
   if (!topic) return;
   el("go").disabled = true;
@@ -462,12 +640,12 @@ async function run(topic) {
     const r = await radar(topic);
     el("results").hidden = false;
     renderTargets(r.targets);
-    renderTooling(r.tooling);
     renderVerified(r.inField);
-    renderChart(r.chartItems);
-    el("status").textContent = r.inField.size
+    renderChart();
+    const note = isExample ? ` <i>— showing an example; search your own field above.</i>` : "";
+    el("status").innerHTML = (r.inField.size
       ? `“${topic}”: ${r.targets.length} candidates · ${r.inField.size} already checked, matching your search (green) — the rest are open.`
-      : `“${topic}”: ${r.targets.length} candidates · none matching your search have been checked yet — every one is an open replication opportunity.`;
+      : `“${topic}”: ${r.targets.length} candidates · none matching your search have been checked yet — every one is an open replication opportunity.`) + note;
   } catch (e) {
     el("status").textContent = `Could not reach the OpenAIRE Graph (${e.message}). Try again or a shorter topic.`;
   } finally {
@@ -482,4 +660,12 @@ el("go").addEventListener("click", () => run(el("topic").value));
 el("topic").addEventListener("keydown", (e) => { if (e.key === "Enter") run(el("topic").value); });
 
 el("status").textContent = "Loading the Science Live verdict layer live from the nanopub network …";
-loadVerdicts().then(() => { el("status").textContent = "Type a research field and hit Scan — or try an example above."; });
+Promise.all([loadVerdicts(), loadCurated()]).then(() => {
+  // Default landing state: populate the radar with a sample field so first-time visitors see the
+  // value immediately, not a blank page — but never clobber a user who has already started.
+  if (!el("topic").value.trim() && el("results").hidden) {
+    run("species distribution", true);
+  } else {
+    el("status").textContent = "Type a research field and hit Scan — or try an example above.";
+  }
+});

replication_radar-0.3.2/site/curated.json

@@ -0,0 +1,12 @@
+{
+  "_comment": "Paper-resolved materials that OpenAIRE does NOT hold as links (verified: search records + relationship layer carry only paper->paper cites for these). Each repo URL is taken from the paper's own Data/Code Availability statement (grounded, not guessed). FAIR is computed LIVE by the app's assessSoftware() against the repo; we only store the resolved link here. This is the P2 'bake-to-static' bridge.",
+  "resolved": {
+    "10.3389/fevo.2024.1148895": {
+      "state": "code",
+      "code": "https://github.com/trias-project/risk-modelling-and-mapping",
+      "lang": "R",
+      "data": ["GBIF", "CHELSA", "EURO-CORDEX", "CORINE"],
+      "source": "the paper's Data & Code Availability statement"
+    }
+  }
+}

replication_radar-0.3.2/site/index.html

@@ -0,0 +1,58 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Replication Radar — what to replicate next, from the OpenAIRE Graph</title>
+  <meta name="description" content="A live tool that turns the OpenAIRE Graph into a ranked replication queue: impact-ranked targets, the claim each one makes, and whether it has already been independently checked — with what verdict." />
+  <link rel="stylesheet" href="style.css" />
+</head>
+<body>
+  <header>
+    <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>
+    </div>
+  </header>
+
+  <main class="wrap">
+    <section class="search">
+      <input id="topic" type="text" placeholder="a topic — e.g. species distribution" autocomplete="off" />
+      <button id="go">Scan</button>
+      <div class="chips" id="chips"></div>
+    </section>
+
+    <p id="status" class="status"></p>
+
+    <section id="results" hidden>
+      <div class="card chartcard">
+        <h2>The replication-gap map</h2>
+        <p class="hint">How much of the high-impact work matching your search has actually been <b class="verified">independently checked</b> — the field at a glance. Everything <b class="open">not yet checked</b> is the replication gap.</p>
+        <div class="chartbox" id="gap"></div>
+      </div>
+      <aside class="card verifiedcard">
+        <h2>Verified, matching your search <span id="vcount" class="pill"></span></h2>
+        <p class="hint">The <b class="verified">checked</b> papers matching your search, with the claim that was tested and the verdict — the reliability signal the Graph can't hold. Click any outcome to open its signed nanopub.</p>
+        <div id="verified"></div>
+      </aside>
+      <div class="card">
+        <h2>Top replication targets <span class="pill" id="tcount"></span></h2>
+        <p class="hint">Candidates matching your search, ranked by <b>replication priority</b> (the PRIORITY score — the number and the order agree). OPEN = an opportunity; VERIFIED = already checked, with its agreement pattern. Paged, 10 at a time. Hover any badge or the score for what it means.</p>
+        <div id="tfilters" class="tfilters"></div>
+        <div id="targets" class="targets"></div>
+        <div id="tpager" class="tpager"></div>
+      </div>
+    </section>
+  </main>
+
+  <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>
+    </div>
+  </footer>
+
+  <script src="app.js"></script>
+</body>
+</html>

{replication_radar-0.3.0 → replication_radar-0.3.2}/site/style.css

@@ -1,7 +1,12 @@
 :root{
-  --navy:#0c1f3f; --navy2:#16305c; --ink:#1b2433; --mut:#5a6b85;
-  --magenta:#e6007e; --magenta-soft:#fde4f1; --green:#11875a; --green-soft:#def0e7;
-  --line:#e4e9f2; --bg:#f6f8fc; --card:#fff;
+  /* Science Live palette — matched to the platform.sciencelive4all.org / sciencelive4all.org
+     design tokens (primary pink, navy foreground, chart green/orange/slate, destructive red). */
+  --navy:#0c2c59; --navy2:#193967; --ink:#15294a; --mut:#505960;
+  --magenta:#be2e78; --magenta-soft:#f7e6ef;
+  /* "verified/confirmed" rides on navy (no green) — the ✅ glyph carries the positive cue.
+     --verified* keep the old --green* names only so existing rules need no churn. */
+  --green:#1f4d8f; --green-soft:#eaf0f9;
+  --line:#e2e5ea; --bg:#fafbfc; --card:#fff;
 }
 *{box-sizing:border-box}
 body{margin:0;font:16px/1.55 -apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Helvetica,Arial,sans-serif;color:var(--ink);background:var(--bg)}
@@ -18,7 +23,7 @@ header .sub{margin:0;color:#aebfdc;font-size:14px}
 #topic{flex:1;min-width:240px;padding:13px 16px;border:1.5px solid var(--line);border-radius:10px;font-size:16px;background:#fff}
 #topic:focus{outline:none;border-color:var(--magenta)}
 #go{padding:13px 26px;border:0;border-radius:10px;background:var(--magenta);color:#fff;font-size:16px;font-weight:600;cursor:pointer}
-#go:hover{background:#c40069}
+#go:hover{background:#a32a6a}
 #go:disabled{opacity:.5;cursor:default}
 .chips{display:flex;gap:8px;flex-wrap:wrap;width:100%}
 .chip{padding:5px 12px;border:1px solid var(--line);border-radius:20px;background:#fff;color:var(--mut);font-size:13px;cursor:pointer}
@@ -26,29 +31,35 @@ header .sub{margin:0;color:#aebfdc;font-size:14px}
 
 .status{color:var(--mut);min-height:22px;margin:10px 0}
 
-.legend{background:#fff;border:1px solid var(--line);border-radius:12px;margin:16px 0 4px;padding:4px 18px}
-.legend>summary{cursor:pointer;font-weight:600;color:var(--navy);padding:11px 0;font-size:13.5px;list-style-position:inside}
-.legend>summary:hover{color:var(--magenta)}
-.legend-grid{display:grid;grid-template-columns:1fr 1fr;gap:14px 30px;padding:6px 0 16px;font-size:13px}
-@media(max-width:680px){.legend-grid{grid-template-columns:1fr}}
-.legend-item{display:flex;flex-direction:column;gap:5px}
-.legend-h{font-weight:700;color:var(--navy2);font-size:10.5px;text-transform:uppercase;letter-spacing:.5px}
-.legend-body{color:var(--mut);line-height:1.7}
-.legend-body em{color:#9aa7bd;font-size:12px}
-.vv.contra{color:#b3005f}
-.grid{display:grid;grid-template-columns:1.5fr 1fr;gap:18px;margin-bottom:18px}
+.vv.contra{color:#cf3a3a}
+.grid{display:grid;grid-template-columns:1.5fr 1fr;gap:18px;margin-bottom:18px;align-items:start}
 @media(max-width:820px){.grid{grid-template-columns:1fr}}
 .card{background:var(--card);border:1px solid var(--line);border-radius:14px;padding:20px 22px;margin-bottom:18px}
 .card h2{margin:0 0 4px;font-size:17px;color:var(--navy)}
 .hint{margin:.2rem 0 14px;font-size:13px;color:var(--mut)}
 .hint .open{color:var(--magenta)} .hint .verified{color:var(--green)}
 .pill{display:inline-block;background:var(--navy);color:#fff;font-size:12px;border-radius:20px;padding:1px 9px;vertical-align:middle}
-.chartbox{position:relative;height:340px;margin-top:8px}
+.chartbox{position:relative;margin-top:10px}
+.gaphead{font-size:15px;color:var(--ink);margin-bottom:12px}
+.gaphead b{font-size:22px;color:var(--navy);font-weight:800}
+.gapsub{color:var(--mut);font-size:13px}
+.gapnone{color:var(--magenta);font-weight:600;font-size:13px}
+.gapbar{display:flex;height:28px;border-radius:8px;overflow:hidden;background:#eef2f9;border:1px solid var(--line)}
+.gapseg{display:block;height:100%;min-width:7px}
+.gapseg:not(:last-child){border-right:1.5px solid #fff}
+.gapkey{display:flex;flex-wrap:wrap;gap:6px 14px;margin-top:14px}
+.gapkeyi{display:inline-flex;align-items:center;gap:6px;font-size:12.5px;color:var(--mut);background:none;border:0;padding:0;cursor:pointer}
+.gapkeyi:hover{color:var(--navy2)}
+.gapkeyi i{width:11px;height:11px;border-radius:3px;display:inline-block}
+.gapkeyi b{color:var(--navy2);font-weight:700}
 
-.fieldtools{font-size:12.5px;color:var(--mut);background:#f3f6fb;border:1px solid var(--line);border-radius:9px;padding:10px 13px;margin:0 0 14px;line-height:1.7}
-.fieldtools:empty{display:none}
-.fieldtools b{color:var(--navy2)}
-.fieldtools .swh{color:var(--green);text-decoration:none;font-size:13px}
+.tfilters{display:flex;flex-wrap:wrap;gap:7px;margin:0 0 14px}
+.tfilters:empty{display:none}
+.tfilter{border:1px solid var(--line);background:#fff;border-radius:20px;padding:5px 12px;font-size:12.5px;font-weight:600;color:var(--mut);cursor:pointer;display:inline-flex;align-items:center;gap:6px;line-height:1.4}
+.tfilter span{background:#eef2f9;color:var(--navy2);border-radius:10px;padding:0 7px;font-size:11px;font-weight:700}
+.tfilter:hover{border-color:var(--magenta);color:var(--navy2)}
+.tfilter.on{border-color:var(--navy2);background:var(--navy);color:#fff}
+.tfilter.on span{background:rgba(255,255,255,.22);color:#fff}
 .targets{display:flex;flex-direction:column;gap:10px}
 .tpager{display:flex;align-items:center;justify-content:center;gap:16px;margin-top:16px;font-size:13px;color:var(--mut)}
 .tpager:empty{display:none}
@@ -56,22 +67,48 @@ header .sub{margin:0;color:#aebfdc;font-size:14px}
 .tpager button:hover:not(:disabled){border-color:var(--magenta);color:var(--magenta)}
 .tpager button:disabled{opacity:.4;cursor:default}
 .target{display:grid;grid-template-columns:auto 1fr auto;gap:14px;align-items:center;padding:12px 14px;border:1px solid var(--line);border-radius:10px}
-.target.verified{background:var(--green-soft);border-color:#bfe3d2}
+.target.verified{background:var(--green-soft);border-color:#cbd9f0}
 .score{width:54px;height:54px;border-radius:12px;display:flex;align-items:center;justify-content:center;font-weight:700;font-size:18px;color:#fff;background:var(--magenta);flex-direction:column;line-height:1}
 .score small{font-size:8px;font-weight:600;opacity:.85;letter-spacing:.4px}
 .target.verified .score{background:var(--green)}
 .t-main b{font-size:15px;color:var(--ink)}
 .t-meta{font-size:12.5px;color:var(--mut);margin-top:3px}
 .badge{display:inline-block;font-size:11px;font-weight:700;padding:1px 7px;border-radius:5px;margin-right:6px}
-.badge.open{background:var(--magenta-soft);color:#b3005f}
-.badge.verified{background:#cfeadd;color:var(--green)}
+.badge.open{background:var(--magenta-soft);color:#a32a6a}
+.badge.verified{background:#e7eefb;color:var(--green)}
 .badge.cls{background:#eef2f9;color:var(--navy2)}
 .badge.yr{background:#eef2f9;color:var(--mut)}
 .badge.imp{background:#e7edf6;color:var(--navy2)}
 .badge.mok{background:var(--green-soft);color:var(--green)}
-.badge.munk{background:#fde8cf;color:#8a5a1b}
+.badge.munk{background:#fdecc8;color:#9a6206}
 .score .unv{font-size:7.5px;font-weight:700;letter-spacing:.2px;opacity:.95}
+.badge.st-ready{background:var(--magenta);color:#fff}
+.badge.st-val{background:#e7eefb;color:var(--green)}
+.badge.st-con{background:#fdecc8;color:#9a6206}
+.badge.st-needs{background:#eef2f9;color:var(--mut)}
+.badge.st-dorm{background:#f0f1f4;color:#9aa7bd}
+.tclaim{font-size:12.5px;color:var(--ink);margin-top:6px;line-height:1.5}
+.claimlbl{font-size:10px;font-weight:700;text-transform:uppercase;letter-spacing:.4px;color:var(--green)}
+.claimq{font-style:italic}
+.badge.ctype{background:#e7edf6;color:var(--navy2);text-transform:capitalize}
 .tverdict{font-size:12px;color:var(--mut);margin-top:4px}
+.onp{display:inline-block;min-width:18px;text-align:center;border:1px solid var(--line);border-radius:4px;padding:0 6px;margin:0 2px;font-weight:700;font-size:11px;line-height:1.6}
+.onp:hover{text-decoration:none}
+/* white body so the chip is visible on tinted (verified) cards; verdict lives in border+text+hover */
+.onp.v-ok{border-color:#9db6df;color:var(--green);background:#fff}
+.onp.v-ok:hover{background:var(--green);color:#fff;border-color:var(--green)}
+.onp.v-part{border-color:#f0c06a;color:#9a6206;background:#fff}
+.onp.v-part:hover{background:#f59e09;color:#fff;border-color:#f59e09}
+.onp.v-con{border-color:#eaa6a0;color:#cf3a3a;background:#fff}
+.onp.v-con:hover{background:#d64545;color:#fff;border-color:#d64545}
+.onp.v-other{border-color:var(--line);color:var(--mut);background:#fff}
+.tresolved{font-size:12px;color:var(--green);margin-top:4px}
+.tresolved a{font-weight:600}
+.tfair{font-size:12px;color:var(--mut);margin-top:3px}
+.tfair b{color:var(--navy2)}
+.treplicate{margin-top:7px}
+.treplicate a{font-size:12px;font-weight:700;background:var(--magenta-soft);color:#a32a6a;padding:4px 11px;border-radius:7px;display:inline-block}
+.treplicate a:hover{background:var(--magenta);color:#fff;text-decoration:none}
 .tool{font-size:12px;color:var(--mut)}
 .tool .swh{color:var(--green);font-weight:600}
 .t-right{text-align:right;font-size:12px;color:var(--mut);white-space:nowrap}
@@ -82,18 +119,19 @@ header .sub{margin:0;color:#aebfdc;font-size:14px}
 .vlist li:last-child{border:0}
 .vt{color:var(--ink);font-weight:600;display:block;margin-bottom:2px}
 .vv{color:var(--green);font-weight:700;font-size:12px}
-.vv.partial{color:#b5820a}
+.vv.partial{color:#9a6206}
 #verified a{font-size:12px}
 .vlist li.match{background:var(--green-soft);margin:0 -8px 10px;padding:12px 13px;border-radius:8px;border:0}
 .nodelabel{display:block;font-size:10px;font-weight:700;letter-spacing:.5px;text-transform:uppercase;color:var(--green);margin-bottom:3px}
 .ochips{display:flex;flex-wrap:wrap;gap:5px;margin:6px 0}
 .ochip{font-size:11px;background:#e7edf6;color:var(--navy2);border-radius:5px;padding:1px 7px;white-space:nowrap}
-.ochip.oa{background:#d3ecdf;color:var(--green);text-transform:capitalize}
+.ochip.oa{background:#e7edf6;color:var(--navy2);text-transform:capitalize}
 .ochip.sdg{background:#fff1d3;color:#8a6d1b}
 .ochip.type{background:var(--navy);color:#fff;text-transform:capitalize}
 .ochip.cites{background:transparent;color:var(--mut);padding-left:0}
+.vclaim{font-size:12.5px;color:var(--ink);margin:7px 0 4px;line-height:1.5}
 .vline{font-size:12.5px;color:var(--mut);margin-top:5px}
-.vrepl{font-size:12.5px;margin-top:8px;padding-top:8px;border-top:1px dashed #bfe3d2;color:var(--ink)}
+.vrepl{font-size:12.5px;margin-top:8px;padding-top:8px;border-top:1px dashed #cbd9f0;color:var(--ink)}
 .vrepl.muted{color:var(--mut);border-top-color:var(--line)}
 .vrepl a{font-weight:600}
 .fairline{display:flex;align-items:center;flex-wrap:wrap;gap:7px;font-size:12px;color:var(--mut);margin-top:6px}
@@ -101,13 +139,13 @@ header .sub{margin:0;color:#aebfdc;font-size:14px}
 .fairrecs{display:flex;flex-wrap:wrap;align-items:center;gap:3px 10px;font-size:11.5px;margin-top:5px}
 .fairrecs b{color:var(--navy2);font-size:12px}
 .fairrecs .rok{color:var(--green)}
-.fairrecs .rno{color:#b5820a}
+.fairrecs .rno{color:#9a6206}
 .fairbar{display:inline-block;width:64px;height:7px;border-radius:4px;background:#e4e9f2;overflow:hidden}
 .fairbar i{display:block;height:100%;background:var(--green)}
 .swhok{color:var(--green);font-weight:600}
-.swhno{color:#b5820a}
-.ochip.wait{background:#fde8cf;color:#8a5a1b}
-.vnone{color:#9c0356;background:var(--magenta-soft);padding:12px 14px;border-radius:8px;font-size:13.5px}
+.swhno{color:#9a6206}
+.ochip.wait{background:#fdecc8;color:#9a6206}
+.vnone{color:#a32a6a;background:var(--magenta-soft);padding:12px 14px;border-radius:8px;font-size:13.5px}
 .vmore-stat{margin-top:14px;padding-top:12px;border-top:1px solid var(--line);font-size:12.5px;color:var(--mut)}
 
 footer{border-top:1px solid var(--line);margin-top:30px;padding:20px 0;color:var(--mut);font-size:13px;background:#fff}

{replication_radar-0.3.0 → replication_radar-0.3.2}/src/replication_radar/__init__.py

@@ -7,4 +7,4 @@ OpenAIRE impact + Software Heritage reuse signals + Science Live nanopub verdict
 from .radar import radar, find_independent_software, replication_status, verified_claims
 
 __all__ = ["radar", "find_independent_software", "replication_status", "verified_claims"]
-__version__ = "0.3.0"
+__version__ = "0.3.1"

{replication_radar-0.3.0 → replication_radar-0.3.2}/src/replication_radar/network.py

@@ -21,6 +21,12 @@ SPARQL = os.environ.get("RADAR_NANOPUB_SPARQL", "https://query.knowledgepixels.c
 TPL_OUTCOME = "https://w3id.org/np/RA2zljn0Nw9SadppOyxZoh-_Rxosslrq-vYG-p9SttnJE"
 TPL_CITO = "https://w3id.org/np/RA43F9EoOuzF0xoNUnCMNyFsfIqlsuWDdPHCnN0wCdCAw"
 VERDICT_RELS = {"confirms", "qualifies", "disputes", "critiques", "extends", "supports", "refutes"}
+# CiTO relations that are METHOD/DATA/CREDIT provenance — they point to a SOURCE paper, not a
+# verdict on it. A verdict must NEVER attach via these: a study that `usesMethodIn` Phillips 2009
+# and was Contradicted does not contradict Phillips 2009 (it reused its method). (lowercased compare)
+NONVERDICT_RELS = {"usesmethodin", "usesdatafrom", "citesasdatasource", "citesasevidence", "credits",
+                   "citesforinformation", "obtainsbackgroundfrom", "obtainssupportfrom", "citesasauthority",
+                   "citesasrelated", "citesassourcedocument", "includesquotationfrom", "sharesauthorinstitutionwith"}
 _CANON = {"validated": "Validated", "partiallysupported": "PartiallySupported", "contradicted": "Contradicted",
           "notsupported": "NotSupported", "mixed": "Mixed", "inconclusive": "Inconclusive"}
 _TIMEOUT = float(os.environ.get("RADAR_HTTP_TIMEOUT", "30"))
@@ -31,6 +37,18 @@ SELECT DISTINCT ?outcome ?status ?repo WHERE {{ GRAPH ?g {{ ?outcome ntpl:wasCre
 _QB = f"""PREFIX np: <http://www.nanopub.org/nschema#> PREFIX ntpl: <https://w3id.org/np/o/ntemplate/> PREFIX cito: <http://purl.org/spar/cito/>
 SELECT DISTINCT ?cito ?subj ?rel ?orig WHERE {{ GRAPH ?g {{ ?cito ntpl:wasCreatedFromTemplate <{TPL_CITO}> . }} ?cito np:hasAssertion ?ca . GRAPH ?ca {{ ?subj ?rel ?orig . }} FILTER(STRSTARTS(STR(?rel),STR(cito:))) FILTER(CONTAINS(STR(?orig),"doi.org/10.")) }} LIMIT 3000"""
 
+# Validity guard, run as its OWN lightweight query (anchored on the Outcome template, so it stays
+# fast — anchoring on two templates, or an inline FILTER NOT EXISTS on the full repo, times the
+# endpoint out at 504). Returns OUR Outcomes that have been retracted / invalidated / superseded by
+# a nanopub from the SAME creator. Same-creator is essential: only the original author can retract
+# their own work — a third party publishing `retracts` must not be able to suppress someone else's.
+# Disapproval (`disapprovesOf`) is deliberately NOT here: that is a third party disagreeing, not a
+# retraction, so it must never hide a verdict. (Only Outcomes are affected in the current network;
+# extend VALUES ?tpl to the CiTO template if a superseded CiTO ever appears — but keep it one
+# query per template to stay under the endpoint timeout.)
+_QV = f"""PREFIX ntpl: <https://w3id.org/np/o/ntemplate/> PREFIX npx: <http://purl.org/nanopub/x/> PREFIX dct: <http://purl.org/dc/terms/>
+SELECT DISTINCT ?np WHERE {{ GRAPH ?g {{ ?np ntpl:wasCreatedFromTemplate <{TPL_OUTCOME}> . }} GRAPH ?supg {{ ?sup ?act ?np . }} VALUES ?act {{ npx:retracts npx:invalidates npx:supersedes }} GRAPH ?cg1 {{ ?sup dct:creator ?cc . }} GRAPH ?cg2 {{ ?np dct:creator ?cc . }} }}"""
+
 
 def _sparql(query: str) -> list[dict]:
     url = f"{SPARQL}?{urllib.parse.urlencode({'query': query})}"
@@ -64,6 +82,10 @@ def build_index() -> dict:
     """
     outcomes = _sparql(_QA)        # sequential: concurrent queries truncate the endpoint
     citos = _sparql(_QB)
+    try:                                                   # best-effort: a guard timeout must not
+        invalid = {_hash(r.get("np")) for r in _sparql(_QV)}   # take down live verdicts
+    except Exception:
+        invalid = set()
     by_hash: dict[str, list] = {}
     for r in citos:
         by_hash.setdefault(_hash(r.get("subj")), []).append({
@@ -73,9 +95,11 @@ def build_index() -> dict:
         })
     index: dict[str, list] = {}
     for o in outcomes:
+        if _hash(o.get("outcome")) in invalid:             # drop a superseded/retracted Outcome
+            continue
         cs = by_hash.get(_hash(o.get("outcome")), [])
         verdict_citos = [c for c in cs if c["rel"] in VERDICT_RELS and not c["orig"].startswith("10.5281/")]
-        targets = verdict_citos or [c for c in cs if not c["orig"].startswith("10.5281/")]
+        targets = verdict_citos or [c for c in cs if c["rel"].lower() not in NONVERDICT_RELS and not c["orig"].startswith("10.5281/")]
         repo_doi = _clean_repo(o.get("repo") or "")
         for c in targets:
             index.setdefault(c["orig"], []).append({

replication_radar-0.3.0/site/index.html

@@ -1,99 +0,0 @@
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1" />
-  <title>Replication Radar — what to replicate next, from the OpenAIRE Graph</title>
-  <meta name="description" content="A live tool that turns the OpenAIRE Graph into a ranked replication queue: impact-ranked targets, independent reusable tooling, and whether a claim has already been checked." />
-  <link rel="stylesheet" href="style.css" />
-  <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.1/dist/chart.umd.min.js"></script>
-</head>
-<body>
-  <header>
-    <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 · independent tooling · already-checked overlay</p>
-    </div>
-  </header>
-
-  <main class="wrap">
-    <section class="search">
-      <input id="topic" type="text" placeholder="a topic — e.g. species distribution" autocomplete="off" />
-      <button id="go">Scan</button>
-      <div class="chips" id="chips"></div>
-    </section>
-
-    <p id="status" class="status"></p>
-
-    <section id="results" hidden>
-      <div class="grid">
-        <div class="card chartcard">
-          <h2>The replication-gap map</h2>
-          <p class="hint">High-impact papers matching your search, ranked by citations. <b class="verified">Green = already checked</b> by Science Live; <b class="open">pink = open</b> — a replication opportunity. All-pink means nothing here has been independently checked yet.</p>
-          <div class="chartbox"><canvas id="gap"></canvas></div>
-        </div>
-        <aside class="card verifiedcard">
-          <h2>Verified, matching your search <span id="vcount" class="pill"></span></h2>
-          <p class="hint">Science Live replications matching your search — these are the <b class="verified">green bars</b>. The verdict is the reliability signal the Graph can't hold; click through to the signed nanopub.</p>
-          <div id="verified"></div>
-        </aside>
-      </div>
-
-      <details class="legend" open>
-        <summary>Legend — what the labels mean</summary>
-        <div class="legend-grid">
-          <div class="legend-item">
-            <span class="legend-h">Impact class · OpenAIRE BIP!</span>
-            <span class="legend-body">
-              <span class="ochip">C1</span> top 0.01% &nbsp;<span class="ochip">C2</span> top 0.1% &nbsp;<span class="ochip">C3</span> top 1% &nbsp;<span class="ochip">C4</span> top 10% &nbsp;<span class="ochip">C5</span> the rest
-              <em>— global percentile of citations, across all of science</em>
-            </span>
-          </div>
-          <div class="legend-item">
-            <span class="legend-h">Status</span>
-            <span class="legend-body"><span class="badge open">OPEN</span> a replication opportunity &nbsp; <span class="badge verified">VERIFIED</span> already independently checked</span>
-          </div>
-          <div class="legend-item">
-            <span class="legend-h">Verdict · Science Live</span>
-            <span class="legend-body"><span class="vv">Validated</span> held up &nbsp; <span class="vv partial">PartiallySupported</span> in part &nbsp; <span class="vv contra">Contradicted</span> did not hold</span>
-          </div>
-          <div class="legend-item">
-            <span class="legend-h">Replicability (the REPLIC. score)</span>
-            <span class="legend-body">a 0–1 potential = impact × independent tooling available × reference data — higher means more worth, and more feasible, to replicate. Shown for every paper, including already-verified ones.</span>
-          </div>
-          <div class="legend-item">
-            <span class="legend-h">Open access · OpenAIRE</span>
-            <span class="legend-body">All mean the paper is <b>free to read</b>; they differ in <b>who paid to publish</b>: <b>gold</b> OA journal (author/funder fee) · <b>hybrid</b> OA in a subscription journal (author fee) · <b>green</b> free self-archived copy · <b>bronze</b> free on the publisher site, no open licence · <b>diamond</b> no fee for authors or readers</span>
-          </div>
-          <div class="legend-item">
-            <span class="legend-h">Subject tags · OpenAIRE</span>
-            <span class="legend-body">auto-classified by OpenAIRE: research field (e.g. <em>biological sciences</em>) and UN Sustainable Development Goal (e.g. <em>13. Climate action</em>)</span>
-          </div>
-          <div class="legend-item">
-            <span class="legend-h">FAIR-software · fair-software.eu</span>
-            <span class="legend-body">a replication's code scored N/5 on the <b>fair-software.eu</b> recommendations — public repository · open license · in a registry · citable (CITATION.cff/DOI) · quality artefacts — computed live from GitHub + Software Heritage. Hover the score for the breakdown.</span>
-          </div>
-        </div>
-      </details>
-
-      <div class="card">
-        <h2>Top replication targets <span class="pill" id="tcount"></span></h2>
-        <p class="hint">Candidates matching your search, ranked by <b>replicability</b> potential (the REPLIC. score). OPEN = an opportunity; VERIFIED = already done (shown at its rank, not buried). Paged, 10 at a time. See the legend above for the badges.</p>
-        <p id="fieldtools" class="fieldtools"></p>
-        <div id="targets" class="targets"></div>
-        <div id="tpager" class="tpager"></div>
-      </div>
-    </section>
-  </main>
-
-  <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>
-    </div>
-  </footer>
-
-  <script src="app.js"></script>
-</body>
-</html>