From ffa7cf757116d7ad91c7b250d38d31f26c7221e4 Mon Sep 17 00:00:00 2001
From: Filippo Ledda <filippo@metacell.us>
Date: Thu, 30 Jul 2026 19:01:54 +0200
Subject: [PATCH 1/4] (cellcard) handle case for non cellcard tabs starting
 when term is found/not found

---
 docs/cell-card.md                             | 354 ++++++++++++++++++
 nginx/default.conf                            |  33 +-
 src/api/endpoints/apiService.ts               |  38 ++
 .../CellCards/CellCard/CellCardPanel.jsx      |  13 +-
 src/components/CellCards/config/gridConfig.ts |  19 +-
 src/components/SingleTermView/index.jsx       |  45 ++-
 src/hooks/useTermRecordAvailability.js        |  41 ++
 vite.config.js                                |  27 +-
 8 files changed, 547 insertions(+), 23 deletions(-)
 create mode 100644 docs/cell-card.md
 create mode 100644 src/hooks/useTermRecordAvailability.js

diff --git a/docs/cell-card.md b/docs/cell-card.md
new file mode 100644
index 0000000..9f1aad5
--- /dev/null
+++ b/docs/cell-card.md
@@ -0,0 +1,354 @@
+# Cell Card — implementation notes
+
+Orientation for follow-up work on the single-term **Cell Card**: what exists, why it is shaped that
+way, and what is genuinely blocked rather than merely unfinished.
+
+Sources of truth, in precedence order:
+
+1. **Figma** — file `vjQBZc9IbwGcC0VxViBNp0` ("Interlex-UI"), frame **`9239:67503` "CellCard term"**
+   inside section `8988:38896` "Cell card + org". Interaction states are sibling top-level frames:
+   `9272:85572` commenting, `8917:35906` graph expanded, `8875:120714` not logged,
+   `9484:84345` loading, `9484:85847` navigating via the graph.
+2. **Meeting transcripts** — [cellcard-spec/meeting-*.md](../cellcard-spec/).
+3. **The v0.8 functional spec** —
+   [cellcard-spec/functional-spec-stakeholders.md](../cellcard-spec/functional-spec-stakeholders.md).
+   Predates the design reviews and is stale in load-bearing ways; see §5.
+
+---
+
+## 1. What it is and where it lives
+
+A read-only three-column dossier for one neuron cell type, added as the **first and default tab** on
+the term page. Overview remains the details/edit surface — the design review explicitly rejected
+inline editing here, replacing the per-widget pencil with one **Edit** button that sends you to
+Overview.
+
+```
+src/components/CellCards/CellCard/
+├── CellCardPanel.jsx        tab entry point: resolve the term, loading/error/not-a-cell states, scroll container
+├── CellCard.jsx             the three-column layout + which widgets appear
+├── CellCardWidget.jsx       the shared widget shell (title + action icons + body)
+├── PropertyList.jsx         label/value rows (exports PropertyRow too)
+├── TermValueLink.jsx        one ResolvedRef rendered as a link via termLink()
+├── DefinitionBanner.jsx     the auto-generated description
+├── WidgetCommentButton.jsx  per-widget comment popover
+├── RelationshipGraphSvg.jsx dagre layout + hand-drawn SVG
+├── buildRelationGraph.js    cell -> {nodes, edges}
+├── buildRows.js             config rows + cell -> row models
+├── widgetVisibility.js      which widgets have anything to show
+├── useCellTerm.js           the data hook
+├── citationService.js       DOI -> CrossRef
+├── commentService.js        discussion thread access
+├── nervoSensusLink.js       NervoSensus deep-link builder
+└── widgets/                 the nine widgets
+```
+
+Supporting changes outside that directory:
+
+| File | What changed |
+|---|---|
+| `src/parsers/neurdfParser.ts` | `@list` fix, annotation allow-list, `parsePredicateDisplay` (§4) |
+| `src/components/CellCards/model/types.ts` | `CellMapping`, `CellAnnotations`, `ValueCombinator`, Cell Card types |
+| `src/components/CellCards/config/cellCardConfig.ts` | **new** — widget rows, graph predicates, NervoSensus vocabulary |
+| `src/components/CellCards/services/ontologyGridService.ts` | `findCell`, `relatedBySource`, `hierarchyNeighbours`, slug helpers |
+| `src/components/SingleTermView/index.jsx` | Cell Card as tab 0; every hardcoded tab index shifted (§3) |
+| `src/components/CellCards/OntologyGridPage.jsx` | tile click navigates instead of raising a snackbar |
+| `src/theme/index.jsx` | 10 new component overrides + `currentTerm` typography + `MuiButton` `tile` variant |
+| `src/components/common/EmptyState.jsx` | **new** — replaces three inlined copies |
+
+---
+
+## 2. Data flow
+
+**The card never reads the InterLex term API.** Precision cells are `npokb:*` only and that endpoint
+404s on every one of them (§5.1). Everything comes from the neurdf ontology graph.
+
+```
+useCellTerm(termSlug, ontologySlug)
+  └─ loadOntology(slug)                     memoised: graphPromise (fetch) + parsedCache (parse)
+       └─ parseNeurdf(graph, rootClass)     -> { cells, hierarchy, predicateDisplay, meta }
+  └─ findCell(data, termSlug)               "npokb_998" -> "npokb:998"
+```
+
+Both memos are module-level, so arriving from a grid tile costs **no network and no reparse**;
+a cold deep-link pays a ~16MB fetch plus a 39,788-node parse before the first render.
+
+**Context ontology travels as `?ontology=`**, written by the grid tile click. It is *not*
+`DataContext.activeOntology` — that is an edit target shown as a chip in the header. Conflating them
+would read the card's data from the wrong place. Tab navigation preserves the query string; without
+that the param is lost on the first tab switch and the card blanks.
+
+The ontology file itself is fetched at container start, not baked into the image — see
+[scripts/README.md](../scripts/README.md).
+
+---
+
+## 3. Tab wiring
+
+Cell Card is index 0, so **every previously hardcoded index shifted**. `CELL_CARD_TAB` and
+`OVERVIEW_TAB` are named constants in `SingleTermView/index.jsx` for that reason. The five touch
+points, all in that file:
+
+- `tabMapping` / `tabNames` / `tabLabels`
+- the `switch (tabValue)` content dispatch
+- the default-tab redirect
+- `if (tabValue !== OVERVIEW_TAB) return null` — gates the code/data-format toggle. It read `!== 0`,
+  which would silently have followed the Cell Card instead of Overview.
+- `handleChangeTabs`, which must carry `location.search`
+
+**Cell-term detection has to be synchronous**, because it decides the default tab inside the mount
+effect and cannot wait on a 16MB load. Two cheap URL-only signals: the slug is `npokb_*`, or
+`?ontology=` is present. Revisit when Precision cells gain ILX ids — the slug shape stops being a
+reliable signal then and the term's own `@type` should decide.
+
+Verified behaviour:
+
+| URL | Result |
+|---|---|
+| `/precision/npokb_1067` | redirects to `/cell-card`; Overview/Variants/History/Discussions **disabled**, because the record probe (§3.1) 404s |
+| `/base/ilx_0101431/overview` | Cell Card disabled, Overview active, code toggle on Overview |
+| `…/overview?ontology=precision` | Cell Card becomes available |
+
+### 3.1 Which tabs are enabled is a backend question, not a slug shape
+
+The four term tabs read the InterLex term API, which can only serve a cell once curation maps its
+`npokb` id to a record. **`/{group}/uris/{prefix}/{id}` is where the backend answers** —
+`/base/uris/npokb/991` returns *"has not been mapped to an InterLex id"* (404) for all 161 today,
+and the tabs light up on their own, with no front-end change, once it stops doing so.
+
+- `hasInterLexRecord` (`apiService.ts`) probes it, once per group+slug, cached for the session.
+  `redirect: 'manual'`, because a mapped id may answer with a cross-origin redirect to the record
+  and following it would fail the CORS check and read as *unmapped*.
+- It probes the page's group and falls back to `base`, exactly as `getSelectedTermLabel` does.
+- `useTermRecordAvailability` is the one hook both the tab bar and the card's discussion link read,
+  so they cannot drift. It answers **`undefined` while the probe is in flight** — `ilx_*`/`tmp_*`
+  slugs skip it and answer `true` synchronously.
+- Pending counts as *disabled* (what the bar shows today, so no flicker), but the default-tab
+  redirect and the term panels both **wait** for it. Redirecting early would rewrite a deep link to
+  `/overview` with `replace: true`; mounting `OverView` early would fire a request that 404s and
+  raise the shared error dialog over a tab about to be redirected away.
+
+The probe needs its own proxy rule in **both** `vite.config.js` and `nginx/default.conf`: the SPA
+fallback is `try_files $uri /index.html`, so unproxied it would answer 200 + the app shell — read as
+"mapped" for every cell, the exact opposite of the truth. The term-file rule next to it was widened
+from `(ilx|tmp)_` to any `{prefix}_{id}` for the same reason: once mapped, Overview fetches
+`/{group}/npokb_991.jsonld`, and that has to reach the backend too. (`/data/` is `location ^~` and
+carries a `(?!data/)` in the vite key so neither rule can ever swallow the 16MB ontology — a regex
+location outranks a plain prefix one, and today's hyphenated filename is the only thing that would
+otherwise stand between them.)
+
+**Two legs of "works as any other term" are still unverified**, both untestable until an id is
+mapped: whether the backend serves `/{group}/npokb_991.jsonld` at all, and `toILX` in
+`OverView.jsx` — `t.replace(/^ilx_/i, "ILX:")`, a no-op on `npokb_991`, so Overview's own calls
+would go out with a raw npokb slug where every other term sends `ILX:0101431`. Look there first if
+the tabs light up and Overview still comes back empty.
+
+> Dev-only gotcha: a bare `/{group}/ilx_*` URL never reaches the SPA — `vite.config.js` proxies
+> `^/[^/]+/(ilx|tmp)_[^/]+$` straight to the backend. Pre-existing, unrelated to the tab work. Use a
+> URL with a tab segment.
+
+---
+
+## 4. Parser changes, and why they mattered
+
+### 4.1 `@list` values were silently dropped — a real data-loss bug
+
+`resolveValue` handled `{@id}`, `{@value}` and strings but not `{"@list":[…]}`. The union family
+serialises members as a JSON-LD list, and `neurdf.eqv.uo:hasSomaLocatedIn` is the **only**
+soma-location predicate on 61 of the 161 cells. Soma location rendered for 100/161; it now renders
+for **161/161**, in the grid as well as the card.
+
+The `.uo`/`.io` family segment is also preserved as `CellProperty.combinator` (`"or"`/`"and"`).
+Without it, "soma in A **or** B" renders identically to asserting both — a different claim. A plain
+family carries no combinator; merging a union with a plain key clears it, because mixed semantics
+have no single reading.
+
+### 4.2 The annotation allow-list, and why it stays off `properties`
+
+`buildCell` kept only `neurdf.*` + two keys. It now also admits `TEMP:assertedSubClassOf` /
+`TEMP:mapsTo` / `TEMP:subClassOf` (→ `CellTerm.mappings`, with evidence derived from *which*
+relation carried it, since there is no evidence predicate) and the prose/id/link annotations
+(→ `CellTerm.annotations`).
+
+**Annotations must not land on `properties`.** `getFacets` derives the grid's filter sidebar from
+that object, so a note or an id there becomes a junk facet. Verified: toggling "Displayed
+properties" off shows 14 facets and none of them are annotations.
+
+Deep links (`hasSPARCMap`, `hasNervoSensusLink`, `hasSPARCTranscriptomicsLink`) are matched by
+**local name under any prefix** (`LINK_ANNOTATIONS`), because the spec's `ilx:` prefix is not in the
+file's `@context` and the widgets originally looked them up as `properties["ilx:has…"]` — a key the
+parser never writes, so they could not have lit up even with the triple present.
+
+### 4.3 Row labels come from the ontology
+
+70 `ilxtr:*` property nodes carry `ilxtr:displayLabel` and `ilxtr:shortDefinition`, covering **14 of
+the 15** neurdf local names Precision cells use ("Soma location", "Observed in", "Marker genes"…).
+`parsePredicateDisplay` reads them; `gridConfig`'s `PREDICATE_LABELS` / `PREDICATE_TOOLTIPS` are only
+the fallback. Changing a `displayLabel` upstream changes the UI with no front-end edit — which
+settles the spec's own "Proposed Approach for Property Labels" debate.
+
+---
+
+## 5. Where the spec is wrong, and what is blocked
+
+### 5.1 Precision cells have no ILX id
+
+All 161 are `npokb:*`; **0** carry `ilxtr:hasIlxId`. `GET /base/npokb_998.jsonld` → **404**. The 41
+`ilxtr:hasIlxId` triples in the graph map *external* terms (UBERON, NIFSTD) to ILX, not cells.
+
+Consequences: the H1 must come from the graph, not `termData`; Overview/Variants/Version
+history/Discussions render **disabled** for these cells — not because of the slug shape but because
+the backend says the id is unmapped, which is asked once and shared (§3.1); and the grid primes
+`primeTermDataCache` before navigating so the doomed term-API request is skipped entirely.
+
+`isIlxTermSlug` is now only the *synchronous shortcut* inside that rule (an `ilx_*` slug addresses a
+record by construction). Gate anything term-API-backed on `useTermRecordAvailability`, not on the
+slug, or it will stay dark after the mapping lands.
+
+### 5.2 The spec's predicate names do not exist
+
+Phenotypes are `neurdf.{eqv|ent}[.neg|.uo|.io]:*`, not `ilxtr:has*Phenotype`. Every
+`ilxtr:has*Phenotype` in the spec is absent. Read its field tables through that translation.
+
+### 5.3 `ilxtr:localLabel` as H1 is unimplementable
+
+The spec says six times that `ilxtr:localLabel` is the display label and "rdfs:label is never shown".
+**0 of 161** cells have `localLabel` (or `simpleLabel`, `origLabel`, `skos:prefLabel`). The only
+human-readable label is `rdfs:label` — the one the spec forbids. `ilxtr:genLabel` is a
+~300-character machine string. We use `rdfs:label`. **Worth raising with Sue/Tom.**
+
+Related: **0 of 161** cells have any definition, so the Definition banner is assembled from the
+structured properties rather than read from a field.
+
+### 5.4 Blocked on backend / curation
+
+| Item | Blocker (verified: zero occurrences) |
+|---|---|
+| SPARC Maps row | `hasSPARCMap` |
+| Transcriptomic SPARC deep link | `hasSPARCTranscriptomicsLink`. The atlas-pill fallback **is** live (54/161) and is what the design shows. |
+| Laminar shading / spinal-cord schematic | `hasLaminarTermination`. The design's explicit "Context image not available" state is what renders. |
+| `determinedByMethod` method chips | No rdf-star, no `rdf:Statement`. Method exists only as 6 unused `ilxtr:hasConnectionDeterminedBy*` declarations — and when populated it arrives as a *separate predicate*, not a value qualifier, so the design's "chip next to the value" needs rework, not just data. |
+| Definition tooltips (spec §2.4) | **Zero** definitions for UBERON / NCBIGene / CHEBI / NCBITaxon / npokb — labels and `NIFRID:synonym` only. Needs OLS/NCBI at runtime or new triples. |
+| Comment posting | `/{group}/discussions/term/{id}` returns **404 for every id**, including a valid `ilx_*` term. The service is not deployed. The popover posts for real and surfaces the failure rather than faking success. |
+| Gene labels | 74% of NCBIGene nodes have `rdfs:label`; the rest render as the CURIE. |
+
+### 5.5 Superseded by the design
+
+- **Tab set** is Cell Card / Overview / Variants / Version history / Discussions — *not* the spec's
+  General / Referenced By / History / Discussion. No "Referenced By" tab.
+- **No inline Discussion widget** in the centre column. The widget-header icon is a comment bubble
+  opening an anchored popover, with "View all related discussions" → the Discussions tab.
+- **Voting is out of scope**: no vote UI anywhere in the design, no fields on the `Discussion`
+  model, no endpoint. Spec §2.8/§10.6 is stale.
+- **Commenting is not login-gated** (spec §10.6 wins here): anonymous posts as `Anonymous` with a
+  sign-in upgrade link.
+- **No widget header bars, no card borders** — "more minimalistic and clean without the borders".
+  Hence `CellCardWidget` is a `Stack`, *not* a `Card`, despite CLAUDE.md's general preference.
+  Please don't "fix" that.
+
+---
+
+## 6. Decisions worth not re-litigating
+
+**Layout** is measured from Figma `9239:67600`: `424 | 848 | 424` inside 1760px, 32px gutters,
+expressed as `26.5rem minmax(0,1fr) 26.5rem` and stacking below `lg`. Dividers between widgets in
+the left and centre columns, **none** in the right — that asymmetry is in the design.
+
+**The card scrolls internally.** `PageContainer` fixes the page height (`calc(100vh - 7.5rem)`) and
+expects each tab to own its scroll, as `OverView` does. Without the `Scroll` wrapper the card runs
+under the site footer. `Scroll` is declared at module scope on purpose: inside the component body it
+would be a new component *type* every render, remounting the whole card and losing an open popover,
+the hierarchy query and the scroll offset.
+
+**Relationship graph** uses `@dagrejs/dagre` for layout and our own SVG for drawing, so nodes keep
+the designed rounded-rect style. It is a **new component, not** `GraphViewer/Graph.jsx`: that one is
+a `d3.cluster()` dendrogram taking a single predicate group, and it resolves `d3.select("#tooltip")`
+plus a global `d3.selectAll(".node--leaf-g")`, so two instances collide — and this widget needs two
+(inline and in the expanded dialog). Two layout details that are not optional:
+
+- parent edges run `parent → cell` so the parent lands on the rank *above*;
+- dagre fixes the rank but **not the order within it**, so the soma-location and expression
+  satellites are pinned by hand to the left and right of the current node.
+
+Which predicates the graph may draw is `RELATION_PREDICATES` in `cellCardConfig.ts`, per Fahim's
+request — adding a predicate there is the only way to get another edge kind.
+
+**NervoSensus is a tool, not per-cell data**, so the Interactive Cell Grouping widget renders
+unconditionally. Gating it on `hasNervoSensusLink` (zero occurrences) meant it never appeared at
+all. `nervoSensusLink.js` builds the best available link by reading the app's *real* deep-link
+vocabulary — which was checked against the deployed build, byte-identical to the copy vendored in
+`nervosensus/`:
+
+- `?atlasannotation=` opens the exact cell. Its keys are our `ilxtr:atlasAnnotation` values minus the
+  `:U19_*` dataset suffix, which resolves **48 of the 161** cells.
+- otherwise `species` / `location` / `axon` / `gene` map from our prose labels onto its filter slugs.
+- The spec's "group by morphology · electrophysiology · markers" **does not exist** in the app; the
+  real groupings are `view=synthesis&groupBy=axon-species|species-axon|source` and
+  `view=tree&grouping=location`. Worth raising with design.
+- Deliberately no copy of the app's 22 cell keys here: unknown values are ignored by its own
+  `<select>` lookup, so passing them costs nothing while duplicating its vocabulary would rot.
+
+**Publication metadata comes from CrossRef** at render time (`citationService.js`) — DOIs in the
+graph are bare `@id` IRIs with no node. One promise per DOI is cached, since siblings share a
+publication. Failure degrades to the bare DOI link; it never blocks a render.
+
+**Custom looks go in the theme, not `sx`.** The NervoSensus tile is `MuiButton` `variant="tile"`;
+`sx` at call sites is layout only. The tile is a `Button component="a"`, so the whole card is one
+click target with real anchor semantics.
+
+---
+
+## 7. Running and verifying
+
+```
+yarn fetch-data          # local copy of the ontology (~16MB, gitignored)
+yarn dev                 # http://localhost:5173
+yarn check-parser        # 36 assertions over a trimmed fixture — runs in CI
+yarn build-fixture       # regenerate the fixture from a fresh download
+```
+
+Useful cells:
+
+| Cell | Why |
+|---|---|
+| `npokb:1067` | richest (24 predicates) — exercises every populated row |
+| `npokb:934` | soma location **only** via `@list` — the regression guard; must read "dorsal root ganglion **or** trigeminal ganglion" |
+| `npokb:1007` | mappings + atlas annotations + curator note |
+| `npokb:998` | the cell in the Figma design; has a precise NervoSensus deep link |
+
+Route: `/{group}/{npokb_slug}/cell-card?ontology=precision`.
+
+`src/parsers/__fixtures__/` holds a 106-node trim of the real graph plus the assertions. The fixture
+builder **asserts its own coverage** — if `npokb:934` ever gains a plain `hasSomaLocatedIn` it fails
+rather than quietly producing a fixture that no longer isolates the `@list` case. Deep-link
+behaviour uses a synthetic graph in the script, since those predicates have zero occurrences
+upstream and a trim cannot cover them.
+
+There is no unit-test runner in the root project (`test/` is a separate Puppeteer/Jest package).
+`check-parser` runs via `scripts/run-ts.mjs`, which bundles the TypeScript with esbuild (already a
+vite dependency) and runs it on plain Node — no new dependency, and it works on the `node:18-alpine`
+build image. Adding `vite-node` or `tsx` instead **breaks the Docker build**: the maintained versions
+require Node ≥20.
+
+---
+
+## 8. Known gaps — the obvious next tasks
+
+1. **The page header is still the old InterLex one.** The design (`9533:71930`) wants: breadcrumb +
+   **Grid View** / **Community hub** / **Active Ontology** chip; H1 + `Curated` badge; **Edit**
+   button → Overview; a meta row of `npokb ID · ILX · full URI` each with a copy button; then type
+   badges. Only the H1 and breadcrumb are wired. `HEADER_BADGES` / `BADGE_COLOR` already exist in
+   `cellCardConfig.ts` for the badges. Render the ILX row only when an ILX id exists (§5.1).
+2. **Atlas-annotation chips truncate uselessly.** All four read `A-PEP.SCGN/ADRA2C:U...` because the
+   theme caps `MuiChip` labels at `20ch` — and the distinguishing part is the *suffix*
+   (`U19_HMS`, `U19_WASHU`, …). Figma shows them in full, wrapping to two rows. Fix as a themed chip
+   variant, not an `sx` override.
+3. **`proposed` evidence badge has no colour.** The design uses Purple; the palette has no purple, so
+   it falls back to an outlined chip. Add a token or get design to pick an existing one.
+4. **Definition tooltips** (§5.4) — needs an OLS/NCBI resolver or new triples.
+5. **The Discussions tab itself is still mock** (`SingleTermView/Discussion/`) and has a live bug:
+   `const Discussion = (term) => {` takes the whole props object, so `getTermDiscussions` receives
+   `{term: "ilx_…"}`. Worth fixing when the endpoint lands.
+6. **Multi-replica ontology fetch** — each replica downloads its own copy at start, which multiplies
+   load on the endpoint we are protecting. Fine at `replicas: 1`; wants a shared volume or an
+   `initContainer` before scaling out.
diff --git a/nginx/default.conf b/nginx/default.conf
index d0efc9a..ebe7bc3 100644
--- a/nginx/default.conf
+++ b/nginx/default.conf
@@ -10,7 +10,13 @@ server {
     # reasons: it needs real caching, and it must 404 when absent rather than fall through to
     # `try_files $uri /index.html` — the loader treats an HTML body as a failure and falls back to
     # upstream, but only if it actually gets one it can recognise, and a 404 is much clearer.
-    location /data/ {
+    #
+    # `^~`, not a plain prefix: a matching regex location would otherwise win, and the term-file
+    # rule below matches any `/{seg}/{prefix}_{id}.jsonld`. Today's filename has no underscore so
+    # it does not, but the day it gains one the whole ontology would be proxied upstream and 404 —
+    # the Cell Card dark in production, nothing else affected. This is the one route that must
+    # never be proxied, so say so rather than depend on a filename.
+    location ^~ /data/ {
         root /usr/share/nginx/html/;
         try_files $uri =404;
 
@@ -91,7 +97,30 @@ server {
         add_header Access-Control-Expose-Headers X-Redirect-Location always;
     }
 
-    location ~ ^/[^/]+/(tmp|ilx)_.*\.(html|ttl|jsonld|n3|owl|csv)$ {
+    # "Is this external id mapped to an InterLex record?" — /{group}/uris/{prefix}/{id} answers
+    # 404 while unmapped, the record otherwise. It needs its own location because the fallback is
+    # `try_files $uri /index.html`: unproxied, every probe would read 200 + the SPA shell, i.e.
+    # "mapped", and light up term tabs that have nothing behind them.
+    # Cannot shadow ^/[^/]+/ontologies/uris/ below — that one has two segments before `uris`.
+    location ~ ^/[^/]+/uris/.+ {
+        proxy_pass https://uri.olympiangods.org;
+        proxy_set_header Host uri.olympiangods.org;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_set_header Authorization $http_authorization;
+        proxy_set_header Cookie $http_cookie;
+        proxy_ssl_verify off;
+
+        # CORS headers
+        add_header Access-Control-Allow-Origin $http_origin always;
+        add_header Access-Control-Allow-Credentials true always;
+    }
+
+    # Any `{prefix}_{id}` term, not just ilx_/tmp_: once an npokb id is mapped to a record its
+    # tabs light up, and they read this endpoint. The extension allow-list keeps the rule off
+    # asset paths.
+    location ~ ^/[^/]+/[A-Za-z][A-Za-z0-9.-]*_[^/]*\.(html|ttl|jsonld|n3|owl|csv)$ {
         proxy_pass https://uri.olympiangods.org;
         proxy_set_header Host uri.olympiangods.org;
         proxy_set_header X-Real-IP $remote_addr;
diff --git a/src/api/endpoints/apiService.ts b/src/api/endpoints/apiService.ts
index 0ca6985..5a431d2 100644
--- a/src/api/endpoints/apiService.ts
+++ b/src/api/endpoints/apiService.ts
@@ -3,6 +3,7 @@ import { API_CONFIG } from "../../config";
 import termParser from "../../parsers/termParser";
 import { jsonldToTriplesAndEdges, PART_OF_IRI } from '../../parsers/hierarchies-parser'
 import { buildPredicateGroupsForFocus } from "../../parsers/predicateParser";
+import { termUriMappingPath } from "../../components/CellCards/config/gridConfig";
 
 // Error enriched with the queried URL + the backend's message, so the UI can
 // show a meaningful dialog instead of a bare "HTTP 404".
@@ -236,6 +237,43 @@ export const getSelectedTermLabel = async (searchTerm: string, group: string = '
   }
 };
 
+// --- InterLex record mapping --------------------------------------------------------------
+//
+// A Precision cell is addressed by an external id (`npokb_991`), and the term API can only serve
+// it once curation maps that id to an InterLex record. /{group}/uris/{prefix}/{id} is where the
+// backend answers: 404 with "has not been mapped to an InterLex id" until it exists. Everything
+// term-API-backed — Overview, Variants, Version history, Discussions — hangs off that answer, so
+// it is probed once per group+slug and remembered for the session.
+const recordMappingCache = new Map<string, Promise<boolean>>();
+
+const probeUriMapping = async (path: string): Promise<boolean> => {
+  // `redirect: manual` on purpose: a mapped id may answer with a redirect to the record on
+  // another origin, and following it would fail the CORS check and read as "unmapped". A
+  // redirect still says what we need to know — something is behind this id. The browser hands it
+  // back opaque (type "opaqueredirect", status 0); Node reports the 3xx as-is.
+  const response = await fetch(path, { credentials: 'include', redirect: 'manual' });
+  return response.type === 'opaqueredirect' || response.ok
+    || (response.status >= 300 && response.status < 400);
+};
+
+/** Is `slug` mapped to an InterLex record the term API can serve? */
+export const hasInterLexRecord = (slug: string, group: string = 'base'): Promise<boolean> => {
+  const path = termUriMappingPath(group, slug);
+  const basePath = termUriMappingPath('base', slug);
+  if (!path || !basePath) return Promise.resolve(false);
+
+  const key = `${group}:${slug}`;
+  if (!recordMappingCache.has(key)) {
+    // Falls back to `base` exactly as getSelectedTermLabel does: a curated mapping lives there,
+    // so a term viewed under another group is still addressable through it.
+    const probe = probeUriMapping(path)
+      .then(found => (found || group === 'base' ? found : probeUriMapping(basePath)))
+      .catch(() => false);
+    recordMappingCache.set(key, probe);
+  }
+  return recordMappingCache.get(key) as Promise<boolean>;
+};
+
 export const createNewEntity = async ({ group, data }: { group: string; data: any; session?: string }): Promise<{ termId: string | null; raw: string; status: number }> => {
   const endpoint = `/${group}${API_CONFIG.REAL_API.CREATE_NEW_ENTITY}`;
 
diff --git a/src/components/CellCards/CellCard/CellCardPanel.jsx b/src/components/CellCards/CellCard/CellCardPanel.jsx
index b7c886a..f0aeb70 100644
--- a/src/components/CellCards/CellCard/CellCardPanel.jsx
+++ b/src/components/CellCards/CellCard/CellCardPanel.jsx
@@ -9,10 +9,10 @@ import { curieToSlug } from "../services/ontologyGridService";
 import {
   termLink,
   ontologyPath,
-  isIlxTermSlug,
   ONTOLOGY_PARAM,
   ONTOLOGY_CATALOG,
 } from "../config/gridConfig";
+import { useTermRecordAvailability } from "../../../hooks/useTermRecordAvailability";
 
 // A three-column skeleton, so the (unavoidable) whole-ontology load reads as the page arriving
 // rather than as a blank panel. Cold entry pays a ~16MB fetch + a 39,788-node parse before the
@@ -61,6 +61,9 @@ const CellCardPanel = ({ term, group, onTermLabel }) => {
   const location = useLocation();
   const ontologySlug = new URLSearchParams(location.search).get(ONTOLOGY_PARAM) || undefined;
   const { cell, data, loading, error } = useCellTerm(term, ontologySlug);
+  // Same answer the page shell gates the Discussions tab on — one probe, shared through the
+  // module-level cache, so the link and the tab cannot disagree.
+  const termRecordAvailable = useTermRecordAvailability(term, group);
 
   // Navigating between cells keeps the context ontology, so the card the user lands on can still
   // populate its hierarchy and sibling widgets (Sue: "you're staying in that context ontology").
@@ -138,10 +141,10 @@ const CellCardPanel = ({ term, group, onTermLabel }) => {
         data={data}
         group={group}
         termSlug={term}
-        // Only when the Discussions tab can actually serve this term. For an npokb-only cell that
-        // tab is disabled (SingleTermView: no ILX id → no term API), so the link would land on a
-        // tab the bar shows as unselectable, against an endpoint that 404s for every one of them.
-        discussionHref={isIlxTermSlug(term) ? `/${group}/${term}/discussions${search}` : undefined}
+        // Only when the Discussions tab can actually serve this term. While the cell's id is not
+        // mapped to an InterLex record that tab is disabled (SingleTermView gates it on the same
+        // probe), so the link would land on a tab the bar shows as unselectable.
+        discussionHref={termRecordAvailable ? `/${group}/${term}/discussions${search}` : undefined}
         onNavigateToCell={goToCell}
         onNavigateToRef={goToRef}
       />
diff --git a/src/components/CellCards/config/gridConfig.ts b/src/components/CellCards/config/gridConfig.ts
index dcdc831..e5c35c5 100644
--- a/src/components/CellCards/config/gridConfig.ts
+++ b/src/components/CellCards/config/gridConfig.ts
@@ -48,13 +48,22 @@ export const DEFAULT_ONTOLOGY_SLUG = "precision";
 // DataContext.activeOntology, which is the *edit* target shown as a chip in the header.
 export const ONTOLOGY_PARAM = "ontology";
 
-// Does this term slug address an InterLex record (`ilx_0101431`, `tmp_0381624`)? Precision cells
-// are npokb-only today, so it is false for them — and every feature backed by the InterLex term
-// API (Overview, Variants, Version history, Discussions) then has nothing to serve. One home for
-// the rule so the tabs SingleTermView disables and the links the Cell Card suppresses cannot
-// drift apart; it goes away once these cells are ingested with ILX ids.
+// Does this term slug address an InterLex record *by construction* (`ilx_0101431`,
+// `tmp_0381624`)? Anything else — a Precision cell's `npokb_991` — may still be addressable, but
+// only once curation maps it, which is a backend question: see `termUriMappingPath` and
+// `hasInterLexRecord`. Callers that gate term-API features (Overview, Variants, Version history,
+// Discussions) want the latter; this is only its synchronous shortcut.
 export const isIlxTermSlug = (slug?: string): boolean => /^(ilx|tmp)[_:]/i.test(slug || "");
 
+// Backend route answering "is this external id mapped to an InterLex record?":
+// `npokb_991` under `base` -> /base/uris/npokb/991, which 404s while unmapped. Split on the first
+// separator so a compound id (`obo_UBERON_0000955`) keeps its own underscores. Returns undefined
+// for a slug carrying no prefix, which the endpoint cannot address at all.
+export const termUriMappingPath = (group: string, slug?: string): string | undefined => {
+  const match = String(slug || "").match(/^([A-Za-z][A-Za-z0-9.-]*)[_:](.+)$/);
+  return match ? `/${group}/uris/${match[1]}/${match[2]}` : undefined;
+};
+
 // --- ontology tabs ----------------------------------------------------------
 
 export interface OntologyTab {
diff --git a/src/components/SingleTermView/index.jsx b/src/components/SingleTermView/index.jsx
index 1a2ed83..06bd15a 100644
--- a/src/components/SingleTermView/index.jsx
+++ b/src/components/SingleTermView/index.jsx
@@ -41,7 +41,7 @@ import DeleteOutlineOutlinedIcon from '@mui/icons-material/DeleteOutlineOutlined
 import CreateNewFolderOutlinedIcon from '@mui/icons-material/CreateNewFolderOutlined';
 import Discussion from "./Discussion";
 import CellCardPanel from "../CellCards/CellCard/CellCardPanel";
-import { ONTOLOGY_PARAM, isIlxTermSlug } from "../CellCards/config/gridConfig";
+import { ONTOLOGY_PARAM } from "../CellCards/config/gridConfig";
 import { CodeIcon } from "../../Icons";
 import CustomSingleSelect from "../common/CustomSingleSelect";
 import CustomButtonGroup from "../common/CustomButtonGroup";
@@ -55,6 +55,7 @@ import { getVersions, addEntityToOntology, getOntologyTerms } from "../../api/en
 import { reportApiError } from "../../api/apiErrorBus";
 import ApiErrorDialog from "../common/ApiErrorDialog";
 import { useTermData } from "../../hooks/useTermData";
+import { useTermRecordAvailability } from "../../hooks/useTermRecordAvailability";
 
 const { gray200, gray500, gray600, error700 } = vars;
 
@@ -164,8 +165,13 @@ const SingleTermView = () => {
     () => /^npokb[_:]/i.test(term || "") || Boolean(contextOntology),
     [term, contextOntology]
   );
-  // Whether the InterLex term API can address this term at all.
-  const hasIlxId = useMemo(() => isIlxTermSlug(term), [term]);
+  // Whether the InterLex term API can address this term at all. For a cell arriving as an
+  // external id (`npokb_991`) that is not a property of the slug but of the data: the id is
+  // addressable once curation maps it to a record, and the backend is the only one who knows.
+  // `undefined` until it answers — see useTermRecordAvailability. Only cell terms are asked;
+  // every other term keeps the tabs it has today, probe or no probe.
+  const termRecordAvailable = useTermRecordAvailability(term, group, isCellTerm);
+  const isTermRecordPending = isCellTerm && termRecordAvailable === undefined;
   const DEFAULT_TAB_INDEX = isCellTerm ? CELL_CARD_TAB : OVERVIEW_TAB;
 
   // Cell Card is the first tab, per the design, so `overview` is index 1 and every
@@ -181,10 +187,11 @@ const SingleTermView = () => {
 
   const tabNames = useMemo(() => ['cell-card', 'overview', 'variants', 'history', 'discussions'], []);
   const tabLabels = useMemo(() => {
-    // A precision cell has no ILX id, so the term API — and therefore every tab that reads it
-    // — has nothing to serve for it. Disable those rather than offer dead tabs; they light up
-    // once these cells are ingested with ILX ids.
-    const termTabsDisabled = isCellTerm && !hasIlxId;
+    // A precision cell's id is not mapped to an InterLex record yet, so the term API — and
+    // therefore every tab that reads it — has nothing to serve for it. Disable those rather than
+    // offer dead tabs; they light up on their own once the mapping exists. Pending counts as
+    // disabled, which is what the bar already shows, so the common case never flickers.
+    const termTabsDisabled = isCellTerm && termRecordAvailable !== true;
     return [
       { label: "Cell Card", disabled: !isCellTerm },
       { label: "Overview", disabled: termTabsDisabled },
@@ -192,7 +199,7 @@ const SingleTermView = () => {
       { label: "Version history", disabled: termTabsDisabled },
       { label: "Discussions", disabled: termTabsDisabled },
     ];
-  }, [isCellTerm, hasIlxId]);
+  }, [isCellTerm, termRecordAvailable]);
 
   // Set initial tab value based on URL
   const [tabValue, setTabValue] = useState(() => {
@@ -334,6 +341,12 @@ const SingleTermView = () => {
     // the URL would mount a panel that can only render an empty state (and, for the Cell Card,
     // pay a ~16MB fetch to find that out) while the Tabs bar shows nothing selected. Fall back to
     // the default tab, which is always enabled: Cell Card for a cell type, Overview otherwise.
+    //
+    // Not while the record probe is in flight, though: the disabled set is not known yet, and the
+    // fallback rewrites the URL with `replace: true`. Judging /overview now would send a deep
+    // link to a mapped cell back to /cell-card with no way back.
+    if (isTermRecordPending) return;
+
     const requested = tabMapping[tab];
     const newTabValue =
       requested !== undefined && !tabLabels[requested]?.disabled ? requested : DEFAULT_TAB_INDEX;
@@ -348,12 +361,24 @@ const SingleTermView = () => {
     if (!versionHash && group && term && tab !== tabNames[newTabValue]) {
       navigate(`/${group}/${term}/${tabNames[newTabValue]}${location.search}`, { replace: true });
     }
-  }, [tab, tabMapping, tabLabels, navigate, group, term, tabValue, versionHash, tabNames, DEFAULT_TAB_INDEX, location.search]);
+  }, [tab, tabMapping, tabLabels, navigate, group, term, tabValue, versionHash, tabNames, DEFAULT_TAB_INDEX, location.search, isTermRecordPending]);
 
   const isItFork = actualGroup === 'base' ? false : true; // Use actualGroup instead of group
 
   // Memoize tab content to prevent unnecessary re-renders
   const tabContent = useMemo(() => {
+    // Every tab but the Cell Card reads the InterLex term API, and whether it can answer for this
+    // cell is still being probed. Mounting one now would fire a request that 404s — raising the
+    // shared error dialog over a tab we are a moment away from redirecting off. The Cell Card
+    // reads the ontology graph instead, so it starts its (much heavier) load straight away.
+    if (isTermRecordPending && tabValue !== CELL_CARD_TAB) {
+      return (
+        <Box display="flex" justifyContent="center" p="3rem">
+          <CircularProgress size={24} />
+        </Box>
+      );
+    }
+
     switch (tabValue) {
       case CELL_CARD_TAB:
         return <CellCardPanel term={searchTerm} group={group} onTermLabel={handleCellLabel} />;
@@ -368,7 +393,7 @@ const SingleTermView = () => {
       default:
         return <OverView searchTerm={searchTerm} isCodeViewVisible={isCodeViewVisible} selectedDataFormat={selectedDataFormat} group={actualGroup} versionHash={versionHash} />;
     }
-  }, [tabValue, searchTerm, group, handleCellLabel, isCodeViewVisible, selectedDataFormat, actualGroup, versionHash, versionsData, versionsLoading, versionsError, clearVersionsError]);
+  }, [tabValue, searchTerm, group, handleCellLabel, isCodeViewVisible, selectedDataFormat, actualGroup, versionHash, versionsData, versionsLoading, versionsError, clearVersionsError, isTermRecordPending]);
 
   // Memoize the toggle button group for overview tab
   const toggleButtonGroup = useMemo(() => {
diff --git a/src/hooks/useTermRecordAvailability.js b/src/hooks/useTermRecordAvailability.js
new file mode 100644
index 0000000..27d51ab
--- /dev/null
+++ b/src/hooks/useTermRecordAvailability.js
@@ -0,0 +1,41 @@
+import { useState, useEffect } from 'react';
+import { isIlxTermSlug } from '../components/CellCards/config/gridConfig';
+import { hasInterLexRecord } from '../api/endpoints/apiService';
+
+/**
+ * Can the InterLex term API serve this term — i.e. are the tabs backed by it (Overview, Variants,
+ * Version history, Discussions) worth offering?
+ *
+ * An `ilx_*` / `tmp_*` slug addresses a record by construction and answers synchronously. A
+ * Precision cell arrives as an external id (`npokb_991`) instead, and is only addressable once
+ * curation maps it — a question only the backend can answer, at /{group}/uris/{prefix}/{id}.
+ *
+ * Returns `true`, `false`, or **`undefined` while the probe is in flight**. Callers must not read
+ * pending as "no": the term page redirects away from a disabled tab with `replace: true`, so
+ * acting on `undefined` would discard a deep link to /overview before the answer lands.
+ *
+ * @param {string} term   term slug from the URL
+ * @param {string} group  group the page is viewed under; falls back to `base`, as term data does
+ * @param {boolean} enabled  pass false to skip the probe entirely (returns `undefined`) — for
+ *   terms whose tabs are not gated on this, so an unrelated term never pays a request.
+ */
+export const useTermRecordAvailability = (term, group, enabled = true) => {
+  const addressesRecord = isIlxTermSlug(term);
+  const [probed, setProbed] = useState(undefined);
+
+  useEffect(() => {
+    if (!enabled || addressesRecord) return undefined;
+    let active = true;
+    // Drop the previous term's answer: leaving it up would gate the new term on the old one.
+    setProbed(undefined);
+    hasInterLexRecord(term, group).then((found) => {
+      if (active) setProbed(found);
+    });
+    return () => { active = false; };
+  }, [term, group, enabled, addressesRecord]);
+
+  if (!enabled) return undefined;
+  return addressesRecord ? true : probed;
+};
+
+export default useTermRecordAvailability;
diff --git a/vite.config.js b/vite.config.js
index 5a52a03..e0b7f9b 100644
--- a/vite.config.js
+++ b/vite.config.js
@@ -160,7 +160,32 @@ export default defineConfig({
           });
         },
       },
-      '^/[^/]+/(tmp|ilx)_.*\\.(html|ttl|jsonld|n3|owl|csv)$': {
+      // "Is this external id mapped to an InterLex record?" — 404 while unmapped, the record
+      // otherwise. Without this rule the request falls through to the SPA and every probe reads
+      // 200 + index.html, i.e. "mapped", which is exactly backwards.
+      '^/[^/]+/uris/.+': {
+        target: 'https://uri.olympiangods.org',
+        changeOrigin: true,
+        secure: false,
+        rewrite: (path) => path, // keep full path
+        configure: (proxy) => {
+          proxy.on('proxyReq', (proxyReq, req) => {
+            // pass through auth/cookies so mappings in a non-base group resolve
+            if (req.headers.authorization) proxyReq.setHeader('Authorization', req.headers.authorization);
+            if (req.headers.cookie) proxyReq.setHeader('Cookie', req.headers.cookie);
+          });
+          proxy.on('proxyRes', (proxyRes, req, res) => {
+            const origin = req.headers.origin;
+            if (origin) res.setHeader('Access-Control-Allow-Origin', origin);
+            res.setHeader('Access-Control-Allow-Credentials', 'true');
+          });
+        },
+      },
+      // Any `{prefix}_{id}` term, not just ilx_/tmp_: once an npokb id is mapped to a record its
+      // tabs light up, and they read this endpoint. The extension allow-list keeps the rule off
+      // asset paths, and `(?!data/)` off the local ontology copy — proxying that would send the
+      // Cell Card's ~16MB source upstream, where it 404s (nginx guards it with `location ^~`).
+      '^/(?!data/)[^/]+/[A-Za-z][A-Za-z0-9.-]*_[^/]*\\.(html|ttl|jsonld|n3|owl|csv)$': {
         target: 'https://uri.olympiangods.org',
         changeOrigin: true,
         secure: false,

From d67137d723cdddc67a7458d4bdb1f7cf6d03fc04 Mon Sep 17 00:00:00 2001
From: Filippo Ledda <filippo@metacell.us>
Date: Thu, 6 Aug 2026 18:17:44 +0200
Subject: [PATCH 2/4] Introduce concept context ontology usage

- use jotai to store the context ontology
- use context ontology info to build paths
---
 CLAUDE.md                                     |   3 +
 docs/cell-card.md                             |  12 +-
 package.json                                  |   1 +
 .../CellCards/CellCard/CellCardPanel.jsx      |  20 +-
 .../CellCards/CellCard/useCellTerm.js         |  20 +-
 src/components/CellCards/OntologyPage.jsx     |   3 +
 src/components/CellCards/config/gridConfig.ts |  22 ++
 .../SingleTermView/OverView/Details.jsx       |   5 +-
 .../SingleTermView/OverView/OverView.jsx      |  67 ++++-
 src/components/SingleTermView/index.jsx       | 127 ++++++---
 src/components/common/CustomTabs.jsx          |  24 +-
 src/hooks/useContextOntology.js               |  61 +++++
 src/parsers/neurdfParser.ts                   | 139 ++++++----
 src/parsers/ontologyTermAdapter.ts            | 244 ++++++++++++++++++
 yarn.lock                                     |   5 +
 15 files changed, 628 insertions(+), 125 deletions(-)
 create mode 100644 src/hooks/useContextOntology.js
 create mode 100644 src/parsers/ontologyTermAdapter.ts

diff --git a/CLAUDE.md b/CLAUDE.md
index f460e44..4748832 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -21,3 +21,6 @@ shadows.
 The `material-ui` skill covers how this project's theme is put together and which MUI defaults it
 does *not* define (the ones that bite when you introduce a new component). The
 `check-figma-design` skill covers working from the Figma file.
+
+## Coding best practices
+- Avoid redundant comments: make the code the source of truth with proper naming and functions refactorings. Only use comments to explain obscure cross-component patch code
\ No newline at end of file
diff --git a/docs/cell-card.md b/docs/cell-card.md
index 9f1aad5..9f0092c 100644
--- a/docs/cell-card.md
+++ b/docs/cell-card.md
@@ -96,6 +96,16 @@ points, all in that file:
   which would silently have followed the Cell Card instead of Overview.
 - `handleChangeTabs`, which must carry `location.search`
 
+**`hidden` and `disabled` are different states**, and `CustomTabs` takes both. A term that is not a
+cell type has no Cell Card and never will, so that tab is **hidden** — the bar reads as a plain term
+page instead of advertising a dead tab. A precision cell's term tabs *do* apply and are merely
+unserved for now, so they stay **disabled** and visible. Hiding must not renumber anything: each
+`Tab` carries its index as an explicit `value`, so `tabValue` keeps meaning "position in
+`tabLabels`" whatever is hidden, and `isTabSelectable` treats both states as unreachable from the
+URL. `SingleTermView`'s *initial* `tabValue` also refuses `CELL_CARD_TAB` when it is hidden: a value
+with no Tab behind it leaves the bar with nothing selected — and MUI logging "the `value` provided
+to the Tabs component is invalid" from its indicator effect — until the URL is rewritten.
+
 **Cell-term detection has to be synchronous**, because it decides the default tab inside the mount
 effect and cannot wait on a 16MB load. Two cheap URL-only signals: the slug is `npokb_*`, or
 `?ontology=` is present. Revisit when Precision cells gain ILX ids — the slug shape stops being a
@@ -106,7 +116,7 @@ Verified behaviour:
 | URL | Result |
 |---|---|
 | `/precision/npokb_1067` | redirects to `/cell-card`; Overview/Variants/History/Discussions **disabled**, because the record probe (§3.1) 404s |
-| `/base/ilx_0101431/overview` | Cell Card disabled, Overview active, code toggle on Overview |
+| `/base/ilx_0101431/overview` | Cell Card **not rendered**, Overview active, code toggle on Overview |
 | `…/overview?ontology=precision` | Cell Card becomes available |
 
 ### 3.1 Which tabs are enabled is a backend question, not a slug shape
diff --git a/package.json b/package.json
index aecca88..34ca05f 100644
--- a/package.json
+++ b/package.json
@@ -28,6 +28,7 @@
     "date-fns": "^3.6.0",
     "dotenv": "16.4.7",
     "express": "^4.21.2",
+    "jotai": "^2.20.2",
     "react": "^18.3.1",
     "react-cookie": "^8.0.1",
     "react-dom": "^18.3.1",
diff --git a/src/components/CellCards/CellCard/CellCardPanel.jsx b/src/components/CellCards/CellCard/CellCardPanel.jsx
index f0aeb70..9f4f35c 100644
--- a/src/components/CellCards/CellCard/CellCardPanel.jsx
+++ b/src/components/CellCards/CellCard/CellCardPanel.jsx
@@ -1,15 +1,14 @@
-import { useCallback, useEffect } from "react";
+import { useCallback } from "react";
 import PropTypes from "prop-types";
 import { useNavigate, useLocation } from "react-router-dom";
 import { Box, Container, Stack, Skeleton, Alert, AlertTitle, Button, Typography } from "@mui/material";
 import CellCard from "./CellCard";
 import EmptyState from "../../common/EmptyState";
-import useCellTerm from "./useCellTerm";
+import { useContextTerm } from "../../../hooks/useContextOntology";
 import { curieToSlug } from "../services/ontologyGridService";
 import {
   termLink,
   ontologyPath,
-  ONTOLOGY_PARAM,
   ONTOLOGY_CATALOG,
 } from "../config/gridConfig";
 import { useTermRecordAvailability } from "../../../hooks/useTermRecordAvailability";
@@ -56,11 +55,12 @@ const LoadingSkeleton = () => (
  * that endpoint 404s on every one of them. The context ontology arrives as `?ontology=`, written
  * by the grid tile click; it is *not* `DataContext.activeOntology`, which is an edit target.
  */
-const CellCardPanel = ({ term, group, onTermLabel }) => {
+const CellCardPanel = ({ term, group }) => {
   const navigate = useNavigate();
   const location = useLocation();
-  const ontologySlug = new URLSearchParams(location.search).get(ONTOLOGY_PARAM) || undefined;
-  const { cell, data, loading, error } = useCellTerm(term, ontologySlug);
+  // Same hook the page shell and the Overview read, so the card cannot end up on a different
+  // ontology than the tab bar thinks it is.
+  const { ontologySlug, cell, ontology: data, loading, error } = useContextTerm(term);
   // Same answer the page shell gates the Discussions tab on — one probe, shared through the
   // module-level cache, so the link and the tab cannot disagree.
   const termRecordAvailable = useTermRecordAvailability(term, group);
@@ -69,12 +69,6 @@ const CellCardPanel = ({ term, group, onTermLabel }) => {
   // populate its hierarchy and sibling widgets (Sue: "you're staying in that context ontology").
   const search = location.search;
 
-  // The page title cannot come from the term API for these cells — it 404s on an npokb id — so
-  // the card hands the label it resolved from the graph back to the page shell.
-  useEffect(() => {
-    if (cell?.label) onTermLabel?.(cell.label);
-  }, [cell, onTermLabel]);
-
   const goToCell = useCallback(
     (target) => navigate(`/${group}/${curieToSlug(target.curie)}/cell-card${search}`),
     [navigate, group, search]
@@ -155,8 +149,6 @@ const CellCardPanel = ({ term, group, onTermLabel }) => {
 CellCardPanel.propTypes = {
   term: PropTypes.string.isRequired,
   group: PropTypes.string.isRequired,
-  // Reports the label resolved from the ontology graph, for the page's H1 and breadcrumb.
-  onTermLabel: PropTypes.func,
 };
 
 export default CellCardPanel;
diff --git a/src/components/CellCards/CellCard/useCellTerm.js b/src/components/CellCards/CellCard/useCellTerm.js
index fa0e049..a4c63f0 100644
--- a/src/components/CellCards/CellCard/useCellTerm.js
+++ b/src/components/CellCards/CellCard/useCellTerm.js
@@ -1,6 +1,6 @@
 import { useEffect, useMemo, useState } from "react";
 import { loadOntology, peekOntology, findCell } from "../services/ontologyGridService";
-import { ONTOLOGY_CATALOG, DEFAULT_ONTOLOGY_SLUG } from "../config/gridConfig";
+import { ONTOLOGY_CATALOG } from "../config/gridConfig";
 
 /**
  * Resolve one cell from a context ontology.
@@ -18,19 +18,19 @@ import { ONTOLOGY_CATALOG, DEFAULT_ONTOLOGY_SLUG } from "../config/gridConfig";
  * around it (spec §3.2), which it cannot do if it is remounted on the way.
  *
  * The card's data never comes from the InterLex term API — Precision cells are npokb-only and
- * that endpoint 404s on them. `ontologySlug` is the *context* ontology (the `?ontology=` param
- * written by the grid), which is a different thing from `DataContext.activeOntology`: the
- * latter is an edit target, not a data source.
+ * that endpoint 404s on them. `ontologySlug` is the context ontology, resolved by
+ * `useContextOntologySlug`; null means there is none and nothing loads, so an ordinary InterLex
+ * term never pays a ~16MB fetch to be told it is not a cell.
  */
-const useCellTerm = (termSlug, ontologySlug = DEFAULT_ONTOLOGY_SLUG) => {
-  const slug = ontologySlug && ONTOLOGY_CATALOG[ontologySlug] ? ontologySlug : DEFAULT_ONTOLOGY_SLUG;
+const useCellTerm = (termSlug, ontologySlug) => {
+  const slug = ontologySlug && ONTOLOGY_CATALOG[ontologySlug] ? ontologySlug : null;
   // Carries the slug it was resolved against, so a switch of context ontology cannot be served
   // the previous ontology's cell for the render before the effect runs.
-  const [state, setState] = useState({ slug, cell: null, data: null, loading: true, error: null });
-  const cached = peekOntology(slug);
+  const [state, setState] = useState({ slug, cell: null, data: null, loading: Boolean(slug), error: null });
+  const cached = slug ? peekOntology(slug) : undefined;
 
   useEffect(() => {
-    if (!termSlug) {
+    if (!termSlug || !slug) {
       setState({ slug, cell: null, data: null, loading: false, error: null });
       return undefined;
     }
@@ -57,6 +57,8 @@ const useCellTerm = (termSlug, ontologySlug = DEFAULT_ONTOLOGY_SLUG) => {
   }, [termSlug, slug]);
 
   return useMemo(() => {
+    // No context ontology: there is nothing to resolve against and nothing in flight.
+    if (!slug) return { cell: null, data: null, loading: false, error: null };
     if (cached) {
       return {
         cell: termSlug ? findCell(cached, termSlug) || null : null,
diff --git a/src/components/CellCards/OntologyPage.jsx b/src/components/CellCards/OntologyPage.jsx
index f282d8b..8eea910 100644
--- a/src/components/CellCards/OntologyPage.jsx
+++ b/src/components/CellCards/OntologyPage.jsx
@@ -4,6 +4,7 @@ import { Box, Typography, CircularProgress, Button } from "@mui/material";
 import OntologyHeader from "./OntologyHeader";
 import { ONTOLOGY_TABS } from "./config/gridConfig";
 import { loadOntology } from "./services/ontologyGridService";
+import { usePublishContextOntology } from "../../hooks/useContextOntology";
 import { vars } from "../../theme/variables";
 
 const { gray500, gray600 } = vars;
@@ -14,6 +15,8 @@ const { gray500, gray600 } = vars;
 const OntologyPage = () => {
   const { slug } = useParams();
   const { pathname } = useLocation();
+  // Reading this ontology *is* the context, for terms later opened without `?ontology=`.
+  usePublishContextOntology(slug);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState(null);
   const [data, setData] = useState(null);
diff --git a/src/components/CellCards/config/gridConfig.ts b/src/components/CellCards/config/gridConfig.ts
index e5c35c5..91b70b0 100644
--- a/src/components/CellCards/config/gridConfig.ts
+++ b/src/components/CellCards/config/gridConfig.ts
@@ -15,6 +15,11 @@ export interface OntologyEntry {
   description?: string;
   // neurdf root: cells are (transitively) subClassOf this; also shown as the header's curie tag.
   rootClass: string;
+  // CURIE prefixes this ontology names its own terms with. Part of its identity, so it belongs
+  // here rather than as a regex at a call site: it is what lets a term page recognise, from the
+  // slug alone and before anything is loaded, that this ontology is the only place the term can
+  // come from (`npokb_997` -> precision). See `ontologyForTermSlug`.
+  termPrefixes?: string[];
 }
 
 export const ONTOLOGY_CATALOG: Record<string, OntologyEntry> = {
@@ -28,6 +33,9 @@ export const ONTOLOGY_CATALOG: Record<string, OntologyEntry> = {
     curationStatus: "Curated",
     description: "HEAL-PRECISION neuron cell types (NPO).",
     rootClass: "ilxtr:NeuronPrecision",
+    // All 161 Precision cells are npokb-only today. Drop this once they are ingested with ILX ids:
+    // by then InterLex addresses them and the ontology stops being their only source.
+    termPrefixes: ["npokb"],
   },
 };
 
@@ -48,6 +56,20 @@ export const DEFAULT_ONTOLOGY_SLUG = "precision";
 // DataContext.activeOntology, which is the *edit* target shown as a chip in the header.
 export const ONTOLOGY_PARAM = "ontology";
 
+// Which catalogued ontology declares the prefix this term slug carries — i.e. the ontology a term
+// page can fall back to when nothing else names a context (a shared link, a search hit). Undefined
+// for a slug no ontology claims, which is the signal not to load one at all: the ~16MB file must
+// never be fetched on an ordinary InterLex term page.
+export const ontologyForTermSlug = (slug?: string): string | undefined => {
+  const prefix = String(slug || "")
+    .match(/^([A-Za-z][A-Za-z0-9.-]*)[_:]/)?.[1]
+    ?.toLowerCase();
+  if (!prefix) return undefined;
+  return Object.values(ONTOLOGY_CATALOG).find((entry) =>
+    entry.termPrefixes?.some((p) => p.toLowerCase() === prefix)
+  )?.slug;
+};
+
 // Does this term slug address an InterLex record *by construction* (`ilx_0101431`,
 // `tmp_0381624`)? Anything else — a Precision cell's `npokb_991` — may still be addressable, but
 // only once curation maps it, which is a backend question: see `termUriMappingPath` and
diff --git a/src/components/SingleTermView/OverView/Details.jsx b/src/components/SingleTermView/OverView/Details.jsx
index beabd92..9cd8149 100644
--- a/src/components/SingleTermView/OverView/Details.jsx
+++ b/src/components/SingleTermView/OverView/Details.jsx
@@ -61,7 +61,10 @@ const Details = ({ loading, data, jsonData }) => {
   const versionDisplay = versionIRI?.includes('/version/')
     ? versionIRI.split('/version/')[1]?.split('/')[0]
     : versionIRI;
-  const versionInfo = formatTimestamp(lastGraphItem?.["owl:versionInfo"]);
+  // Blank, not "Invalid date", when the document carries no owl:versionInfo — as an ontology-backed
+  // term never does.
+  const versionInfoRaw = lastGraphItem?.["owl:versionInfo"];
+  const versionInfo = versionInfoRaw ? formatTimestamp(versionInfoRaw) : "";
 
   return (
     <>
diff --git a/src/components/SingleTermView/OverView/OverView.jsx b/src/components/SingleTermView/OverView/OverView.jsx
index 61997a1..e36f9da 100644
--- a/src/components/SingleTermView/OverView/OverView.jsx
+++ b/src/components/SingleTermView/OverView/OverView.jsx
@@ -27,6 +27,15 @@ import {
   dedupePredicateGroups,
 } from "../../../parsers/hierarchies-parser";
 import { createOverviewStore } from "./overviewStore";
+import {
+  ontologyDetails,
+  ontologyFocus,
+  ontologyHierarchy,
+  ontologyPredicateGroups,
+} from "../../../parsers/ontologyTermAdapter";
+import { findCell } from "../../CellCards/services/ontologyGridService";
+import { useContextTerm } from "../../../hooks/useContextOntology";
+import { useTermRecordAvailability } from "../../../hooks/useTermRecordAvailability";
 import { DetailsSection, HierarchySection, PredicatesSection } from "./OverviewSections";
 import OverviewSideNav from "./OverviewSideNav";
 import { emitPredicateRowUpdate, makeRowKey } from "./predicateMutationBus";
@@ -157,6 +166,20 @@ const OverView = ({ searchTerm, isCodeViewVisible = false, selectedDataFormat, g
   if (!storeRef.current) storeRef.current = createOverviewStore();
   const store = storeRef.current;
 
+  // The Overview's second source, for a term InterLex has no record of: the context ontology's own
+  // record, rendered through `ontologyTermAdapter` instead of the term API.
+  const {
+    cell: ontologyCell,
+    ontology,
+    loading: ontologyLoading,
+  } = useContextTerm(searchTerm);
+  // Only asked once the ontology has an answer, so an ordinary term page adds no probe of its own;
+  // the result is shared through the hook's module cache with the page shell's copy.
+  const termRecordAvailable = useTermRecordAvailability(searchTerm, group, Boolean(ontologyCell));
+  // The ontology is the *fallback*. An InterLex record, once curation creates one, is the term's
+  // real home and the only editable one, so it takes the tab back.
+  const fromOntology = Boolean(ontologyCell) && !versionHash && termRecordAvailable !== true;
+
   // Guards against stale async writes after the term/group changed.
   const loadTokenRef = useRef(0);
   // Latest raw inputs to the predicate merge (arrive independently).
@@ -192,9 +215,11 @@ const OverView = ({ searchTerm, isCodeViewVisible = false, selectedDataFormat, g
     [store, searchTerm, curies]
   );
 
-  // Live (head) load. Each fetch resolves and writes its own stream.
+  // Live (head) load. Each fetch resolves and writes its own stream. Skipped once the ontology is
+  // serving the term, and while that lookup is open: these requests 404 for such a term, and their
+  // failures would raise the shared error dialog over a page that renders fine without them.
   useEffect(() => {
-    if (versionHash) return undefined;
+    if (versionHash || fromOntology || ontologyLoading) return undefined;
     const token = ++loadTokenRef.current;
     const isStale = () => token !== loadTokenRef.current;
 
@@ -314,7 +339,39 @@ const OverView = ({ searchTerm, isCodeViewVisible = false, selectedDataFormat, g
       // eslint-disable-next-line react-hooks/exhaustive-deps
       loadTokenRef.current++;
     };
-  }, [group, searchTerm, versionHash, store, maybePushPredicates]);
+  }, [group, searchTerm, versionHash, store, maybePushPredicates, fromOntology, ontologyLoading]);
+
+  // Ontology load: the same three streams, filled from the parse. Synchronous throughout, so moving
+  // the hierarchy focus re-derives rather than fetching, and a focus the ontology has no record for
+  // (the root the cells hang from) still gets its hierarchy, just no predicates.
+  useEffect(() => {
+    if (!fromOntology) return undefined;
+    const token = ++loadTokenRef.current;
+    const isStale = () => token !== loadTokenRef.current;
+
+    const focus = ontologyFocus(ontologyCell);
+    store.details$.next({ loading: false, data: ontologyDetails(ontologyCell), jsonData: null });
+    // Before subscribing: selectedValue$ replays, so the subscription fills the other two streams.
+    store.selectedValue$.next(focus);
+
+    const sub = store.selectedValue$.subscribe((sv) => {
+      if (isStale()) return;
+      const focusId = sv?.id || focus.id;
+      const focusCell = ontology ? findCell(ontology, focusId) : null;
+      store.hierarchy$.next({ loading: false, ...ontologyHierarchy(ontology, focusId) });
+      store.predicates$.next({
+        loading: false,
+        data: focusCell ? ontologyPredicateGroups(focusCell, ontology?.predicateDisplay) : [],
+        focusId,
+      });
+    });
+
+    return () => {
+      sub.unsubscribe();
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      loadTokenRef.current++;
+    };
+  }, [fromOntology, ontologyCell, ontology, store]);
 
   // Version mode: load a single term-version snapshot through the same pipeline.
   useEffect(() => {
@@ -487,7 +544,9 @@ const OverView = ({ searchTerm, isCodeViewVisible = false, selectedDataFormat, g
     [store, group, searchTerm, reloadAfterMutation, curies]
   );
 
-  const onMutate = versionHash ? undefined : handlePredicateMutation;
+  // No `onMutate` -> Predicates renders read-only, as in version mode: neither has an InterLex
+  // record behind it to PATCH.
+  const onMutate = versionHash || fromOntology ? undefined : handlePredicateMutation;
 
   return (
     <Box p="2.5rem 5rem" sx={{ overflow: "auto" }}>
diff --git a/src/components/SingleTermView/index.jsx b/src/components/SingleTermView/index.jsx
index 06bd15a..1706568 100644
--- a/src/components/SingleTermView/index.jsx
+++ b/src/components/SingleTermView/index.jsx
@@ -11,6 +11,7 @@ import {
   MenuItem,
   CircularProgress,
   Alert,
+  Skeleton,
   Snackbar
 } from "@mui/material";
 import ToggleButtonGroup from '@mui/material/ToggleButtonGroup';
@@ -41,7 +42,8 @@ import DeleteOutlineOutlinedIcon from '@mui/icons-material/DeleteOutlineOutlined
 import CreateNewFolderOutlinedIcon from '@mui/icons-material/CreateNewFolderOutlined';
 import Discussion from "./Discussion";
 import CellCardPanel from "../CellCards/CellCard/CellCardPanel";
-import { ONTOLOGY_PARAM } from "../CellCards/config/gridConfig";
+import { ONTOLOGY_PARAM, isIlxTermSlug, ontologyForTermSlug } from "../CellCards/config/gridConfig";
+import { useContextTerm } from "../../hooks/useContextOntology";
 import { CodeIcon } from "../../Icons";
 import CustomSingleSelect from "../common/CustomSingleSelect";
 import CustomButtonGroup from "../common/CustomButtonGroup";
@@ -104,6 +106,10 @@ const buildDownloadFilename = (termId, label, ext) => {
 const CELL_CARD_TAB = 0;
 const OVERVIEW_TAB = 1;
 
+// Can the URL select this tab? Disabled means "applies here, but has nothing to serve yet";
+// hidden means "does not apply to this term at all". Neither can be navigated to.
+const isTabSelectable = (tab) => Boolean(tab) && !tab.disabled && !tab.hidden;
+
 const SingleTermView = () => {
   const { group, term, tab, versionHash } = useParams();
   const location = useLocation();
@@ -130,14 +136,14 @@ const SingleTermView = () => {
   const openDataFormatMenu = Boolean(dataFormatAnchorEl);
   const { storedSearchTerm, updateStoredSearchTerm, user, activeOntology, setOntologyData } = useContext(GlobalDataContext);
   const [ontologySnackbar, setOntologySnackbar] = useState(null); // { severity, message }
-  // Label resolved by the Cell Card from the ontology graph. The term API cannot supply it for a
-  // precision cell (npokb ids 404), so without this the H1 would read "NPOKB:1067".
-  //
-  // Kept as { term, label } and read only when the term still matches, rather than being cleared
-  // by an effect on `term`: navigating between cells resolves the new cell synchronously (see
-  // useCellTerm), so the card reports its label in the *same* commit that a clearing effect would
-  // run in — and effects run child-before-parent, so the clear would land last and win.
-  const [cellLabel, setCellLabel] = useState(null);
+
+  // The term as the context ontology describes it. The term API can supply neither label nor IRI
+  // for a precision cell (npokb ids 404), so without this the H1 would read "NPOKB:1067".
+  const {
+    cell: contextCell,
+    ontology: contextOntologyData,
+    loading: contextLoading,
+  } = useContextTerm(term);
 
   // Whether the term currently in view is a member of the active ontology.
   const hasActiveOntology = !!activeOntology;
@@ -147,24 +153,33 @@ const SingleTermView = () => {
     return !!termId && ontologyTerms.some((id) => extractIlxId(id) === termId);
   }, [term, activeOntology]);
 
-  // Is this term a cell type, and therefore does the Cell Card tab apply?
-  //
-  // This has to be answered *synchronously*, because it decides the default tab in the mount
-  // effect below — waiting on the ontology load (a ~16MB fetch) would block every term page.
-  // Two cheap signals, both available from the URL alone:
-  //   - the term slug is an `npokb_*` id: all 161 Precision cells are npokb-only today;
-  //   - an `?ontology=` param is present: the user arrived from an ontology grid.
-  // Revisit once Precision cells are ingested with ILX ids — at that point the slug shape stops
-  // being a reliable signal and the term's own @type should decide.
+  // Is this term a cell type, and therefore does the Cell Card tab apply? Answered from the URL
+  // alone — a catalogued ontology claims the slug's prefix, or `?ontology=` says the user came from
+  // a grid — because it decides the default tab, which cannot wait on a ~16MB load. Deliberately
+  // not the resolved `contextCell`: that lands later and would move the default tab under a user
+  // already reading one.
   const contextOntology = new URLSearchParams(location.search).get(ONTOLOGY_PARAM);
 
-  const handleCellLabel = useCallback((label) => setCellLabel({ term, label }), [term]);
-  const resolvedCellLabel = cellLabel?.term === term ? cellLabel.label : null;
+  const resolvedCellLabel = contextCell?.label || null;
 
   const isCellTerm = useMemo(
-    () => /^npokb[_:]/i.test(term || "") || Boolean(contextOntology),
+    () => Boolean(ontologyForTermSlug(term)) || Boolean(contextOntology),
     [term, contextOntology]
   );
+
+  // The URL that names this term, which depends on what kind of term it is:
+  //   - an `ilx_*` / `tmp_*` slug is an InterLex record, addressed by group
+  //     (`uri.interlex.org/{group}/ilx_0101431`);
+  //   - a cell is named by its own IRI, which only the context ontology can give: the CURIE prefix
+  //     expanded through that file's @context. Until it arrives there is no link, rather than a
+  //     group path that names nothing — an unmapped external id 404s under every group.
+  const termIdentityUrl = useMemo(() => {
+    const groupUrl = `http://uri.interlex.org/${actualGroup}/${searchTerm}`;
+    if (isIlxTermSlug(searchTerm)) return groupUrl;
+    if (contextCell) return contextCell.iri || groupUrl;
+    return isCellTerm ? "" : groupUrl;
+  }, [searchTerm, actualGroup, contextCell, isCellTerm]);
+
   // Whether the InterLex term API can address this term at all. For a cell arriving as an
   // external id (`npokb_991`) that is not a property of the slug but of the data: the id is
   // addressable once curation maps it to a record, and the backend is the only one who knows.
@@ -172,6 +187,9 @@ const SingleTermView = () => {
   // every other term keeps the tabs it has today, probe or no probe.
   const termRecordAvailable = useTermRecordAvailability(term, group, isCellTerm);
   const isTermRecordPending = isCellTerm && termRecordAvailable === undefined;
+  // Same condition OverView applies to pick its source, so the page cannot say "read-only, from the
+  // ontology" over an Overview that has gone back to the (editable) InterLex record.
+  const servedByOntology = Boolean(contextCell) && termRecordAvailable !== true;
   const DEFAULT_TAB_INDEX = isCellTerm ? CELL_CARD_TAB : OVERVIEW_TAB;
 
   // Cell Card is the first tab, per the design, so `overview` is index 1 and every
@@ -193,17 +211,30 @@ const SingleTermView = () => {
     // disabled, which is what the bar already shows, so the common case never flickers.
     const termTabsDisabled = isCellTerm && termRecordAvailable !== true;
     return [
-      { label: "Cell Card", disabled: !isCellTerm },
-      { label: "Overview", disabled: termTabsDisabled },
+      // Hidden, not disabled: a term that is not a cell type has no Cell Card to offer and never
+      // will, so the bar should read as a plain term page rather than advertise a dead tab. The
+      // term tabs above are the other case — they apply, they just have no data yet.
+      { label: "Cell Card", hidden: !isCellTerm },
+      // Overview is the one term tab with a second source: the context ontology's own record. Its
+      // pending state counts as *not* disabled, unlike the probe above — the ontology takes seconds
+      // to load, and the sync effect below would spend them redirecting a deep link to /overview
+      // away. The other three read endpoints that answer only for an InterLex record.
+      { label: "Overview", disabled: termTabsDisabled && !contextCell && !contextLoading },
       { label: "Variants", disabled: termTabsDisabled },
       { label: "Version history", disabled: termTabsDisabled },
       { label: "Discussions", disabled: termTabsDisabled },
     ];
-  }, [isCellTerm, termRecordAvailable]);
+  }, [isCellTerm, termRecordAvailable, contextCell, contextLoading]);
 
   // Set initial tab value based on URL
   const [tabValue, setTabValue] = useState(() => {
-    return tabMapping[tab] !== undefined ? tabMapping[tab] : DEFAULT_TAB_INDEX;
+    const requested = tabMapping[tab];
+    // `/cell-card` on a term that is not a cell type: that tab is not rendered at all, and a
+    // value with no Tab behind it leaves the bar with nothing selected — plus an invalid-value
+    // warning from MUI — until the effect below rewrites the URL. The disabled cases are fine to
+    // select: they still exist in the bar.
+    if (requested === undefined || (requested === CELL_CARD_TAB && !isCellTerm)) return DEFAULT_TAB_INDEX;
+    return requested;
   });
 
   // Memoize the displayed term label to prevent unnecessary re-renders
@@ -337,10 +368,11 @@ const SingleTermView = () => {
   // Optimize tab URL synchronization
   useEffect(() => {
     // A URL can name a tab this term has no data for — `/cell-card` on a term that is not a cell
-    // type, or a term tab on a precision cell. Those tabs are disabled in the bar, so honouring
-    // the URL would mount a panel that can only render an empty state (and, for the Cell Card,
-    // pay a ~16MB fetch to find that out) while the Tabs bar shows nothing selected. Fall back to
-    // the default tab, which is always enabled: Cell Card for a cell type, Overview otherwise.
+    // type, or a term tab on a precision cell. The bar hides the former and disables the latter,
+    // so honouring the URL would mount a panel that can only render an empty state (and, for the
+    // Cell Card, pay a ~16MB fetch to find that out) while the Tabs bar shows nothing selected.
+    // Fall back to the default tab, which is always selectable: Cell Card for a cell type,
+    // Overview otherwise.
     //
     // Not while the record probe is in flight, though: the disabled set is not known yet, and the
     // fallback rewrites the URL with `replace: true`. Judging /overview now would send a deep
@@ -348,8 +380,7 @@ const SingleTermView = () => {
     if (isTermRecordPending) return;
 
     const requested = tabMapping[tab];
-    const newTabValue =
-      requested !== undefined && !tabLabels[requested]?.disabled ? requested : DEFAULT_TAB_INDEX;
+    const newTabValue = isTabSelectable(tabLabels[requested]) ? requested : DEFAULT_TAB_INDEX;
 
     if (newTabValue !== tabValue) {
       setTabValue(newTabValue);
@@ -381,9 +412,9 @@ const SingleTermView = () => {
 
     switch (tabValue) {
       case CELL_CARD_TAB:
-        return <CellCardPanel term={searchTerm} group={group} onTermLabel={handleCellLabel} />;
+        return <CellCardPanel term={searchTerm} group={group} />;
       case OVERVIEW_TAB:
-        return <OverView searchTerm={searchTerm} isCodeViewVisible={isCodeViewVisible} selectedDataFormat={selectedDataFormat} group={actualGroup} versionHash={versionHash} />;
+        return <OverView searchTerm={searchTerm} isCodeViewVisible={isCodeViewVisible && !servedByOntology} selectedDataFormat={selectedDataFormat} group={actualGroup} versionHash={versionHash} />;
       case 2:
         return <VariantsPanel searchTerm={searchTerm} group={actualGroup} versionsData={versionsData} versionsLoading={versionsLoading} versionsError={versionsError} onDismissError={clearVersionsError} />;
       case 3:
@@ -391,15 +422,18 @@ const SingleTermView = () => {
       case 4:
         return <Discussion term={searchTerm} />;
       default:
-        return <OverView searchTerm={searchTerm} isCodeViewVisible={isCodeViewVisible} selectedDataFormat={selectedDataFormat} group={actualGroup} versionHash={versionHash} />;
+        return <OverView searchTerm={searchTerm} isCodeViewVisible={isCodeViewVisible && !servedByOntology} selectedDataFormat={selectedDataFormat} group={actualGroup} versionHash={versionHash} />;
     }
-  }, [tabValue, searchTerm, group, handleCellLabel, isCodeViewVisible, selectedDataFormat, actualGroup, versionHash, versionsData, versionsLoading, versionsError, clearVersionsError, isTermRecordPending]);
+  }, [tabValue, searchTerm, group, servedByOntology, isCodeViewVisible, selectedDataFormat, actualGroup, versionHash, versionsData, versionsLoading, versionsError, clearVersionsError, isTermRecordPending]);
 
   // Memoize the toggle button group for overview tab
   const toggleButtonGroup = useMemo(() => {
     // Overview owns the raw-data view; before Cell Card took index 0 this read `!== 0`, which
     // would now follow the Cell Card instead.
-    if (tabValue !== OVERVIEW_TAB) return null;
+    //
+    // Nothing to offer for a term read from the context ontology: the raw view downloads that one
+    // term's document, and its source is a node inside the ontology file, not a document.
+    if (tabValue !== OVERVIEW_TAB || servedByOntology) return null;
 
     return (
       <Box display="flex">
@@ -432,7 +466,7 @@ const SingleTermView = () => {
         </ToggleButtonGroup>
       </Box>
     );
-  }, [tabValue, isCodeViewVisible, selectedDataFormat, toggleButtonValue, onToggleButtonChange]);
+  }, [tabValue, servedByOntology, isCodeViewVisible, selectedDataFormat, toggleButtonValue, onToggleButtonChange]);
 
   const handleAddToActiveOntology = useCallback(async () => {
     if (!activeOntology || !actualGroup || !searchTerm) return;
@@ -575,7 +609,14 @@ const SingleTermView = () => {
               </Grid>
               <Grid item xs={6}>
                 <Stack direction="row" spacing="1rem" alignItems="center">
-                  <CopyLinkComponent url={`http://uri.interlex.org/${actualGroup}/${searchTerm}`} />
+                  {termIdentityUrl ? (
+                    <CopyLinkComponent url={termIdentityUrl} />
+                  ) : (
+                    // Waiting on the ontology for a cell's IRI (see termIdentityUrl). The
+                    // placeholder holds the row's height so the tab bar below does not jump when
+                    // the link arrives.
+                    <Skeleton variant="text" width="20rem" height="2.5rem" />
+                  )}
                   {graphId && (
                     <Typography fontSize=".875rem" color={gray500}>
                       Graph ID: {graphId}
@@ -597,6 +638,16 @@ const SingleTermView = () => {
             </Alert>
           </Box>
         )}
+        {/* Why nothing on the Overview is editable: the record shown is the ontology's, not InterLex's. */}
+        {!versionHash && servedByOntology && tabValue === OVERVIEW_TAB && (
+          <Box px="5rem" pt="1.5rem">
+            <Alert severity="info">
+              This term has no InterLex record yet, so its Overview is read from{" "}
+              {contextOntologyData?.meta?.title || "the context ontology"} and is read-only. Curate
+              it by editing that ontology.
+            </Alert>
+          </Box>
+        )}
         {tabContent}
       </Box>
       {/* TODO: Re-enable when merge request feature is implemented */}
diff --git a/src/components/common/CustomTabs.jsx b/src/components/common/CustomTabs.jsx
index 237ca7c..662a3c9 100644
--- a/src/components/common/CustomTabs.jsx
+++ b/src/components/common/CustomTabs.jsx
@@ -70,11 +70,19 @@ const BasicTabs = ({ tabs, tabValue, handleChange, onMouseDown, parentBoxStyles,
         onMouseDown={(event) => event.preventDefault()}
       >
         {
-          // A tab is either a plain label or { label, disabled } — the latter for a tab that
-          // is part of the design but has no view behind it yet.
-          tabs.map((tab, i) => typeof tab === 'string'
-            ? <Tab key={i} label={tab} {...a11yProps(i)} />
-            : <Tab key={i} label={tab.label} disabled={tab.disabled} {...a11yProps(i)} />)
+          // A tab is either a plain label or { label, disabled, hidden }: `disabled` for one that
+          // is part of the design but has no view behind it yet, `hidden` for one that does not
+          // apply to what is being shown at all.
+          //
+          // Each Tab carries its index as an explicit `value`, so hiding one does not renumber
+          // the others — callers keep addressing tabs by their position in `tabs`, which is what
+          // the value MUI hands back to `handleChange` still means.
+          tabs.map((tab, i) => {
+            const { label, disabled, hidden } = typeof tab === 'string' ? { label: tab } : tab;
+            return hidden
+              ? null
+              : <Tab key={i} value={i} label={label} disabled={disabled} {...a11yProps(i)} />;
+          })
         }
       </Tabs>
     </Box>
@@ -84,7 +92,11 @@ const BasicTabs = ({ tabs, tabValue, handleChange, onMouseDown, parentBoxStyles,
 BasicTabs.propTypes = {
   tabs: PropTypes.arrayOf(PropTypes.oneOfType([
     PropTypes.string,
-    PropTypes.shape({ label: PropTypes.string.isRequired, disabled: PropTypes.bool })
+    PropTypes.shape({
+      label: PropTypes.string.isRequired,
+      disabled: PropTypes.bool,
+      hidden: PropTypes.bool
+    })
   ])).isRequired,
   tabValue: PropTypes.number.isRequired,
   handleChange: PropTypes.func.isRequired,
diff --git a/src/hooks/useContextOntology.js b/src/hooks/useContextOntology.js
new file mode 100644
index 0000000..e397167
--- /dev/null
+++ b/src/hooks/useContextOntology.js
@@ -0,0 +1,61 @@
+import { useEffect } from "react";
+import { atom, useAtom, useSetAtom } from "jotai";
+import { useLocation } from "react-router-dom";
+import {
+  ONTOLOGY_CATALOG,
+  ONTOLOGY_PARAM,
+  ontologyForTermSlug,
+} from "../components/CellCards/config/gridConfig";
+import useCellTerm from "../components/CellCards/CellCard/useCellTerm";
+
+/**
+ * The ontology the user is currently reading — the *context ontology*, a data source. Not
+ * `DataContext.activeOntology`, which is an edit target.
+ *
+ * Holds the ontology's identity only; the parse itself stays in `ontologyGridService`'s module
+ * cache, shared with the grid. No jotai `<Provider>` is mounted, so this is the module default
+ * store and a non-React reader can reach it with `getDefaultStore()`.
+ */
+export const contextOntologyAtom = atom(null);
+
+/** Publish the ontology a route *is*, so terms opened from it inherit the context. */
+export const usePublishContextOntology = (slug) => {
+  const setSlug = useSetAtom(contextOntologyAtom);
+  useEffect(() => {
+    if (slug && ONTOLOGY_CATALOG[slug]) setSlug(slug);
+  }, [slug, setSlug]);
+};
+
+/**
+ * Which ontology is in context for this term: `?ontology=` first, then the atom, then a catalogued
+ * ontology claiming the slug's prefix. Null for an ordinary InterLex term, which must not load one.
+ *
+ * The URL wins and is read synchronously so a shared deep link resolves on its first render; the
+ * sync is one-way (URL -> atom), leaving react-router the only writer of the URL.
+ */
+export const useContextOntologySlug = (termSlug) => {
+  const [stored, setStored] = useAtom(contextOntologyAtom);
+  const { search } = useLocation();
+  const fromUrl = new URLSearchParams(search).get(ONTOLOGY_PARAM);
+  const valid = fromUrl && ONTOLOGY_CATALOG[fromUrl] ? fromUrl : null;
+
+  useEffect(() => {
+    if (valid && valid !== stored) setStored(valid);
+  }, [valid, stored, setStored]);
+
+  return valid || stored || ontologyForTermSlug(termSlug) || null;
+};
+
+/**
+ * The term as the context ontology describes it — the seam the page header, the tab bar, the
+ * Overview and the Cell Card all read, so none of them has to tell the others what it found.
+ *
+ * `cell` null with `loading` false means "no ontology record": fall back to the InterLex term API.
+ */
+export const useContextTerm = (termSlug) => {
+  const ontologySlug = useContextOntologySlug(termSlug);
+  const { cell, data, loading, error } = useCellTerm(termSlug, ontologySlug);
+  return { ontologySlug, ontology: data, cell, loading, error };
+};
+
+export default useContextTerm;
diff --git a/src/parsers/neurdfParser.ts b/src/parsers/neurdfParser.ts
index b58b94f..431657b 100644
--- a/src/parsers/neurdfParser.ts
+++ b/src/parsers/neurdfParser.ts
@@ -76,33 +76,60 @@ const isIri = (id: string): boolean => id.includes("://");
 // It is not a real term, so it must never surface as a value / facet option / tile chip.
 const isMissingSentinel = (id: string): boolean => /^TEMP:MISSING/i.test(id);
 
-// Compact an @id (curie or IRI) into { curie, kind } without needing the @context.
-const classify = (id: string): { curie: string; kind: RefKind } => {
+// --- prefix table: the parsed file's own @context ---------------------------
+
+// Prefix -> base IRI, read from the graph's @context. Every curie <-> IRI conversion below goes
+// through it, so no prefix is known to the front end: `npokb:997` is `@context.npokb` + `997`,
+// i.e. http://uri.interlex.org/npo/uris/neurons/997, and an ontology that names its terms with a
+// different prefix needs no edit here. Every CURIE prefix the shipped graph uses is declared in
+// its @context.
+export type Prefixes = Record<string, string>;
+
+// A JSON-LD @context mixes prefix declarations ("npokb": ".../neurons/") with term definitions
+// ("definition": ".../IAO_0000115"), and either may be written as an object ({"@id": …}). Both
+// are kept: expansion only looks up the part before a ":", where a term name cannot appear, and
+// compaction requires a non-empty local part, which a term's own IRI cannot leave behind.
+export const contextPrefixes = (context?: Record<string, unknown>): Prefixes => {
+  const out: Prefixes = {};
+  for (const [key, value] of Object.entries(context || {})) {
+    if (key.startsWith("@")) continue; // @vocab / @base / @version are not prefixes
+    const base =
+      typeof value === "string"
+        ? value
+        : value && typeof value === "object"
+          ? firstString((value as { "@id"?: unknown })["@id"])
+          : undefined;
+    if (base) out[key] = base;
+  }
+  return out;
+};
+
+// Compact an @id (curie or IRI) into { curie, kind } against the @context.
+const classify = (id: string, prefixes: Prefixes): { curie: string; kind: RefKind } => {
   if (!isIri(id)) {
     // already a curie like "npokb:1067", "NCBIGene:233222", "ilxtr:SensoryPhenotype"
     const prefix = id.split(":")[0];
     return { curie: id, kind: kindForPrefix(prefix, id) };
   }
-  // full IRI — derive a short curie + kind from known bases
-  for (const [prefix, base] of Object.entries(IRI_BASES)) {
-    if (id.startsWith(base)) {
-      return { curie: `${prefix}:${id.slice(base.length)}`, kind: kindForPrefix(prefix, id) };
+  // Full IRI: compact it against the longest declared base that covers it, since a context
+  // routinely declares both a family and its members (".../obo/" and ".../obo/UBERON_") and only
+  // the longer one names the term. The base must leave a local part behind, which is what stops a
+  // term definition — an IRI complete in itself — from being read as a prefix.
+  let best = "";
+  let bestPrefix = "";
+  for (const [prefix, base] of Object.entries(prefixes)) {
+    if (base.length > best.length && id.length > base.length && id.startsWith(base)) {
+      best = base;
+      bestPrefix = prefix;
     }
   }
+  if (best) {
+    return { curie: `${bestPrefix}:${id.slice(best.length)}`, kind: kindForPrefix(bestPrefix, id) };
+  }
   const tail = id.split(/[/#]/).filter(Boolean).pop() || id;
   return { curie: tail, kind: "external" };
 };
 
-const IRI_BASES: Record<string, string> = {
-  UBERON: "http://purl.obolibrary.org/obo/UBERON_",
-  CHEBI: "http://purl.obolibrary.org/obo/CHEBI_",
-  NCBITaxon: "http://purl.obolibrary.org/obo/NCBITaxon_",
-  NCBIGene: "http://www.ncbi.nlm.nih.gov/gene/",
-  ILX: "http://uri.interlex.org/base/ilx_",
-  ilxtr: "http://uri.interlex.org/tgbugs/uris/readable/",
-  npokb: "http://uri.interlex.org/npo/uris/neurons/",
-};
-
 const kindForPrefix = (prefix: string, id: string): RefKind => {
   switch (prefix) {
     case "UBERON":
@@ -124,11 +151,13 @@ const kindForPrefix = (prefix: string, id: string): RefKind => {
   }
 };
 
-// Full IRI for linking out (expand a curie via known bases; pass through IRIs).
-const toIri = (id: string): string => {
+// Full IRI for linking out: expand a curie through the @context, pass an IRI through. "" when the
+// file declares no base for the prefix, which the UI reads as "not addressable" and renders as
+// plain text rather than a dead link.
+const toIri = (id: string, prefixes: Prefixes): string => {
   if (isIri(id)) return id;
   const [prefix, ...rest] = id.split(":");
-  const base = IRI_BASES[prefix];
+  const base = prefixes[prefix];
   return base ? base + rest.join(":") : "";
 };
 
@@ -145,7 +174,7 @@ const indexGraph = (graph: GraphNode[]): Index => {
   return idx;
 };
 
-const labelFor = (id: string, idx: Index): string => {
+const labelFor = (id: string, idx: Index, prefixes: Prefixes): string => {
   const node = idx.get(id);
   if (node) {
     for (const key of LABEL_KEYS) {
@@ -153,7 +182,7 @@ const labelFor = (id: string, idx: Index): string => {
       if (s) return s;
     }
   }
-  return classify(id).curie; // fall back to a compact curie when no label exists
+  return classify(id, prefixes).curie; // fall back to a compact curie when no label exists
 };
 
 // Turn a predicate value (ref object, array, @list, or literal) into ResolvedRefs.
@@ -162,7 +191,7 @@ const labelFor = (id: string, idx: Index): string => {
 // ({"@list":[{...},{...}]}), and `neurdf.eqv.uo:hasSomaLocatedIn` is the *only* soma-location
 // predicate on 61 of the 161 Precision cells. Treating a list object as an unrecognised value
 // silently dropped the property for all of them.
-const resolveValue = (raw: unknown, idx: Index): ResolvedRef[] => {
+const resolveValue = (raw: unknown, idx: Index, prefixes: Prefixes): ResolvedRef[] => {
   const out: ResolvedRef[] = [];
   const push = (item: unknown) => {
     if (item && typeof item === "object" && "@list" in (item as object)) {
@@ -173,8 +202,8 @@ const resolveValue = (raw: unknown, idx: Index): ResolvedRef[] => {
     if (item && typeof item === "object" && "@id" in (item as object)) {
       const id = String((item as JsonLdRefish)["@id"]);
       if (isBlankNode(id) || isMissingSentinel(id)) return; // skip restriction blanks + "not specified" sentinels
-      const { curie, kind } = classify(id);
-      out.push({ id, curie, label: labelFor(id, idx), iri: toIri(id), kind });
+      const { curie, kind } = classify(id, prefixes);
+      out.push({ id, curie, label: labelFor(id, idx, prefixes), iri: toIri(id, prefixes), kind });
     } else if (item && typeof item === "object" && "@value" in (item as object)) {
       // JSON-LD literal object, e.g. {"@value":"foo"} / {"@value":"foo","@language":"en"}
       const v = (item as { "@value"?: unknown })["@value"];
@@ -258,9 +287,9 @@ const LINK_ANNOTATIONS = {
 
 type LinkAnnotationField = (typeof LINK_ANNOTATIONS)[keyof typeof LINK_ANNOTATIONS];
 
-const linkAnnotationField = (key: string): LinkAnnotationField | undefined => {
+const linkAnnotationField = (key: string, prefixes: Prefixes): LinkAnnotationField | undefined => {
   if (key.startsWith("neurdf.")) return undefined; // a phenotype family, never a deep link
-  const localName = classify(key).curie.split(":").pop() || "";
+  const localName = classify(key, prefixes).curie.split(":").pop() || "";
   return LINK_ANNOTATIONS[localName as keyof typeof LINK_ANNOTATIONS];
 };
 
@@ -314,9 +343,9 @@ const mergeValues = (existing: ResolvedRef[], incoming: ResolvedRef[]): Resolved
   return [...byId.values()];
 };
 
-const buildCell = (node: GraphNode, idx: Index): CellTerm => {
+const buildCell = (node: GraphNode, idx: Index, prefixes: Prefixes): CellTerm => {
   const id = String(node["@id"]);
-  const { curie } = classify(id);
+  const { curie } = classify(id, prefixes);
   const properties: Record<string, CellProperty> = {};
   const negated: Record<string, CellProperty> = {};
   const annotations = emptyAnnotations();
@@ -325,21 +354,21 @@ const buildCell = (node: GraphNode, idx: Index): CellTerm => {
 
   for (const [key, raw] of Object.entries(node)) {
     if (key === "ilxtr:literatureCitation") {
-      sources = resolveValue(raw, idx); // a cell may cite several publications
+      sources = resolveValue(raw, idx, prefixes); // a cell may cite several publications
       continue;
     }
     if (key === "ilxtr:dataCitation") {
-      annotations.dataCitations = resolveValue(raw, idx);
+      annotations.dataCitations = resolveValue(raw, idx, prefixes);
       continue;
     }
     if (key in TEXT_ANNOTATIONS) {
       const field = TEXT_ANNOTATIONS[key as keyof typeof TEXT_ANNOTATIONS];
       // These are plain strings in the graph; resolveValue normalises the literal shapes.
-      annotations[field] = resolveValue(raw, idx).map((r) => r.label);
+      annotations[field] = resolveValue(raw, idx, prefixes).map((r) => r.label);
       continue;
     }
     if (key === "ilxtr:hasTemporaryId") {
-      annotations.temporaryId = resolveValue(raw, idx)[0]?.curie;
+      annotations.temporaryId = resolveValue(raw, idx, prefixes)[0]?.curie;
       continue;
     }
     if (key === "ilxtr:genLabel") {
@@ -347,18 +376,18 @@ const buildCell = (node: GraphNode, idx: Index): CellTerm => {
       continue;
     }
     if (key === "ilxtr:error") {
-      annotations.errors = resolveValue(raw, idx).map((r) => r.curie);
+      annotations.errors = resolveValue(raw, idx, prefixes).map((r) => r.curie);
       continue;
     }
-    const linkField = linkAnnotationField(key);
+    const linkField = linkAnnotationField(key, prefixes);
     if (linkField) {
       // The same link can be asserted under more than one prefix; merge rather than overwrite.
-      annotations[linkField] = mergeValues(annotations[linkField], resolveValue(raw, idx));
+      annotations[linkField] = mergeValues(annotations[linkField], resolveValue(raw, idx, prefixes));
       continue;
     }
     if (key in MAPPING_PREDICATES) {
       const evidence = MAPPING_PREDICATES[key];
-      for (const ref of resolveValue(raw, idx)) {
+      for (const ref of resolveValue(raw, idx, prefixes)) {
         // A cell can be related to the same record by more than one relation; the stronger
         // claim (an explicit description) wins over an inferred mapping.
         const prev = mappings.find((m) => m.ref.id === ref.id);
@@ -372,13 +401,13 @@ const buildCell = (node: GraphNode, idx: Index): CellTerm => {
     }
     if (key in LITERAL_PREDICATES) {
       const local = LITERAL_PREDICATES[key];
-      const values = resolveValue(raw, idx);
+      const values = resolveValue(raw, idx, prefixes);
       if (values.length) properties[local] = { localName: local, family: "eqv", negated: false, values };
       continue;
     }
     const parsed = parseNeurdfKey(key);
     if (!parsed) continue; // skip @id/@type/owl:*/rdfs:*/etc.
-    const values = resolveValue(raw, idx);
+    const values = resolveValue(raw, idx, prefixes);
     if (!values.length) continue;
     const bucket = parsed.negated ? negated : properties;
     const prev = bucket[parsed.localName];
@@ -403,9 +432,9 @@ const buildCell = (node: GraphNode, idx: Index): CellTerm => {
   return {
     id,
     curie,
-    iri: toIri(id),
-    label: labelFor(id, idx),
-    rdfTypes: rdfTypesOf(node),
+    iri: toIri(id, prefixes),
+    label: labelFor(id, idx, prefixes),
+    rdfTypes: rdfTypesOf(node, prefixes),
     definition: definition?.text,
     definitionCurated: definition?.curated,
     properties,
@@ -419,8 +448,8 @@ const buildCell = (node: GraphNode, idx: Index): CellTerm => {
 // rdf:type for the Terms table. The design asks for the OWL type of the record
 // (owl:Class / owl:ObjectProperty), so the neurdf marker types are dropped — but a record
 // carrying no owl:* type shows every type it has rather than nothing.
-const rdfTypesOf = (node: GraphNode): string[] => {
-  const all = asType(node["@type"]).map((t) => classify(t).curie);
+const rdfTypesOf = (node: GraphNode, prefixes: Prefixes): string[] => {
+  const all = asType(node["@type"]).map((t) => classify(t, prefixes).curie);
   const owl = all.filter((t) => t.startsWith("owl:"));
   return owl.length ? owl : all;
 };
@@ -447,7 +476,8 @@ const definitionOf = (
 const buildHierarchy = (
   rootClass: string,
   cells: CellTerm[],
-  idx: Index
+  idx: Index,
+  prefixes: Prefixes
 ): HierarchyNode[] => {
   if (!rootClass) return [];
   const inScope = new Set(cells.map((c) => c.id));
@@ -497,9 +527,9 @@ const buildHierarchy = (
     return {
       id: path,
       termId,
-      label: cell ? cell.label : labelFor(termId, idx),
-      curie: cell ? cell.curie : classify(termId).curie,
-      iri: cell ? cell.iri : toIri(termId),
+      label: cell ? cell.label : labelFor(termId, idx, prefixes),
+      curie: cell ? cell.curie : classify(termId, prefixes).curie,
+      iri: cell ? cell.iri : toIri(termId, prefixes),
       children: kids
         .map((kid) => nodeAt(kid, `${path}/${kid}`, nextSeen))
         .sort((a, b) => a.label.localeCompare(b.label)),
@@ -537,7 +567,10 @@ export const parseOntologyMeta = (graph: GraphNode[]): OntologyMeta => {
 //
 // Keyed by *local name* (`hasSomaLocatedIn`), because that is how a CellProperty is keyed,
 // while the annotation lives on the `ilxtr:hasSomaLocatedIn` node.
-export const parsePredicateDisplay = (graph: GraphNode[]): Record<string, PredicateDisplay> => {
+export const parsePredicateDisplay = (
+  graph: GraphNode[],
+  prefixes: Prefixes = {}
+): Record<string, PredicateDisplay> => {
   const out: Record<string, PredicateDisplay> = {};
   for (const node of graph) {
     const id = node["@id"];
@@ -546,7 +579,7 @@ export const parsePredicateDisplay = (graph: GraphNode[]): Record<string, Predic
     const description = firstString(node["ilxtr:shortDefinition"]);
     if (!label && !description) continue;
     // "ilxtr:hasSomaLocatedIn" and the expanded IRI both reduce to the same local name.
-    const localName = classify(id).curie.split(":").pop() || "";
+    const localName = classify(id, prefixes).curie.split(":").pop() || "";
     if (!localName) continue;
     out[localName] = {
       localName,
@@ -559,18 +592,20 @@ export const parsePredicateDisplay = (graph: GraphNode[]): Record<string, Predic
 
 export const parseNeurdf = (data: OntologyGraph, rootClass: string): ParsedOntology => {
   const graph = data["@graph"] || [];
+  // The file's own prefix declarations, which every curie <-> IRI conversion below reads.
+  const prefixes = contextPrefixes(data["@context"]);
   const idx = indexGraph(graph);
   const neurons = graph.filter((n) => asType(n["@type"]).includes("neurdf:Neuron"));
   const inScope = rootClass
     ? neurons.filter((n) => reaches(String(n["@id"] ?? ""), rootClass, idx))
     : neurons;
-  const cells = inScope.map((n) => buildCell(n, idx));
+  const cells = inScope.map((n) => buildCell(n, idx, prefixes));
   cells.sort((a, b) => a.label.localeCompare(b.label));
   return {
     meta: parseOntologyMeta(graph),
     cells,
-    hierarchy: buildHierarchy(rootClass, cells, idx),
-    predicateDisplay: parsePredicateDisplay(graph),
+    hierarchy: buildHierarchy(rootClass, cells, idx, prefixes),
+    predicateDisplay: parsePredicateDisplay(graph, prefixes),
   };
 };
 
diff --git a/src/parsers/ontologyTermAdapter.ts b/src/parsers/ontologyTermAdapter.ts
new file mode 100644
index 0000000..2aaed5c
--- /dev/null
+++ b/src/parsers/ontologyTermAdapter.ts
@@ -0,0 +1,244 @@
+// Adapt a term as the context ontology describes it into the shapes the term Overview's three
+// streams carry (details$ / hierarchy$ / predicates$ in OverView.jsx), which the term API fills for
+// every other term. Pure functions over the parse, so the ontology path needs no fetch.
+
+import type {
+  CellTerm,
+  CellProperty,
+  HierarchyNode,
+  ParsedOntology,
+  PredicateDisplay,
+  ResolvedRef,
+} from "../components/CellCards/model/types";
+import { labelFor } from "../components/CellCards/config/gridConfig";
+
+// The CURIE is the term's identity throughout this mode: the hierarchy focus, a tree node's `iri`
+// and a predicate row's subject must all match, and `Hierarchy` passes a non-ILX id through
+// unchanged.
+export const ontologyFocus = (cell: CellTerm): { id: string; label: string } => ({
+  id: cell.curie,
+  label: cell.label,
+});
+
+// --- details ----------------------------------------------------------------
+
+// The subset of termParser's `Term` that Details reads. The ontology carries no synonyms, existing
+// ids, OWL equivalent or provenance for these cells, so those are left out rather than faked.
+export interface OntologyTermDetails {
+  id: string;
+  label: string;
+  description?: string;
+  type?: string;
+}
+
+export const ontologyDetails = (cell: CellTerm): OntologyTermDetails => ({
+  id: cell.curie,
+  label: cell.label,
+  description: cell.definition,
+  type: cell.rdfTypes.join(", "),
+});
+
+// --- hierarchy --------------------------------------------------------------
+
+// `TreeItem` in hierarchies-parser: `id` unique per position (RichTreeView), `iri` the identity the
+// focus is matched against.
+export interface OntologyTreeItem {
+  id: string;
+  label: string;
+  iri: string;
+  children: OntologyTreeItem[];
+}
+
+export interface OntologyHierarchyOption {
+  id: string;
+  label: string;
+}
+
+export interface OntologyHierarchy {
+  options: { children: OntologyHierarchyOption[]; superclasses: OntologyHierarchyOption[] };
+  treeChildren: OntologyTreeItem[];
+  treeSuperclasses: OntologyTreeItem[];
+}
+
+const EMPTY_HIERARCHY: OntologyHierarchy = {
+  options: { children: [], superclasses: [] },
+  treeChildren: [],
+  treeSuperclasses: [],
+};
+
+const toTreeItem = (node: HierarchyNode): OntologyTreeItem => ({
+  id: node.id,
+  label: node.label,
+  iri: node.curie,
+  children: node.children.map(toTreeItem),
+});
+
+// Any position of the class will do: the parse computes children per class, not per position.
+const findNode = (nodes: HierarchyNode[], termId: string): HierarchyNode | undefined => {
+  for (const node of nodes) {
+    if (node.termId === termId) return node;
+    const hit = findNode(node.children, termId);
+    if (hit) return hit;
+  }
+  return undefined;
+};
+
+// The hierarchy is a DAG: 15 Precision cells have several parents, and the superclass tree shows
+// every way of reaching the term, as the API path's forest does.
+const pathsTo = (
+  nodes: HierarchyNode[],
+  termId: string,
+  trail: HierarchyNode[] = []
+): HierarchyNode[][] => {
+  const out: HierarchyNode[][] = [];
+  for (const node of nodes) {
+    const here = [...trail, node];
+    if (node.termId === termId) out.push(here);
+    else out.push(...pathsTo(node.children, termId, here));
+  }
+  return out;
+};
+
+// Folded into one forest, so two parents render as two branches of one root, not two trees.
+const mergePaths = (paths: HierarchyNode[][]): OntologyTreeItem[] => {
+  const roots: OntologyTreeItem[] = [];
+  for (const path of paths) {
+    let level = roots;
+    let id = "";
+    for (const node of path) {
+      id = id ? `${id}/${node.termId}` : node.termId;
+      let item = level.find((candidate) => candidate.iri === node.curie);
+      if (!item) {
+        item = { id, label: node.label, iri: node.curie, children: [] };
+        level.push(item);
+      }
+      level = item.children;
+    }
+  }
+  return roots;
+};
+
+const collectOptions = (items: OntologyTreeItem[]): OntologyHierarchyOption[] => {
+  const byId = new Map<string, string>();
+  const walk = (list: OntologyTreeItem[]) => {
+    for (const item of list) {
+      if (!byId.has(item.iri)) byId.set(item.iri, item.label);
+      walk(item.children);
+    }
+  };
+  walk(items);
+  return [...byId.entries()]
+    .map(([id, label]) => ({ id, label }))
+    .sort((a, b) => a.label.localeCompare(b.label));
+};
+
+/**
+ * Both hierarchy directions for one class, from the tree the parse already reduced. Keyed by
+ * `termId`, so it answers for a class with no record of its own — the root the cells hang from.
+ */
+export const ontologyHierarchy = (
+  ontology: Pick<ParsedOntology, "hierarchy"> | null | undefined,
+  termId: string
+): OntologyHierarchy => {
+  const roots = ontology?.hierarchy;
+  if (!roots?.length || !termId) return EMPTY_HIERARCHY;
+
+  const self = findNode(roots, termId);
+  const treeChildren = self ? [toTreeItem(self)] : [];
+  const treeSuperclasses = mergePaths(pathsTo(roots, termId));
+
+  return {
+    options: {
+      children: collectOptions(treeChildren),
+      superclasses: collectOptions(treeSuperclasses),
+    },
+    treeChildren,
+    treeSuperclasses,
+  };
+};
+
+// --- predicates -------------------------------------------------------------
+
+// `predicateParser`'s PredicateGroup: what CustomizedTable normalises into Subject | Predicates |
+// Objects rows.
+export interface OntologyPredicateRow {
+  subject: string;
+  predicate: string;
+  object: string;
+}
+
+export interface OntologyPredicateGroup {
+  title: string;
+  count: number;
+  tableData: OntologyPredicateRow[];
+}
+
+const refText = (ref: ResolvedRef): string => ref.label || ref.curie;
+
+// "soma in A *or* B" is a different claim from two independent assertions, and a flat table has
+// nowhere else to say which one it is.
+const withCombinator = (title: string, prop: CellProperty): string =>
+  prop.combinator ? `${title} (${prop.combinator === "or" ? "any of" : "all of"})` : title;
+
+/**
+ * Everything the ontology asserts about one cell, grouped per predicate. Titles come from the
+ * ontology's own `ilxtr:displayLabel` as the Cell Card's rows do, so both tabs name a predicate the
+ * same way; objects fall back to the CURIE for a value the graph never labels.
+ */
+export const ontologyPredicateGroups = (
+  cell: CellTerm,
+  display: Record<string, PredicateDisplay> = {}
+): OntologyPredicateGroup[] => {
+  const groups: OntologyPredicateGroup[] = [];
+  const subject = cell.curie;
+
+  const add = (title: string, objects: (string | undefined)[]) => {
+    const values = objects.filter((value): value is string => Boolean(value));
+    if (!values.length) return;
+    groups.push({
+      title,
+      count: values.length,
+      tableData: values.map((object) => ({ subject, predicate: title, object })),
+    });
+  };
+
+  const titleFor = (localName: string) => display[localName]?.label || labelFor(localName);
+
+  add("@id", [cell.curie]);
+  add("Label", [cell.label]);
+  add("Type", cell.rdfTypes);
+  // For every Precision cell today this is the generated phenotype string, not curated prose.
+  if (cell.definition) {
+    add(cell.definitionCurated === false ? "Definition (generated)" : "Definition", [cell.definition]);
+  }
+
+  for (const [localName, prop] of Object.entries(cell.properties)) {
+    add(withCombinator(titleFor(localName), prop), prop.values.map(refText));
+  }
+  // Without the marker in the title, the row would state the opposite of what the ontology says.
+  for (const [localName, prop] of Object.entries(cell.negated)) {
+    add(withCombinator(`Not: ${titleFor(localName)}`, prop), prop.values.map(refText));
+  }
+
+  add("Source publication", cell.sources.map(refText));
+  for (const evidence of ["described", "inferred", "proposed"] as const) {
+    add(
+      `Cross-nomenclature mapping (${evidence})`,
+      cell.mappings.filter((m) => m.evidence === evidence).map((m) => refText(m.ref))
+    );
+  }
+
+  const { annotations } = cell;
+  add("Dataset annotation", annotations.atlasAnnotation);
+  add("Data citation", annotations.dataCitations.map(refText));
+  add("Curator note", annotations.curatorNotes);
+  add("Alert", annotations.alertNotes);
+  add("Temporary ID", [annotations.temporaryId]);
+  add("Generated label", [annotations.generatedLabel]);
+  add("Error", annotations.errors);
+  add("SPARC transcriptomics", annotations.sparcTranscriptomicsLinks.map(refText));
+  add("SPARC map", annotations.sparcMaps.map(refText));
+  add("NervoSensus", annotations.nervoSensusLinks.map(refText));
+
+  return groups;
+};
diff --git a/yarn.lock b/yarn.lock
index 2ce8659..6b81276 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -3771,6 +3771,11 @@ iterator.prototype@^1.1.2:
     reflect.getprototypeof "^1.0.4"
     set-function-name "^2.0.1"
 
+jotai@^2.20.2:
+  version "2.20.2"
+  resolved "https://registry.yarnpkg.com/jotai/-/jotai-2.20.2.tgz#fccdc02ee68b314c2a723a8b9c35de6fcca5e644"
+  integrity sha512-aHB4CNb9qRcyf0mwSB6EO5bCGAjx8cTwFgOFCE2leOnTzqACbnSWG8XoWB3LxCT1Qoj03I1OWAHszDmN4uHb/w==
+
 "js-tokens@^3.0.0 || ^4.0.0", js-tokens@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499"

From 2af5f638339b75098c83ad077317cd1a0e18a77a Mon Sep 17 00:00:00 2001
From: Filippo Ledda <filippo@metacell.us>
Date: Fri, 7 Aug 2026 14:52:20 +0200
Subject: [PATCH 3/4] Fix context ontology related breadcrumbs

---
 src/App.jsx                                   | 12 +++
 .../CellCards/CellCard/CellCardPanel.jsx      | 22 ++++--
 src/components/CellCards/OntologyGridPage.jsx | 15 ++--
 src/components/CellCards/OntologyHeader.jsx   |  1 -
 src/components/CellCards/OntologyPage.jsx     |  2 +-
 src/components/CellCards/config/gridConfig.ts | 26 +++++--
 src/components/SingleTermView/index.jsx       | 76 +++++++++++++------
 src/hooks/useContextOntology.js               | 11 ++-
 8 files changed, 109 insertions(+), 56 deletions(-)

diff --git a/src/App.jsx b/src/App.jsx
index 0d7a8fe..c27cda6 100644
--- a/src/App.jsx
+++ b/src/App.jsx
@@ -198,6 +198,18 @@ function MainContent() {
 						<Route index element={<OntologyGridPage />} />
 						<Route path="browse" element={<OntologyBrowsePage />} />
 					</Route>
+					{/* A term read inside an ontology: the same page as the plain term route below, with
+					    the context ontology named by the path. A sibling of the ontology route rather than a
+					    child of it — the term page brings its own header, and the layout route above would
+					    render the ontology's on top of it. */}
+					<Route
+						path="/:group/ontology/:ontologySlug/:term/:tab?"
+						element={
+							<PageContainer>
+								<SingleTermView />
+							</PageContainer>
+						}
+					/>
 					<Route path="/login" element={<Login />} />
 					<Route path="/register" element={<Register />} />
 					<Route path="/forgot" element={<ForgotPassword />} />
diff --git a/src/components/CellCards/CellCard/CellCardPanel.jsx b/src/components/CellCards/CellCard/CellCardPanel.jsx
index 9f4f35c..a5f1919 100644
--- a/src/components/CellCards/CellCard/CellCardPanel.jsx
+++ b/src/components/CellCards/CellCard/CellCardPanel.jsx
@@ -9,6 +9,7 @@ import { curieToSlug } from "../services/ontologyGridService";
 import {
   termLink,
   ontologyPath,
+  termPath,
   ONTOLOGY_CATALOG,
 } from "../config/gridConfig";
 import { useTermRecordAvailability } from "../../../hooks/useTermRecordAvailability";
@@ -52,8 +53,9 @@ const LoadingSkeleton = () => (
  * The Cell Card tab: resolves the term against the context ontology and renders the card.
  *
  * The card's data never comes from the InterLex term API — Precision cells are npokb-only and
- * that endpoint 404s on every one of them. The context ontology arrives as `?ontology=`, written
- * by the grid tile click; it is *not* `DataContext.activeOntology`, which is an edit target.
+ * that endpoint 404s on every one of them. The context ontology is the `/ontology/{slug}/` the term
+ * is read under, written by the grid tile click; it is *not* `DataContext.activeOntology`, which is
+ * an edit target.
  */
 const CellCardPanel = ({ term, group }) => {
   const navigate = useNavigate();
@@ -65,13 +67,15 @@ const CellCardPanel = ({ term, group }) => {
   // module-level cache, so the link and the tab cannot disagree.
   const termRecordAvailable = useTermRecordAvailability(term, group);
 
-  // Navigating between cells keeps the context ontology, so the card the user lands on can still
-  // populate its hierarchy and sibling widgets (Sue: "you're staying in that context ontology").
+  // Navigating between cells keeps the context ontology — it stays in the path — so the card the
+  // user lands on can still populate its hierarchy and sibling widgets (Sue: "you're staying in
+  // that context ontology").
   const search = location.search;
 
   const goToCell = useCallback(
-    (target) => navigate(`/${group}/${curieToSlug(target.curie)}/cell-card${search}`),
-    [navigate, group, search]
+    (target) =>
+      navigate(`${termPath(group, ontologySlug, curieToSlug(target.curie), "cell-card")}${search}`),
+    [navigate, group, ontologySlug, search]
   );
 
   // A graph node may be a cell (stay in the card) or an external term (open its own page).
@@ -138,7 +142,11 @@ const CellCardPanel = ({ term, group }) => {
         // Only when the Discussions tab can actually serve this term. While the cell's id is not
         // mapped to an InterLex record that tab is disabled (SingleTermView gates it on the same
         // probe), so the link would land on a tab the bar shows as unselectable.
-        discussionHref={termRecordAvailable ? `/${group}/${term}/discussions${search}` : undefined}
+        discussionHref={
+          termRecordAvailable
+            ? `${termPath(group, ontologySlug, term, "discussions")}${search}`
+            : undefined
+        }
         onNavigateToCell={goToCell}
         onNavigateToRef={goToRef}
       />
diff --git a/src/components/CellCards/OntologyGridPage.jsx b/src/components/CellCards/OntologyGridPage.jsx
index 3450a72..1e1809a 100644
--- a/src/components/CellCards/OntologyGridPage.jsx
+++ b/src/components/CellCards/OntologyGridPage.jsx
@@ -7,7 +7,7 @@ import CellTileGrid from "./CellTileGrid";
 import CustomSingleSelect from "../common/CustomSingleSelect";
 import CustomPagination from "../common/CustomPagination";
 import { getFacets, curieToSlug } from "./services/ontologyGridService";
-import { ONTOLOGY_PARAM } from "./config/gridConfig";
+import { termPath } from "./config/gridConfig";
 import { primeTermDataCache } from "../../hooks/useTermData";
 import { vars } from "../../theme/variables";
 
@@ -121,17 +121,16 @@ const OntologyGridPage = () => {
 
   // Tile click -> that cell's Cell Card (the tile's primary action, per the design).
   //
-  // Two things travel with the navigation. `?ontology=` is the context ontology, which is how the
-  // card knows which graph to resolve the term against. And the label is pushed into the term-data
-  // cache first: the term page would otherwise fetch `/{group}/npokb_998.jsonld`, which 404s for
-  // every Precision cell, and a cache hit skips the request entirely and titles the page at once.
+  // Two things travel with the navigation. The card is opened under this ontology's own path, which
+  // is how it knows which graph to resolve the term against. And the label is pushed into the
+  // term-data cache first: the term page would otherwise fetch `/{group}/npokb_998.jsonld`, which
+  // 404s for every Precision cell, and a cache hit skips the request entirely and titles the page
+  // at once.
   const openCellCard = useCallback(
     (cell) => {
       const slug = curieToSlug(cell.curie);
       primeTermDataCache(data.entry.org, slug, cell.label);
-      navigate(
-        `/${data.entry.org}/${slug}/cell-card?${ONTOLOGY_PARAM}=${encodeURIComponent(data.entry.slug)}`
-      );
+      navigate(termPath(data.entry.org, data.entry.slug, slug, "cell-card"));
     },
     [navigate, data]
   );
diff --git a/src/components/CellCards/OntologyHeader.jsx b/src/components/CellCards/OntologyHeader.jsx
index 0bfd844..a9a78c3 100644
--- a/src/components/CellCards/OntologyHeader.jsx
+++ b/src/components/CellCards/OntologyHeader.jsx
@@ -22,7 +22,6 @@ const OntologyHeader = ({ data, tab }) => {
       <BreadcrumbBar
         breadcrumbItems={[
           { label: "", href: "/", icon: HomeOutlinedIcon },
-          { label: "Search", href: "/" },
           { label: data.entry.community, href: `/${data.entry.org}` },
           { label: data.meta.title },
         ]}
diff --git a/src/components/CellCards/OntologyPage.jsx b/src/components/CellCards/OntologyPage.jsx
index 8eea910..eed2e07 100644
--- a/src/components/CellCards/OntologyPage.jsx
+++ b/src/components/CellCards/OntologyPage.jsx
@@ -15,7 +15,7 @@ const { gray500, gray600 } = vars;
 const OntologyPage = () => {
   const { slug } = useParams();
   const { pathname } = useLocation();
-  // Reading this ontology *is* the context, for terms later opened without `?ontology=`.
+  // Reading this ontology *is* the context, for terms later opened on a path that does not name one.
   usePublishContextOntology(slug);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState(null);
diff --git a/src/components/CellCards/config/gridConfig.ts b/src/components/CellCards/config/gridConfig.ts
index 91b70b0..4a8fe50 100644
--- a/src/components/CellCards/config/gridConfig.ts
+++ b/src/components/CellCards/config/gridConfig.ts
@@ -39,23 +39,33 @@ export const ONTOLOGY_CATALOG: Record<string, OntologyEntry> = {
   },
 };
 
+const ontologySegment = (slug: string): string => `/ontology/${slug}`;
+
 // Canonical route to an ontology tab, mirroring the breadcrumb hierarchy:
 // /[organization]/ontology/[ontology slug](/[tab]).
 export const ontologyPath = (entry: OntologyEntry, tab = ""): string =>
-  `/${entry.org}/ontology/${entry.slug}${tab ? `/${tab}` : ""}`;
+  `/${entry.org}${ontologySegment(entry.slug)}${tab ? `/${tab}` : ""}`;
+
+// Route to a term page. A term read inside an ontology hangs off that ontology's path, so the URL
+// carries the context the Cell Card resolves against — /[org]/ontology/[slug]/[term](/[tab]) — and
+// the breadcrumb can name the ontology the user came through. Without a context ontology it is the
+// plain /[group]/[term](/[tab]) an InterLex term has always had.
+export const termPath = (
+  group: string,
+  ontologySlug: string | null | undefined,
+  termSlug: string,
+  tab = ""
+): string =>
+  `/${group}${ontologySlug ? ontologySegment(ontologySlug) : ""}/${termSlug}${tab ? `/${tab}` : ""}`;
 
 // The single hardcoded search result until an ontology search backend exists.
 export const HARDCODED_RESULTS: OntologyEntry[] = [ONTOLOGY_CATALOG.precision];
 
-// Context ontology assumed when a Cell Card is opened without an `?ontology=` param (a shared
-// link, or a term reached from search rather than from the grid). With one entry in the
-// catalog this is unambiguous; it becomes a real lookup once there are several.
+// Context ontology assumed when a Cell Card is opened on a path that does not name one (a term
+// reached from search rather than from the grid). With one entry in the catalog this is
+// unambiguous; it becomes a real lookup once there are several.
 export const DEFAULT_ONTOLOGY_SLUG = "precision";
 
-// Query param carrying the context ontology across a term-page navigation. Distinct from
-// DataContext.activeOntology, which is the *edit* target shown as a chip in the header.
-export const ONTOLOGY_PARAM = "ontology";
-
 // Which catalogued ontology declares the prefix this term slug carries — i.e. the ontology a term
 // page can fall back to when nothing else names a context (a shared link, a search hit). Undefined
 // for a slug no ontology claims, which is the signal not to load one at all: the ~16MB file must
diff --git a/src/components/SingleTermView/index.jsx b/src/components/SingleTermView/index.jsx
index 1706568..04ba8c0 100644
--- a/src/components/SingleTermView/index.jsx
+++ b/src/components/SingleTermView/index.jsx
@@ -42,7 +42,13 @@ import DeleteOutlineOutlinedIcon from '@mui/icons-material/DeleteOutlineOutlined
 import CreateNewFolderOutlinedIcon from '@mui/icons-material/CreateNewFolderOutlined';
 import Discussion from "./Discussion";
 import CellCardPanel from "../CellCards/CellCard/CellCardPanel";
-import { ONTOLOGY_PARAM, isIlxTermSlug, ontologyForTermSlug } from "../CellCards/config/gridConfig";
+import {
+  ONTOLOGY_CATALOG,
+  isIlxTermSlug,
+  ontologyForTermSlug,
+  ontologyPath,
+  termPath,
+} from "../CellCards/config/gridConfig";
 import { useContextTerm } from "../../hooks/useContextOntology";
 import { CodeIcon } from "../../Icons";
 import CustomSingleSelect from "../common/CustomSingleSelect";
@@ -111,7 +117,7 @@ const OVERVIEW_TAB = 1;
 const isTabSelectable = (tab) => Boolean(tab) && !tab.disabled && !tab.hidden;
 
 const SingleTermView = () => {
-  const { group, term, tab, versionHash } = useParams();
+  const { group, term, tab, versionHash, ontologySlug } = useParams();
   const location = useLocation();
   const navigate = useNavigate();
   const [dataFormatAnchorEl, setDataFormatAnchorEl] = useState(null);
@@ -153,19 +159,20 @@ const SingleTermView = () => {
     return !!termId && ontologyTerms.some((id) => extractIlxId(id) === termId);
   }, [term, activeOntology]);
 
-  // Is this term a cell type, and therefore does the Cell Card tab apply? Answered from the URL
-  // alone — a catalogued ontology claims the slug's prefix, or `?ontology=` says the user came from
-  // a grid — because it decides the default tab, which cannot wait on a ~16MB load. Deliberately
-  // not the resolved `contextCell`: that lands later and would move the default tab under a user
-  // already reading one.
-  const contextOntology = new URLSearchParams(location.search).get(ONTOLOGY_PARAM);
+  // The ontology this term is being read inside: the one the path names
+  // (`/{org}/ontology/{slug}/{term}`, written by the grid), or — for a term reached from search —
+  // the catalogued ontology claiming the slug's prefix. Answered from the URL alone because it
+  // decides whether the Cell Card tab applies, and so the default tab, which cannot wait on a
+  // ~16MB load. Deliberately not the resolved `contextCell`: that lands later and would move the
+  // default tab under a user already reading one.
+  const contextEntry = useMemo(
+    () => ONTOLOGY_CATALOG[ontologySlug] || ONTOLOGY_CATALOG[ontologyForTermSlug(term)] || null,
+    [ontologySlug, term]
+  );
 
   const resolvedCellLabel = contextCell?.label || null;
 
-  const isCellTerm = useMemo(
-    () => Boolean(ontologyForTermSlug(term)) || Boolean(contextOntology),
-    [term, contextOntology]
-  );
+  const isCellTerm = Boolean(contextEntry);
 
   // The URL that names this term, which depends on what kind of term it is:
   //   - an `ilx_*` / `tmp_*` slug is an InterLex record, addressed by group
@@ -243,21 +250,40 @@ const SingleTermView = () => {
   }, [termData, resolvedCellLabel, storedSearchTerm, searchTerm]);
 
   // Memoize breadcrumb items to prevent unnecessary re-renders
-  const breadcrumbItems = useMemo(() => [
-    { label: '', href: '/', icon: HomeOutlinedIcon },
-    { label: 'Term search', href: `/${group}/search?searchTerm=${storedSearchTerm}` },
-    { label: group, href: '#' },
-    { label: displayedTermLabel },
-  ], [group, displayedTermLabel, storedSearchTerm]);
+  const breadcrumbItems = useMemo(() => {
+    // Read inside an ontology: retrace the trail the user arrived by, which is the chain the
+    // ontology's own pages show (OntologyHeader) with this term appended. The ontology crumb is
+    // built from the catalog entry, not from `group`, so a cell opened under another group still
+    // points at the one page that ontology has.
+    if (contextEntry) {
+      return [
+        { label: '', href: '/', icon: HomeOutlinedIcon },
+        { label: contextEntry.community, href: `/${contextEntry.org}` },
+        {
+          label: contextOntologyData?.meta?.title || contextEntry.label,
+          href: ontologyPath(contextEntry),
+        },
+        { label: displayedTermLabel },
+      ];
+    }
+    return [
+      { label: '', href: '/', icon: HomeOutlinedIcon },
+      { label: 'Term search', href: `/${group}/search?searchTerm=${storedSearchTerm}` },
+      { label: group, href: '#' },
+      { label: displayedTermLabel },
+    ];
+  }, [group, displayedTermLabel, storedSearchTerm, contextEntry, contextOntologyData]);
 
   // Optimize handlers with useCallback
   const handleChangeTabs = useCallback((event, newValue) => {
     setTabValue(newValue);
     const newTab = tabNames[newValue];
-    // Carry the query string across: the Cell Card's context ontology lives in `?ontology=`,
-    // and dropping it here would blank the card whenever the user came back to this tab.
-    navigate(`/${group}/${term}/${newTab}${location.search}`, { replace: true });
-  }, [navigate, group, term, tabNames, location.search]);
+    // A term read inside an ontology stays under that ontology's path, which is where the Cell Card
+    // reads its context from. Built from the resolved context rather than from the current path, so
+    // a term that arrived from search (context claimed by its prefix) names its ontology from here
+    // on and the link a user copies off the page carries it.
+    navigate(`${termPath(group, contextEntry?.slug, term, newTab)}${location.search}`, { replace: true });
+  }, [navigate, group, contextEntry, term, tabNames, location.search]);
 
   const handleForkDialogClose = useCallback(() => {
     setOpenForkDialog(false);
@@ -388,11 +414,11 @@ const SingleTermView = () => {
 
     // Rewrite the URL when it does not name the tab in view: no tab at all, or one that resolved
     // elsewhere. Skipped on the version route, which has no `tab` segment to write into.
-    // Preserves the query string for the same reason handleChangeTabs does.
+    // Keeps the ontology path and the query string for the same reason handleChangeTabs does.
     if (!versionHash && group && term && tab !== tabNames[newTabValue]) {
-      navigate(`/${group}/${term}/${tabNames[newTabValue]}${location.search}`, { replace: true });
+      navigate(`${termPath(group, contextEntry?.slug, term, tabNames[newTabValue])}${location.search}`, { replace: true });
     }
-  }, [tab, tabMapping, tabLabels, navigate, group, term, tabValue, versionHash, tabNames, DEFAULT_TAB_INDEX, location.search, isTermRecordPending]);
+  }, [tab, tabMapping, tabLabels, navigate, group, contextEntry, term, tabValue, versionHash, tabNames, DEFAULT_TAB_INDEX, location.search, isTermRecordPending]);
 
   const isItFork = actualGroup === 'base' ? false : true; // Use actualGroup instead of group
 
diff --git a/src/hooks/useContextOntology.js b/src/hooks/useContextOntology.js
index e397167..2ef5b90 100644
--- a/src/hooks/useContextOntology.js
+++ b/src/hooks/useContextOntology.js
@@ -1,9 +1,8 @@
 import { useEffect } from "react";
 import { atom, useAtom, useSetAtom } from "jotai";
-import { useLocation } from "react-router-dom";
+import { useParams } from "react-router-dom";
 import {
   ONTOLOGY_CATALOG,
-  ONTOLOGY_PARAM,
   ontologyForTermSlug,
 } from "../components/CellCards/config/gridConfig";
 import useCellTerm from "../components/CellCards/CellCard/useCellTerm";
@@ -27,16 +26,16 @@ export const usePublishContextOntology = (slug) => {
 };
 
 /**
- * Which ontology is in context for this term: `?ontology=` first, then the atom, then a catalogued
- * ontology claiming the slug's prefix. Null for an ordinary InterLex term, which must not load one.
+ * Which ontology is in context for this term: the `/ontology/{slug}/` the path was opened under
+ * first, then the atom, then a catalogued ontology claiming the slug's prefix. Null for an ordinary
+ * InterLex term, which must not load one.
  *
  * The URL wins and is read synchronously so a shared deep link resolves on its first render; the
  * sync is one-way (URL -> atom), leaving react-router the only writer of the URL.
  */
 export const useContextOntologySlug = (termSlug) => {
   const [stored, setStored] = useAtom(contextOntologyAtom);
-  const { search } = useLocation();
-  const fromUrl = new URLSearchParams(search).get(ONTOLOGY_PARAM);
+  const { ontologySlug: fromUrl } = useParams();
   const valid = fromUrl && ONTOLOGY_CATALOG[fromUrl] ? fromUrl : null;
 
   useEffect(() => {

From 83dc0329f7c49f77e07f58a863e8fd4908260823 Mon Sep 17 00:00:00 2001
From: Filippo Ledda <filippo@metacell.us>
Date: Fri, 7 Aug 2026 18:24:39 +0200
Subject: [PATCH 4/4] Configuration through mapping files

---
 CLAUDE.md                                     |   2 +-
 nginx/default.conf                            |  21 +-
 public/config/cell-card-mappings.json         | 194 ++++++++
 src/api/endpoints/apiService.ts               |   8 +-
 .../CellCards/CellCard/CellCard.jsx           |   5 +-
 .../CellCards/CellCard/DefinitionBanner.jsx   |  21 +-
 .../CellCards/CellCard/PropertyList.jsx       |   4 +-
 .../CellCards/CellCard/buildRelationGraph.js  |  22 +-
 .../CellCards/CellCard/buildRows.js           |  22 +-
 .../CellCards/CellCard/nervoSensusLink.js     |  28 +-
 .../CellCards/CellCard/widgetVisibility.js    |  23 +-
 .../CellCard/widgets/AnatomicalContext.jsx    |  12 +-
 .../CellCard/widgets/BiologicalProperties.jsx |  22 +-
 .../CellCard/widgets/CellGrouping.jsx         |   4 +-
 .../CellCard/widgets/OntologyHierarchy.jsx    |  17 +-
 .../CellCard/widgets/RelationshipGraph.jsx    |  30 +-
 .../widgets/TranscriptomicProfile.jsx         |  14 +-
 src/components/CellCards/CellTile.jsx         |  41 +-
 src/components/CellCards/CellTileGrid.jsx     |   4 +-
 .../CellCards/OntologyBrowsePage.jsx          |  92 +++-
 src/components/CellCards/OntologyGridPage.jsx |   6 +-
 .../CellCards/OntologyHierarchyPanel.jsx      |  60 ++-
 .../CellCards/OntologyHierarchyTree.jsx       |  80 ++-
 .../CellCards/OntologyTermsTable.jsx          |  88 ++--
 .../CellCards/config/cellCardConfig.ts        | 127 +----
 src/components/CellCards/config/gridConfig.ts |  70 +--
 .../CellCards/config/mappingDefaults.ts       | 277 +++++++++++
 .../CellCards/config/mappingsAtom.ts          |  36 ++
 .../CellCards/config/mappingsService.ts       | 463 ++++++++++++++++++
 src/components/CellCards/model/mappings.ts    | 209 ++++++++
 src/components/CellCards/model/types.ts       |   8 +-
 .../CellCards/services/ontologyGridService.ts | 186 ++++++-
 .../SingleTermView/OverView/OverView.jsx      |   4 +-
 src/components/SingleTermView/index.jsx       |  10 +-
 src/hooks/useContextOntology.js               |  18 +-
 src/parsers/__fixtures__/checkParser.mjs      |  43 ++
 src/parsers/neurdfParser.ts                   | 451 +++++++++--------
 src/parsers/ontologyTermAdapter.ts            |   9 +-
 vite.config.js                                |   7 +-
 39 files changed, 2115 insertions(+), 623 deletions(-)
 create mode 100644 public/config/cell-card-mappings.json
 create mode 100644 src/components/CellCards/config/mappingDefaults.ts
 create mode 100644 src/components/CellCards/config/mappingsAtom.ts
 create mode 100644 src/components/CellCards/config/mappingsService.ts
 create mode 100644 src/components/CellCards/model/mappings.ts

diff --git a/CLAUDE.md b/CLAUDE.md
index 4748832..f03f889 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -23,4 +23,4 @@ does *not* define (the ones that bite when you introduce a new component). The
 `check-figma-design` skill covers working from the Figma file.
 
 ## Coding best practices
-- Avoid redundant comments: make the code the source of truth with proper naming and functions refactorings. Only use comments to explain obscure cross-component patch code
\ No newline at end of file
+- Avoid redundant comments: make the code the source of truth with proper naming and functions refactorings. Only use comments about the why some code is written, not the what nor the how. Clean comments that do not comply at the end of each session.
\ No newline at end of file
diff --git a/nginx/default.conf b/nginx/default.conf
index ebe7bc3..e750fad 100644
--- a/nginx/default.conf
+++ b/nginx/default.conf
@@ -39,6 +39,21 @@ server {
         gzip_comp_level 5;
     }
 
+    # Runtime configuration (the Cell Cards mappings document). Its own location for the same two
+    # reasons `/data/` has one: it must 404 when absent rather than fall through to
+    # `try_files $uri /index.html` — the loader treats an HTML body as a failure, but a 404 says so
+    # much more clearly — and it must *not* be cached, since the point of fetching it at runtime is
+    # that an operator can edit the file in place and reload.
+    location ^~ /config/ {
+        root /usr/share/nginx/html/;
+        try_files $uri =404;
+
+        types { }
+        default_type application/json;
+
+        add_header Cache-Control "no-cache" always;
+    }
+
     # Proxy for Elasticsearch API requests
     location /api/elasticsearch {
         proxy_pass https://api.scicrunch.io/elastic/v1/Interlex_pr/_search;
@@ -277,7 +292,11 @@ server {
         return 200 '{"location":"$upstream_http_location"}';
     }
 
-    location /static/ {
+    # `^~` for the same reason `/data/` has it: the term-file regex below matches any
+    # `/{seg}/{prefix}_{id}.(html|ttl|jsonld|n3|owl|csv)`, which a dropped-in file like
+    # `user_guide.html` or `export_2026.csv` satisfies. Without the guard a plain prefix location
+    # loses to that regex and the file gets proxied upstream and 404s instead of serving locally.
+    location ^~ /static/ {
         autoindex on;
         alias /usr/share/nginx/html/static/;
     }
diff --git a/public/config/cell-card-mappings.json b/public/config/cell-card-mappings.json
new file mode 100644
index 0000000..6b95d32
--- /dev/null
+++ b/public/config/cell-card-mappings.json
@@ -0,0 +1,194 @@
+{
+  "$comment": "Cell Cards configuration — cellcard-spec/mappings.md §1 (grid tile) and §2 (cell card). Fetched at runtime by src/components/CellCards/config/mappingsService.ts, so editing this file next to the served bundle changes what the views read, with no rebuild. Two parts: `fields` binds each fixed field of the data model to the source that fills it, best first (a fallback chain); `regions` lists the additional fields each part of the UI puts on screen. `default` applies to every ontology, `ontologies.<slug>` overrides it for one, and any key may be omitted — the layer beneath shows through (built-in values live in config/mappingDefaults.ts).",
+  "version": 1,
+
+  "default": {
+    "fields": {
+      "$comment": "Model fields and where they read from. `title` and `description` are ordered fallback chains — spec §1.1: 'ilxtr:localLabel (if no localLabel, then rdfs:label)'. Source keys are matched against the graph exactly as written, because `definition`, `skos:definition` and `NIFRID:definition` are three different sources sharing one local name. Where the prefix is not yet settled, `{ \"sources\": [...], \"matchLocalName\": true }` matches the predicate's local name under any prefix.",
+
+      "title": ["ilxtr:localLabel", "rdfs:label", "dc:title", "dcterms:title"],
+      "description": [
+        "definition",
+        "skos:definition",
+        "NIFRID:definition",
+        "rdfs:comment",
+        "ilxtr:genLabel",
+        "ilxtr:curatorNote"
+      ],
+      "curatedDescriptionSources": 4,
+
+      "cellType": ["neurdf:Neuron"],
+      "parent": ["rdfs:subClassOf"],
+
+      "literatureCitation": ["ilxtr:literatureCitation"],
+      "dataCitation": ["ilxtr:dataCitation"],
+      "atlasAnnotation": ["ilxtr:atlasAnnotation"],
+      "curatorNote": ["ilxtr:curatorNote"],
+      "alertNote": ["ilxtr:alertNote"],
+      "temporaryId": ["ilxtr:hasTemporaryId"],
+      "generatedLabel": ["ilxtr:genLabel"],
+      "error": ["ilxtr:error"],
+
+      "sparcTranscriptomicsLink": {
+        "sources": ["ilx:hasSPARCTranscriptomicsLink"],
+        "matchLocalName": true
+      },
+      "sparcMap": { "sources": ["ilx:hasSPARCMap"], "matchLocalName": true },
+      "nervoSensusLink": { "sources": ["ilx:hasNervoSensusLink"], "matchLocalName": true },
+
+      "literalProperties": ["ilxtr:neurondmBaseClass"],
+
+      "crossNomenclature": {
+        "described": ["TEMP:assertedSubClassOf", "TEMP:subClassOf"],
+        "inferred": ["TEMP:mapsTo"],
+        "proposed": []
+      },
+
+      "predicateLabel": ["ilxtr:displayLabel"],
+      "predicateDescription": ["ilxtr:shortDefinition"],
+
+      "ontologyTitle": ["dc:title", "dcterms:title", "rdfs:label", "skos:prefLabel"],
+      "ontologyDescription": ["dc:description", "dcterms:description", "rdfs:comment"],
+      "ontologyVersion": ["owl:versionInfo"],
+
+      "missingValuePrefixes": ["TEMP:MISSING"]
+    },
+
+    "$predicatesComment": "Row labels come from the ontology's own ilxtr:displayLabel where it has one; these are the fallback, plus the tooltip text from pyontutils neuron_phenotype_edges.csv (displayDescription). ilxtr:literatureCitation is addressed as `source` below: the parser lifts citations onto CellTerm.sources.",
+    "predicates": {
+      "ilxtr:neurondmBaseClass": { "label": "Cell class" },
+      "ilxtr:hasInstanceInTaxon": {
+        "label": "Species",
+        "tooltip": "Species the cell type is observed in."
+      },
+      "ilxtr:hasSomaLocatedIn": {
+        "label": "Soma location",
+        "tooltip": "Anatomical location of the cell body (soma)."
+      },
+      "ilxtr:hasCircuitRolePhenotype": {
+        "label": "Circuit role",
+        "tooltip": "Excitatory / inhibitory circuit role."
+      },
+      "ilxtr:hasFunctionalPhenotype": {
+        "label": "Physiology",
+        "tooltip": "Functional / physiological properties."
+      },
+      "ilxtr:hasAxonPhenotype": { "label": "Axon type", "tooltip": "Axon fiber type." },
+      "ilxtr:hasAdaptationPhenotype": { "label": "Adaptation" },
+      "ilxtr:hasThresholdPhenotype": { "label": "Threshold" },
+      "ilxtr:hasNeurotransmitterPhenotype": {
+        "label": "Neurotransmitter",
+        "tooltip": "Neurotransmitters the cell type produces or releases."
+      },
+      "ilxtr:hasNucleicAcidExpressionPhenotype": {
+        "label": "Marker genes",
+        "tooltip": "Marker genes expressed by the cell type."
+      },
+      "ilxtr:hasBiologicalSex": { "label": "Sex" },
+      "ilxtr:hasMorphologicalPhenotype": { "label": "Morphology" },
+      "ilxtr:literatureCitation": {
+        "label": "Source",
+        "tooltip": "Source publication for the cell type."
+      }
+    },
+
+    "regions": {
+      "tile": {
+        "$comment": "§1.1 Grid Tile: header chips (left to right), then the property rows, then the source footer. A row with no value hides itself and the tile shrinks. `tone` picks the chip palette; `label` pins a row label for the tile only.",
+        "headerChips": [
+          { "predicate": "ilxtr:neurondmBaseClass", "tone": "class" },
+          { "predicate": "ilxtr:hasAxonPhenotype", "tone": "subtype" },
+          { "predicate": "ilxtr:hasInstanceInTaxon", "tone": "species" }
+        ],
+        "rows": [
+          { "predicate": "ilxtr:hasSomaLocatedIn", "render": "text" },
+          { "predicate": "ilxtr:hasNucleicAcidExpressionPhenotype", "render": "chip" },
+          { "predicate": "ilxtr:hasFunctionalPhenotype", "render": "chip" }
+        ],
+        "footer": { "predicate": "ilxtr:literatureCitation" }
+      },
+
+      "filters": {
+        "$comment": "§1.2 Grid Filter Bar. `minOptions` hides a facet offering fewer distinct values — one option cannot narrow anything. `displayed` lists what the \"Displayed properties\" toggle restricts the sidebar to; omitted, it is derived from the tile above so the two cannot drift apart.",
+        "minOptions": 2
+      },
+
+      "cellCard": {
+        "definition": {
+          "$comment": "§2.1 Auto-Generated Description: one predicate per sentence token. The banner is suppressed unless `minPredicates` of species/somaLocation/markerGenes are populated, so it never renders a sentence with holes in it.",
+          "cellClass": "ilxtr:neurondmBaseClass",
+          "species": "ilxtr:hasInstanceInTaxon",
+          "somaLocation": "ilxtr:hasSomaLocatedIn",
+          "markerGenes": "ilxtr:hasNucleicAcidExpressionPhenotype",
+          "minPredicates": 2
+        },
+
+        "biologicalProperties": {
+          "$comment": "§2.2, in the design's order (Figma 9535:96273). Every row is `required`, so the table keeps a fixed shape and an absent phenotype reads \"not specified\" rather than disappearing.",
+          "rows": [
+            { "predicate": "ilxtr:hasInstanceInTaxon", "required": true },
+            { "predicate": "ilxtr:hasSomaLocatedIn", "required": true },
+            { "predicate": "ilxtr:neurondmBaseClass", "required": true },
+            { "predicate": "ilxtr:hasCircuitRolePhenotype", "required": true },
+            { "predicate": "ilxtr:hasFunctionalPhenotype", "required": true },
+            { "predicate": "ilxtr:hasAxonPhenotype", "required": true },
+            { "predicate": "ilxtr:hasAdaptationPhenotype", "required": true },
+            { "predicate": "ilxtr:hasThresholdPhenotype", "required": true },
+            { "predicate": "ilxtr:hasNeurotransmitterPhenotype", "required": true },
+            {
+              "predicate": "ilxtr:hasNucleicAcidExpressionPhenotype",
+              "render": "chip",
+              "required": true
+            }
+          ]
+        },
+
+        "anatomicalContext": {
+          "$comment": "§2.3 (Figma 9239:67695). Soma location repeats from Biological Properties by design — it is the anchor for the anatomical reading.",
+          "rows": [
+            { "predicate": "ilxtr:hasSomaLocatedIn", "required": true },
+            { "predicate": "ilxtr:hasAxonSensorySubcellularElementIn", "required": true },
+            { "predicate": "ilxtr:hasAxonPresynapticElementIn", "required": true },
+            { "predicate": "ilxtr:hasCircuitRolePhenotype", "required": true }
+          ]
+        },
+
+        "relationshipGraph": {
+          "$comment": "§2.4. Only the predicates listed here are drawn — every phenotype would make the graph unreadable. `kind` selects the stroke and must be one of subClassOf | assertedSubClassOf | somaLocation | expresses; `direction` places the target relative to the current node. The two structural edges come from the hierarchy and the mapping table, so they carry a label rather than a predicate.",
+          "predicates": [
+            {
+              "predicate": "ilxtr:hasSomaLocatedIn",
+              "kind": "somaLocation",
+              "label": "soma location",
+              "direction": "left"
+            },
+            {
+              "predicate": "ilxtr:hasNucleicAcidExpressionPhenotype",
+              "kind": "expresses",
+              "label": "expresses",
+              "direction": "right"
+            }
+          ],
+          "legend": [
+            { "kind": "subClassOf", "label": "Sub class of" },
+            { "kind": "somaLocation", "label": "Soma location" },
+            { "kind": "assertedSubClassOf", "label": "Asserted Subclass of" },
+            { "kind": "expresses", "label": "expresses" }
+          ],
+          "subClassOfLabel": "subclass of",
+          "assertedSubClassOfLabel": "asserted subclass of"
+        },
+
+        "transcriptomicProfile": {
+          "$comment": "§2.5. The gene chips read the same predicate as the Biological Properties row rather than duplicating the list.",
+          "markerGenePredicate": "ilxtr:hasNucleicAcidExpressionPhenotype"
+        }
+      }
+    }
+  },
+
+  "ontologies": {
+    "$comment": "Per-ontology overrides, keyed by the catalogue slug in config/gridConfig.ts. Precision uses the defaults above unchanged.",
+    "precision": {}
+  }
+}
diff --git a/src/api/endpoints/apiService.ts b/src/api/endpoints/apiService.ts
index 5a431d2..8c3cc65 100644
--- a/src/api/endpoints/apiService.ts
+++ b/src/api/endpoints/apiService.ts
@@ -268,7 +268,13 @@ export const hasInterLexRecord = (slug: string, group: string = 'base'): Promise
     // so a term viewed under another group is still addressable through it.
     const probe = probeUriMapping(path)
       .then(found => (found || group === 'base' ? found : probeUriMapping(basePath)))
-      .catch(() => false);
+      .catch(() => {
+        // The probe itself failed (network error), not a confirmed "unmapped" answer from the
+        // backend — drop the cache entry so the next call retries instead of the tabs staying
+        // disabled for the rest of the session on a transient failure.
+        recordMappingCache.delete(key);
+        return false;
+      });
     recordMappingCache.set(key, probe);
   }
   return recordMappingCache.get(key) as Promise<boolean>;
diff --git a/src/components/CellCards/CellCard/CellCard.jsx b/src/components/CellCards/CellCard/CellCard.jsx
index 95b1b43..6a32623 100644
--- a/src/components/CellCards/CellCard/CellCard.jsx
+++ b/src/components/CellCards/CellCard/CellCard.jsx
@@ -13,6 +13,7 @@ import CrossNomenclature, { TITLE as MAPPING_TITLE } from "./widgets/CrossNomenc
 import SourcePublication, { TITLE as PUBLICATION_TITLE } from "./widgets/SourcePublication";
 import RelatedCells, { TITLE as RELATED_TITLE } from "./widgets/RelatedCells";
 import { relatedBySource, hierarchyNeighbours } from "../services/ontologyGridService";
+import { useMappings } from "../config/mappingsAtom";
 import {
   hasDefinition,
   hasTranscriptomicProfile,
@@ -38,6 +39,8 @@ const COLUMNS = { xs: "1fr", lg: "26.5rem minmax(0, 1fr) 26.5rem" };
 const CellCard = ({ cell, data, group, termSlug, discussionHref, onNavigateToCell, onNavigateToRef }) => {
   const neighbours = useMemo(() => hierarchyNeighbours(data, cell), [data, cell]);
   const related = useMemo(() => relatedBySource(data, cell), [data, cell]);
+  // Only for `hasDefinition`; every widget reads the same atom for itself.
+  const mappings = useMappings();
 
   // One comment affordance per widget, prefilled with that widget's name (design 9272:85572).
   const commentFor = (widgetTitle) => (
@@ -119,7 +122,7 @@ const CellCard = ({ cell, data, group, termSlug, discussionHref, onNavigateToCel
   return (
     <Container sx={{ py: 3 }}>
       <Stack gap={3}>
-        {hasDefinition(cell) && <DefinitionBanner cell={cell} />}
+        {hasDefinition(cell, mappings) && <DefinitionBanner cell={cell} />}
 
         <Box sx={{ display: "grid", gridTemplateColumns: COLUMNS, gap: 4, alignItems: "start" }}>
           <Stack gap={4} sx={{ minWidth: 0 }}>
diff --git a/src/components/CellCards/CellCard/DefinitionBanner.jsx b/src/components/CellCards/CellCard/DefinitionBanner.jsx
index e110668..764bfad 100644
--- a/src/components/CellCards/CellCard/DefinitionBanner.jsx
+++ b/src/components/CellCards/CellCard/DefinitionBanner.jsx
@@ -3,6 +3,7 @@ import PropTypes from "prop-types";
 import { Alert, AlertTitle, Typography, Link } from "@mui/material";
 import TermValueLink from "./TermValueLink";
 import { toDoi } from "./citationService";
+import { useMappings } from "../config/mappingsAtom";
 
 const joinRefs = (values, conjunction = "and") =>
   values.map((v, i) => (
@@ -20,14 +21,20 @@ const joinRefs = (values, conjunction = "and") =>
  * `rdfs:comment`. (The parser's `definition` therefore always falls through to
  * `ilxtr:genLabel`, a ~300-character machine string — usable as a tooltip, not as prose.)
  *
- * Suppressed when fewer than two of species / soma location / marker genes are populated, so it
- * never renders a sentence with holes in it.
+ * Suppressed when too few of its tokens are populated (see `hasDefinition`), so it never renders a
+ * sentence with holes in it.
+ *
+ * The sentence's shape is fixed; which predicate fills each token is the `definition` region of the
+ * mappings document (spec §2.1).
  */
 const DefinitionBanner = ({ cell }) => {
-  const taxon = cell.properties.hasInstanceInTaxon?.values || [];
-  const soma = cell.properties.hasSomaLocatedIn?.values || [];
-  const genes = cell.properties.hasNucleicAcidExpressionPhenotype?.values || [];
-  const baseClass = cell.properties.neurondmBaseClass?.values?.[0];
+  const config = useMappings().regions.cellCard.definition;
+  const valuesOf = (localName) => (localName && cell.properties[localName]?.values) || [];
+  const taxon = valuesOf(config.species);
+  const somaProperty = config.somaLocation ? cell.properties[config.somaLocation] : undefined;
+  const soma = somaProperty?.values || [];
+  const genes = valuesOf(config.markerGenes);
+  const baseClass = valuesOf(config.cellClass)[0];
   const source = cell.sources?.[0];
   const doi = toDoi(source?.iri || source?.id);
 
@@ -41,7 +48,7 @@ const DefinitionBanner = ({ cell }) => {
         {soma.length > 0 && (
           <>
             {" "}
-            is located in {joinRefs(soma, cell.properties.hasSomaLocatedIn?.combinator === "or" ? "or" : "and")}
+            is located in {joinRefs(soma, somaProperty?.combinator === "or" ? "or" : "and")}
           </>
         )}
         {genes.length > 0 && <> and expresses {joinRefs(genes)}</>}
diff --git a/src/components/CellCards/CellCard/PropertyList.jsx b/src/components/CellCards/CellCard/PropertyList.jsx
index 3ed4b3c..9a70083 100644
--- a/src/components/CellCards/CellCard/PropertyList.jsx
+++ b/src/components/CellCards/CellCard/PropertyList.jsx
@@ -78,8 +78,8 @@ PropertyRow.propTypes = {
 };
 
 /**
- * A divider-separated run of property rows. Rows are built by the calling widget from
- * `cellCardConfig`, so order and membership are config, not JSX.
+ * A divider-separated run of property rows. Rows are built by the calling widget from its region
+ * of the mappings document, so order and membership are configuration, not JSX.
  */
 const PropertyList = ({ rows }) => {
   const visible = rows.filter((r) => r.required || r.prop?.values?.length);
diff --git a/src/components/CellCards/CellCard/buildRelationGraph.js b/src/components/CellCards/CellCard/buildRelationGraph.js
index f231b7f..56e029d 100644
--- a/src/components/CellCards/CellCard/buildRelationGraph.js
+++ b/src/components/CellCards/CellCard/buildRelationGraph.js
@@ -1,8 +1,4 @@
-import {
-  RELATION_PREDICATES,
-  SUBCLASS_EDGE_LABEL,
-  ASSERTED_SUBCLASS_EDGE_LABEL,
-} from "../config/cellCardConfig";
+import { DEFAULT_MAPPINGS } from "../config/mappingDefaults";
 
 // A cell label carries its provenance as a trailing parenthetical — "DRG PEP3.2 (Krauter2025)".
 // The graph node shows the id and that provenance on its own line, so strip it from the title.
@@ -37,14 +33,16 @@ const refNode = (ref) => ({
  * asserted-subclass mappings fanned out below, and two lateral satellites — soma location to the
  * left and gene expression to the right.
  *
- * Which phenotype predicates may appear is `RELATION_PREDICATES` in cellCardConfig, not a
- * hardcoded list here: Fahim asked for this explicitly, because drawing every phenotype would
+ * Which phenotype predicates may appear is the mappings document's `relationshipGraph` region, not
+ * a hardcoded list here: Fahim asked for this explicitly, because drawing every phenotype would
  * make the graph unreadable.
  *
  * @param {object} cell      the CellTerm at the centre
  * @param {object} neighbours { parents, children } from hierarchyNeighbours
+ * @param {object} mappings  the loaded ontology's mappings
  */
-export const buildRelationGraph = (cell, neighbours = {}) => {
+export const buildRelationGraph = (cell, neighbours = {}, mappings = DEFAULT_MAPPINGS) => {
+  const config = mappings.regions.cellCard.relationshipGraph;
   const nodes = [cellNode(cell, true)];
   const edges = [];
   const seen = new Set([cell.id]);
@@ -64,7 +62,7 @@ export const buildRelationGraph = (cell, neighbours = {}) => {
         from: parent.id,
         to: cell.id,
         kind: "subClassOf",
-        label: SUBCLASS_EDGE_LABEL,
+        label: config.subClassOfLabel,
       });
     }
   }
@@ -84,7 +82,7 @@ export const buildRelationGraph = (cell, neighbours = {}) => {
         from: cell.id,
         to: mapping.ref.id,
         kind: "assertedSubClassOf",
-        label: ASSERTED_SUBCLASS_EDGE_LABEL,
+        label: config.assertedSubClassOfLabel,
       });
     }
   }
@@ -96,14 +94,14 @@ export const buildRelationGraph = (cell, neighbours = {}) => {
         from: cell.id,
         to: child.id,
         kind: "subClassOf",
-        label: SUBCLASS_EDGE_LABEL,
+        label: config.subClassOfLabel,
       });
     }
   }
 
   // Lateral phenotype satellites. Several values collapse into one node ("SCGN, ADRA2C" in the
   // design) so the graph shows the relation rather than one node per gene.
-  for (const predicate of RELATION_PREDICATES) {
+  for (const predicate of config.predicates) {
     const values = cell.properties[predicate.localName]?.values || [];
     if (!values.length) continue;
     const id = `${cell.id}::${predicate.localName}`;
diff --git a/src/components/CellCards/CellCard/buildRows.js b/src/components/CellCards/CellCard/buildRows.js
index 7e1fd8c..043d3ee 100644
--- a/src/components/CellCards/CellCard/buildRows.js
+++ b/src/components/CellCards/CellCard/buildRows.js
@@ -1,24 +1,26 @@
-import { labelFor, PREDICATE_TOOLTIPS } from "../config/gridConfig";
+import { DEFAULT_MAPPINGS, predicateLabel, predicateTooltip } from "../config/mappingDefaults";
 
 /**
- * Turn `cellCardConfig` rows + a cell into the row models PropertyList renders.
+ * Turn a region's configured rows + a cell into the row models PropertyList renders.
  *
  * Labels and tooltips prefer the ontology's own `ilxtr:displayLabel` / `ilxtr:shortDefinition`
- * (14 of the 15 predicates Precision cells use ship both), falling back to gridConfig's
- * hardcoded maps. That keeps the wording in the curators' hands: changing a displayLabel in the
- * ontology changes the Cell Card, with no front-end edit.
+ * (14 of the 15 predicates Precision cells use ship both), falling back to the mappings document's
+ * `predicates` section. That keeps the wording in the curators' hands: changing a displayLabel in
+ * the ontology changes the Cell Card, with no front-end edit. A row that pins its own `label`
+ * outranks both — that is the region saying it wants different wording here.
  *
- * @param {Array} rows            entries from cellCardConfig (localName, render, required)
+ * @param {Array} rows            the region's rows (localName, render, required, label)
  * @param {object} cell           the CellTerm
  * @param {object} display        predicateDisplay from the parse, keyed by local name
+ * @param {object} mappings       the loaded ontology's mappings
  */
-export const buildRows = (rows, cell, display = {}) =>
-  rows.map(({ localName, render, required }) => {
+export const buildRows = (rows, cell, display = {}, mappings = DEFAULT_MAPPINGS) =>
+  rows.map(({ localName, render, required, label }) => {
     const meta = display[localName];
     return {
       localName,
-      label: meta?.label || labelFor(localName),
-      tooltip: meta?.description || PREDICATE_TOOLTIPS[localName],
+      label: label || meta?.label || predicateLabel(mappings, localName),
+      tooltip: meta?.description || predicateTooltip(mappings, localName),
       prop: cell.properties[localName],
       render,
       required,
diff --git a/src/components/CellCards/CellCard/nervoSensusLink.js b/src/components/CellCards/CellCard/nervoSensusLink.js
index f4d8665..b3e85df 100644
--- a/src/components/CellCards/CellCard/nervoSensusLink.js
+++ b/src/components/CellCards/CellCard/nervoSensusLink.js
@@ -3,8 +3,8 @@ import {
   NERVOSENSUS_SPECIES,
   NERVOSENSUS_SOMA,
   NERVOSENSUS_AXON,
-  MARKER_GENE_PREDICATE,
 } from "../config/cellCardConfig";
+import { DEFAULT_MAPPINGS } from "../config/mappingDefaults";
 
 /**
  * Build the NervoSensus deep link for a cell.
@@ -50,12 +50,14 @@ export const atlasCellKey = (cell) => {
 };
 
 /**
+ * @param {object} cell      the CellTerm
+ * @param {object} mappings  the loaded ontology's mappings (species/soma/axon/gene predicates)
  * @returns {{ href: string, precise: boolean, filters: string[] }}
  *   href     where the tile points
  *   precise  true when the link opens this exact cell rather than a filtered list
  *   filters  human-readable names of the filters applied, for the widget's caption
  */
-export const buildNervoSensusLink = (cell) => {
+export const buildNervoSensusLink = (cell, mappings = DEFAULT_MAPPINGS) => {
   // A curator-supplied per-cell link wins outright — it is more specific than anything we infer.
   // (`hasNervoSensusLink` has zero occurrences upstream today; this is the forward-compatible path.)
   const curated = cell?.annotations?.nervoSensusLinks?.[0];
@@ -75,25 +77,35 @@ export const buildNervoSensusLink = (cell) => {
   const atlas = atlasCellKey(cell);
   if (atlas) url.searchParams.set("atlasannotation", atlas);
 
-  const species = matchLabel(firstValue(cell, "hasInstanceInTaxon")?.label, NERVOSENSUS_SPECIES);
+  // Species and soma location read the same bindings the auto-generated description uses
+  // (`regions.cellCard.definition`): both features mean the same predicate, so repointing one
+  // for an ontology whose cells carry it under a different name keeps the two in agreement rather
+  // than requiring the operator to update two independent settings to stay in sync.
+  const { species: speciesPredicate, somaLocation: somaPredicate } = mappings.regions.cellCard.definition;
+  const { axonPredicate } = mappings.regions.cellCard.cellGrouping;
+
+  const speciesValue = firstValue(cell, speciesPredicate);
+  const species = matchLabel(speciesValue?.label, NERVOSENSUS_SPECIES);
   if (species) {
     url.searchParams.set("species", species);
     filters.push(species);
   }
 
-  const soma = matchLabel(firstValue(cell, "hasSomaLocatedIn")?.label, NERVOSENSUS_SOMA);
+  const somaValue = firstValue(cell, somaPredicate);
+  const soma = matchLabel(somaValue?.label, NERVOSENSUS_SOMA);
   if (soma) {
     url.searchParams.set("location", soma);
-    filters.push(firstValue(cell, "hasSomaLocatedIn").label);
+    filters.push(somaValue.label);
   }
 
-  const axon = matchLabel(firstValue(cell, "hasAxonPhenotype")?.label, NERVOSENSUS_AXON);
+  const axonValue = firstValue(cell, axonPredicate);
+  const axon = matchLabel(axonValue?.label, NERVOSENSUS_AXON);
   if (axon) {
     url.searchParams.set("axon", axon);
-    filters.push(firstValue(cell, "hasAxonPhenotype").label);
+    filters.push(axonValue.label);
   }
 
-  const gene = firstValue(cell, MARKER_GENE_PREDICATE);
+  const gene = firstValue(cell, mappings.regions.cellCard.transcriptomicProfile.markerGenePredicate);
   // Only a resolved symbol is useful; an unlabelled gene falls back to its CURIE
   // ("NCBIGene:667742"), which the app's gene filter has no option for.
   if (gene && gene.label && !gene.label.includes(":")) {
diff --git a/src/components/CellCards/CellCard/widgetVisibility.js b/src/components/CellCards/CellCard/widgetVisibility.js
index aeaeea8..d53b054 100644
--- a/src/components/CellCards/CellCard/widgetVisibility.js
+++ b/src/components/CellCards/CellCard/widgetVisibility.js
@@ -9,16 +9,21 @@
  * context image, which the design gives an explicit "not available" state.
  */
 
-// Species / soma location / marker genes. The auto-description needs at least two of these to
-// read as a sentence rather than a fragment (spec §6).
-const DESCRIPTION_PREDICATES = [
-  "hasInstanceInTaxon",
-  "hasSomaLocatedIn",
-  "hasNucleicAcidExpressionPhenotype",
-];
+import { DEFAULT_MAPPINGS } from "../config/mappingDefaults";
 
-export const hasDefinition = (cell) =>
-  DESCRIPTION_PREDICATES.filter((n) => cell.properties[n]?.values?.length).length >= 2;
+// Species / soma location / marker genes by default. The auto-description needs at least two of
+// them to read as a sentence rather than a fragment (spec §6) — the bindings and the minimum are
+// both the `definition` region of the mappings document, so an ontology whose cells are described
+// by other predicates still gets a banner. Counted straight off the same three bindings
+// `DefinitionBanner` reads (not a separately configured list), so the two cannot drift apart:
+// `cellClass` is excluded because its clause always falls back to "cell" and is never a hole.
+export const hasDefinition = (cell, mappings = DEFAULT_MAPPINGS) => {
+  const { species, somaLocation, markerGenes, minPredicates } = mappings.regions.cellCard.definition;
+  const populated = [species, somaLocation, markerGenes].filter(
+    (localName) => localName && cell.properties[localName]?.values?.length
+  ).length;
+  return populated >= minPredicates;
+};
 
 // Either the SPARC deep link or the atlas annotation pills. The link's triple does not exist in
 // the shipped ontology, so in practice this is the atlas-pill branch (54 of 161 cells).
diff --git a/src/components/CellCards/CellCard/widgets/AnatomicalContext.jsx b/src/components/CellCards/CellCard/widgets/AnatomicalContext.jsx
index 126e59d..3cecec2 100644
--- a/src/components/CellCards/CellCard/widgets/AnatomicalContext.jsx
+++ b/src/components/CellCards/CellCard/widgets/AnatomicalContext.jsx
@@ -5,7 +5,7 @@ import CellCardWidget from "../CellCardWidget";
 import PropertyList, { PropertyRow } from "../PropertyList";
 import EmptyState from "../../../common/EmptyState";
 import { buildRows } from "../buildRows";
-import { ANATOMICAL_CONTEXT_ROWS } from "../../config/cellCardConfig";
+import { useMappings } from "../../config/mappingsAtom";
 
 export const TITLE = "Anatomical & Circuit Context";
 
@@ -24,6 +24,7 @@ export const TITLE = "Anatomical & Circuit Context";
  *   occurrences, so a drawn diagram would be decorative rather than data-bearing.
  */
 const AnatomicalContext = ({ cell, predicateDisplay, actions }) => {
+  const mappings = useMappings();
   // hasSPARCMap is a deep link, so the parser routes it to `annotations` rather than treating it
   // as a phenotype. Shaped into a CellProperty here so PropertyRow renders it like any other row.
   const sparcMaps = cell.annotations?.sparcMaps || [];
@@ -33,7 +34,14 @@ const AnatomicalContext = ({ cell, predicateDisplay, actions }) => {
 
   return (
     <CellCardWidget title={TITLE} actions={actions}>
-      <PropertyList rows={buildRows(ANATOMICAL_CONTEXT_ROWS, cell, predicateDisplay)} />
+      <PropertyList
+        rows={buildRows(
+          mappings.regions.cellCard.anatomicalContext.rows,
+          cell,
+          predicateDisplay,
+          mappings
+        )}
+      />
 
       {sparcMap ? (
         <Stack divider={<Divider />} gap={1}>
diff --git a/src/components/CellCards/CellCard/widgets/BiologicalProperties.jsx b/src/components/CellCards/CellCard/widgets/BiologicalProperties.jsx
index defbc7d..91a9047 100644
--- a/src/components/CellCards/CellCard/widgets/BiologicalProperties.jsx
+++ b/src/components/CellCards/CellCard/widgets/BiologicalProperties.jsx
@@ -2,7 +2,7 @@ import PropTypes from "prop-types";
 import CellCardWidget from "../CellCardWidget";
 import PropertyList from "../PropertyList";
 import { buildRows } from "../buildRows";
-import { BIOLOGICAL_PROPERTY_ROWS } from "../../config/cellCardConfig";
+import { useMappings } from "../../config/mappingsAtom";
 
 export const TITLE = "Biological Properties";
 
@@ -20,11 +20,21 @@ export const TITLE = "Biological Properties";
  * populated it will arrive as a *separate predicate*, not a qualifier on a value, so the chip
  * needs a design revision rather than just data.
  */
-const BiologicalProperties = ({ cell, predicateDisplay, actions }) => (
-  <CellCardWidget title={TITLE} actions={actions}>
-    <PropertyList rows={buildRows(BIOLOGICAL_PROPERTY_ROWS, cell, predicateDisplay)} />
-  </CellCardWidget>
-);
+const BiologicalProperties = ({ cell, predicateDisplay, actions }) => {
+  const mappings = useMappings();
+  return (
+    <CellCardWidget title={TITLE} actions={actions}>
+      <PropertyList
+        rows={buildRows(
+          mappings.regions.cellCard.biologicalProperties.rows,
+          cell,
+          predicateDisplay,
+          mappings
+        )}
+      />
+    </CellCardWidget>
+  );
+};
 
 BiologicalProperties.propTypes = {
   cell: PropTypes.object.isRequired,
diff --git a/src/components/CellCards/CellCard/widgets/CellGrouping.jsx b/src/components/CellCards/CellCard/widgets/CellGrouping.jsx
index 9634a6b..f1b0b32 100644
--- a/src/components/CellCards/CellCard/widgets/CellGrouping.jsx
+++ b/src/components/CellCards/CellCard/widgets/CellGrouping.jsx
@@ -5,6 +5,7 @@ import { ArrowOutwardIcon } from "../../../../Icons";
 import CellCardWidget from "../CellCardWidget";
 import { buildNervoSensusLink } from "../nervoSensusLink";
 import { NERVOSENSUS_VIEWS } from "../../config/cellCardConfig";
+import { useMappings } from "../../config/mappingsAtom";
 
 export const TITLE = "Interactive Cell Grouping";
 
@@ -36,7 +37,8 @@ const withParams = (href, params) => {
  * from the cell.
  */
 const CellGrouping = ({ cell, actions }) => {
-  const { href, precise, filters } = buildNervoSensusLink(cell);
+  const mappings = useMappings();
+  const { href, precise, filters } = buildNervoSensusLink(cell, mappings);
 
   return (
     <CellCardWidget title={TITLE} actions={actions}>
diff --git a/src/components/CellCards/CellCard/widgets/OntologyHierarchy.jsx b/src/components/CellCards/CellCard/widgets/OntologyHierarchy.jsx
index e6ab756..5b06fc6 100644
--- a/src/components/CellCards/CellCard/widgets/OntologyHierarchy.jsx
+++ b/src/components/CellCards/CellCard/widgets/OntologyHierarchy.jsx
@@ -147,19 +147,6 @@ const OntologyHierarchy = ({ cell, hierarchy, rootLabel, onNavigate, actions })
   }, [mode, query, items, anchorPath]);
   const expandedItems = expanded ?? defaultExpanded;
 
-  // Every position of the term the page is on: a class with several parents (17 of them here) is
-  // highlighted wherever it appears, the same rule the tree's `isCurrent` styling follows.
-  const selectedItems = useMemo(() => {
-    const ids = [];
-    const walk = (nodes) =>
-      nodes.forEach((n) => {
-        if (n.termId === cell.id) ids.push(n.id);
-        walk(n.children || []);
-      });
-    walk(items);
-    return ids;
-  }, [items, cell.id]);
-
   // Scrolls the highlighted row into view inside the tree's own box. `block: "nearest"` keeps the
   // scroll inside that box while the widget itself is on screen.
   const reveal = useCallback(() => {
@@ -275,10 +262,10 @@ const OntologyHierarchy = ({ cell, hierarchy, rootLabel, onNavigate, actions })
           <Box ref={treeBoxRef} sx={{ maxHeight: "24rem", overflow: "auto" }}>
             <OntologyHierarchyTree
               items={items}
-              currentTermId={cell.id}
               expandedItems={expandedItems}
               onExpandedItemsChange={(_e, ids) => setExpanded(ids)}
-              selectedItems={selectedItems}
+              anchorTermId={cell.id}
+              anchorIsCurrent
               onSelectTerm={handleSelectTerm}
             />
           </Box>
diff --git a/src/components/CellCards/CellCard/widgets/RelationshipGraph.jsx b/src/components/CellCards/CellCard/widgets/RelationshipGraph.jsx
index a983a79..9f44620 100644
--- a/src/components/CellCards/CellCard/widgets/RelationshipGraph.jsx
+++ b/src/components/CellCards/CellCard/widgets/RelationshipGraph.jsx
@@ -21,7 +21,8 @@ import RelationshipGraphSvg from "../RelationshipGraphSvg";
 import EmptyState from "../../../common/EmptyState";
 import { CloseIcon } from "../../../../Icons";
 import buildRelationGraph from "../buildRelationGraph";
-import { RELATION_LEGEND, FLAGGED_FOOTNOTE } from "../../config/cellCardConfig";
+import { FLAGGED_FOOTNOTE } from "../../config/cellCardConfig";
+import { useMappings } from "../../config/mappingsAtom";
 
 export const TITLE = "Relationship Graph";
 
@@ -57,10 +58,10 @@ LegendSwatch.propTypes = { kind: PropTypes.string.isRequired };
 // `hasFlagged` gates the footnote: nothing in the shipped graph produces "proposed" evidence, so
 // an unconditional footnote explains a marker no node can carry. Same rule as CrossNomenclature,
 // which describes the same asterisk.
-const Legend = ({ hasFlagged }) => (
+const Legend = ({ rows, hasFlagged }) => (
   <Stack gap={0.5}>
     <Stack direction="row" flexWrap="wrap" gap={2}>
-      {RELATION_LEGEND.map(({ kind, label }) => (
+      {rows.map(({ kind, label }) => (
         <Stack key={kind} direction="row" alignItems="center" gap={0.75}>
           <LegendSwatch kind={kind} />
           <Typography variant="caption" sx={{ color: "text.secondary" }}>
@@ -77,7 +78,7 @@ const Legend = ({ hasFlagged }) => (
   </Stack>
 );
 
-Legend.propTypes = { hasFlagged: PropTypes.bool };
+Legend.propTypes = { rows: PropTypes.array.isRequired, hasFlagged: PropTypes.bool };
 
 /**
  * §4.1 Relationship Graph (Figma 9478:72004 inline, 8917:35906 expanded).
@@ -88,8 +89,13 @@ Legend.propTypes = { hasFlagged: PropTypes.bool };
  * widget needs two (inline and in the dialog). The Overview tab's graphs are left untouched.
  */
 const RelationshipGraph = ({ cell, neighbours, onNavigate, actions }) => {
+  const mappings = useMappings();
   const [expanded, setExpanded] = useState(false);
-  const graph = useMemo(() => buildRelationGraph(cell, neighbours), [cell, neighbours]);
+  const graph = useMemo(
+    () => buildRelationGraph(cell, neighbours, mappings),
+    [cell, neighbours, mappings]
+  );
+  const legend = mappings.regions.cellCard.relationshipGraph.legend;
 
   // One node is always the cell itself; fewer than two means there is nothing to relate.
   const hasRelations = graph.nodes.length > 1;
@@ -128,7 +134,7 @@ const RelationshipGraph = ({ cell, neighbours, onNavigate, actions }) => {
               <Typography variant="body2">Legend</Typography>
             </AccordionSummary>
             <AccordionDetails>
-              <Legend hasFlagged={hasFlagged} />
+              <Legend rows={legend} hasFlagged={hasFlagged} />
             </AccordionDetails>
           </Accordion>
         </Paper>
@@ -136,17 +142,19 @@ const RelationshipGraph = ({ cell, neighbours, onNavigate, actions }) => {
         <EmptyState message="No related terms in this ontology." />
       )}
 
-      <Dialog open={expanded} onClose={() => setExpanded(false)} maxWidth="lg" fullWidth>
+      <Dialog open={expanded} onClose={() => setExpanded(false)} fullScreen>
         <DialogTitle sx={{ display: "flex", alignItems: "center", gap: 1 }}>
           <IconButton onClick={() => setExpanded(false)} aria-label="Close" sx={{ ml: -1 }}>
             <CloseIcon />
           </IconButton>
           {TITLE}
         </DialogTitle>
-        <DialogContent>
-          <Stack gap={2}>
-            <RelationshipGraphSvg graph={graph} onSelect={handleSelect} />
-            <Legend hasFlagged={hasFlagged} />
+        <DialogContent sx={{ display: "flex", flexDirection: "column", minHeight: 0 }}>
+          <Stack gap={2} sx={{ flex: 1, minHeight: 0 }}>
+            <Box sx={{ flex: 1, minHeight: 0 }}>
+              <RelationshipGraphSvg graph={graph} onSelect={handleSelect} height="100%" />
+            </Box>
+            <Legend rows={legend} hasFlagged={hasFlagged} />
           </Stack>
         </DialogContent>
       </Dialog>
diff --git a/src/components/CellCards/CellCard/widgets/TranscriptomicProfile.jsx b/src/components/CellCards/CellCard/widgets/TranscriptomicProfile.jsx
index 35926f0..9f476f2 100644
--- a/src/components/CellCards/CellCard/widgets/TranscriptomicProfile.jsx
+++ b/src/components/CellCards/CellCard/widgets/TranscriptomicProfile.jsx
@@ -2,10 +2,7 @@ import PropTypes from "prop-types";
 import { Typography, Chip, Divider, Box, Alert, Link } from "@mui/material";
 import { ArrowOutwardIcon } from "../../../../Icons";
 import CellCardWidget from "../CellCardWidget";
-import {
-  MARKER_GENE_PREDICATE,
-  SPARC_TRANSCRIPTOMICS_PREDICATE,
-} from "../../config/cellCardConfig";
+import { useMappings } from "../../config/mappingsAtom";
 
 export const TITLE = "Transcriptomic profile";
 
@@ -25,9 +22,14 @@ export const TITLE = "Transcriptomic profile";
  * when the triple is added" note is worth showing — it is guidance for curators, not for readers.
  */
 const TranscriptomicProfile = ({ cell, actions }) => {
+  const mappings = useMappings();
   const sparcLink = cell.annotations?.sparcTranscriptomicsLinks?.[0];
   const atlas = cell.annotations?.atlasAnnotation || [];
-  const genes = cell.properties[MARKER_GENE_PREDICATE]?.values || [];
+  const { markerGenePredicate } = mappings.regions.cellCard.transcriptomicProfile;
+  // Named from the field binding itself, so the note tells a curator the predicate the app is
+  // actually watching rather than a constant that could drift from it.
+  const [sparcPredicate] = mappings.fields.sparcTranscriptomicsLink.sources;
+  const genes = cell.properties[markerGenePredicate]?.values || [];
 
   return (
     <CellCardWidget title={TITLE} actions={actions}>
@@ -74,7 +76,7 @@ const TranscriptomicProfile = ({ cell, actions }) => {
           {/* Guidance for curators, in one sentence: emphasising the predicate name would mean
               typography at the call site, which the theme owns. */}
           <Typography variant="caption" sx={{ color: "text.disabled" }}>
-            {`SPARC Portal link appears when ${SPARC_TRANSCRIPTOMICS_PREDICATE} is added.`}
+            {`SPARC Portal link appears when ${sparcPredicate} is added.`}
           </Typography>
         </>
       )}
diff --git a/src/components/CellCards/CellTile.jsx b/src/components/CellCards/CellTile.jsx
index f4b753b..5e707a3 100644
--- a/src/components/CellCards/CellTile.jsx
+++ b/src/components/CellCards/CellTile.jsx
@@ -2,7 +2,9 @@ import PropTypes from "prop-types";
 import { Box, Card, CardContent, Checkbox, Typography, Chip, Divider, Link } from "@mui/material";
 import { ArrowOutwardIcon, CheckboxDefault, CheckboxSelected } from "../../Icons";
 import { vars } from "../../theme/variables";
-import { TILE_HEADER_CHIPS, TILE_ROWS, labelFor, termLink } from "./config/gridConfig";
+import { termLink } from "./config/gridConfig";
+import { predicateLabel } from "./config/mappingDefaults";
+import { useMappings } from "./config/mappingsAtom";
 
 const { gray500, gray700, gray800, brand700 } = vars;
 
@@ -47,8 +49,18 @@ const CHECKBOX_SX = { p: 1, mt: -0.5, mr: -0.5 };
 // A cell record as a grid tile: header (title/id/chips + select checkbox) → property rows → source
 // footer. Apart from the checkbox and the source links, the tile interior is not clickable; the
 // whole tile navigates (handled by the grid).
-const CellTile = ({ cell, selected = false, onToggleSelect }) => {
-  const headerChips = TILE_HEADER_CHIPS.flatMap(({ localName, tone }) => {
+//
+// Which chips, which rows and which footer is `mappings.regions.tile`, fetched at runtime — spec
+// §1.1: "the organization can choose which header elements and property rows to display".
+const CellTile = ({ cell, predicateDisplay = {}, selected = false, onToggleSelect }) => {
+  const mappings = useMappings();
+  const { headerChips: chipConfig, rows: rowConfig, footer } = mappings.regions.tile;
+  // The ontology's own `ilxtr:displayLabel` outranks the mappings document's label, same
+  // precedence buildRows.js gives the Cell Card's rows — a curator's edit renames the predicate
+  // here too, not just on the card.
+  const labelFor = (localName) => predicateDisplay[localName]?.label || predicateLabel(mappings, localName);
+
+  const headerChips = chipConfig.flatMap(({ localName, tone }) => {
     const prop = cell.properties[localName];
     if (!prop) return [];
     return prop.values.map((v) => (
@@ -56,14 +68,16 @@ const CellTile = ({ cell, selected = false, onToggleSelect }) => {
     ));
   });
 
-  const rows = TILE_ROWS.map(({ localName, render }) => (
-    <PropertyRow
-      key={localName}
-      label={labelFor(localName)}
-      prop={cell.properties[localName]}
-      render={render}
-    />
-  )).filter((row) => row.props.prop);
+  const rows = rowConfig
+    .map(({ localName, render, label }) => (
+      <PropertyRow
+        key={localName}
+        label={label || labelFor(localName)}
+        prop={cell.properties[localName]}
+        render={render}
+      />
+    ))
+    .filter((row) => row.props.prop);
 
   return (
     <Card
@@ -117,7 +131,7 @@ const CellTile = ({ cell, selected = false, onToggleSelect }) => {
         </>
       )}
 
-      {cell.sources.length > 0 && (
+      {footer && cell.sources.length > 0 && (
         <>
           <Divider />
           <CardContent
@@ -130,7 +144,7 @@ const CellTile = ({ cell, selected = false, onToggleSelect }) => {
             }}
           >
             <Typography variant="body2" sx={{ color: gray500, flexShrink: 0 }}>
-              {labelFor("source")}
+              {labelFor(footer.localName)}
             </Typography>
             <Box display="flex" flexWrap="wrap" justifyContent="flex-end" gap={1}>
               {cell.sources.map((src) =>
@@ -165,6 +179,7 @@ const CellTile = ({ cell, selected = false, onToggleSelect }) => {
 
 CellTile.propTypes = {
   cell: PropTypes.object.isRequired,
+  predicateDisplay: PropTypes.object,
   selected: PropTypes.bool,
   onToggleSelect: PropTypes.func,
 };
diff --git a/src/components/CellCards/CellTileGrid.jsx b/src/components/CellCards/CellTileGrid.jsx
index 129cdbe..a55dfbe 100644
--- a/src/components/CellCards/CellTileGrid.jsx
+++ b/src/components/CellCards/CellTileGrid.jsx
@@ -6,7 +6,7 @@ import { vars } from "../../theme/variables";
 const { gray500 } = vars;
 
 // Responsive tile grid. Whole-tile click navigates; the per-tile checkbox selects instead.
-const CellTileGrid = ({ cells, onSelect, selectedIds, onToggleSelect }) => {
+const CellTileGrid = ({ cells, predicateDisplay, onSelect, selectedIds, onToggleSelect }) => {
   if (!cells.length) {
     return (
       <Box
@@ -41,6 +41,7 @@ const CellTileGrid = ({ cells, onSelect, selectedIds, onToggleSelect }) => {
         >
           <CellTile
             cell={cell}
+            predicateDisplay={predicateDisplay}
             selected={!!selectedIds[cell.id]}
             onToggleSelect={() => onToggleSelect(cell.id)}
           />
@@ -52,6 +53,7 @@ const CellTileGrid = ({ cells, onSelect, selectedIds, onToggleSelect }) => {
 
 CellTileGrid.propTypes = {
   cells: PropTypes.array.isRequired,
+  predicateDisplay: PropTypes.object,
   onSelect: PropTypes.func.isRequired,
   selectedIds: PropTypes.object.isRequired,
   onToggleSelect: PropTypes.func.isRequired,
diff --git a/src/components/CellCards/OntologyBrowsePage.jsx b/src/components/CellCards/OntologyBrowsePage.jsx
index e305948..368c9d3 100644
--- a/src/components/CellCards/OntologyBrowsePage.jsx
+++ b/src/components/CellCards/OntologyBrowsePage.jsx
@@ -1,12 +1,80 @@
+import { useCallback, useMemo, useState } from "react";
 import { useOutletContext } from "react-router-dom";
 import { Container, Grid } from "@mui/material";
 import OntologyHierarchyPanel from "./OntologyHierarchyPanel";
 import OntologyTermsTable from "./OntologyTermsTable";
+import { SUBCLASSES, SUPERCLASSES, scopedCells } from "./services/ontologyGridService";
 
-// The "Browse" tab: the ontology's subClassOf hierarchy next to the flat list of its terms.
+// Local name of a curie or IRI: "ilxtr:NeuronPrecision" -> "NeuronPrecision".
+const localName = (id) => String(id).split(/[:/#]/).filter(Boolean).pop() || id;
+
+// The "Type:" select names the direction *first*. These labels carry a term name that runs to 75
+// characters, and the select is one control in a row that also holds a label, a divider and two
+// buttons inside a one-third panel — so it ellipsises, and whatever trails the term name is the
+// part the user loses. The one word that distinguishes the two options has to come before it.
+const scopeOption = (scope, termLabel) =>
+  `${scope === SUPERCLASSES ? "super" : "sub"} classes of ${termLabel}`;
+
+// The caption over the table has a line to itself, so there it can be exact: reading down includes
+// the selected class (see `scopedCells`), unless that class is the ontology's root, which is not
+// one of its terms and so is never a row.
+const scopeCaption = (scope, termLabel, anchorIsRoot) =>
+  scope === SUBCLASSES && !anchorIsRoot
+    ? `${termLabel} and its sub classes`
+    : scopeOption(scope, termLabel);
+
+// The "Browse" tab: the ontology's subClassOf hierarchy next to the terms it places.
 // One third / two thirds, matching the design's 576 / 1152 split of a 1760px container.
+//
+// The two panels are one view, not two: the class selected in the tree is what the table lists,
+// read in the direction the tree's "Type:" select names. (The MVP shipped them independent —
+// `figma-grid-skeleton.md` §"do not interact" — which this supersedes.) Both halves therefore hang
+// off state owned here, their common parent.
 const OntologyBrowsePage = () => {
   const { data } = useOutletContext();
+  const { entry, hierarchy, cells } = data;
+
+  // The ontology's root class is the starting selection the design calls for, and reading down
+  // from it is every term in the set — so the table opens on the full list, as it always has.
+  // `selected` holds only an explicit choice; null is that default.
+  const [selected, setSelected] = useState(null);
+  const [scope, setScope] = useState(SUBCLASSES);
+
+  const rootAnchor = useMemo(
+    () => ({ termId: entry.rootClass, label: localName(entry.rootClass) }),
+    [entry.rootClass]
+  );
+  const anchor = selected ?? rootAnchor;
+
+  // Choosing the root again is choosing the default: the root node's own label is its bare curie
+  // (it carries no rdfs:label), and letting that reach the select would rename the scope the user
+  // is already looking at.
+  const selectTerm = useCallback(
+    (node) =>
+      setSelected(
+        node.termId === entry.rootClass ? null : { termId: node.termId, label: node.label }
+      ),
+    [entry.rootClass]
+  );
+
+  // Back to the opening view. Reading *up* from the root is the one scope that is empty by
+  // definition — the root has nothing above it — so returning the anchor there returns the
+  // direction too, rather than landing the user on a guaranteed-empty table.
+  const selectRoot = useCallback(() => {
+    setSelected(null);
+    setScope(SUBCLASSES);
+  }, []);
+
+  const scopeOptions = useMemo(
+    () =>
+      [SUBCLASSES, SUPERCLASSES].map((value) => ({
+        value,
+        label: scopeOption(value, anchor.label),
+      })),
+    [anchor.label]
+  );
+
+  const terms = useMemo(() => scopedCells(data, anchor.termId, scope), [data, anchor.termId, scope]);
 
   // Side by side the two panels each own the full height and scroll internally. Once they
   // stack (below md) a full-height panel would push the other off-screen, so there they take
@@ -18,12 +86,28 @@ const OntologyBrowsePage = () => {
       <Grid container spacing={4} sx={{ height: { md: 1 }, minHeight: 0 }}>
         <Grid item xs={12} md={4} sx={{ height: panelHeight, minHeight: 0 }}>
           <OntologyHierarchyPanel
-            hierarchy={data.hierarchy}
-            rootClass={data.entry.rootClass}
+            hierarchy={hierarchy}
+            anchorTermId={anchor.termId}
+            scope={scope}
+            scopeOptions={scopeOptions}
+            onScopeChange={setScope}
+            onSelectTerm={selectTerm}
+            onSelectRoot={selectRoot}
           />
         </Grid>
         <Grid item xs={12} md={8} sx={{ height: panelHeight, minHeight: 0 }}>
-          <OntologyTermsTable cells={data.cells} />
+          <OntologyTermsTable
+            cells={terms}
+            entry={entry}
+            scopeDescription={scopeCaption(scope, anchor.label, selected === null)}
+            // The table only ever runs out of rows reading upwards: reading down always holds at
+            // least the selected term, so the other case left is an ontology with no terms at all.
+            emptyMessage={
+              cells.length
+                ? `No term in this ontology is a super class of ${anchor.label}.`
+                : "This ontology has no terms."
+            }
+          />
         </Grid>
       </Grid>
     </Container>
diff --git a/src/components/CellCards/OntologyGridPage.jsx b/src/components/CellCards/OntologyGridPage.jsx
index 1e1809a..7e649a2 100644
--- a/src/components/CellCards/OntologyGridPage.jsx
+++ b/src/components/CellCards/OntologyGridPage.jsx
@@ -8,6 +8,7 @@ import CustomSingleSelect from "../common/CustomSingleSelect";
 import CustomPagination from "../common/CustomPagination";
 import { getFacets, curieToSlug } from "./services/ontologyGridService";
 import { termPath } from "./config/gridConfig";
+import { SOURCE_PREDICATE } from "./model/mappings";
 import { primeTermDataCache } from "../../hooks/useTermData";
 import { vars } from "../../theme/variables";
 
@@ -24,7 +25,7 @@ const cellText = (cell) => {
 
 // The value keys a cell exposes for a given facet.
 const cellFacetKeys = (cell, localName) => {
-  if (localName === "source") return cell.sources.map((s) => s.id);
+  if (localName === SOURCE_PREDICATE) return cell.sources.map((s) => s.id);
   return (cell.properties[localName]?.values || []).map((v) => v.id);
 };
 
@@ -50,7 +51,7 @@ const OntologyGridPage = () => {
   }, [data]);
 
   const cells = useMemo(() => data?.cells || [], [data]);
-  const facets = useMemo(() => getFacets(cells, displayedOnly), [cells, displayedOnly]);
+  const facets = useMemo(() => (data ? getFacets(data, displayedOnly) : []), [data, displayedOnly]);
   // Only currently-visible facets constrain results — a facet hidden by the
   // "Displayed properties" toggle must not silently filter (its checks are kept
   // but inert until it is shown again).
@@ -185,6 +186,7 @@ const OntologyGridPage = () => {
         <Box sx={{ flex: 1, overflowY: "auto", px: 4, py: 3 }}>
           <CellTileGrid
             cells={pageCells}
+            predicateDisplay={data?.predicateDisplay}
             onSelect={openCellCard}
             selectedIds={selectedIds}
             onToggleSelect={onToggleSelect}
diff --git a/src/components/CellCards/OntologyHierarchyPanel.jsx b/src/components/CellCards/OntologyHierarchyPanel.jsx
index 1775b87..496ce7d 100644
--- a/src/components/CellCards/OntologyHierarchyPanel.jsx
+++ b/src/components/CellCards/OntologyHierarchyPanel.jsx
@@ -5,33 +5,36 @@ import CustomSingleSelect from "../common/CustomSingleSelect";
 import OntologyHierarchyTree from "./OntologyHierarchyTree";
 import { RestartAlt, TargetCross } from "../../Icons";
 
-// Local name of a curie or IRI: "ilxtr:NeuronPrecision" -> "NeuronPrecision".
-const localName = (id) => String(id).split(/[:/#]/).filter(Boolean).pop() || id;
-
-// The "Ontology hierarchy" widget: the subClassOf tree of the ontology, opened on its root
-// class (the starting selection the design calls for). Per the MVP decision this widget does
-// not drive the Terms table beside it — the two are independent views of the same ontology.
-const OntologyHierarchyPanel = ({ hierarchy, rootClass }) => {
+// The "Ontology hierarchy" widget: the subClassOf tree of the ontology, opened on its root class
+// (the starting selection the design calls for).
+//
+// The tree always shows the whole hierarchy — clicking a term picks what the Terms table beside it
+// lists, so re-scoping the tree to the choice would take away the rows the user browses *with*.
+// Which term is picked, and the direction the "Type:" select reads it in, belong to the page that
+// owns both panels; expansion is this widget's own business.
+const OntologyHierarchyPanel = ({
+  hierarchy,
+  anchorTermId,
+  scope,
+  scopeOptions,
+  onScopeChange,
+  onSelectTerm,
+  onSelectRoot,
+}) => {
   const rootIds = useMemo(() => hierarchy.map((node) => node.id), [hierarchy]);
   const [expandedItems, setExpandedItems] = useState(rootIds);
-  const [selectedItems, setSelectedItems] = useState([]);
-
-  // Only one hierarchy exists for a neurdf ontology, but the label is built from the root
-  // class rather than hardcoded — the same rule the rest of this view follows.
-  const typeOptions = useMemo(
-    () => [{ value: "subClassOf", label: `sub class of ${localName(rootClass)}` }],
-    [rootClass]
-  );
 
+  // Both buttons put the scope back on the root class; they differ in what they do to the tree.
+  // Reset closes it back to the opening view, while focus only makes sure the root is open.
   const handleReset = useCallback(() => {
     setExpandedItems(rootIds);
-    setSelectedItems([]);
-  }, [rootIds]);
+    onSelectRoot();
+  }, [rootIds, onSelectRoot]);
 
   const handleFocusRoot = useCallback(() => {
     setExpandedItems((prev) => [...new Set([...prev, ...rootIds])]);
-    setSelectedItems(rootIds);
-  }, [rootIds]);
+    onSelectRoot();
+  }, [rootIds, onSelectRoot]);
 
   return (
     <Stack sx={{ height: 1, minHeight: 0 }} gap={2}>
@@ -41,7 +44,7 @@ const OntologyHierarchyPanel = ({ hierarchy, rootClass }) => {
         <Typography variant="body2" color="text.secondary">
           Type:
         </Typography>
-        <CustomSingleSelect value="subClassOf" onChange={() => {}} options={typeOptions} />
+        <CustomSingleSelect value={scope} onChange={onScopeChange} options={scopeOptions} />
         <Box sx={{ flex: 1 }} />
         <Divider orientation="vertical" flexItem />
         <Button
@@ -56,8 +59,8 @@ const OntologyHierarchyPanel = ({ hierarchy, rootClass }) => {
         <Button
           variant="outlined"
           onClick={handleFocusRoot}
-          aria-label="Highlight the root class"
-          title="Highlight the root class"
+          aria-label="Select the root class"
+          title="Select the root class"
           sx={{ p: "0.625rem 0.5625rem", minWidth: "0.0625rem" }}
         >
           <TargetCross />
@@ -70,7 +73,8 @@ const OntologyHierarchyPanel = ({ hierarchy, rootClass }) => {
           items={hierarchy}
           expandedItems={expandedItems}
           onExpandedItemsChange={(_e, ids) => setExpandedItems(ids)}
-          selectedItems={selectedItems}
+          anchorTermId={anchorTermId}
+          onSelectTerm={onSelectTerm}
         />
       </Box>
     </Stack>
@@ -79,7 +83,15 @@ const OntologyHierarchyPanel = ({ hierarchy, rootClass }) => {
 
 OntologyHierarchyPanel.propTypes = {
   hierarchy: PropTypes.array.isRequired,
-  rootClass: PropTypes.string.isRequired,
+  // The class the table is scoped to; highlighted at every position it occupies.
+  anchorTermId: PropTypes.string.isRequired,
+  scope: PropTypes.string.isRequired,
+  scopeOptions: PropTypes.arrayOf(
+    PropTypes.shape({ value: PropTypes.string, label: PropTypes.string })
+  ).isRequired,
+  onScopeChange: PropTypes.func.isRequired,
+  onSelectTerm: PropTypes.func.isRequired,
+  onSelectRoot: PropTypes.func.isRequired,
 };
 
 export default OntologyHierarchyPanel;
diff --git a/src/components/CellCards/OntologyHierarchyTree.jsx b/src/components/CellCards/OntologyHierarchyTree.jsx
index db4d091..76edaf2 100644
--- a/src/components/CellCards/OntologyHierarchyTree.jsx
+++ b/src/components/CellCards/OntologyHierarchyTree.jsx
@@ -5,24 +5,22 @@ import { RichTreeView } from "@mui/x-tree-view/RichTreeView";
 import { TreeItem } from "@mui/x-tree-view/TreeItem";
 import ExpandLessOutlinedIcon from "@mui/icons-material/ExpandLessOutlined";
 import ChevronRightOutlinedIcon from "@mui/icons-material/ChevronRightOutlined";
-import { termLink } from "./config/gridConfig";
 
 // Tree row: label + the term's CURIE, per the design. The CURIE is dropped when it *is* the
 // label (a class with no rdfs:label falls back to its curie, and showing it twice is noise).
 //
 // The label is the row's activation target, not the row itself: it stops the click from reaching
-// the item, so opening a term never doubles as expanding it. Expansion stays on the chevron. It
+// the item, so activating a term never doubles as expanding it. Expansion stays on the chevron. It
 // carries the term's own colour rather than the link colour — the design draws these as plain
 // text.
 //
-// Where it goes depends on the caller. Without `onSelectTerm` it is a real link that opens the
-// term in a new tab (the Browse tab's behaviour), which gets middle-click and keyboard activation
-// for free. With `onSelectTerm` the caller navigates in place instead — the Cell Card needs the
-// tree to stay put while the page moves, which a new document cannot do.
+// What activation *does* is the caller's business (`onSelectTerm`): the Browse tab scopes its
+// Terms table to the clicked class, the Cell Card navigates to it. Neither is a document link, so
+// the label is a button.
 const HierarchyTreeItem = forwardRef(function HierarchyTreeItem(props, ref) {
   // `meta` and `onSelectTerm` arrive via slotProps and must not reach the DOM.
   const { meta, onSelectTerm, label, itemId, ...treeItemProps } = props;
-  const { curie, href, isCurrent, node } = meta?.get(itemId) || {};
+  const { curie, isAnchor, isCurrent, node } = meta?.get(itemId) || {};
 
   return (
     <TreeItem
@@ -31,18 +29,21 @@ const HierarchyTreeItem = forwardRef(function HierarchyTreeItem(props, ref) {
       itemId={itemId}
       label={
         <Stack direction="row" alignItems="center" gap={1} sx={{ minWidth: 0 }}>
-          {/* The term whose page we are on is the anchor of the tree, so it reads as text rather
-              than a link to itself, in the theme's `currentTerm` variant — the semibold brand
-              emphasis is a design token, not a call-site style. */}
+          {/* The anchor of the tree is marked two ways: the row's selected background, and the
+              label in brand rather than the plain text colour the other rows inherit. A caller
+              already *on* that term gets the `currentTerm` variant instead — same emphasis, but as
+              text, because activating a link to the page you are on would go nowhere. (That
+              variant is not reused for the activatable case: `MuiLink`'s own styleOverrides set a
+              weight, and component styles win over a typography variant.) */}
           {onSelectTerm && !isCurrent ? (
             <Link
               component="button"
               type="button"
-              color="inherit"
+              color={isAnchor ? "primary" : "inherit"}
               underline="hover"
               variant="body2"
               noWrap
-              title={`Open ${label}`}
+              title={label}
               onClick={(e) => {
                 e.stopPropagation();
                 onSelectTerm(node);
@@ -50,20 +51,6 @@ const HierarchyTreeItem = forwardRef(function HierarchyTreeItem(props, ref) {
             >
               {label}
             </Link>
-          ) : href && !isCurrent ? (
-            <Link
-              href={href}
-              target="_blank"
-              rel="noopener noreferrer"
-              color="inherit"
-              underline="hover"
-              variant="body2"
-              noWrap
-              title={`Open ${label} in a new tab`}
-              onClick={(e) => e.stopPropagation()}
-            >
-              {label}
-            </Link>
           ) : (
             <Typography variant={isCurrent ? "currentTerm" : "body2"} noWrap title={label}>
               {label}
@@ -91,28 +78,32 @@ const OntologyHierarchyTree = ({
   items,
   expandedItems,
   onExpandedItemsChange,
-  selectedItems,
-  currentTermId,
+  anchorTermId,
+  anchorIsCurrent,
   onSelectTerm,
 }) => {
-  // itemId -> { node, curie, href, isCurrent }, resolved once here so the item slot needs no walk
-  // of its own. `currentTermId` is a *term* id, matched against node.termId — a class with several
-  // parents appears at more than one path, and every one of those positions is "current".
-  const meta = useMemo(() => {
+  // itemId -> { node, curie, isCurrent }, plus the anchor's positions, resolved in one walk here
+  // so neither the item slot nor the caller needs a walk of its own. `anchorTermId` is a *term*
+  // id: a class with several parents (17 of these) appears at more than one path, and every one
+  // of those positions is the anchor.
+  const { meta, selectedItems } = useMemo(() => {
     const map = new Map();
+    const positions = [];
     const stack = [...items];
     while (stack.length) {
       const node = stack.pop();
+      const isAnchor = !!anchorTermId && node.termId === anchorTermId;
+      if (isAnchor) positions.push(node.id);
       map.set(node.id, {
         node,
         curie: node.curie,
-        href: termLink(node),
-        isCurrent: !!currentTermId && node.termId === currentTermId,
+        isAnchor,
+        isCurrent: isAnchor && !!anchorIsCurrent,
       });
       stack.push(...(node.children || []));
     }
-    return map;
-  }, [items, currentTermId]);
+    return { meta: map, selectedItems: positions };
+  }, [items, anchorTermId, anchorIsCurrent]);
 
   return (
     <RichTreeView
@@ -122,6 +113,12 @@ const OntologyHierarchyTree = ({
       getItemLabel={(item) => item.label}
       expandedItems={expandedItems}
       onExpandedItemsChange={onExpandedItemsChange}
+      // The anchor is highlighted at every position it occupies, which is a set — hence
+      // `multiSelect`, whose contract is the array. Selection is ours to set, never the row
+      // click's: the label already carries the term's action, so `disableSelection` keeps a stray
+      // click on the row's padding from moving the highlight away from what is actually anchored.
+      multiSelect
+      disableSelection
       selectedItems={selectedItems}
       slots={{
         item: HierarchyTreeItem,
@@ -137,11 +134,12 @@ OntologyHierarchyTree.propTypes = {
   items: PropTypes.array.isRequired,
   expandedItems: PropTypes.arrayOf(PropTypes.string).isRequired,
   onExpandedItemsChange: PropTypes.func.isRequired,
-  selectedItems: PropTypes.arrayOf(PropTypes.string),
-  // The term the page is about; every position of that class renders highlighted.
-  currentTermId: PropTypes.string,
-  // Given a hierarchy node, take the caller somewhere in this same page. When set, term labels
-  // activate this instead of opening the term in a new tab.
+  // The term the tree is read around; every position of that class renders highlighted.
+  anchorTermId: PropTypes.string,
+  // Render the anchor as plain current-term text instead of an activatable label. For a caller
+  // already *on* that term (the Cell Card), where activating it would go nowhere.
+  anchorIsCurrent: PropTypes.bool,
+  // Given a hierarchy node, do whatever this tree's owner does with a chosen term.
   onSelectTerm: PropTypes.func,
 };
 
diff --git a/src/components/CellCards/OntologyTermsTable.jsx b/src/components/CellCards/OntologyTermsTable.jsx
index 9aad9d2..07be254 100644
--- a/src/components/CellCards/OntologyTermsTable.jsx
+++ b/src/components/CellCards/OntologyTermsTable.jsx
@@ -1,10 +1,12 @@
 import PropTypes from "prop-types";
 import { useMemo, useState } from "react";
-import { Box, IconButton, Stack, Tooltip, Typography } from "@mui/material";
+import { Link as RouterLink } from "react-router-dom";
+import { Box, IconButton, Link, Stack, Tooltip, Typography } from "@mui/material";
 import { DataGrid } from "@mui/x-data-grid";
 import OpenInNewOutlinedIcon from "@mui/icons-material/OpenInNewOutlined";
 import GridSearchBar from "./GridSearchBar";
-import { termLink } from "./config/gridConfig";
+import { termPath } from "./config/gridConfig";
+import { curieToSlug } from "./services/ontologyGridService";
 
 // Most of these terms describe themselves in far more than the two lines the design's row
 // allows, so the text is capped at two and the cell's title carries the whole thing.
@@ -25,16 +27,32 @@ const definitionTitle = (row) =>
 
 // Column widths are the design's (280 / 176 / 176 / 448 / 72 of 1152) expressed as flex
 // ratios, so the table keeps its proportions at any viewport.
+//
+// The term's name is the primary action, and it opens the term *without* naming a tab: which view
+// a term opens on is the term page's decision, and only it knows whether there is a Cell Card to
+// show (SingleTermView defaults a cell to the Cell Card and anything else to Overview). The action
+// column is the same destination in a new tab, for reading a term without losing the browse.
 const columns = [
   {
     field: "label",
     headerName: "Term",
     flex: 280,
     minWidth: 180,
-    renderCell: ({ row }) => (
-      <Typography variant="body2" color="text.primary" title={row.label}>
+    // The grid gives each *cell* a roving tabIndex but does not manage focusable children, so an
+    // interactive cell has to take it or every row becomes a permanent tab stop — 100 rows a page,
+    // two links each.
+    renderCell: ({ row, tabIndex }) => (
+      <Link
+        component={RouterLink}
+        to={row.href}
+        tabIndex={tabIndex}
+        variant="body2"
+        color="text.primary"
+        underline="hover"
+        title={row.label}
+      >
         {row.label}
-      </Typography>
+      </Link>
     ),
   },
   { field: "curie", headerName: "ID", flex: 176, minWidth: 130 },
@@ -57,21 +75,21 @@ const columns = [
     width: 72,
     sortable: false,
     align: "center",
-    renderCell: ({ row }) =>
-      row.href ? (
-        <Tooltip title="Open term in new tab">
-          <IconButton
-            size="small"
-            component="a"
-            href={row.href}
-            target="_blank"
-            rel="noopener noreferrer"
-            aria-label={`Open ${row.label} in a new tab`}
-          >
-            <OpenInNewOutlinedIcon fontSize="inherit" />
-          </IconButton>
-        </Tooltip>
-      ) : null,
+    renderCell: ({ row, tabIndex }) => (
+      <Tooltip title="Open term in new tab">
+        <IconButton
+          size="small"
+          component="a"
+          href={row.href}
+          target="_blank"
+          rel="noopener noreferrer"
+          tabIndex={tabIndex}
+          aria-label={`Open ${row.label} in a new tab`}
+        >
+          <OpenInNewOutlinedIcon fontSize="inherit" />
+        </IconButton>
+      </Tooltip>
+    ),
   },
 ];
 
@@ -83,9 +101,9 @@ const matches = (row, query) =>
     .toLowerCase()
     .includes(query);
 
-// The "Terms" widget: every term in the ontology, whatever the hierarchy beside it is showing.
-// The two widgets deliberately do not interact in this MVP.
-const OntologyTermsTable = ({ cells }) => {
+// The "Terms" widget: the terms the hierarchy beside it has scoped to, named by `scopeDescription`
+// so the table says why these rows and not others. The word filter narrows that further.
+const OntologyTermsTable = ({ cells, entry, scopeDescription, emptyMessage }) => {
   const [word, setWord] = useState("");
 
   const rows = useMemo(
@@ -94,12 +112,12 @@ const OntologyTermsTable = ({ cells }) => {
         id: cell.id,
         label: cell.label,
         curie: cell.curie,
-        href: termLink(cell),
+        href: termPath(entry.org, entry.slug, curieToSlug(cell.curie)),
         rdfType: cell.rdfTypes.join(", "),
         definition: cell.definition || "",
         definitionCurated: cell.definitionCurated ?? true,
       })),
-    [cells]
+    [cells, entry]
   );
 
   const filteredRows = useMemo(() => {
@@ -109,7 +127,12 @@ const OntologyTermsTable = ({ cells }) => {
 
   return (
     <Stack sx={{ height: 1, minHeight: 0 }} gap={2}>
-      <Typography variant="sectionTitle">Terms</Typography>
+      <Stack gap={0.5}>
+        <Typography variant="sectionTitle">Terms</Typography>
+        <Typography variant="body2" color="text.secondary">
+          {scopeDescription}
+        </Typography>
+      </Stack>
       <GridSearchBar value={word} onSubmit={setWord} />
       <Box sx={{ flex: 1, minHeight: 0 }}>
         {filteredRows.length ? (
@@ -135,12 +158,11 @@ const OntologyTermsTable = ({ cells }) => {
         ) : (
           // The design calls for an empty state when the filter matches nothing, and rendering
           // one also keeps the grid from ever holding zero rows: DataGrid v7 dereferences a
-          // null row node in useGridRowAriaAttributes when its last row is filtered away.
+          // null row node in useGridRowAriaAttributes when its last row is filtered away. The
+          // scope can empty the table too (a leaf has no subclasses), hence the caller's message.
           <Stack alignItems="center" justifyContent="center" sx={{ height: 1, p: 3 }}>
             <Typography variant="body2" color="text.secondary">
-              {rows.length
-                ? "No terms match this filter."
-                : "This ontology has no terms."}
+              {rows.length ? "No terms match this filter." : emptyMessage}
             </Typography>
           </Stack>
         )}
@@ -151,6 +173,12 @@ const OntologyTermsTable = ({ cells }) => {
 
 OntologyTermsTable.propTypes = {
   cells: PropTypes.array.isRequired,
+  // The ontology every row's term page hangs off — /[org]/ontology/[slug]/[term].
+  entry: PropTypes.shape({ org: PropTypes.string, slug: PropTypes.string }).isRequired,
+  // What the rows are, in the hierarchy's own words ("sub class of X").
+  scopeDescription: PropTypes.string.isRequired,
+  // Shown when the scope holds no term at all, as opposed to the filter matching none of them.
+  emptyMessage: PropTypes.string.isRequired,
 };
 
 export default OntologyTermsTable;
diff --git a/src/components/CellCards/config/cellCardConfig.ts b/src/components/CellCards/config/cellCardConfig.ts
index 32e6bf0..7cd5e72 100644
--- a/src/components/CellCards/config/cellCardConfig.ts
+++ b/src/components/CellCards/config/cellCardConfig.ts
@@ -1,109 +1,13 @@
-// Display configuration for the single-cell Cell Card.
+// Non-mapping display configuration for the single-cell Cell Card: the copy and the integration
+// details that are the same whatever ontology is being read.
 //
-// Deliberately data, not JSX: meeting 3 asked for the property rows *and* the relationship
-// graph's predicates to be specified in config so curators can change what a widget shows
-// without a component edit. Row *labels* are not here — they come from the ontology's own
-// ilxtr:displayLabel (see parsePredicateDisplay), with gridConfig's PREDICATE_LABELS as the
-// fallback; this file only decides which predicates appear, in what order, and how.
-
-import type { RelationEdgeKind } from "../model/types";
-
-// How a row renders its values: plain text (comma/or-joined) or one chip per value.
-export type RowRender = "text" | "chip";
-
-export interface CellCardRow {
-  localName: string;
-  render?: RowRender; // default "text"
-  // Show the row with "not specified" when the predicate is absent, rather than hiding it.
-  // The design's Biological Properties table keeps a fixed shape (Function / Adaptation /
-  // Threshold all read "not specified" on npokb:998), so its rows are all required.
-  required?: boolean;
-}
-
-// --- left column -------------------------------------------------------------
-
-// §3.1 Biological Properties, in the design's order (Figma 9535:96273).
-export const BIOLOGICAL_PROPERTY_ROWS: CellCardRow[] = [
-  { localName: "hasInstanceInTaxon", required: true },
-  { localName: "hasSomaLocatedIn", required: true },
-  { localName: "neurondmBaseClass", required: true },
-  { localName: "hasCircuitRolePhenotype", required: true },
-  { localName: "hasFunctionalPhenotype", required: true },
-  { localName: "hasAxonPhenotype", required: true },
-  { localName: "hasAdaptationPhenotype", required: true },
-  { localName: "hasThresholdPhenotype", required: true },
-  { localName: "hasNeurotransmitterPhenotype", required: true },
-  { localName: "hasNucleicAcidExpressionPhenotype", render: "chip", required: true },
-];
-
-// §3.3 Anatomical & Circuit Context (Figma 9239:67695). Soma location repeats here by design —
-// it is the anchor for the anatomical reading, and Sue asked for it in both widgets.
-export const ANATOMICAL_CONTEXT_ROWS: CellCardRow[] = [
-  { localName: "hasSomaLocatedIn", required: true },
-  { localName: "hasAxonSensorySubcellularElementIn", required: true },
-  { localName: "hasAxonPresynapticElementIn", required: true },
-  { localName: "hasCircuitRolePhenotype", required: true },
-];
-
-// --- centre column -----------------------------------------------------------
-
-// Which predicates the relationship graph may draw, and as which edge type. Fahim: "what is
-// shown in this graph needs to be specified in some sort of config … otherwise this graph
-// could get very complex depending on the cell type." Adding a predicate here is the only way
-// to get another edge kind into the graph.
-export interface RelationPredicate {
-  localName: string;
-  kind: RelationEdgeKind;
-  label: string; // the edge caption drawn on the connector
-  // Which side of the current node the targets sit on. "down" = a rank below (children),
-  // "up" = a rank above (parents), "left"/"right" = a satellite on the same rank.
-  direction: "up" | "down" | "left" | "right";
-}
-
-export const RELATION_PREDICATES: RelationPredicate[] = [
-  { localName: "hasSomaLocatedIn", kind: "somaLocation", label: "soma location", direction: "left" },
-  {
-    localName: "hasNucleicAcidExpressionPhenotype",
-    kind: "expresses",
-    label: "expresses",
-    direction: "right",
-  },
-];
-
-// Edge captions for the two structural relations, which come from the hierarchy and the
-// mapping table rather than from a phenotype predicate.
-export const SUBCLASS_EDGE_LABEL = "subclass of";
-export const ASSERTED_SUBCLASS_EDGE_LABEL = "asserted subclass of";
-
-// Legend rows, in the order the expanded dialog shows them (Figma 8917:35906).
-export const RELATION_LEGEND: { kind: RelationEdgeKind; label: string }[] = [
-  { kind: "subClassOf", label: "Sub class of" },
-  { kind: "somaLocation", label: "Soma location" },
-  { kind: "assertedSubClassOf", label: "Asserted Subclass of" },
-  { kind: "expresses", label: "expresses" },
-];
+// The *field mappings* — which predicate feeds which widget row, which predicates the relationship
+// graph may draw, and what a row is labelled — used to live here too. Meeting 3 asked for them to
+// be curator-editable, so they moved to the runtime-fetched mappings document: see
+// `config/mappingsService` and `cellcard-spec/mappings.md` §2.
 
 export const FLAGGED_FOOTNOTE = '* flagged "don\'t add" → proposed only';
 
-// Marker genes are shown both in Biological Properties and as the Transcriptomic Profile's
-// gene chips, so the widget reads the same predicate rather than duplicating the list.
-export const MARKER_GENE_PREDICATE = "hasNucleicAcidExpressionPhenotype";
-
-// --- conditional widgets -----------------------------------------------------
-
-// Triples that would activate the deep-link widgets. None of these exist in the shipped
-// ontology (verified: zero occurrences, and the `ilx:` prefix is not even in the @context),
-// so the widgets render their "appears when the triple is added" state.
-//
-// These are the curator-facing *names*, shown in those "appears when … is added" notes. The data
-// path is `cell.annotations.sparcTranscriptomicsLinks` / `.sparcMaps` / `.nervoSensusLinks`: the
-// parser matches all three by local name under any prefix (LINK_ANNOTATIONS in neurdfParser), so
-// the widget really does light up with no code change — a CURIE key looked up against
-// `cell.properties`, which is keyed by bare local name, would never have matched anything.
-export const SPARC_TRANSCRIPTOMICS_PREDICATE = "ilx:hasSPARCTranscriptomicsLink";
-export const SPARC_MAP_PREDICATE = "ilx:hasSPARCMap";
-export const NERVOSENSUS_PREDICATE = "ilx:hasNervoSensusLink";
-
 // --- NervoSensus -------------------------------------------------------------
 
 // NervoSensus is a single application, not a per-cell resource, so the Interactive Cell Grouping
@@ -147,24 +51,7 @@ export const NERVOSENSUS_AXON: Record<string, string> = {
   "type c": "fiber_c",
 };
 
-// --- header ------------------------------------------------------------------
-
-// Type badges beside the title, left→right, with the tone each uses. `Purple` in the design has
-// no palette equivalent, so nothing here maps to it — see EVIDENCE_TONE.
-export const HEADER_BADGES: { localName: string; tone: "class" | "subtype" | "species" }[] = [
-  { localName: "neurondmBaseClass", tone: "class" },
-  { localName: "hasAxonPhenotype", tone: "subtype" },
-  { localName: "hasCircuitRolePhenotype", tone: "subtype" },
-  { localName: "hasInstanceInTaxon", tone: "species" },
-];
-
-// Chip colour per header tone, matching the grid tile so a cell looks the same in both views
-// (CellTile.jsx CHIP_COLOR).
-export const BADGE_COLOR: Record<string, "secondary" | "success" | "default"> = {
-  class: "secondary",
-  subtype: "success",
-  species: "default",
-};
+// --- badges ------------------------------------------------------------------
 
 // Cross-nomenclature evidence badge tones. The design uses Success / Warning / Purple; the
 // theme has no purple, so "proposed" falls back to an outlined chip rather than inlining a hex
diff --git a/src/components/CellCards/config/gridConfig.ts b/src/components/CellCards/config/gridConfig.ts
index 4a8fe50..80c6d3f 100644
--- a/src/components/CellCards/config/gridConfig.ts
+++ b/src/components/CellCards/config/gridConfig.ts
@@ -146,71 +146,11 @@ export const PREFER_LOCAL_NEURDF =
   import.meta.env?.VITE_PREFER_LOCAL_NEURDF !== "false";
 
 // --- predicate display metadata ---------------------------------------------
-
-// local name (family-stripped) -> human label. Any predicate not listed falls back
-// to its local name, so nothing is silently dropped ("render everything").
-export const PREDICATE_LABELS: Record<string, string> = {
-  neurondmBaseClass: "Cell class",
-  hasInstanceInTaxon: "Species",
-  hasSomaLocatedIn: "Soma location",
-  hasCircuitRolePhenotype: "Circuit role",
-  hasFunctionalPhenotype: "Physiology",
-  hasAxonPhenotype: "Axon type",
-  hasAdaptationPhenotype: "Adaptation",
-  hasThresholdPhenotype: "Threshold",
-  hasNeurotransmitterPhenotype: "Neurotransmitter",
-  hasNucleicAcidExpressionPhenotype: "Marker genes",
-  hasBiologicalSex: "Sex",
-  hasMorphologicalPhenotype: "Morphology",
-  source: "Source",
-};
-
-// Tooltip text sourced from pyontutils neuron_phenotype_edges.csv (displayDescription).
-export const PREDICATE_TOOLTIPS: Record<string, string> = {
-  hasInstanceInTaxon: "Species the cell type is observed in.",
-  hasSomaLocatedIn: "Anatomical location of the cell body (soma).",
-  hasFunctionalPhenotype: "Functional / physiological properties.",
-  hasAxonPhenotype: "Axon fiber type.",
-  hasNucleicAcidExpressionPhenotype: "Marker genes expressed by the cell type.",
-  hasNeurotransmitterPhenotype: "Neurotransmitters the cell type produces or releases.",
-  hasCircuitRolePhenotype: "Excitatory / inhibitory circuit role.",
-  source: "Source publication for the cell type.",
-};
-
-export const labelFor = (localName: string): string =>
-  PREDICATE_LABELS[localName] || localName;
-
-// --- tile layout ------------------------------------------------------------
-
-export type ChipTone = "class" | "subtype" | "species";
-
-// Header chips (left→right), from the mockup: class + fiber/subtype + species.
-export const TILE_HEADER_CHIPS: { localName: string; tone: ChipTone }[] = [
-  { localName: "neurondmBaseClass", tone: "class" },
-  { localName: "hasAxonPhenotype", tone: "subtype" },
-  { localName: "hasInstanceInTaxon", tone: "species" },
-];
-
-export type RowRender = "text" | "chip";
-
-// Ordered property rows shown on a tile (auto-hidden when empty).
-export const TILE_ROWS: { localName: string; render: RowRender }[] = [
-  { localName: "hasSomaLocatedIn", render: "text" },
-  { localName: "hasNucleicAcidExpressionPhenotype", render: "chip" },
-  { localName: "hasFunctionalPhenotype", render: "chip" },
-];
-
-// --- facets -----------------------------------------------------------------
-
-// The properties actually shown on a tile: header chips + rows + the footer source.
-// The "Displayed properties" toggle ON restricts facets to exactly these; OFF shows a
-// facet for every property found on the terms. Derived from the tile config above so the
-// two never drift apart.
-export const DISPLAYED_PROPERTIES: string[] = [
-  ...TILE_HEADER_CHIPS.map((c) => c.localName),
-  ...TILE_ROWS.map((r) => r.localName),
-  "source",
-];
+//
+// Predicate labels/tooltips, the tile layout and the facet configuration used to live here. They
+// are field *mappings*, which `cellcard-spec/mappings.md` §1.1 asks to be configurable per
+// ontology, so they now come from the runtime-fetched document — see `config/mappingsService` for
+// the fetch and `config/mappingDefaults` for the built-in fallback and the readers.
 
 // --- term links ---------------------------------------------------------------
 
diff --git a/src/components/CellCards/config/mappingDefaults.ts b/src/components/CellCards/config/mappingDefaults.ts
new file mode 100644
index 0000000..895709b
--- /dev/null
+++ b/src/components/CellCards/config/mappingDefaults.ts
@@ -0,0 +1,277 @@
+// The built-in mappings, and the pure helpers that read a mappings document.
+//
+// `DEFAULT_MAPPINGS` is what the app renders when the configuration file cannot be fetched — a
+// missing bake, a bad `VITE_CELLCARD_MAPPINGS_URL`, an offline dev box. It deliberately mirrors
+// the shipped `public/config/cell-card-mappings.json` rather than degrading to something derived
+// from the data: a tile that silently swaps its three designed rows for "whatever this cell
+// happens to carry" looks like a bug, and Biological Properties would lose the fixed shape its
+// `required` rows exist to keep.
+//
+// Kept free of `import.meta.env` and of the fetch itself, so the pure consumers (the parser,
+// widgetVisibility, buildRelationGraph, nervoSensusLink) can default to it and still run under
+// plain node — `yarn check-parser` bundles them with esbuild, outside any browser.
+
+import type {
+  FieldSource,
+  FieldSources,
+  MappingRow,
+  OntologyMappings,
+  PredicateConfig,
+} from "../model/mappings";
+import { RELATION_EDGE_KINDS, SOURCE_PREDICATE } from "../model/mappings";
+
+// --- predicate keys ----------------------------------------------------------
+
+// A configured predicate as a local name. Regions are written in the CURIEs the spec and the
+// ontology use (`ilxtr:hasSomaLocatedIn`, or the expanded IRI), while a `CellProperty` is keyed by
+// the bare local name — the same reduction `parsePredicateDisplay` makes on the annotation nodes.
+export const normalizePredicate = (key: string): string => {
+  const local = String(key || "").trim().split(/[/#:]/).filter(Boolean).pop() || "";
+  // The literature citation is lifted onto `CellTerm.sources` by the parser, and addressed as the
+  // "source" pseudo-predicate everywhere downstream.
+  return local === "literatureCitation" ? SOURCE_PREDICATE : local;
+};
+
+// --- reading a document ------------------------------------------------------
+
+// A predicate's configured label, falling back to the bare local name so nothing is silently
+// dropped. This is the last step everywhere a predicate needs a label — the tile, the facet
+// sidebar and the Cell Card's rows all prefer the ontology's own `ilxtr:displayLabel` first (see
+// `getFacets` and `CellTile`'s `labelFor`, and `buildRows.js`), and fall back to this.
+export const predicateLabel = (mappings: OntologyMappings, localName: string): string =>
+  mappings.predicates[localName]?.label || localName;
+
+export const predicateTooltip = (
+  mappings: OntologyMappings,
+  localName: string
+): string | undefined => mappings.predicates[localName]?.tooltip;
+
+const pluck = (
+  predicates: Record<string, PredicateConfig>,
+  field: "label" | "tooltip"
+): Record<string, string> => {
+  const out: Record<string, string> = {};
+  for (const [localName, config] of Object.entries(predicates)) {
+    const value = config[field];
+    if (value) out[localName] = value;
+  }
+  return out;
+};
+
+export const predicateLabels = (mappings: OntologyMappings): Record<string, string> =>
+  pluck(mappings.predicates, "label");
+
+export const predicateTooltips = (mappings: OntologyMappings): Record<string, string> =>
+  pluck(mappings.predicates, "tooltip");
+
+// The properties a tile actually shows: header chips + rows + the source footer. The facet
+// sidebar's "Displayed properties" toggle restricts itself to exactly these, so it is derived from
+// the tile region rather than listed twice — an explicit `filters.displayed` overrides it for a
+// configuration that wants the two to differ.
+export const displayedProperties = (mappings: OntologyMappings): string[] => {
+  const { tile, filters } = mappings.regions;
+  if (filters.displayed.length) return [...new Set(filters.displayed)];
+  return [
+    ...new Set([
+      ...tile.headerChips.map((chip) => chip.localName),
+      ...tile.rows.map((row) => row.localName),
+      ...(tile.footer ? [tile.footer.localName] : []),
+    ]),
+  ];
+};
+
+export const isRelationEdgeKind = (kind: string): boolean =>
+  (RELATION_EDGE_KINDS as string[]).includes(kind);
+
+// --- the built-in fields -----------------------------------------------------
+
+const exact = (...sources: string[]): FieldSource => ({ sources });
+
+// Matched on the predicate's local name under any prefix. Only for fields whose predicate is not
+// yet declared in the file's @context — see FieldSource.matchLocalName.
+const anyPrefix = (...sources: string[]): FieldSource => ({ sources, matchLocalName: true });
+
+export const DEFAULT_FIELD_SOURCES: FieldSources = {
+  // Most-human-readable first, machine id last (spec §1.1: "if no localLabel, then rdfs:label").
+  // `ilxtr:genLabel` is deliberately absent — it is the verbose machine-generated phenotype
+  // string, usable as a description but never as a title.
+  title: exact("ilxtr:localLabel", "rdfs:label", "dc:title", "dcterms:title"),
+  // The first four are prose written by a curator; the last two are fallbacks so a term with none
+  // of those is still described.
+  description: exact(
+    "definition",
+    "skos:definition",
+    "NIFRID:definition",
+    "rdfs:comment",
+    "ilxtr:genLabel",
+    "ilxtr:curatorNote"
+  ),
+  curatedDescriptionSources: 4,
+
+  cellType: exact("neurdf:Neuron"),
+  parent: exact("rdfs:subClassOf"),
+
+  literatureCitation: exact("ilxtr:literatureCitation"),
+  dataCitation: exact("ilxtr:dataCitation"),
+  atlasAnnotation: exact("ilxtr:atlasAnnotation"),
+  curatorNote: exact("ilxtr:curatorNote"),
+  alertNote: exact("ilxtr:alertNote"),
+  temporaryId: exact("ilxtr:hasTemporaryId"),
+  generatedLabel: exact("ilxtr:genLabel"),
+  error: exact("ilxtr:error"),
+  // Zero occurrences in the shipped graph, and the `ilx:` prefix is not even in its @context — so
+  // these match on the local name and light up whichever prefix the curators end up writing.
+  sparcTranscriptomicsLink: anyPrefix("ilx:hasSPARCTranscriptomicsLink"),
+  sparcMap: anyPrefix("ilx:hasSPARCMap"),
+  nervoSensusLink: anyPrefix("ilx:hasNervoSensusLink"),
+
+  literalProperties: exact("ilxtr:neurondmBaseClass"),
+
+  // Evidence is derived from the relation: an explicit description outranks an inferred mapping.
+  // `proposed` waits on a curator "don't add" flag, which the shipped graph does not carry.
+  crossNomenclature: {
+    described: ["TEMP:assertedSubClassOf", "TEMP:subClassOf"],
+    inferred: ["TEMP:mapsTo"],
+    proposed: [],
+  },
+
+  predicateLabel: exact("ilxtr:displayLabel"),
+  predicateDescription: exact("ilxtr:shortDefinition"),
+
+  ontologyTitle: exact("dc:title", "dcterms:title", "rdfs:label", "skos:prefLabel"),
+  ontologyDescription: exact("dc:description", "dcterms:description", "rdfs:comment"),
+  ontologyVersion: exact("owl:versionInfo"),
+
+  missingValuePrefixes: ["TEMP:MISSING"],
+};
+
+// --- the built-in regions ----------------------------------------------------
+
+// Tooltip text sourced from pyontutils neuron_phenotype_edges.csv (displayDescription).
+const PREDICATES: Record<string, PredicateConfig> = {
+  neurondmBaseClass: { label: "Cell class" },
+  hasInstanceInTaxon: {
+    label: "Species",
+    tooltip: "Species the cell type is observed in.",
+  },
+  hasSomaLocatedIn: {
+    label: "Soma location",
+    tooltip: "Anatomical location of the cell body (soma).",
+  },
+  hasCircuitRolePhenotype: {
+    label: "Circuit role",
+    tooltip: "Excitatory / inhibitory circuit role.",
+  },
+  hasFunctionalPhenotype: {
+    label: "Physiology",
+    tooltip: "Functional / physiological properties.",
+  },
+  hasAxonPhenotype: { label: "Axon type", tooltip: "Axon fiber type." },
+  hasAdaptationPhenotype: { label: "Adaptation" },
+  hasThresholdPhenotype: { label: "Threshold" },
+  hasNeurotransmitterPhenotype: {
+    label: "Neurotransmitter",
+    tooltip: "Neurotransmitters the cell type produces or releases.",
+  },
+  hasNucleicAcidExpressionPhenotype: {
+    label: "Marker genes",
+    tooltip: "Marker genes expressed by the cell type.",
+  },
+  hasBiologicalSex: { label: "Sex" },
+  hasMorphologicalPhenotype: { label: "Morphology" },
+  [SOURCE_PREDICATE]: {
+    label: "Source",
+    tooltip: "Source publication for the cell type.",
+  },
+};
+
+// Every Biological Properties row is `required`, so the table keeps the fixed shape the design
+// shows: Function / Adaptation / Threshold read "not specified" rather than disappearing.
+const required = (localName: string, render?: MappingRow["render"]): MappingRow => ({
+  localName,
+  ...(render ? { render } : {}),
+  required: true,
+});
+
+export const DEFAULT_MAPPINGS: OntologyMappings = {
+  fields: DEFAULT_FIELD_SOURCES,
+  predicates: PREDICATES,
+  regions: {
+    tile: {
+      headerChips: [
+        { localName: "neurondmBaseClass", tone: "class" },
+        { localName: "hasAxonPhenotype", tone: "subtype" },
+        { localName: "hasInstanceInTaxon", tone: "species" },
+      ],
+      rows: [
+        { localName: "hasSomaLocatedIn", render: "text" },
+        { localName: "hasNucleicAcidExpressionPhenotype", render: "chip" },
+        { localName: "hasFunctionalPhenotype", render: "chip" },
+      ],
+      footer: { localName: SOURCE_PREDICATE },
+    },
+    filters: { minOptions: 2, displayed: [] },
+    cellCard: {
+      definition: {
+        cellClass: "neurondmBaseClass",
+        species: "hasInstanceInTaxon",
+        somaLocation: "hasSomaLocatedIn",
+        markerGenes: "hasNucleicAcidExpressionPhenotype",
+        minPredicates: 2,
+      },
+      biologicalProperties: {
+        rows: [
+          required("hasInstanceInTaxon"),
+          required("hasSomaLocatedIn"),
+          required("neurondmBaseClass"),
+          required("hasCircuitRolePhenotype"),
+          required("hasFunctionalPhenotype"),
+          required("hasAxonPhenotype"),
+          required("hasAdaptationPhenotype"),
+          required("hasThresholdPhenotype"),
+          required("hasNeurotransmitterPhenotype"),
+          required("hasNucleicAcidExpressionPhenotype", "chip"),
+        ],
+      },
+      anatomicalContext: {
+        rows: [
+          required("hasSomaLocatedIn"),
+          required("hasAxonSensorySubcellularElementIn"),
+          required("hasAxonPresynapticElementIn"),
+          required("hasCircuitRolePhenotype"),
+        ],
+      },
+      relationshipGraph: {
+        predicates: [
+          {
+            localName: "hasSomaLocatedIn",
+            kind: "somaLocation",
+            label: "soma location",
+            direction: "left",
+          },
+          {
+            localName: "hasNucleicAcidExpressionPhenotype",
+            kind: "expresses",
+            label: "expresses",
+            direction: "right",
+          },
+        ],
+        // In the order the expanded dialog shows them (Figma 8917:35906).
+        legend: [
+          { kind: "subClassOf", label: "Sub class of" },
+          { kind: "somaLocation", label: "Soma location" },
+          { kind: "assertedSubClassOf", label: "Asserted Subclass of" },
+          { kind: "expresses", label: "expresses" },
+        ],
+        subClassOfLabel: "subclass of",
+        assertedSubClassOfLabel: "asserted subclass of",
+      },
+      transcriptomicProfile: {
+        markerGenePredicate: "hasNucleicAcidExpressionPhenotype",
+      },
+      cellGrouping: {
+        axonPredicate: "hasAxonPhenotype",
+      },
+    },
+  },
+};
diff --git a/src/components/CellCards/config/mappingsAtom.ts b/src/components/CellCards/config/mappingsAtom.ts
new file mode 100644
index 0000000..85a456c
--- /dev/null
+++ b/src/components/CellCards/config/mappingsAtom.ts
@@ -0,0 +1,36 @@
+// The mappings the views are currently rendering against, as an atom.
+//
+// Every widget on a Cell Card and every tile in the grid needs them, and threading them down as a
+// prop meant `CellTileGrid`, `CellCard` and each widget's propTypes all carried a value none of
+// them had an opinion about. They read this instead; the loaded ontology still carries `mappings`
+// for the service layer and the pure helpers (`buildRows`, `buildRelationGraph`, `getFacets`),
+// which take it as an argument because they run outside React — `yarn check-parser` executes them
+// under plain node.
+//
+// Written by `loadOntology`, synchronously, before it resolves. That ordering matters: a `useEffect`
+// publisher would run *after* the first render of the components below it, so a configuration that
+// differs from the built-in one would show one frame of the wrong rows. Since no jotai `<Provider>`
+// is mounted (see `useContextOntology`), the module default store is the one React reads, and a
+// non-React caller can write it directly.
+//
+// One value, not one per ontology: the app shows a single ontology at a time and both entry points
+// (the ontology layout route and the term page's `useCellTerm`) go through `loadOntology`, so the
+// last load is the one on screen. It lives beside `mappingsService` rather than in `src/hooks/` to
+// keep the configuration subsystem — fetch, defaults, delivery — in one place.
+
+import { atom, getDefaultStore, useAtomValue } from "jotai";
+import { DEFAULT_MAPPINGS } from "./mappingDefaults";
+import type { OntologyMappings } from "../model/mappings";
+
+export const mappingsAtom = atom<OntologyMappings>(DEFAULT_MAPPINGS);
+
+/** Publish the mappings of the ontology just loaded. Safe to call repeatedly. */
+export const publishMappings = (mappings: OntologyMappings): void => {
+  const store = getDefaultStore();
+  // Resolved mappings are cached per slug, so an unchanged configuration is the same object and
+  // must not notify — that would re-render every tile on each navigation.
+  if (store.get(mappingsAtom) !== mappings) store.set(mappingsAtom, mappings);
+};
+
+/** The current mappings, for components. */
+export const useMappings = (): OntologyMappings => useAtomValue(mappingsAtom);
diff --git a/src/components/CellCards/config/mappingsService.ts b/src/components/CellCards/config/mappingsService.ts
new file mode 100644
index 0000000..50b4581
--- /dev/null
+++ b/src/components/CellCards/config/mappingsService.ts
@@ -0,0 +1,463 @@
+// Fetches the Cell Cards mappings document and normalises it into an `OntologyMappings`.
+//
+// Fetched rather than imported so the binding between the ontology and the views can be changed on
+// a running deployment: edit `config/cell-card-mappings.json` next to the served bundle and reload.
+// `cellcard-spec/mappings.md` §1.1 calls this "the ontology Grid JSON file", and the document is
+// keyed by ontology slug for exactly that reason — a second ontology names its title, its
+// description and its tile layout for itself instead of inheriting Precision's.
+//
+// Document shape:
+//   { "version": 1, "default": <section>, "ontologies": { "<slug>": <section> } }
+// A document carrying neither `default` nor `ontologies` is read as a single `<section>`, which is
+// what a per-ontology URL wants (set VITE_CELLCARD_MAPPINGS_URL to a template containing `{slug}`
+// and each ontology is fetched from its own file).
+//
+// Resolution is layered, weakest first: DEFAULT_MAPPINGS -> the document's `default` ->
+// `ontologies[slug]`. Every key is optional at every layer, so a configuration that only wants to
+// re-point the title at another annotation says just that.
+
+import type {
+  FieldSource,
+  MappingChip,
+  MappingRelation,
+  MappingRow,
+  OntologyMappings,
+} from "../model/mappings";
+import type { RelationEdgeKind } from "../model/types";
+import { DEFAULT_MAPPINGS, isRelationEdgeKind, normalizePredicate } from "./mappingDefaults";
+
+// Same-origin by default: `public/config/` is copied into the served root at build time, so the
+// file ships with the bundle and can be edited in place afterwards. `{slug}` in the template is
+// replaced with the ontology slug, which is how one file per ontology is configured.
+export const CELL_CARD_MAPPINGS_URL: string =
+  import.meta.env?.VITE_CELLCARD_MAPPINGS_URL || "/config/cell-card-mappings.json";
+
+const urlFor = (slug: string): string =>
+  CELL_CARD_MAPPINGS_URL.replace("{slug}", encodeURIComponent(slug));
+
+// --- shape coercion ----------------------------------------------------------
+//
+// The document is operator-edited JSON, so every read is defensive: a malformed entry is dropped
+// and the layer beneath it shows through, rather than taking a widget down with it.
+
+type Raw = Record<string, unknown>;
+
+const asRecord = (value: unknown): Raw | undefined =>
+  value && typeof value === "object" && !Array.isArray(value) ? (value as Raw) : undefined;
+
+const asList = (value: unknown): unknown[] | undefined =>
+  Array.isArray(value) ? value : undefined;
+
+const asText = (value: unknown): string | undefined =>
+  typeof value === "string" && value.trim() ? value.trim() : undefined;
+
+const asCount = (value: unknown): number | undefined =>
+  typeof value === "number" && Number.isFinite(value) ? value : undefined;
+
+// A list of predicate keys, kept verbatim: a field's sources are matched against the graph's own
+// keys, where the difference between `definition` and `skos:definition` is the whole point.
+const asKeys = (value: unknown): string[] | undefined => {
+  const single = asText(value);
+  if (single) return [single];
+  return asList(value)
+    ?.map(asText)
+    .filter((key): key is string => Boolean(key));
+};
+
+const warn = (message: string) => {
+  console.warn(`[cell-card mappings] ${message}`);
+};
+
+// --- fields ------------------------------------------------------------------
+
+// `"title": "rdfs:label"`, `"title": ["a", "b"]` and
+// `"title": { "sources": ["a"], "matchLocalName": true }` all mean the same kind of thing. An
+// explicit empty list is a real answer — "nothing feeds this field" — while a value of the wrong
+// shape is a mistake, and leaves the layer beneath in place.
+const readField = (raw: unknown): FieldSource | undefined => {
+  const shorthand = asKeys(raw);
+  if (shorthand) return { sources: shorthand };
+  const object = asRecord(raw);
+  const sources = object && asKeys(object.sources);
+  if (!sources) return undefined;
+  return object?.matchLocalName === true ? { sources, matchLocalName: true } : { sources };
+};
+
+const FIELD_KEYS = [
+  "title",
+  "description",
+  "cellType",
+  "parent",
+  "literatureCitation",
+  "dataCitation",
+  "atlasAnnotation",
+  "curatorNote",
+  "alertNote",
+  "temporaryId",
+  "generatedLabel",
+  "error",
+  "sparcTranscriptomicsLink",
+  "sparcMap",
+  "nervoSensusLink",
+  "literalProperties",
+  "predicateLabel",
+  "predicateDescription",
+  "ontologyTitle",
+  "ontologyDescription",
+  "ontologyVersion",
+] as const;
+
+// Fields the views cannot do without. Clearing one is legal — an empty source list is a real
+// answer — but it empties the app (no `cellType` finds no cells at all), so it is said out loud
+// rather than left to look like a broken deployment.
+const ESSENTIAL_FIELDS = ["title", "cellType", "parent"];
+
+const applyFields = (
+  base: OntologyMappings["fields"],
+  raw: unknown
+): OntologyMappings["fields"] => {
+  const section = asRecord(raw);
+  if (!section) return base;
+
+  const fields = { ...base };
+  for (const key of FIELD_KEYS) {
+    if (!(key in section)) continue;
+    const field = readField(section[key]);
+    if (!field) {
+      warn(`ignoring field "${key}": expected a predicate, a list of them, or { sources: [...] }`);
+      continue;
+    }
+    if (!field.sources.length && ESSENTIAL_FIELDS.includes(key)) {
+      warn(`field "${key}" was cleared — the views have nothing to read it from`);
+    }
+    fields[key] = field;
+  }
+
+  const evidence = asRecord(section.crossNomenclature);
+  if (evidence) {
+    fields.crossNomenclature = {
+      described: asKeys(evidence.described) || base.crossNomenclature.described,
+      inferred: asKeys(evidence.inferred) || base.crossNomenclature.inferred,
+      proposed: asKeys(evidence.proposed) || base.crossNomenclature.proposed,
+    };
+  }
+  fields.curatedDescriptionSources =
+    asCount(section.curatedDescriptionSources) ?? base.curatedDescriptionSources;
+  fields.missingValuePrefixes =
+    asKeys(section.missingValuePrefixes) || base.missingValuePrefixes;
+
+  return fields;
+};
+
+// --- regions -----------------------------------------------------------------
+
+// An entry names its predicate as `"ilxtr:hasSomaLocatedIn"` (shorthand) or as
+// `{ "predicate": "ilxtr:hasSomaLocatedIn", … }`. `localName` is accepted too, since that is what
+// the model calls it.
+const predicateOf = (entry: unknown): string | undefined => {
+  const direct = asText(entry);
+  if (direct) return normalizePredicate(direct);
+  const object = asRecord(entry);
+  const named = object && (asText(object.predicate) || asText(object.localName));
+  return named ? normalizePredicate(named) : undefined;
+};
+
+const TONES: MappingChip["tone"][] = ["class", "subtype", "species"];
+const RENDERS: NonNullable<MappingRow["render"]>[] = ["text", "chip"];
+const DIRECTIONS: MappingRelation["direction"][] = ["up", "down", "left", "right"];
+
+// Every list reader below shares one rule: an explicit empty list is a real answer ("nothing
+// here"), but a non-empty list where every entry failed to parse is a mistake — falling back to
+// `undefined` lets the `readX(...) || base.X` call site keep the existing configuration instead
+// of silently emptying the region, and `warn` says why.
+const droppedEntirely = <T>(label: string, list: unknown[], parsed: T[]): boolean => {
+  if (!list.length || parsed.length) return false;
+  warn(`ignoring ${label}: no entry in the list could be parsed, keeping the existing configuration`);
+  return true;
+};
+
+const readChips = (raw: unknown, label: string): MappingChip[] | undefined => {
+  const list = asList(raw);
+  if (!list) return undefined;
+  const chips = list.flatMap((entry) => {
+    const localName = predicateOf(entry);
+    if (!localName) return [];
+    const tone = asText(asRecord(entry)?.tone) as MappingChip["tone"] | undefined;
+    // An unrecognised tone falls back to the neutral one rather than dropping the chip: the
+    // predicate is the mapping, the colour is decoration.
+    return [{ localName, tone: tone && TONES.includes(tone) ? tone : "species" }];
+  });
+  return droppedEntirely(label, list, chips) ? undefined : chips;
+};
+
+const readRows = (raw: unknown, label: string): MappingRow[] | undefined => {
+  const list = asList(raw);
+  if (!list) return undefined;
+  const rows = list.flatMap((entry) => {
+    const localName = predicateOf(entry);
+    if (!localName) return [];
+    const object = asRecord(entry) || {};
+    const render = asText(object.render) as MappingRow["render"] | undefined;
+    const row: MappingRow = { localName };
+    if (render && RENDERS.includes(render)) row.render = render;
+    if (object.required === true) row.required = true;
+    const rowLabel = asText(object.label);
+    if (rowLabel) row.label = rowLabel;
+    return [row];
+  });
+  return droppedEntirely(label, list, rows) ? undefined : rows;
+};
+
+const readRelations = (raw: unknown, label: string): MappingRelation[] | undefined => {
+  const list = asList(raw);
+  if (!list) return undefined;
+  const relations = list.flatMap((entry) => {
+    const localName = predicateOf(entry);
+    const object = asRecord(entry) || {};
+    const kind = asText(object.kind);
+    const relationLabel = asText(object.label);
+    const direction = asText(object.direction) as MappingRelation["direction"] | undefined;
+    if (!localName || !kind || !relationLabel || !direction) return [];
+    // The SVG draws a fixed set of edge kinds; anything else would render as an invisible edge.
+    if (!isRelationEdgeKind(kind)) {
+      warn(`ignoring relation "${localName}": unknown edge kind "${kind}"`);
+      return [];
+    }
+    if (!DIRECTIONS.includes(direction)) return [];
+    return [{ localName, kind: kind as RelationEdgeKind, label: relationLabel, direction }];
+  });
+  return droppedEntirely(label, list, relations) ? undefined : relations;
+};
+
+const readLegend = (
+  raw: unknown,
+  label: string
+): { kind: RelationEdgeKind; label: string }[] | undefined => {
+  const list = asList(raw);
+  if (!list) return undefined;
+  const legend = list.flatMap((entry) => {
+    const object = asRecord(entry) || {};
+    const kind = asText(object.kind);
+    const entryLabel = asText(object.label);
+    if (!kind || !entryLabel || !isRelationEdgeKind(kind)) return [];
+    return [{ kind: kind as RelationEdgeKind, label: entryLabel }];
+  });
+  return droppedEntirely(label, list, legend) ? undefined : legend;
+};
+
+// Used by `filters.displayed`: a list of predicate names.
+const readPredicateList = (raw: unknown, label: string): string[] | undefined => {
+  const list = asList(raw);
+  if (!list) return undefined;
+  const names = list.map(predicateOf).filter((name): name is string => Boolean(name));
+  return droppedEntirely(label, list, names) ? undefined : names;
+};
+
+const readPredicates = (raw: unknown): Record<string, { label?: string; tooltip?: string }> => {
+  const object = asRecord(raw);
+  if (!object) return {};
+  const out: Record<string, { label?: string; tooltip?: string }> = {};
+  for (const [key, value] of Object.entries(object)) {
+    if (key.startsWith("$")) continue; // "$comment" and friends are documentation, not predicates
+    const localName = normalizePredicate(key);
+    if (!localName) continue;
+    // `"ilxtr:hasSomaLocatedIn": "Soma location"` is the shorthand for a label with no tooltip.
+    const shorthand = asText(value);
+    const entry = asRecord(value);
+    const label = shorthand || (entry && asText(entry.label));
+    const tooltip = entry && asText(entry.tooltip);
+    if (!label && !tooltip) continue;
+    out[localName] = { ...(label ? { label } : {}), ...(tooltip ? { tooltip } : {}) };
+  }
+  return out;
+};
+
+const applyRegions = (
+  base: OntologyMappings["regions"],
+  raw: unknown
+): OntologyMappings["regions"] => {
+  const section = asRecord(raw);
+  if (!section) return base;
+
+  const tile = asRecord(section.tile);
+  const filters = asRecord(section.filters);
+  const card = asRecord(section.cellCard);
+  const definition = asRecord(card?.definition);
+  const biological = asRecord(card?.biologicalProperties);
+  const anatomical = asRecord(card?.anatomicalContext);
+  const graph = asRecord(card?.relationshipGraph);
+  const transcriptomic = asRecord(card?.transcriptomicProfile);
+  const grouping = asRecord(card?.cellGrouping);
+
+  // `"footer": null` removes it; anything nameable replaces it; anything else is a mistake and
+  // keeps the existing footer rather than silently dropping it.
+  const footer = ((): OntologyMappings["regions"]["tile"]["footer"] => {
+    if (!tile || !("footer" in tile)) return base.tile.footer;
+    if (tile.footer === null) return undefined;
+    const localName = predicateOf(tile.footer);
+    if (!localName) {
+      warn("ignoring tile.footer: expected a predicate name or null, keeping the existing configuration");
+      return base.tile.footer;
+    }
+    return { localName };
+  })();
+
+  // A present-but-malformed value (wrong type, empty string, an object missing predicate/
+  // localName) keeps `fallback` rather than silently clearing the role, matching every other
+  // reader's "a mistake leaves the layer beneath in place" rule.
+  const role = (key: string, fallback: string | undefined): string | undefined => {
+    if (!definition || !(key in definition)) return fallback;
+    const value = predicateOf(definition[key]);
+    if (!value) {
+      warn(`ignoring cellCard.definition.${key}: expected a predicate name, keeping the existing configuration`);
+      return fallback;
+    }
+    return value;
+  };
+
+  return {
+    tile: {
+      headerChips: readChips(tile?.headerChips, "tile.headerChips") || base.tile.headerChips,
+      rows: readRows(tile?.rows, "tile.rows") || base.tile.rows,
+      footer,
+    },
+    filters: {
+      minOptions: asCount(filters?.minOptions) ?? base.filters.minOptions,
+      displayed:
+        readPredicateList(filters?.displayed, "filters.displayed") || base.filters.displayed,
+    },
+    cellCard: {
+      definition: {
+        cellClass: role("cellClass", base.cellCard.definition.cellClass),
+        species: role("species", base.cellCard.definition.species),
+        somaLocation: role("somaLocation", base.cellCard.definition.somaLocation),
+        markerGenes: role("markerGenes", base.cellCard.definition.markerGenes),
+        minPredicates:
+          asCount(definition?.minPredicates) ?? base.cellCard.definition.minPredicates,
+      },
+      biologicalProperties: {
+        rows:
+          readRows(biological?.rows, "cellCard.biologicalProperties.rows") ||
+          base.cellCard.biologicalProperties.rows,
+      },
+      anatomicalContext: {
+        rows:
+          readRows(anatomical?.rows, "cellCard.anatomicalContext.rows") ||
+          base.cellCard.anatomicalContext.rows,
+      },
+      relationshipGraph: {
+        predicates:
+          readRelations(graph?.predicates, "cellCard.relationshipGraph.predicates") ||
+          base.cellCard.relationshipGraph.predicates,
+        legend:
+          readLegend(graph?.legend, "cellCard.relationshipGraph.legend") ||
+          base.cellCard.relationshipGraph.legend,
+        subClassOfLabel:
+          asText(graph?.subClassOfLabel) || base.cellCard.relationshipGraph.subClassOfLabel,
+        assertedSubClassOfLabel:
+          asText(graph?.assertedSubClassOfLabel) ||
+          base.cellCard.relationshipGraph.assertedSubClassOfLabel,
+      },
+      transcriptomicProfile: {
+        markerGenePredicate:
+          predicateOf(transcriptomic?.markerGenePredicate) ||
+          base.cellCard.transcriptomicProfile.markerGenePredicate,
+      },
+      cellGrouping: {
+        axonPredicate:
+          predicateOf(grouping?.axonPredicate) || base.cellCard.cellGrouping.axonPredicate,
+      },
+    },
+  };
+};
+
+// --- layering ----------------------------------------------------------------
+
+// `predicates` merges per predicate *and* per field within it, so the documented relabel
+// shorthand (naming just a label) does not erase that predicate's built-in tooltip.
+const mergePredicates = (
+  base: Record<string, { label?: string; tooltip?: string }>,
+  overrides: Record<string, { label?: string; tooltip?: string }>
+): Record<string, { label?: string; tooltip?: string }> => {
+  const merged = { ...base };
+  for (const [key, value] of Object.entries(overrides)) {
+    merged[key] = { ...merged[key], ...value };
+  }
+  return merged;
+};
+
+// Apply one document section over the mappings resolved so far. Absent keys leave the layer
+// beneath untouched; a present key replaces it wholesale (a configuration listing tile rows is
+// stating the whole row set, not appending to the default one). `predicates` is the exception: it
+// merges per predicate, so naming one label does not erase the other twelve.
+const applySection = (base: OntologyMappings, raw: unknown): OntologyMappings => {
+  const section = asRecord(raw);
+  if (!section) return base;
+  return {
+    fields: applyFields(base.fields, section.fields),
+    predicates: mergePredicates(base.predicates, readPredicates(section.predicates)),
+    regions: applyRegions(base.regions, section.regions),
+  };
+};
+
+// Resolve a whole document for one ontology: the document's `default` section, then its
+// per-ontology one, over the built-in mappings.
+export const resolveMappings = (document: unknown, slug: string): OntologyMappings => {
+  const root = asRecord(document);
+  if (!root) return DEFAULT_MAPPINGS;
+  const ontologies = asRecord(root.ontologies);
+  // A document with neither key *is* the section — the one-file-per-ontology layout.
+  const shared = "default" in root || ontologies ? root.default : root;
+  return applySection(applySection(DEFAULT_MAPPINGS, shared), ontologies?.[slug]);
+};
+
+// --- fetch -------------------------------------------------------------------
+
+const fetchDocument = async (url: string): Promise<unknown> => {
+  const res = await fetch(url, { headers: { Accept: "application/json" }, credentials: "omit" });
+  if (!res.ok) throw new Error(`HTTP ${res.status} fetching ${url}`);
+  const text = await res.text();
+  // A missing path under the SPA answers with index.html (HTTP 200), not JSON — the same trap the
+  // ontology loader guards against.
+  if (text.trimStart().startsWith("<")) {
+    throw new Error(`Expected JSON but received HTML from ${url}`);
+  }
+  return JSON.parse(text);
+};
+
+// One in-flight fetch per resolved URL, dropped again on failure so a later navigation retries
+// instead of being served the fallback for the rest of the session.
+const documents = new Map<string, Promise<unknown>>();
+
+const getDocument = (url: string): Promise<unknown> => {
+  const pending = documents.get(url);
+  if (pending) return pending;
+  const request = fetchDocument(url).catch((err) => {
+    documents.delete(url);
+    throw err;
+  });
+  documents.set(url, request);
+  return request;
+};
+
+// Resolved mappings per slug, so `loadOntology` gets a stable object identity on repeat calls and
+// can tell "same configuration" from "the configuration finally loaded" by reference.
+const resolved = new Map<string, OntologyMappings>();
+
+/**
+ * The mappings for one ontology. Never rejects: a document that cannot be fetched or parsed leaves
+ * the app on `DEFAULT_MAPPINGS`, which is what it renders today, and logs why.
+ */
+export const loadMappings = async (slug: string): Promise<OntologyMappings> => {
+  const cached = resolved.get(slug);
+  if (cached) return cached;
+  const url = urlFor(slug);
+  try {
+    const mappings = resolveMappings(await getDocument(url), slug);
+    resolved.set(slug, mappings);
+    return mappings;
+  } catch (err) {
+    warn(`${err instanceof Error ? err.message : err} — falling back to the built-in mappings`);
+    return DEFAULT_MAPPINGS;
+  }
+};
diff --git a/src/components/CellCards/model/mappings.ts b/src/components/CellCards/model/mappings.ts
new file mode 100644
index 0000000..d6f3613
--- /dev/null
+++ b/src/components/CellCards/model/mappings.ts
@@ -0,0 +1,209 @@
+// Configuration for the Cell Cards views, in two parts.
+//
+// **fields** — the data model's own fields are fixed: a term always has a title, a description, an
+// identifier, source publications, cross-nomenclature mappings. What a configuration changes is
+// *which source* fills each one, as an ordered list with fallbacks — `cellcard-spec/mappings.md`
+// §1.1 writes exactly that: "localLabel (title) | npokb ID → ilxtr:localLabel (if no localLabel,
+// then rdfs:label)". Rebinding a field never changes `CellTerm`'s shape, only where its value came
+// from, so every consumer downstream is unaffected.
+//
+// **regions** — which *additional* fields each region of the UI puts on screen: the grid tile's
+// header chips, property rows and footer; the Cell Card's per-widget rows and graph edges. These
+// are lists because the spec makes them the organisation's choice ("the organization can choose
+// which header elements and property rows to display").
+//
+// Predicates are keyed by *local name* here (`hasSomaLocatedIn`), because that is how the parser
+// keys a `CellProperty`. The JSON is written in CURIEs, which is how the spec and the ontology name
+// them. `fields` is the exception: its sources stay in the form the graph writes them, since the
+// order of `definition` vs `skos:definition` vs `NIFRID:definition` is the whole point of the list
+// and all three share one local name.
+
+import type { RelationEdgeKind } from "./types";
+
+export type ChipTone = "class" | "subtype" | "species";
+export type RowRender = "text" | "chip";
+
+// --- fields: model field <- ordered sources ----------------------------------
+
+/**
+ * Where one model field's value comes from, best source first. The parser takes the first source
+ * the node actually carries, which is what makes the list a fallback chain.
+ *
+ * `matchLocalName` relaxes the match to the predicate's local name under any prefix, for fields
+ * whose predicate is not yet in the file's @context — the SPARC / NervoSensus deep links arrive
+ * under `ilx:`, `ilxtr:` or an expanded IRI depending on who writes them. It is off by default
+ * because most local names are not unique: `TEMP:subClassOf` and `rdfs:subClassOf` are different
+ * relations that would collide.
+ */
+export interface FieldSource {
+  sources: string[];
+  matchLocalName?: boolean;
+}
+
+// Evidence type -> the relations that assert it. Cross-nomenclature evidence has no predicate of
+// its own in the graph; it is derived from *which* relation made the link (spec §2.7).
+export interface MappingEvidenceSources {
+  described: string[];
+  inferred: string[];
+  proposed: string[];
+}
+
+export interface FieldSources {
+  // Term identity and prose.
+  title: FieldSource;
+  description: FieldSource;
+  // How many entries of `description.sources` count as curated prose. Anything past this is still
+  // shown, but reported as uncurated so the UI can say where the text came from instead of passing
+  // generated output off as a definition.
+  curatedDescriptionSources: number;
+  // The class marking a record as a cell (matched on @type), and the relation the hierarchy walks.
+  cellType: FieldSource;
+  parent: FieldSource;
+
+  // Annotations that are not phenotypes. One model field each; see CellAnnotations.
+  literatureCitation: FieldSource;
+  dataCitation: FieldSource;
+  atlasAnnotation: FieldSource;
+  curatorNote: FieldSource;
+  alertNote: FieldSource;
+  temporaryId: FieldSource;
+  generatedLabel: FieldSource;
+  error: FieldSource;
+  sparcTranscriptomicsLink: FieldSource;
+  sparcMap: FieldSource;
+  nervoSensusLink: FieldSource;
+
+  // Literal-valued predicates lifted onto `properties`, so they are facetable and can fill a row.
+  // (The `neurdf.*` phenotype families need no configuration: the model keys them by local name
+  // whatever they are.)
+  literalProperties: FieldSource;
+
+  crossNomenclature: MappingEvidenceSources;
+
+  // The annotations that carry a predicate's own display metadata, which is what lets an ontology
+  // name its rows rather than the front end doing it.
+  predicateLabel: FieldSource;
+  predicateDescription: FieldSource;
+
+  // The owl:Ontology node's header fields.
+  ontologyTitle: FieldSource;
+  ontologyDescription: FieldSource;
+  ontologyVersion: FieldSource;
+
+  // Placeholder object ids meaning "this phenotype is *not specified*". Not real terms, so they
+  // must never surface as a value, a facet option or a tile chip. Matched as a prefix.
+  missingValuePrefixes: string[];
+}
+
+// --- regions: which additional fields each part of the UI shows ---------------
+
+// Label / tooltip for a predicate the ontology does not describe itself. The ontology's own
+// `ilxtr:displayLabel` / `ilxtr:shortDefinition` win wherever they are consulted; this covers the
+// rest — `neurondmBaseClass` and the source footer have no property node to carry an annotation.
+export interface PredicateConfig {
+  label?: string;
+  tooltip?: string;
+}
+
+// A tile header chip: a predicate plus the palette tone its chips take.
+export interface MappingChip {
+  localName: string;
+  tone: ChipTone;
+}
+
+// One property row of a tile or a Cell Card widget.
+export interface MappingRow {
+  localName: string;
+  render?: RowRender;
+  // Keep the row (reading "not specified") when the predicate is absent, instead of hiding it.
+  required?: boolean;
+  // Pins this row's label for this region only, ahead of every other source. The spec's tile rows
+  // deliberately read differently from the same predicate's Cell Card row ("Physiology" against
+  // the ontology's "Function"), and this is how a configuration says so.
+  label?: string;
+}
+
+// A phenotype predicate the relationship graph may draw, and as which edge.
+export interface MappingRelation {
+  localName: string;
+  kind: RelationEdgeKind;
+  label: string; // the caption drawn on the connector
+  // Which side of the current node the targets sit on. "down" = a rank below (children), "up" = a
+  // rank above (parents), "left"/"right" = a satellite on the same rank.
+  direction: "up" | "down" | "left" | "right";
+}
+
+// The edge kinds `RelationshipGraphSvg` knows how to draw. A configured relation naming anything
+// else is dropped in normalisation: there is no stroke, dash or arrow marker for it, so drawing it
+// would produce an invisible edge rather than a new one.
+export const RELATION_EDGE_KINDS: RelationEdgeKind[] = [
+  "subClassOf",
+  "assertedSubClassOf",
+  "somaLocation",
+  "expresses",
+];
+
+export interface TileRegion {
+  headerChips: MappingChip[];
+  rows: MappingRow[];
+  // The tile's source footer. Omit it to drop the footer entirely.
+  footer?: { localName: string };
+}
+
+export interface FiltersRegion {
+  // A facet offering fewer than this many distinct options can't narrow anything, so it is hidden.
+  minOptions: number;
+  // Which properties the "Displayed properties" toggle restricts the sidebar to. Empty means
+  // "derive from the tile", which is the default and keeps the two from drifting apart.
+  displayed: string[];
+}
+
+// The auto-generated description (spec §2.1): fixed sentence tokens, each bound to a predicate.
+export interface DefinitionRegion {
+  cellClass?: string;
+  species?: string;
+  somaLocation?: string;
+  markerGenes?: string;
+  // The banner is suppressed unless at least `minPredicates` of species/somaLocation/markerGenes
+  // are populated on the cell, so it never renders a sentence with holes in it. `cellClass` is not
+  // one of them: the sentence's subject falls back to "cell" and is never blank, so it cannot be
+  // one of the holes this gate exists to catch. Counted straight off these bindings rather than a
+  // separately configured list, so the gate can't drift from what the banner actually renders.
+  minPredicates: number;
+}
+
+export interface RelationshipGraphRegion {
+  predicates: MappingRelation[];
+  legend: { kind: RelationEdgeKind; label: string }[];
+  subClassOfLabel: string;
+  assertedSubClassOfLabel: string;
+}
+
+export interface CellCardRegion {
+  definition: DefinitionRegion;
+  biologicalProperties: { rows: MappingRow[] };
+  anatomicalContext: { rows: MappingRow[] };
+  relationshipGraph: RelationshipGraphRegion;
+  transcriptomicProfile: { markerGenePredicate: string };
+  // The Interactive Cell Grouping widget's NervoSensus deep link reads its fiber-type filter from
+  // here; its species/soma filters reuse `definition.species`/`somaLocation` directly, since both
+  // features mean the same predicate.
+  cellGrouping: { axonPredicate: string };
+}
+
+export interface MappingRegions {
+  tile: TileRegion;
+  filters: FiltersRegion;
+  cellCard: CellCardRegion;
+}
+
+export interface OntologyMappings {
+  fields: FieldSources;
+  predicates: Record<string, PredicateConfig>;
+  regions: MappingRegions;
+}
+
+// The pseudo-predicate the model uses for the literature citation: the parser lifts citations off
+// `properties` onto `CellTerm.sources`, and the tile footer and the source facet address them under
+// this name. A region may write either form.
+export const SOURCE_PREDICATE = "source";
diff --git a/src/components/CellCards/model/types.ts b/src/components/CellCards/model/types.ts
index cf7c396..9f44289 100644
--- a/src/components/CellCards/model/types.ts
+++ b/src/components/CellCards/model/types.ts
@@ -75,7 +75,8 @@ export interface CellMapping {
 // the parse is the ontology→model seam and the fixture check pins them (checkParser.mjs), not
 // because something renders them: `curatorNotes` is destined for the Discussions thread as
 // system comments (spec §10.4), which is blocked on a service that 404s for every term id, and
-// the three link fields are the widgets' forward-compatible path — see LINK_ANNOTATIONS.
+// the three link fields are the widgets' forward-compatible path — see `fields.sparcMap` and its
+// neighbours in model/mappings.ts, which match the predicate under any prefix.
 export interface CellAnnotations {
   atlasAnnotation: string[]; // ilxtr:atlasAnnotation — Precision dataset annotation pills
   curatorNotes: string[]; // ilxtr:curatorNote — awaiting the Discussions wire-up (spec §10.4)
@@ -160,7 +161,8 @@ export interface Facet {
 
 // Display metadata for a predicate, read from the ontology itself: the 70 ilxtr:* property
 // nodes carry ilxtr:displayLabel + ilxtr:shortDefinition, which cover 14 of the 15 neurdf
-// local names used by Precision cells. gridConfig's hardcoded maps are only the fallback.
+// local names used by Precision cells. The mappings document's `predicates` section is only the
+// fallback for what the ontology omits.
 export interface PredicateDisplay {
   localName: string;
   label: string;
@@ -173,7 +175,7 @@ export interface PropertyRowModel {
   label: string;
   tooltip?: string;
   prop?: CellProperty; // absent => the row renders "not specified"
-  render?: "text" | "chip"; // carried through from the row's cellCardConfig entry
+  render?: "text" | "chip"; // carried through from the region's row entry
   required?: boolean; // keep the row (as "not specified") when the predicate is absent
 }
 
diff --git a/src/components/CellCards/services/ontologyGridService.ts b/src/components/CellCards/services/ontologyGridService.ts
index 6d96b4e..d5e63d4 100644
--- a/src/components/CellCards/services/ontologyGridService.ts
+++ b/src/components/CellCards/services/ontologyGridService.ts
@@ -8,10 +8,15 @@ import {
   NEURDF_LOCAL_URL,
   PREFER_LOCAL_NEURDF,
   ONTOLOGY_CATALOG,
-  DISPLAYED_PROPERTIES,
-  PREDICATE_LABELS,
-  PREDICATE_TOOLTIPS,
 } from "../config/gridConfig";
+import { loadMappings } from "../config/mappingsService";
+import { DEFAULT_MAPPINGS } from "../config/mappingDefaults";
+import { publishMappings } from "../config/mappingsAtom";
+import {
+  displayedProperties,
+  predicateLabels,
+  predicateTooltips,
+} from "../config/mappingDefaults";
 import type {
   OntologyGraph,
   ParsedOntology,
@@ -19,6 +24,8 @@ import type {
   CellTerm,
   HierarchyNode,
 } from "../model/types";
+import type { FieldSources, OntologyMappings } from "../model/mappings";
+import { SOURCE_PREDICATE } from "../model/mappings";
 import type { OntologyEntry } from "../config/gridConfig";
 
 export interface LoadedOntology {
@@ -27,6 +34,9 @@ export interface LoadedOntology {
   cells: CellTerm[];
   hierarchy: HierarchyNode[];
   predicateDisplay: ParsedOntology["predicateDisplay"];
+  // Which predicate feeds which tile row / widget row / graph edge, fetched alongside the graph
+  // so a view never renders before it knows what to show. See config/mappingsService.
+  mappings: OntologyMappings;
 }
 
 const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
@@ -109,17 +119,36 @@ const getGraph = (): Promise<OntologyGraph> => {
   return graphPromise;
 };
 
-// Parsed result cache, keyed by ontology slug (parse depends on the root class).
-const parsedCache = new Map<string, LoadedOntology>();
+// Parsed result cache, keyed by ontology slug (the parse depends on the root class *and* on the
+// field sources, so the sources it was produced with are kept alongside it). Split from the
+// composed result below so that a mappings fetch which failed on the first load is retried on the
+// next navigation, and only re-parses if the retry actually changed where a field reads from.
+const parsedCache = new Map<string, { fields: FieldSources; parsed: ParsedOntology }>();
+const loadedCache = new Map<string, LoadedOntology>();
 
 export const loadOntology = async (slug: string): Promise<LoadedOntology> => {
   const entry = ONTOLOGY_CATALOG[slug];
   if (!entry) throw new Error(`Unknown ontology "${slug}"`);
-  const cached = parsedCache.get(slug);
-  if (cached) return cached;
 
-  const graph = await getGraph();
-  const parsed = parseNeurdf(graph, entry.rootClass);
+  // Cheap and separately cached: resolved config comes back by identity, so an unchanged config
+  // hands back the very same LoadedOntology and the grid keeps its filter state.
+  const mappings = await loadMappings(slug);
+  // Published here rather than from an effect, so the components rendered from the result below
+  // never see one frame of the built-in configuration first.
+  publishMappings(mappings);
+  const cached = loadedCache.get(slug);
+  if (cached && cached.mappings === mappings) return cached;
+
+  let entryParse = parsedCache.get(slug);
+  if (entryParse?.fields !== mappings.fields) {
+    entryParse = {
+      fields: mappings.fields,
+      parsed: parseNeurdf(await getGraph(), entry.rootClass, mappings.fields),
+    };
+    parsedCache.set(slug, entryParse);
+  }
+  const parsed = entryParse.parsed;
+
   const loaded: LoadedOntology = {
     entry,
     // Header identity is read straight from the file's owl:Ontology node
@@ -128,8 +157,12 @@ export const loadOntology = async (slug: string): Promise<LoadedOntology> => {
     cells: parsed.cells,
     hierarchy: parsed.hierarchy,
     predicateDisplay: parsed.predicateDisplay,
+    mappings,
   };
-  parsedCache.set(slug, loaded);
+  // A `DEFAULT_MAPPINGS` result means the fetch failed and `loadMappings` will retry it on the
+  // next call — caching that here would let `peekOntology`'s synchronous fast path (see
+  // useCellTerm) serve the fallback forever instead of picking up the retry.
+  if (mappings !== DEFAULT_MAPPINGS) loadedCache.set(slug, loaded);
   return loaded;
 };
 
@@ -138,7 +171,7 @@ export const loadOntology = async (slug: string): Promise<LoadedOntology> => {
 // it unmounts the Cell Card and takes every widget's state with it. The hierarchy widget has to
 // survive a cell → cell navigation (spec §3.2), so `useCellTerm` reads through this instead and
 // only falls back to the async path on a cold load.
-export const peekOntology = (slug: string): LoadedOntology | undefined => parsedCache.get(slug);
+export const peekOntology = (slug: string): LoadedOntology | undefined => loadedCache.get(slug);
 
 // --- single-term selectors (Cell Card) ---------------------------------------
 
@@ -215,6 +248,83 @@ export const hierarchyNeighbours = (
   return { parents, children };
 };
 
+// --- hierarchy scopes (Browse) ------------------------------------------------
+
+// The two directions the Browse tab reads the subClassOf hierarchy in, around the class selected
+// in its tree: the terms below that class, or the terms above it.
+export const SUBCLASSES = "subclasses" as const;
+export const SUPERCLASSES = "superclasses" as const;
+export type HierarchyScope = typeof SUBCLASSES | typeof SUPERCLASSES;
+
+// termId -> its direct children / parents, collapsed out of the positional hierarchy. A class with
+// several parents is drawn at several paths, so the same edge is reached more than once; a Set per
+// side makes the adjacency the DAG the positions were expanded from.
+const adjacency = (roots: HierarchyNode[]) => {
+  const children = new Map<string, Set<string>>();
+  const parents = new Map<string, Set<string>>();
+  const add = (map: Map<string, Set<string>>, from: string, to: string) => {
+    const set = map.get(from);
+    if (set) set.add(to);
+    else map.set(from, new Set([to]));
+  };
+  const walk = (nodes: HierarchyNode[], parent?: string) => {
+    for (const node of nodes) {
+      if (parent) {
+        add(children, parent, node.termId);
+        add(parents, node.termId, parent);
+      }
+      walk(node.children, node.termId);
+    }
+  };
+  walk(roots);
+  return { children, parents };
+};
+
+// Everything reachable from `start` along one side of the adjacency, transitively.
+//
+// This is a union over *every* path, unlike the Cell Card hierarchy widget's ancestor spine
+// (`findPath`, first position only) — the widget has to draw one nested chain, while a term list is
+// a set and so takes them all. `start` is never in the result; whether the caller wants it back is
+// its own decision (see `scopedCells`).
+const closure = (start: string, edges: Map<string, Set<string>>): Set<string> => {
+  const out = new Set<string>();
+  const stack = [...(edges.get(start) || [])];
+  while (stack.length) {
+    const id = stack.pop() as string;
+    if (out.has(id)) continue;
+    out.add(id);
+    stack.push(...(edges.get(id) || []));
+  }
+  out.delete(start); // a subClassOf cycle can walk back to it
+  return out;
+};
+
+// The ontology's terms that sit under (or over) `termId`, in the parse's alphabetical order.
+//
+// The two directions are deliberately not symmetric, and the labels the Browse tab puts on them say
+// so. Downwards is "<term> and its sub classes" — it includes the class itself, because 126 of the
+// 161 Precision terms are leaves and a scope that dropped the very term you clicked would answer
+// most of the tree with an empty table. Upwards is "super class of <term>", a question about other
+// terms, which the term itself is not an answer to.
+//
+// Only terms are returned either way, so the ontology's root class — `ilxtr:NeuronPrecision`, what
+// the set is defined *against* rather than a member of it — never appears as a row. Reading upwards
+// from a top-level cell therefore lands on the empty list, which is the honest answer: no term in
+// this ontology is a superclass of it.
+export const scopedCells = (
+  data: LoadedOntology,
+  termId: string,
+  scope: HierarchyScope
+): CellTerm[] => {
+  const { children, parents } = adjacency(data.hierarchy);
+  if (scope === SUPERCLASSES) {
+    const above = closure(termId, parents);
+    return data.cells.filter((c) => above.has(c.id));
+  }
+  const below = closure(termId, children);
+  return data.cells.filter((c) => c.id === termId || below.has(c.id));
+};
+
 // Which predicates are present across the cells (+ "source" from literatureCitation).
 const presentNames = (cells: CellTerm[]): { found: Set<string>; hasSource: boolean } => {
   const found = new Set<string>();
@@ -227,22 +337,52 @@ const presentNames = (cells: CellTerm[]): { found: Set<string>; hasSource: boole
 };
 
 const isPresent = (n: string, found: Set<string>, hasSource: boolean): boolean =>
-  found.has(n) || (n === "source" && hasSource);
+  found.has(n) || (n === SOURCE_PREDICATE && hasSource);
 
 // Facet localnames in display order. displayedOnly=true keeps only the properties shown on
 // the tiles; otherwise every property found on the terms, the tile ones first.
-const facetNames = (cells: CellTerm[], displayedOnly: boolean): string[] => {
+const facetNames = (
+  cells: CellTerm[],
+  displayed: string[],
+  displayedOnly: boolean
+): string[] => {
   const { found, hasSource } = presentNames(cells);
-  const displayed = DISPLAYED_PROPERTIES.filter((n) => isPresent(n, found, hasSource));
-  if (displayedOnly) return displayed;
-  const rest = [...found].filter((n) => !DISPLAYED_PROPERTIES.includes(n)).sort();
-  return [...displayed, ...rest];
+  const shown = displayed.filter((n) => isPresent(n, found, hasSource));
+  if (displayedOnly) return shown;
+  // "source" lives on `cell.sources`, not `cell.properties`, so it never joins `found` on its
+  // own — add it back here so "show everything" can still recover the Source facet even when
+  // `tile.footer` (and therefore `displayed`) has been configured to hide the tile's source row.
+  const rest = [...found, ...(hasSource ? [SOURCE_PREDICATE] : [])]
+    .filter((n) => !displayed.includes(n))
+    .sort();
+  return [...shown, ...rest];
 };
 
-// A facet needs at least this many distinct options to be worth showing — filtering on a
-// single-option facet (e.g. Cell class = only "neuron") can't narrow anything.
-const MIN_FACET_OPTIONS = 2;
+// The ontology's own `ilxtr:displayLabel`/`ilxtr:shortDefinition` outrank the mappings document's
+// `predicates` section, same as the Cell Card's row labels (see buildRows.js) — a curator editing
+// a displayLabel upstream should rename a predicate everywhere it appears, not just on the card.
+const withPredicateDisplay = (
+  data: LoadedOntology
+): { titles: Record<string, string>; tooltips: Record<string, string> } => {
+  const titles = { ...predicateLabels(data.mappings) };
+  const tooltips = { ...predicateTooltips(data.mappings) };
+  for (const [localName, display] of Object.entries(data.predicateDisplay)) {
+    titles[localName] = display.label;
+    if (display.description) tooltips[localName] = display.description;
+  }
+  return { titles, tooltips };
+};
 
-// Facets built from the data. displayedOnly=true → only the properties shown on the tiles.
-export const getFacets = (cells: CellTerm[], displayedOnly: boolean): Facet[] =>
-  buildFacets(cells, facetNames(cells, displayedOnly), PREDICATE_LABELS, PREDICATE_TOOLTIPS, MIN_FACET_OPTIONS);
+// Facets built from the data. displayedOnly=true → only the properties shown on the tiles, which
+// the mappings define (see `displayedProperties`); the minimum option count is configured too —
+// a facet offering a single value (Cell class = only "neuron") can't narrow anything.
+export const getFacets = (data: LoadedOntology, displayedOnly: boolean): Facet[] => {
+  const { titles, tooltips } = withPredicateDisplay(data);
+  return buildFacets(
+    data.cells,
+    facetNames(data.cells, displayedProperties(data.mappings), displayedOnly),
+    titles,
+    tooltips,
+    data.mappings.regions.filters.minOptions
+  );
+};
diff --git a/src/components/SingleTermView/OverView/OverView.jsx b/src/components/SingleTermView/OverView/OverView.jsx
index e36f9da..6f7d4ac 100644
--- a/src/components/SingleTermView/OverView/OverView.jsx
+++ b/src/components/SingleTermView/OverView/OverView.jsx
@@ -361,7 +361,9 @@ const OverView = ({ searchTerm, isCodeViewVisible = false, selectedDataFormat, g
       store.hierarchy$.next({ loading: false, ...ontologyHierarchy(ontology, focusId) });
       store.predicates$.next({
         loading: false,
-        data: focusCell ? ontologyPredicateGroups(focusCell, ontology?.predicateDisplay) : [],
+        data: focusCell
+          ? ontologyPredicateGroups(focusCell, ontology?.predicateDisplay, ontology?.mappings)
+          : [],
         focusId,
       });
     });
diff --git a/src/components/SingleTermView/index.jsx b/src/components/SingleTermView/index.jsx
index 04ba8c0..aadd88d 100644
--- a/src/components/SingleTermView/index.jsx
+++ b/src/components/SingleTermView/index.jsx
@@ -67,6 +67,10 @@ import { useTermRecordAvailability } from "../../hooks/useTermRecordAvailability
 
 const { gray200, gray500, gray600, error700 } = vars;
 
+// Groups that own a curated ontology (per ONTOLOGY_CATALOG) are first-class sources in their own
+// right, same as base — not a fork of it. Only a group outside this set is actually a fork.
+const CURATED_GROUPS = new Set(["base", ...Object.values(ONTOLOGY_CATALOG).map((entry) => entry.org)]);
+
 // Pull the InterLex id (ilx_/tmp_) out of an arbitrary IRI/string for membership checks.
 const extractIlxId = (value) => {
   const match = String(value || "").match(/(?:ilx|tmp)_\d+/i);
@@ -420,7 +424,7 @@ const SingleTermView = () => {
     }
   }, [tab, tabMapping, tabLabels, navigate, group, contextEntry, term, tabValue, versionHash, tabNames, DEFAULT_TAB_INDEX, location.search, isTermRecordPending]);
 
-  const isItFork = actualGroup === 'base' ? false : true; // Use actualGroup instead of group
+  const isItFork = !CURATED_GROUPS.has(actualGroup);
 
   // Memoize tab content to prevent unnecessary re-renders
   const tabContent = useMemo(() => {
@@ -565,7 +569,7 @@ const SingleTermView = () => {
               </Stack>
             </Grid>
             <Grid container mt="1.75rem">
-              <Grid item xs={12} lg={2}>
+              <Grid item xs={12} lg="auto">
                 <Stack direction="row" spacing=".75rem" alignItems="center">
                   <Typography color={gray600} fontSize="1.875rem" fontWeight={600}>
                     {/* The label is already known from the search (storedSearchTerm),
@@ -593,7 +597,7 @@ const SingleTermView = () => {
                   </Typography>
                 )}
               </Grid>
-              <Grid display="flex" justifyContent='end' mt=".56rem" item xs={12} lg={10}>
+              <Grid display="flex" justifyContent='end' mt=".56rem" item xs={12} lg>
                 <Stack direction="row" spacing="1rem" alignItems="center">
                   <Button type="string" color="secondary" startIcon={<ModeEditOutlineOutlinedIcon />} onClick={handleOpenEditTermDialog}>
                     Suggest changes
diff --git a/src/hooks/useContextOntology.js b/src/hooks/useContextOntology.js
index 2ef5b90..671722e 100644
--- a/src/hooks/useContextOntology.js
+++ b/src/hooks/useContextOntology.js
@@ -4,6 +4,7 @@ import { useParams } from "react-router-dom";
 import {
   ONTOLOGY_CATALOG,
   ontologyForTermSlug,
+  isIlxTermSlug,
 } from "../components/CellCards/config/gridConfig";
 import useCellTerm from "../components/CellCards/CellCard/useCellTerm";
 
@@ -27,8 +28,17 @@ export const usePublishContextOntology = (slug) => {
 
 /**
  * Which ontology is in context for this term: the `/ontology/{slug}/` the path was opened under
- * first, then the atom, then a catalogued ontology claiming the slug's prefix. Null for an ordinary
- * InterLex term, which must not load one.
+ * first — an explicit route beats every fallback below, including for an `ilx_`/`tmp_` slug that
+ * has been mapped to a catalogued ontology's cell and is being read on its ontology-scoped route.
+ * Absent that, a catalogued ontology claiming the slug's own prefix, then the atom (the last
+ * ontology route visited this session). Null for an ordinary InterLex term read on its plain
+ * route, which must not load one.
+ *
+ * The prefix match outranks the atom — a term that names a specific ontology by construction must
+ * resolve to that one even if the atom is still holding an unrelated ontology from an earlier
+ * page — and an `ilx_`/`tmp_` slug short-circuits to null rather than falling through to the atom:
+ * it addresses an ordinary InterLex term by construction, so on its plain route the atom (which
+ * nothing ever clears) must not get a vote for it either.
  *
  * The URL wins and is read synchronously so a shared deep link resolves on its first render; the
  * sync is one-way (URL -> atom), leaving react-router the only writer of the URL.
@@ -42,7 +52,9 @@ export const useContextOntologySlug = (termSlug) => {
     if (valid && valid !== stored) setStored(valid);
   }, [valid, stored, setStored]);
 
-  return valid || stored || ontologyForTermSlug(termSlug) || null;
+  if (valid) return valid;
+  if (isIlxTermSlug(termSlug)) return null;
+  return ontologyForTermSlug(termSlug) || stored || null;
 };
 
 /**
diff --git a/src/parsers/__fixtures__/checkParser.mjs b/src/parsers/__fixtures__/checkParser.mjs
index 458946a..4e50f6b 100644
--- a/src/parsers/__fixtures__/checkParser.mjs
+++ b/src/parsers/__fixtures__/checkParser.mjs
@@ -8,6 +8,8 @@ import { dirname, join } from "node:path";
 import { parseNeurdf, parsePredicateDisplay } from "../neurdfParser";
 import { hasTranscriptomicProfile } from "../../components/CellCards/CellCard/widgetVisibility";
 import { buildNervoSensusLink, atlasCellKey } from "../../components/CellCards/CellCard/nervoSensusLink";
+import { resolveMappings } from "../../components/CellCards/config/mappingsService";
+import { DEFAULT_MAPPINGS } from "../../components/CellCards/config/mappingDefaults";
 
 const here = dirname(fileURLToPath(import.meta.url));
 const data = JSON.parse(readFileSync(join(here, "neurdf-precision-sample.jsonld"), "utf8"));
@@ -196,5 +198,46 @@ check(
   true
 );
 
+// --- runtime mappings ---------------------------------------------------------
+// The shipped configuration file and the built-in fallback must stay the same document: the
+// fallback exists so that a failed fetch renders what the file would have, and that guarantee is
+// only worth anything if nobody edits one without the other.
+console.log("\nmappings document");
+const shipped = JSON.parse(
+  readFileSync(join(here, "../../../public/config/cell-card-mappings.json"), "utf8")
+);
+check(
+  "public/config/cell-card-mappings.json resolves to DEFAULT_MAPPINGS",
+  resolveMappings(shipped, "precision"),
+  DEFAULT_MAPPINGS
+);
+
+// Rebinding a field moves where the model reads from, without changing the model's shape.
+const rebound = resolveMappings(
+  {
+    fields: {
+      title: ["ilxtr:genLabel", "rdfs:label"],
+      description: ["ilxtr:curatorNote"],
+      literalProperties: [],
+    },
+  },
+  "precision"
+).fields;
+const rebuilt = parseNeurdf(data, "ilxtr:NeuronPrecision", rebound);
+const rebuilt1067 = rebuilt.cells.find((c) => c.id === "npokb:1067");
+check(
+  "a rebound title reads the other annotation",
+  rebuilt1067.label,
+  byId["npokb:1067"].annotations.generatedLabel
+);
+check("…and the default did not", byId["npokb:1067"].label !== rebuilt1067.label, true);
+check("a rebound description follows too", rebuilt1067.definition, undefined);
+check(
+  "dropping a literal property drops it from `properties`",
+  "neurondmBaseClass" in rebuilt1067.properties,
+  false
+);
+check("while the rest of the model is untouched", rebuilt.cells.length, cells.length);
+
 console.log(failed ? `\n${failed} check(s) failed` : "\nall checks passed");
 process.exit(failed ? 1 : 0);
diff --git a/src/parsers/neurdfParser.ts b/src/parsers/neurdfParser.ts
index 431657b..7528104 100644
--- a/src/parsers/neurdfParser.ts
+++ b/src/parsers/neurdfParser.ts
@@ -22,31 +22,16 @@ import type {
   FacetValue,
   PredicateDisplay,
 } from "../components/CellCards/model/types";
+import type { FieldSource, FieldSources } from "../components/CellCards/model/mappings";
+import { DEFAULT_FIELD_SOURCES } from "../components/CellCards/config/mappingDefaults";
 
-// --- label + value helpers -------------------------------------------------
+// Which source fills which model field is configuration, not code: `FieldSources` binds `title`,
+// `description`, the citation and every annotation to an ordered list of predicates, so an
+// ontology that names its terms with `skos:prefLabel` needs no edit here. The model's own shape is
+// not configurable — a `CellTerm` always has a title and a description, whatever fills them.
+// See components/CellCards/model/mappings.ts and config/mappingDefaults.ts for the built-in list.
 
-// Display-label sources, ordered most-human-readable → machine-id last (spec §2.2 / §8).
-// Try the curated short label, then the standard label, then a title; only when a node
-// carries none of these do we fall back to its CURIE (the machine id). ilxtr:genLabel is
-// deliberately excluded — it is the verbose machine-generated string, never a title.
-const LABEL_KEYS = ["ilxtr:localLabel", "rdfs:label", "dc:title", "dcterms:title"];
-
-// Definition sources for the Terms table, best first. The first four are prose written by a
-// curator. The last two are fallbacks so the column still describes a term that has none of
-// those: ilxtr:genLabel is the phenotype string generated from the term's own axioms, and the
-// curator note is a last resort. Everything past CURATED_DEFINITION_KEYS is reported as
-// uncurated, so the UI can say where the text came from instead of passing generated output
-// off as a definition (the same care LABEL_KEYS takes in excluding genLabel as a *title*).
-const DEFINITION_KEYS = [
-  "definition",
-  "skos:definition",
-  "NIFRID:definition",
-  "rdfs:comment",
-  "ilxtr:genLabel",
-  "ilxtr:curatorNote",
-];
-
-const CURATED_DEFINITION_KEYS = 4;
+// --- label + value helpers -------------------------------------------------
 
 type LabelLike =
   | string
@@ -72,10 +57,6 @@ const firstString = (v: unknown): string | undefined => {
 const isBlankNode = (id: string): boolean => id.startsWith("_:");
 const isIri = (id: string): boolean => id.includes("://");
 
-// Some cells carry a "TEMP:MISSING_" placeholder meaning the phenotype is *not specified*.
-// It is not a real term, so it must never surface as a value / facet option / tile chip.
-const isMissingSentinel = (id: string): boolean => /^TEMP:MISSING/i.test(id);
-
 // --- prefix table: the parsed file's own @context ---------------------------
 
 // Prefix -> base IRI, read from the graph's @context. Every curie <-> IRI conversion below goes
@@ -174,24 +155,132 @@ const indexGraph = (graph: GraphNode[]): Index => {
   return idx;
 };
 
-const labelFor = (id: string, idx: Index, prefixes: Prefixes): string => {
-  const node = idx.get(id);
-  if (node) {
-    for (const key of LABEL_KEYS) {
-      const s = firstString(node[key]);
-      if (s) return s;
+// A predicate key reduced to its local name, so a source can be matched whatever prefix the file
+// wrote it under. "rdfs:label" -> "label", "http://…/hasSPARCMap" -> "hasSPARCMap".
+const localNameOf = (key: string, prefixes: Prefixes): string =>
+  classify(key, prefixes).curie.split(":").pop() || "";
+
+// Where one predicate's values land on the model. Annotation fields are single-purpose — one
+// predicate fills one slot — so the configured sources are inverted once into a lookup the
+// per-node loop can hit directly, instead of testing every key against every field.
+type FieldTarget =
+  | { slot: "sources" }
+  | { slot: "refs"; field: "dataCitations" }
+  | { slot: "text"; field: "atlasAnnotation" | "curatorNotes" | "alertNotes" }
+  | { slot: "links"; field: "sparcTranscriptomicsLinks" | "sparcMaps" | "nervoSensusLinks" }
+  | { slot: "temporaryId" }
+  | { slot: "generatedLabel" }
+  | { slot: "errors" }
+  | { slot: "property" }
+  | { slot: "mapping"; evidence: MappingEvidence };
+
+interface ParseContext {
+  idx: Index;
+  prefixes: Prefixes;
+  fields: FieldSources;
+  // Exact key -> target, and (for fields declaring `matchLocalName`) local name -> target.
+  exact: Map<string, FieldTarget>;
+  local: Map<string, FieldTarget>;
+  // Upper-cased "this phenotype is not specified" id prefixes.
+  missing: string[];
+}
+
+const buildContext = (
+  idx: Index,
+  prefixes: Prefixes,
+  fields: FieldSources
+): ParseContext => {
+  const exact = new Map<string, FieldTarget>();
+  const local = new Map<string, FieldTarget>();
+
+  // First registration wins, so a key claimed by two fields behaves as the ordered checks it
+  // replaces did.
+  const claim = (field: FieldSource, target: FieldTarget) => {
+    for (const key of field.sources) {
+      if (!exact.has(key)) exact.set(key, target);
+      if (field.matchLocalName) {
+        const name = localNameOf(key, prefixes);
+        if (name && !local.has(name)) local.set(name, target);
+      }
     }
+  };
+
+  claim(fields.literatureCitation, { slot: "sources" });
+  claim(fields.dataCitation, { slot: "refs", field: "dataCitations" });
+  claim(fields.atlasAnnotation, { slot: "text", field: "atlasAnnotation" });
+  claim(fields.curatorNote, { slot: "text", field: "curatorNotes" });
+  claim(fields.alertNote, { slot: "text", field: "alertNotes" });
+  claim(fields.temporaryId, { slot: "temporaryId" });
+  claim(fields.generatedLabel, { slot: "generatedLabel" });
+  claim(fields.error, { slot: "errors" });
+  claim(fields.sparcTranscriptomicsLink, { slot: "links", field: "sparcTranscriptomicsLinks" });
+  claim(fields.sparcMap, { slot: "links", field: "sparcMaps" });
+  claim(fields.nervoSensusLink, { slot: "links", field: "nervoSensusLinks" });
+  for (const [evidence, sources] of Object.entries(fields.crossNomenclature)) {
+    claim({ sources }, { slot: "mapping", evidence: evidence as MappingEvidence });
   }
-  return classify(id, prefixes).curie; // fall back to a compact curie when no label exists
+  // Literal-valued predicates surfaced as properties (not neurdf refs), so they are facetable and
+  // can fill a tile row.
+  claim(fields.literalProperties, { slot: "property" });
+
+  return {
+    idx,
+    prefixes,
+    fields,
+    exact,
+    local,
+    missing: fields.missingValuePrefixes.map((p) => p.toUpperCase()),
+  };
 };
 
+const targetFor = (key: string, ctx: ParseContext): FieldTarget | undefined => {
+  const direct = ctx.exact.get(key);
+  if (direct) return direct;
+  if (!ctx.local.size || key.startsWith("neurdf.")) return undefined; // a phenotype family
+  return ctx.local.get(localNameOf(key, ctx.prefixes));
+};
+
+// The first of a field's sources this node actually carries a string for, and how far down the
+// fallback chain it was found (which is what tells a curated definition from a generated one).
+const firstFieldText = (
+  node: GraphNode | undefined,
+  field: FieldSource,
+  ctx: ParseContext
+): { text: string; rank: number } | undefined => {
+  if (!node) return undefined;
+  for (let rank = 0; rank < field.sources.length; rank++) {
+    const key = field.sources[rank];
+    const direct = firstString(node[key]);
+    if (direct) return { text: direct, rank };
+    if (!field.matchLocalName) continue;
+    const wanted = localNameOf(key, ctx.prefixes);
+    for (const candidate of Object.keys(node)) {
+      if (localNameOf(candidate, ctx.prefixes) !== wanted) continue;
+      const text = firstString(node[candidate]);
+      if (text) return { text, rank };
+    }
+  }
+  return undefined;
+};
+
+// Some cells carry a "TEMP:MISSING_" placeholder meaning the phenotype is *not specified*. It is
+// not a real term, so it must never surface as a value / facet option / tile chip.
+const isMissingSentinel = (id: string, ctx: ParseContext): boolean => {
+  const upper = id.toUpperCase();
+  return ctx.missing.some((prefix) => upper.startsWith(prefix));
+};
+
+const labelFor = (id: string, ctx: ParseContext): string =>
+  firstFieldText(ctx.idx.get(id), ctx.fields.title, ctx)?.text ||
+  classify(id, ctx.prefixes).curie; // fall back to a compact curie when no label exists
+
 // Turn a predicate value (ref object, array, @list, or literal) into ResolvedRefs.
 //
 // `@list` matters: the union/intersection families serialise their members as a JSON-LD list
 // ({"@list":[{...},{...}]}), and `neurdf.eqv.uo:hasSomaLocatedIn` is the *only* soma-location
 // predicate on 61 of the 161 Precision cells. Treating a list object as an unrecognised value
 // silently dropped the property for all of them.
-const resolveValue = (raw: unknown, idx: Index, prefixes: Prefixes): ResolvedRef[] => {
+const resolveValue = (raw: unknown, ctx: ParseContext): ResolvedRef[] => {
   const out: ResolvedRef[] = [];
   const push = (item: unknown) => {
     if (item && typeof item === "object" && "@list" in (item as object)) {
@@ -201,16 +290,16 @@ const resolveValue = (raw: unknown, idx: Index, prefixes: Prefixes): ResolvedRef
     }
     if (item && typeof item === "object" && "@id" in (item as object)) {
       const id = String((item as JsonLdRefish)["@id"]);
-      if (isBlankNode(id) || isMissingSentinel(id)) return; // skip restriction blanks + "not specified" sentinels
-      const { curie, kind } = classify(id, prefixes);
-      out.push({ id, curie, label: labelFor(id, idx, prefixes), iri: toIri(id, prefixes), kind });
+      if (isBlankNode(id) || isMissingSentinel(id, ctx)) return; // skip restriction blanks + "not specified" sentinels
+      const { curie, kind } = classify(id, ctx.prefixes);
+      out.push({ id, curie, label: labelFor(id, ctx), iri: toIri(id, ctx.prefixes), kind });
     } else if (item && typeof item === "object" && "@value" in (item as object)) {
       // JSON-LD literal object, e.g. {"@value":"foo"} / {"@value":"foo","@language":"en"}
       const v = (item as { "@value"?: unknown })["@value"];
       const s = v == null ? "" : String(v);
       if (s) out.push({ id: s, curie: s, label: s, iri: "", kind: "literal" });
     } else if (typeof item === "string") {
-      if (isMissingSentinel(item)) return;
+      if (isMissingSentinel(item, ctx)) return;
       out.push({ id: item, curie: item, label: item, iri: "", kind: "literal" });
     }
   };
@@ -247,52 +336,6 @@ const parseNeurdfKey = (
   };
 };
 
-// A few literal-valued ilxtr predicates we surface directly (not neurdf refs). These land on
-// `properties`, so they are facetable and can appear on a tile row.
-const LITERAL_PREDICATES: Record<string, string> = {
-  "ilxtr:neurondmBaseClass": "neurondmBaseClass",
-};
-
-// Cross-nomenclature relations. The evidence type is derived from *which* relation it is,
-// since the graph has no dedicated evidence predicate.
-const MAPPING_PREDICATES: Record<string, MappingEvidence> = {
-  "TEMP:assertedSubClassOf": "described",
-  "TEMP:subClassOf": "described",
-  "TEMP:mapsTo": "inferred",
-};
-
-// Prose / id / dataset annotations. Deliberately kept off `properties` so widening the parser
-// cannot add new facets to the grid sidebar or new rows to a tile — they land on
-// `CellTerm.annotations` instead, which only the Cell Card reads.
-const TEXT_ANNOTATIONS = {
-  "ilxtr:atlasAnnotation": "atlasAnnotation",
-  "ilxtr:curatorNote": "curatorNotes",
-  "ilxtr:alertNote": "alertNotes",
-} as const;
-
-// Deep-link targets for the Cell Card's external widgets (SPARC Portal, SPARC Maps, NervoSensus).
-// None of these predicates occur in the shipped graph yet, and the front end must not need an edit
-// when they arrive — so they are matched by *local name* and every prefix works: `ilx:`, `ilxtr:`
-// or the expanded IRI all reduce to the same compact form, exactly as parsePredicateDisplay does
-// for the display annotations.
-//
-// They land on `annotations` rather than `properties` for the same reason TEXT_ANNOTATIONS does: a
-// deep-link URL is not a phenotype, and every key on `properties` becomes a facet option in the
-// grid sidebar as soon as the "Displayed properties" toggle is off.
-const LINK_ANNOTATIONS = {
-  hasSPARCTranscriptomicsLink: "sparcTranscriptomicsLinks",
-  hasSPARCMap: "sparcMaps",
-  hasNervoSensusLink: "nervoSensusLinks",
-} as const;
-
-type LinkAnnotationField = (typeof LINK_ANNOTATIONS)[keyof typeof LINK_ANNOTATIONS];
-
-const linkAnnotationField = (key: string, prefixes: Prefixes): LinkAnnotationField | undefined => {
-  if (key.startsWith("neurdf.")) return undefined; // a phenotype family, never a deep link
-  const localName = classify(key, prefixes).curie.split(":").pop() || "";
-  return LINK_ANNOTATIONS[localName as keyof typeof LINK_ANNOTATIONS];
-};
-
 // A source label like "DRG TG Calca+Bmpr1b human (Bhuiyan2024)" carries its provenance in a
 // trailing parenthetical; the Cross-Nomenclature table shows it as its own Source column.
 const trailingParenthetical = (label: string): string | undefined =>
@@ -312,25 +355,28 @@ const emptyAnnotations = (): CellAnnotations => ({
 const asType = (t: unknown): string[] =>
   Array.isArray(t) ? (t as string[]) : typeof t === "string" ? [t] : [];
 
-const subClassRefs = (node: GraphNode | undefined): string[] => {
+// The parents a node asserts, through whichever relation `fields.parent` binds (rdfs:subClassOf).
+const subClassRefs = (node: GraphNode | undefined, ctx: ParseContext): string[] => {
   if (!node) return [];
-  const s = node["rdfs:subClassOf"];
-  const arr = Array.isArray(s) ? s : [s];
-  return arr
-    .map((x) => (x && typeof x === "object" ? String((x as JsonLdRefish)["@id"] ?? "") : ""))
-    .filter(Boolean);
+  return ctx.fields.parent.sources.flatMap((key) => {
+    const s = node[key];
+    const arr = Array.isArray(s) ? s : [s];
+    return arr
+      .map((x) => (x && typeof x === "object" ? String((x as JsonLdRefish)["@id"] ?? "") : ""))
+      .filter(Boolean);
+  });
 };
 
-// Does `startId` reach `targetId` through the transitive rdfs:subClassOf chain?
-const reaches = (startId: string, targetId: string, idx: Index): boolean => {
+// Does `startId` reach `targetId` through the transitive parent chain?
+const reaches = (startId: string, targetId: string, ctx: ParseContext): boolean => {
   const seen = new Set<string>();
-  const stack = subClassRefs(idx.get(startId));
+  const stack = subClassRefs(ctx.idx.get(startId), ctx);
   while (stack.length) {
     const cur = stack.pop() as string;
     if (cur === targetId) return true;
     if (seen.has(cur)) continue;
     seen.add(cur);
-    stack.push(...subClassRefs(idx.get(cur)));
+    stack.push(...subClassRefs(ctx.idx.get(cur), ctx));
   }
   return false;
 };
@@ -343,9 +389,9 @@ const mergeValues = (existing: ResolvedRef[], incoming: ResolvedRef[]): Resolved
   return [...byId.values()];
 };
 
-const buildCell = (node: GraphNode, idx: Index, prefixes: Prefixes): CellTerm => {
+const buildCell = (node: GraphNode, ctx: ParseContext): CellTerm => {
   const id = String(node["@id"]);
-  const { curie } = classify(id, prefixes);
+  const { curie } = classify(id, ctx.prefixes);
   const properties: Record<string, CellProperty> = {};
   const negated: Record<string, CellProperty> = {};
   const annotations = emptyAnnotations();
@@ -353,61 +399,70 @@ const buildCell = (node: GraphNode, idx: Index, prefixes: Prefixes): CellTerm =>
   let sources: ResolvedRef[] = [];
 
   for (const [key, raw] of Object.entries(node)) {
-    if (key === "ilxtr:literatureCitation") {
-      sources = resolveValue(raw, idx, prefixes); // a cell may cite several publications
-      continue;
-    }
-    if (key === "ilxtr:dataCitation") {
-      annotations.dataCitations = resolveValue(raw, idx, prefixes);
-      continue;
-    }
-    if (key in TEXT_ANNOTATIONS) {
-      const field = TEXT_ANNOTATIONS[key as keyof typeof TEXT_ANNOTATIONS];
-      // These are plain strings in the graph; resolveValue normalises the literal shapes.
-      annotations[field] = resolveValue(raw, idx, prefixes).map((r) => r.label);
-      continue;
-    }
-    if (key === "ilxtr:hasTemporaryId") {
-      annotations.temporaryId = resolveValue(raw, idx, prefixes)[0]?.curie;
-      continue;
-    }
-    if (key === "ilxtr:genLabel") {
-      annotations.generatedLabel = firstString(raw);
-      continue;
-    }
-    if (key === "ilxtr:error") {
-      annotations.errors = resolveValue(raw, idx, prefixes).map((r) => r.curie);
-      continue;
-    }
-    const linkField = linkAnnotationField(key, prefixes);
-    if (linkField) {
-      // The same link can be asserted under more than one prefix; merge rather than overwrite.
-      annotations[linkField] = mergeValues(annotations[linkField], resolveValue(raw, idx, prefixes));
-      continue;
-    }
-    if (key in MAPPING_PREDICATES) {
-      const evidence = MAPPING_PREDICATES[key];
-      for (const ref of resolveValue(raw, idx, prefixes)) {
-        // A cell can be related to the same record by more than one relation; the stronger
-        // claim (an explicit description) wins over an inferred mapping.
-        const prev = mappings.find((m) => m.ref.id === ref.id);
-        if (prev) {
-          if (evidence === "described") prev.evidence = evidence;
-          continue;
+    // Where this predicate lands is `fields`, inverted into a lookup by `buildContext`. Annotations
+    // are deliberately kept off `properties`: everything on `properties` becomes a facet in the
+    // grid sidebar as soon as the "Displayed properties" toggle is off, and a curator note or a
+    // deep-link URL is not a phenotype.
+    const target = targetFor(key, ctx);
+    if (target) {
+      switch (target.slot) {
+        case "sources":
+          sources = resolveValue(raw, ctx); // a cell may cite several publications
+          break;
+        case "refs":
+          annotations[target.field] = resolveValue(raw, ctx);
+          break;
+        case "text":
+          // These are plain strings in the graph; resolveValue normalises the literal shapes.
+          annotations[target.field] = resolveValue(raw, ctx).map((r) => r.label);
+          break;
+        case "links":
+          // The same link can be asserted under more than one prefix; merge rather than overwrite.
+          annotations[target.field] = mergeValues(
+            annotations[target.field],
+            resolveValue(raw, ctx)
+          );
+          break;
+        case "temporaryId":
+          annotations.temporaryId = resolveValue(raw, ctx)[0]?.curie;
+          break;
+        case "generatedLabel":
+          annotations.generatedLabel = firstString(raw);
+          break;
+        case "errors":
+          annotations.errors = resolveValue(raw, ctx).map((r) => r.curie);
+          break;
+        case "mapping":
+          for (const ref of resolveValue(raw, ctx)) {
+            // A cell can be related to the same record by more than one relation; the stronger
+            // claim (an explicit description) wins over an inferred mapping.
+            const prev = mappings.find((m) => m.ref.id === ref.id);
+            if (prev) {
+              if (target.evidence === "described") prev.evidence = target.evidence;
+              continue;
+            }
+            mappings.push({
+              ref,
+              evidence: target.evidence,
+              source: trailingParenthetical(ref.label),
+            });
+          }
+          break;
+        case "property": {
+          // Keyed by local name, as every `CellProperty` is.
+          const local = localNameOf(key, ctx.prefixes);
+          const values = resolveValue(raw, ctx);
+          if (local && values.length) {
+            properties[local] = { localName: local, family: "eqv", negated: false, values };
+          }
+          break;
         }
-        mappings.push({ ref, evidence, source: trailingParenthetical(ref.label) });
       }
       continue;
     }
-    if (key in LITERAL_PREDICATES) {
-      const local = LITERAL_PREDICATES[key];
-      const values = resolveValue(raw, idx, prefixes);
-      if (values.length) properties[local] = { localName: local, family: "eqv", negated: false, values };
-      continue;
-    }
     const parsed = parseNeurdfKey(key);
     if (!parsed) continue; // skip @id/@type/owl:*/rdfs:*/etc.
-    const values = resolveValue(raw, idx, prefixes);
+    const values = resolveValue(raw, ctx);
     if (!values.length) continue;
     const bucket = parsed.negated ? negated : properties;
     const prev = bucket[parsed.localName];
@@ -427,14 +482,14 @@ const buildCell = (node: GraphNode, idx: Index, prefixes: Prefixes): CellTerm =>
     }
   }
 
-  const definition = definitionOf(node);
+  const definition = definitionOf(node, ctx);
 
   return {
     id,
     curie,
-    iri: toIri(id, prefixes),
-    label: labelFor(id, idx, prefixes),
-    rdfTypes: rdfTypesOf(node, prefixes),
+    iri: toIri(id, ctx.prefixes),
+    label: labelFor(id, ctx),
+    rdfTypes: rdfTypesOf(node, ctx.prefixes),
     definition: definition?.text,
     definitionCurated: definition?.curated,
     properties,
@@ -454,14 +509,16 @@ const rdfTypesOf = (node: GraphNode, prefixes: Prefixes): string[] => {
   return owl.length ? owl : all;
 };
 
+// Everything past `curatedDescriptionSources` is reported as uncurated, so the UI can say where
+// the text came from instead of passing generated output off as a definition.
 const definitionOf = (
-  node: GraphNode
+  node: GraphNode,
+  ctx: ParseContext
 ): { text: string; curated: boolean } | undefined => {
-  for (let i = 0; i < DEFINITION_KEYS.length; i++) {
-    const text = firstString(node[DEFINITION_KEYS[i]]);
-    if (text) return { text, curated: i < CURATED_DEFINITION_KEYS };
-  }
-  return undefined;
+  const hit = firstFieldText(node, ctx.fields.description, ctx);
+  return hit
+    ? { text: hit.text, curated: hit.rank < ctx.fields.curatedDescriptionSources }
+    : undefined;
 };
 
 // Build the subClassOf hierarchy over the in-scope terms.
@@ -476,8 +533,7 @@ const definitionOf = (
 const buildHierarchy = (
   rootClass: string,
   cells: CellTerm[],
-  idx: Index,
-  prefixes: Prefixes
+  ctx: ParseContext
 ): HierarchyNode[] => {
   if (!rootClass) return [];
   const inScope = new Set(cells.map((c) => c.id));
@@ -485,7 +541,7 @@ const buildHierarchy = (
   for (const cell of cells) {
     parentsOf.set(
       cell.id,
-      subClassRefs(idx.get(cell.id)).filter((p) => p === rootClass || inScope.has(p))
+      subClassRefs(ctx.idx.get(cell.id), ctx).filter((p) => p === rootClass || inScope.has(p))
     );
   }
 
@@ -527,9 +583,9 @@ const buildHierarchy = (
     return {
       id: path,
       termId,
-      label: cell ? cell.label : labelFor(termId, idx, prefixes),
-      curie: cell ? cell.curie : classify(termId, prefixes).curie,
-      iri: cell ? cell.iri : toIri(termId, prefixes),
+      label: cell ? cell.label : labelFor(termId, ctx),
+      curie: cell ? cell.curie : classify(termId, ctx.prefixes).curie,
+      iri: cell ? cell.iri : toIri(termId, ctx.prefixes),
       children: kids
         .map((kid) => nodeAt(kid, `${path}/${kid}`, nextSeen))
         .sort((a, b) => a.label.localeCompare(b.label)),
@@ -539,47 +595,51 @@ const buildHierarchy = (
   return [nodeAt(rootClass, rootClass, new Set())];
 };
 
-export const parseOntologyMeta = (graph: GraphNode[]): OntologyMeta => {
+// The ontology header. Title, description and version are fixed fields of the model; which
+// annotation fills each is `fields.ontologyTitle` / `ontologyDescription` / `ontologyVersion`.
+export const parseOntologyMeta = (
+  graph: GraphNode[],
+  fields: FieldSources = DEFAULT_FIELD_SOURCES,
+  prefixes: Prefixes = {}
+): OntologyMeta => {
+  // No graph index: these three read literals off the ontology node and never resolve a reference.
+  const ctx = buildContext(new Map(), prefixes, fields);
   const onto = graph.find((n) => asType(n["@type"]).includes("owl:Ontology"));
-  const iri = onto ? String(onto["@id"] ?? "") : "";
-  const title =
-    (onto &&
-      (firstString(onto["dc:title"]) ||
-        firstString(onto["dcterms:title"]) ||
-        firstString(onto["rdfs:label"]) ||
-        firstString(onto["skos:prefLabel"]))) ||
-    "Ontology";
-  const description =
-    onto &&
-    (firstString(onto["dc:description"]) ||
-      firstString(onto["dcterms:description"]) ||
-      firstString(onto["rdfs:comment"]));
-  const version = onto ? firstString(onto["owl:versionInfo"]) : undefined;
-  return { iri, title, description: description || undefined, version };
+  const title = firstFieldText(onto, fields.ontologyTitle, ctx)?.text || "Ontology";
+  return {
+    iri: onto ? String(onto["@id"] ?? "") : "",
+    title,
+    description: firstFieldText(onto, fields.ontologyDescription, ctx)?.text,
+    version: firstFieldText(onto, fields.ontologyVersion, ctx)?.text,
+  };
 };
 
 // Parse the graph into cells that are (transitively) subClassOf `rootClass`.
 // Row labels and tooltips ship inside the ontology: the ilxtr:* property nodes carry
 // ilxtr:displayLabel ("Soma location") and ilxtr:shortDefinition, which between them cover 14
 // of the 15 neurdf local names Precision cells use. Reading them here keeps the UI's wording
-// in the curators' hands instead of a hardcoded map in the front end — gridConfig's
-// PREDICATE_LABELS / PREDICATE_TOOLTIPS are only the fallback for what the file omits.
+// in the curators' hands instead of a hardcoded map in the front end — the mappings document's
+// `predicates` section is only the fallback for what the file omits. Which annotation carries
+// each is itself a field binding (`fields.predicateLabel` / `predicateDescription`).
 //
 // Keyed by *local name* (`hasSomaLocatedIn`), because that is how a CellProperty is keyed,
 // while the annotation lives on the `ilxtr:hasSomaLocatedIn` node.
 export const parsePredicateDisplay = (
   graph: GraphNode[],
-  prefixes: Prefixes = {}
+  prefixes: Prefixes = {},
+  fields: FieldSources = DEFAULT_FIELD_SOURCES
 ): Record<string, PredicateDisplay> => {
+  // No graph index: a display annotation is a literal on the property node, never a reference.
+  const ctx = buildContext(new Map(), prefixes, fields);
   const out: Record<string, PredicateDisplay> = {};
   for (const node of graph) {
     const id = node["@id"];
     if (typeof id !== "string") continue;
-    const label = firstString(node["ilxtr:displayLabel"]);
-    const description = firstString(node["ilxtr:shortDefinition"]);
+    const label = firstFieldText(node, fields.predicateLabel, ctx)?.text;
+    const description = firstFieldText(node, fields.predicateDescription, ctx)?.text;
     if (!label && !description) continue;
     // "ilxtr:hasSomaLocatedIn" and the expanded IRI both reduce to the same local name.
-    const localName = classify(id, prefixes).curie.split(":").pop() || "";
+    const localName = localNameOf(id, prefixes);
     if (!localName) continue;
     out[localName] = {
       localName,
@@ -590,22 +650,31 @@ export const parsePredicateDisplay = (
   return out;
 };
 
-export const parseNeurdf = (data: OntologyGraph, rootClass: string): ParsedOntology => {
+export const parseNeurdf = (
+  data: OntologyGraph,
+  rootClass: string,
+  fields: FieldSources = DEFAULT_FIELD_SOURCES
+): ParsedOntology => {
   const graph = data["@graph"] || [];
   // The file's own prefix declarations, which every curie <-> IRI conversion below reads.
   const prefixes = contextPrefixes(data["@context"]);
   const idx = indexGraph(graph);
-  const neurons = graph.filter((n) => asType(n["@type"]).includes("neurdf:Neuron"));
+  const ctx = buildContext(idx, prefixes, fields);
+  const cellTypes = fields.cellType.sources;
+  const neurons = graph.filter((n) => {
+    const types = asType(n["@type"]);
+    return cellTypes.some((t) => types.includes(t));
+  });
   const inScope = rootClass
-    ? neurons.filter((n) => reaches(String(n["@id"] ?? ""), rootClass, idx))
+    ? neurons.filter((n) => reaches(String(n["@id"] ?? ""), rootClass, ctx))
     : neurons;
-  const cells = inScope.map((n) => buildCell(n, idx, prefixes));
+  const cells = inScope.map((n) => buildCell(n, ctx));
   cells.sort((a, b) => a.label.localeCompare(b.label));
   return {
-    meta: parseOntologyMeta(graph),
+    meta: parseOntologyMeta(graph, fields, prefixes),
     cells,
-    hierarchy: buildHierarchy(rootClass, cells, idx, prefixes),
-    predicateDisplay: parsePredicateDisplay(graph, prefixes),
+    hierarchy: buildHierarchy(rootClass, cells, ctx),
+    predicateDisplay: parsePredicateDisplay(graph, prefixes, fields),
   };
 };
 
diff --git a/src/parsers/ontologyTermAdapter.ts b/src/parsers/ontologyTermAdapter.ts
index 2aaed5c..63b6d43 100644
--- a/src/parsers/ontologyTermAdapter.ts
+++ b/src/parsers/ontologyTermAdapter.ts
@@ -10,7 +10,8 @@ import type {
   PredicateDisplay,
   ResolvedRef,
 } from "../components/CellCards/model/types";
-import { labelFor } from "../components/CellCards/config/gridConfig";
+import { DEFAULT_MAPPINGS, predicateLabel } from "../components/CellCards/config/mappingDefaults";
+import type { OntologyMappings } from "../components/CellCards/model/mappings";
 
 // The CURIE is the term's identity throughout this mode: the hierarchy focus, a tree node's `iri`
 // and a predicate row's subject must all match, and `Hierarchy` passes a non-ILX id through
@@ -187,7 +188,8 @@ const withCombinator = (title: string, prop: CellProperty): string =>
  */
 export const ontologyPredicateGroups = (
   cell: CellTerm,
-  display: Record<string, PredicateDisplay> = {}
+  display: Record<string, PredicateDisplay> = {},
+  mappings: OntologyMappings = DEFAULT_MAPPINGS
 ): OntologyPredicateGroup[] => {
   const groups: OntologyPredicateGroup[] = [];
   const subject = cell.curie;
@@ -202,7 +204,8 @@ export const ontologyPredicateGroups = (
     });
   };
 
-  const titleFor = (localName: string) => display[localName]?.label || labelFor(localName);
+  const titleFor = (localName: string) =>
+    display[localName]?.label || predicateLabel(mappings, localName);
 
   add("@id", [cell.curie]);
   add("Label", [cell.label]);
diff --git a/vite.config.js b/vite.config.js
index e0b7f9b..affc31d 100644
--- a/vite.config.js
+++ b/vite.config.js
@@ -183,9 +183,10 @@ export default defineConfig({
       },
       // Any `{prefix}_{id}` term, not just ilx_/tmp_: once an npokb id is mapped to a record its
       // tabs light up, and they read this endpoint. The extension allow-list keeps the rule off
-      // asset paths, and `(?!data/)` off the local ontology copy — proxying that would send the
-      // Cell Card's ~16MB source upstream, where it 404s (nginx guards it with `location ^~`).
-      '^/(?!data/)[^/]+/[A-Za-z][A-Za-z0-9.-]*_[^/]*\\.(html|ttl|jsonld|n3|owl|csv)$': {
+      // asset paths, and `(?!data/|static/)` off the local ontology copy and the static dir —
+      // proxying either would send them upstream, where they 404 (nginx guards both with
+      // `location ^~`).
+      '^/(?!data/|static/)[^/]+/[A-Za-z][A-Za-z0-9.-]*_[^/]*\\.(html|ttl|jsonld|n3|owl|csv)$': {
         target: 'https://uri.olympiangods.org',
         changeOrigin: true,
         secure: false,