Fold the views into one panel, right-size the controls, and open Database from a group

FEATURE_BACKLOG.md

@@ -55,7 +55,7 @@ Decisions and dependencies for implementation:
 
 - Implemented: eukaryotic tree with bounded subtrees and exact, expandable “Other lineages” aggregates; NCBI taxonomy with source checksums and dates; merged IDs resolved. Unresolved taxonomy is excluded from the eukaryotic view.
 - Implemented: English names beside every scientific name, from NCBI Taxonomy common names plus a curated gloss table (`refresh_common_names.py`).
-- Remaining: connect the taxonomy inventory to accession-level annotation results and distinguish partial/complete base coverage.
+- Implemented: a **Show database results** jump from the selected group into the Database tab, backed by the `assemblies` table from `refresh_assemblies.py`. It hands over one annotated accession; listing every assembly in a group, and distinguishing partial from complete base coverage, remain open.
 - Implemented: clade silhouettes from PhyloPic, filtered to CC0/Public Domain Mark/CC BY at build time (`refresh_icons.py`), with every CC BY artist credited in the interface.
 
 ## F003 — Comparison with RefSeq annotations

README.md

@@ -17,13 +17,13 @@ Future features and open design decisions are tracked in the [feature backlog](F
 
 ## GenBank taxonomy
 
-The landing page opens with an interactive **tree of eukaryotic life**, using NCBI's current GenBank assembly summary and taxonomy. It is drawn as a Sankey diagram running **down the page**: each group is a horizontal bar split into annotated (green) and not-annotated (gray) assemblies, and flows carry both parts from a group into its lineages on the level below. Expanding a group adds a level underneath rather than a column to the right, so a full lineage — eukaryotes down to humans is about thirty levels — is one ordinary page scroll instead of an endless sideways one. The chart itself only scrolls on screens too narrow to keep the labels legible. Shortcut buttons above the tree jump straight to a lineage: animals, mammals, humans, birds, ray-finned fish, insects, jellyfish, green plants, flowering plants and fungi. Counts and percentages appear beside the groups, with details on hover. Each group is labelled with its scientific name and, where one exists, a plain-English name underneath, so the Latin backbone of the tree (Opisthokonta, Eumetazoa, Ecdysozoa) stays readable without prior knowledge. The default **Genome Atlas** tab contains the tree and its lineage controls. A separate **Database** tab holds accession search, segment visualization, and downloads, using the full published-file snapshot. RefSeq exploration can be added beneath the tree. The two equal-width navigation options span the top of the page.
+The landing page opens with an interactive **tree of eukaryotic life**, using NCBI's current GenBank assembly summary and taxonomy. It is drawn as a Sankey diagram running **down the page**: each group is a horizontal bar split into annotated (green) and not-annotated (gray) assemblies, and flows carry both parts from a group into its lineages on the level below. Expanding a group adds a level underneath rather than a column to the right, so a full lineage — eukaryotes down to humans is about thirty levels — is one ordinary page scroll instead of an endless sideways one. The chart itself only scrolls on screens too narrow to keep the labels legible. Shortcut buttons above the tree jump straight to a lineage: animals, mammals, humans, birds, ray-finned fish, insects, jellyfish, green plants, flowering plants and fungi. Each group shows a silhouette, its scientific name and its English name; counts and percentages live in the tooltip, which appears over a group or over the flux arriving at it. The flux feeding the current selection stays highlighted, so the trunk you have walked reads against the lineages you passed over. Each group is labelled with its scientific name and, where one exists, a plain-English name underneath, so the Latin backbone of the tree (Opisthokonta, Eumetazoa, Ecdysozoa) stays readable without prior knowledge. The two views sit inside one curved panel, switched by a full-width toggle at the top: the **Genome Atlas** holds the tree and its lineage controls, and **Database** holds accession search, segment visualization, and downloads over the full published-file snapshot. A **Show database results** button carries the current group across, handing the Database tab one annotated assembly from the selected lineage; it says so plainly when a group has none. RefSeq exploration can be added beneath the tree.
 
 The viewer is restricted to **Eukaryota (NCBI taxid 2759) and its descendants**, including search, breadcrumbs, and parent navigation. The model predicts eukaryotic annotations; bacteria, archaea, and viruses are outside this display. The current eukaryotic snapshot contains **70,395 assemblies**, of which **17,561 (24.9%)** have published annotations. The underlying SQLite snapshot retains the full NCBI inventory for refresh/provenance, while the interface uses only the eukaryotic subtree and its denominators. Assemblies with unresolved taxonomy cannot be assigned to that subtree and are excluded.
 
 The inventory accepts `GCA_` accessions with `version_status=latest`. Each assembly contributes once to its taxon and each ancestor. These counts describe genome assemblies, not all GenBank nucleotide records. An assembly counts as having annotations when it occurs in the publication inventory; this includes partial assemblies and does not imply full base coverage. Exact accession versions are matched to the NCBI snapshot. Published versions outside that snapshot are excluded from percentages.
 
-Click a group to expand its direct lineages into a new column on the right; every ancestor column stays visible, so the full path from Eukaryota is always on screen. Clicking a group in an earlier column replaces the columns after it. Use breadcrumbs, “Collapse last group”, or shortcuts to go back. Nodes support Enter/Space keyboard navigation. The opening view expands the actual animal/fungal ancestor, Opisthokonta. Each column shows six direct lineages, an expandable remainder, and the selected lineage if it falls outside the top six. Bar and flow heights follow assembly counts within a column; every column is rescaled to the full height. “Other lineages” is an explicitly labeled display aggregate, not an invented clade; its counts sum the remaining siblings. Repeated expansion reaches all siblings without truncating them. Scientific-name/taxon-ID search also reaches individual taxa. Column spacing does not encode time. The view scrolls horizontally, and jumps to the newest column after each expansion.
+Click a group to open its direct lineages as a new level below; every ancestor level stays visible, so the full path from Eukaryota is always on screen. Clicking a group in an earlier level replaces the levels after it. Use breadcrumbs, “Collapse last group”, or shortcuts to go back. Nodes support Enter/Space keyboard navigation. The opening view expands the actual animal/fungal ancestor, Opisthokonta. Each level shows six direct lineages, an expandable remainder, and the selected lineage if it falls outside the top six. Bar and flow widths follow assembly counts within a level; every level is rescaled to the full width. “Other lineages” is an explicitly labeled display aggregate, not an invented clade; its counts sum the remaining siblings. Repeated expansion reaches all siblings without truncating them. Search reaches individual taxa by scientific name, taxon ID, or English name, so "sponges", "jellyfish" or "house mouse" all work; matches appear as a list with the closest first and already selected, and Enter opens it. Level spacing does not encode time. Expanding nudges the page down only when the new level has fallen past the viewport.
 
 English names come from `data/common_names.json`, built by `refresh_common_names.py` from NCBI Taxonomy's `genbank common name` and `common name` entries (about 9,200 taxa) plus a curated table of roughly 190 short glosses for the large unranked clades NCBI leaves unnamed. Glosses are plain-language summaries of the living members of a clade, not formal synonyms; the scientific name stays the primary label and a gloss that merely repeats it is dropped at build time. Rebuild it with `python refresh_common_names.py` once `.cache/coverage/taxdump.tar.gz` is present; the build fails if a curated taxid no longer matches its scientific name in the snapshot.
 
@@ -33,6 +33,8 @@ The graphic uses server-rendered SVG/HTML with scoped styles in `atlas.css` and
 
 The annotation workspace shares the atlas palette and typography through `style.py` and `app.css`: warm panels, serif section headings, green controls, and matching tables, downloads, and disclosures. CDS plots use a solid green positive strand and a dashed warm-brown negative strand; binary labels use green. The fixed light palette stays consistent with the landing graphic under either OS color preference. Include both style files when deploying; Gradio 6 receives the theme and stylesheet in `launch()`.
 
+The **Show database results** jump needs a taxon-to-accession table, which `refresh_assemblies.py` writes into `data/taxonomy.sqlite` as an `assemblies` table: one row per annotated eukaryotic assembly, about 33,600 of them. It reads the NCBI assembly summary and the existing `data/coverage.json`, and deliberately leaves the counts alone — rebuilding those here would re-read a newer summary and shift every total in the interface away from the published snapshot. Only annotated assemblies are stored, so the jump never offers an accession with nothing behind it.
+
 ### Refresh the taxonomy snapshot
 
 ```bash

app.css

@@ -1,7 +1,8 @@
 /* Global component styling, paired with the landing graphic's scoped atlas.css. */
 .gradio-container { max-width:1280px!important; margin:auto!important; padding:24px 20px 40px!important; color-scheme:light; }
 #eukaryotic-atlas { padding:0!important; border:0!important; background:transparent!important; }
-.gradio-container .atlas-panel { background:#f7f8f0; border:1px solid #e0e6d8; border-radius:24px; padding:26px 30px; box-shadow:0 8px 32px #234b2908; gap:18px; margin-top:6px; }
+.gradio-container .atlas-panel { background:transparent; border:0; border-radius:0; padding:22px 20px; box-shadow:none; gap:16px; margin-top:0; }
+.gradio-container .atlas-panel + .atlas-panel { border-top:1px solid #e3e9dc; }
 .workspace-heading { display:flex; align-items:flex-start; gap:14px; padding:0 0 4px; }
 .workspace-step { width:32px; height:32px; border:1px solid #cdddc8; background:#eaf1e2; border-radius:50%; display:flex; align-items:center; justify-content:center; flex-shrink:0; font:500 11px Arial,sans-serif; color:#527261; margin-top:4px; }
 .workspace-heading h2 { margin:0 0 8px; font:400 32px/1.15 Georgia,'Times New Roman',serif; letter-spacing:-.7px; color:#173c30; }
@@ -17,8 +18,17 @@
 .gradio-container button:focus-visible,.gradio-container a:focus-visible { outline:2px solid #327555; outline-offset:3px; }
 .gradio-container .prose a { text-underline-offset:3px; }
 .gradio-container .prose code { color:#315641; }
-.gradio-container .atlas-disclosure { border:1px solid #e0e6d8; border-radius:14px; box-shadow:none; }
-.gradio-container .atlas-disclosure > button { padding:15px 18px; }
+/* Gradio's block padding sat around the whole disclosure, so a one-line title
+   occupied 76px. The frame is the button; the body carries its own padding. */
+.gradio-container .atlas-disclosure { border:1px solid #e3e9dc; border-radius:12px; box-shadow:none; margin-top:8px; padding:0; background:#fbfcf7; }
+.gradio-container .atlas-disclosure > button.label-wrap { padding:11px 14px; min-height:0; }
+.gradio-container .atlas-disclosure > button.label-wrap > span:first-child { font:600 14px/1.4 Arial,Helvetica,sans-serif; color:#2a4a38; }
+.gradio-container .atlas-disclosure > button.label-wrap > span.icon { font-size:9px; line-height:1; color:#8c9a86; }
+.gradio-container .atlas-disclosure > button.label-wrap + * { padding:0 14px 14px; }
+.lineage-query textarea, .lineage-query input { font-size:14px; }
+.lineage-matches .wrap { display:flex; flex-direction:column; gap:2px; }
+.lineage-matches label { border-radius:8px; padding:7px 10px; font-size:13px; }
+.lineage-matches label:hover { background:#eef3e9; }
 #annotation-plot { border:1px solid #e0e6d8; background:#fffefa; border-radius:16px; overflow:hidden; }
 #annotation-plot .plot-container { background:#fffefa; }
 #annotation-examples { font-size:12px; }
@@ -29,7 +39,8 @@
 .workspace-footer a:hover { text-decoration:underline; }
 @media(max-width:700px) {
  .gradio-container { padding:12px 10px 24px!important; }
- .gradio-container .atlas-panel { border-radius:18px; padding:20px 15px; }
+ .gradio-container .atlas-panel { padding:18px 12px; }
+ #atlas-navigation { border-radius:18px; padding:8px 8px 0; }
  .workspace-heading h2 { font-size:28px; }
  .workspace-heading { gap:10px; }
  .gradio-container .action-button { width:100%; }
@@ -38,12 +49,14 @@
 
 /* Full-width navigation: one equal segment for each view. */
 .gradio-container { width:100%!important; min-width:0!important; box-sizing:border-box; }
-#atlas-navigation { border:0; background:transparent; min-width:0; max-width:100%; }
-#atlas-navigation > .tab-wrapper { width:100%; height:auto!important; min-height:0; border:0!important; box-shadow:none!important; margin:0 0 18px; padding:0; }
-#atlas-navigation > .tab-wrapper > .tab-container { display:flex!important; justify-content:flex-start; gap:26px; width:100%!important; height:auto!important; box-sizing:border-box; border:0!important; border-bottom:1px solid #dbe3d3!important; border-radius:0; padding:0; margin:0; background:transparent; box-shadow:none!important; }
-#atlas-navigation > .tab-wrapper > .tab-container > button { display:inline-flex!important; align-items:center; justify-content:flex-start; width:auto; min-width:0; min-height:0; height:auto!important; box-sizing:border-box; padding:0 2px 11px; margin:0!important; border:0!important; border-bottom:2px solid transparent!important; border-radius:0; box-shadow:none!important; background:transparent; color:#6c7d6a; font:600 14px/1.4 Arial,Helvetica,sans-serif; white-space:nowrap; text-align:left; text-decoration:none!important; transition:color .15s; }
-#atlas-navigation > .tab-wrapper > .tab-container > button:hover { background:transparent; color:#173c30; }
-#atlas-navigation > .tab-wrapper > .tab-container > button[aria-selected="true"] { background:transparent; color:#173c30; border-bottom-color:#245d45!important; }
+/* The navigation is the card: the two views sit inside one curved boundary and
+   the control reads as a toggle rather than a pair of tabs. */
+#atlas-navigation { border:1px solid #e0e6d8; background:#f7f8f0; border-radius:24px; padding:12px 12px 0; min-width:0; max-width:100%; box-shadow:0 12px 50px #234b2910; }
+#atlas-navigation > .tab-wrapper { width:100%; height:auto!important; min-height:0; border:0!important; box-shadow:none!important; margin:0; padding:0; }
+#atlas-navigation > .tab-wrapper > .tab-container { display:grid!important; grid-template-columns:1fr 1fr; gap:4px; width:100%!important; height:auto!important; box-sizing:border-box; border:0!important; border-radius:14px; padding:4px; margin:0; background:#e7eee0; box-shadow:none!important; }
+#atlas-navigation > .tab-wrapper > .tab-container > button { display:flex!important; align-items:center; justify-content:center; width:100%; min-width:0; min-height:40px; height:auto!important; box-sizing:border-box; padding:9px 12px; margin:0!important; border:0!important; border-radius:11px; box-shadow:none!important; background:transparent; color:#4c6450; font:600 14px/1.3 Arial,Helvetica,sans-serif; white-space:nowrap; text-align:center; text-decoration:none!important; transition:background-color .15s, color .15s; }
+#atlas-navigation > .tab-wrapper > .tab-container > button:hover { background:#dce6d4; color:#173c30; }
+#atlas-navigation > .tab-wrapper > .tab-container > button[aria-selected="true"] { background:#1f5740; color:#f6faf3; }
 #atlas-navigation > .tab-wrapper::before, #atlas-navigation > .tab-wrapper::after,
 #atlas-navigation > .tab-wrapper > .tab-container::before, #atlas-navigation > .tab-wrapper > .tab-container::after,
 #atlas-navigation > .tab-wrapper > .tab-container > button::before, #atlas-navigation > .tab-wrapper > .tab-container > button::after { content:none!important; display:none!important; }

app.py

@@ -129,9 +129,9 @@ def build_app(catalog=None):
         return str(target)
 
     with gr.Blocks(title="GenBank Annotation Explorer", delete_cache=(3600, 3600)) as demo:
-        with gr.Tabs(selected="atlas", elem_id="atlas-navigation"):
+        with gr.Tabs(selected="atlas", elem_id="atlas-navigation") as navigation:
             with gr.Tab("Genome Atlas", id="atlas", elem_id="atlas-overview"):
-                build_taxonomy_tab()
+                atlas = build_taxonomy_tab()
             with gr.Tab("Database", id="database", elem_id="atlas-database"):
                 gr.HTML('<header class="database-heading"><p class="database-eyebrow">THE ANNOTATION COLLECTION</p>'
                         '<h1>Explore the database</h1><p>Find an accession, explore its coding landscape, and download the annotations.</p></header>',
@@ -196,6 +196,16 @@ def build_app(catalog=None):
         gr.HTML('<footer class="workspace-footer"><span>Hugging Face Bio · Genome Atlas</span>'
                 '<a href="https://huggingface.co/buckets/HuggingFaceBio/genbank-annotations" target="_blank" rel="noopener noreferrer">Explore the annotation collection ↗</a></footer>', apply_default_css=False)
         outputs = [status, results, segment, file]
+        if atlas:
+            # The atlas names a group; the Database tab searches accessions. The
+            # jump hands over one annotated assembly from the selected group and
+            # runs the ordinary search with it.
+            def open_database(path):
+                return gr.Tabs(selected="database"), atlas["accession_for"](path)
+
+            atlas["button"].click(open_database, atlas["route"], [navigation, accession]) \
+                .then(search, accession, outputs) \
+                .then(select_segment, [segment, mode, threshold], [metadata, start, end, plot, note, file])
         for event in (search_button.click, accession.submit):
             event(search, accession, outputs).then(select_segment, [segment, mode, threshold], [metadata, start, end, plot, note, file])
         segment.input(select_segment, [segment, mode, threshold], [metadata, start, end, plot, note, file])

atlas.css

@@ -1,4 +1,4 @@
-.atlas { --ink:#173c30; --muted:#647467; position:relative; overflow:hidden; color:var(--ink); background:#f7f8f0; border:1px solid #e0e6d8; border-radius:24px; padding:32px 30px 18px; font-family:Arial,Helvetica,sans-serif; box-shadow:0 12px 50px #234b2910; }
+.atlas { --ink:#173c30; --muted:#647467; position:relative; overflow:hidden; color:var(--ink); background:transparent; border:0; border-radius:0; padding:24px 20px 14px; font-family:Arial,Helvetica,sans-serif; }
 .atlas * { box-sizing:border-box; }
 .atlas-header { display:flex; justify-content:space-between; align-items:center; gap:28px; }
 .atlas-kicker { font-size:10px; font-weight:700; letter-spacing:1.5px; line-height:1.6; text-transform:uppercase; color:#527261; }
@@ -72,7 +72,7 @@
 .atlas button:focus-visible { outline:2px solid #327555; outline-offset:3px; }
 .atlas-leaf-note { color:#647467; font-size:13px; text-align:center; margin:0 0 20px; }
 @media(max-width:800px) {
- .atlas { padding:22px 16px 16px; border-radius:18px; }
+ .atlas { padding:18px 10px 14px; }
  /* Levels fill the page width, so on a phone the only way to keep the labels
     legible is to let the chart itself scroll sideways again. */
  .tree-scroll { overflow-x:auto; overscroll-behavior-x:contain; }

data/taxonomy.sqlite

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:2bfd9a61f9dbd59cbb22b87dc25ae0ae640daac147f3bf66cb72bff0add3505e
-size 24825856
+oid sha256:88e8b10a82026dfe21a3022ae788e50d82a4ca521f948a29f4a219e111b185b1
+size 26984448

refresh_assemblies.py

@@ -0,0 +1,96 @@
+"""Add the taxon-to-accession table the atlas needs to open Database results.
+
+The taxonomy snapshot stores counts, not accessions, so a group in the atlas had
+no way to name a single assembly the Database tab could look up. This writes an
+``assemblies`` table into the existing ``data/taxonomy.sqlite`` holding one row
+per *annotated* eukaryotic assembly: the accession the Database tab searches and
+the taxon it belongs to.
+
+Only annotated assemblies are kept. The atlas offers this as a jump into
+published annotations, so an accession with nothing behind it would be a dead
+end, and the restriction keeps the table at roughly 33,000 rows.
+
+Counts are deliberately untouched. Rebuilding them here would re-read a newer
+assembly summary and silently shift every total in the interface away from the
+published snapshot; see refresh_taxonomy.py for that, which is a separate
+decision.
+"""
+import argparse
+from datetime import datetime, timezone
+import json
+from pathlib import Path
+import sqlite3
+import tarfile
+
+ROOT = Path(__file__).resolve().parent
+
+
+def merged_taxids(taxdump):
+    with tarfile.open(taxdump, "r:gz") as archive, archive.extractfile("merged.dmp") as stream:
+        return {int(parts[0]): int(parts[1]) for parts in
+                ([p.strip() for p in line.decode().split("|")] for line in stream)}
+
+
+def build(summary, taxdump, database, coverage):
+    annotated = set(json.loads(Path(coverage).read_text())["accessions"])
+    merged = merged_taxids(taxdump)
+    with sqlite3.connect(database) as conn:
+        known = {row[0] for row in conn.execute("SELECT taxid FROM taxa")}
+
+    rows, skipped, unresolved = [], 0, 0
+    with open(summary) as stream:
+        columns = None
+        for line in stream:
+            if line.startswith("##"):
+                continue
+            if line.startswith("#"):
+                header = line.lstrip("# ").rstrip("\n").split("\t")
+                columns = {name: header.index(name) for name in ("assembly_accession", "taxid", "version_status")}
+                continue
+            row = line.rstrip("\n").split("\t")
+            accession = row[columns["assembly_accession"]]
+            if accession not in annotated or row[columns["version_status"]] != "latest":
+                skipped += 1
+                continue
+            try:
+                taxid = int(row[columns["taxid"]])
+            except ValueError:
+                unresolved += 1
+                continue
+            seen = set()
+            while taxid in merged and taxid not in seen:
+                seen.add(taxid)
+                taxid = merged[taxid]
+            if taxid not in known:
+                unresolved += 1
+                continue
+            rows.append((accession, taxid))
+
+    if not rows:
+        raise ValueError("No annotated assemblies matched the summary; check the inputs.")
+    with sqlite3.connect(database) as conn:
+        conn.executescript("DROP TABLE IF EXISTS assemblies;"
+                           "CREATE TABLE assemblies (accession TEXT PRIMARY KEY, taxid INTEGER);")
+        conn.executemany("INSERT OR REPLACE INTO assemblies VALUES (?,?)", rows)
+        conn.execute("CREATE INDEX assembly_taxa ON assemblies(taxid)")
+        metadata = json.loads(conn.execute("SELECT value FROM metadata").fetchone()[0])
+        metadata["assemblies"] = {"created_at": datetime.now(timezone.utc).isoformat(),
+                                 "rows": len(rows), "scope": "annotated eukaryotic assemblies only",
+                                 "source": "https://ftp.ncbi.nlm.nih.gov/genomes/ASSEMBLY_REPORTS/assembly_summary_genbank.txt"}
+        conn.execute("UPDATE metadata SET value=?", (json.dumps(metadata),))
+    print(json.dumps({"rows": len(rows), "annotated_accessions": len(annotated),
+                      "unresolved_taxids": unresolved, "rows_skipped": skipped}, indent=2))
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--summary", type=Path, default=ROOT / ".cache/coverage/assembly_summary_genbank.txt")
+    parser.add_argument("--taxdump", type=Path, default=ROOT / ".cache/coverage/taxdump.tar.gz")
+    parser.add_argument("--database", type=Path, default=ROOT / "data/taxonomy.sqlite")
+    parser.add_argument("--coverage", type=Path, default=ROOT / "data/coverage.json")
+    args = parser.parse_args()
+    build(args.summary, args.taxdump, args.database, args.coverage)
+
+
+if __name__ == "__main__":
+    main()

taxonomy.py

@@ -39,6 +39,7 @@ SHORTCUTS = ((33208, "Animals"), (40674, "Mammals"), (9606, "Humans"), (8782, "B
 
 
 COLUMN_LIMIT = 6
+SEARCH_LIMIT = 12
 MAX_DEPTH = 80
 DEFAULT_PATH = "2759/33154"
 
@@ -75,17 +76,51 @@ class Taxonomy:
         conn.row_factory = sqlite3.Row
         return conn
 
-    def search(self, query):
+    def closeness(self, row, needle):
+        """Whole-name matches first, then word starts: 'thale' should find thale cress
+        before it finds Magnaporthales."""
+        names = [row['name'].casefold(), self.english.get(row['taxid'], "").casefold()]
+        if any(name == needle for name in names):
+            return 0
+        if any(name.startswith(needle) for name in names):
+            return 1
+        if any(word.startswith(needle) for name in names for word in name.split()):
+            return 2
+        return 3
+
+    def label(self, row):
+        english = self.english.get(row['taxid'], "")
+        return (f"{row['name']}" + (f" · {english}" if english else "") +
+                f" · {row['total_count']:,} assemblies · taxid {row['taxid']}")
+
+    def search(self, query, limit=SEARCH_LIMIT):
+        """Match a taxon id, a scientific name, or one of the English names.
+
+        The eukaryote set is already in memory, so the filtering happens here
+        rather than in a recursive CTE the query would otherwise re-walk on every
+        keystroke.
+        """
         query = str(query or "").strip()
-        aliases = {"animals": "33208", "plants": "33090", "green plants": "33090", "eukaryotes": "2759"}
-        query = aliases.get(query.casefold(), query)
+        if len(query) < 2 and not query.isdigit():
+            return []
+        needle = query.casefold()
         with closing(self.connect()) as conn:
             if query.lstrip("-").isdigit():
-                rows = conn.execute(EUK_TREE + "SELECT taxa.* FROM taxa JOIN euk USING(taxid) WHERE taxid=?", (int(query),)).fetchall()
+                row = conn.execute("SELECT * FROM taxa WHERE taxid=?", (int(query),)).fetchone()
+                rows = [row] if row and row['taxid'] in self.eukaryote_ids else []
             else:
                 pattern = "%" + query.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_") + "%"
-                rows = conn.execute(EUK_TREE + "SELECT taxa.* FROM taxa JOIN euk USING(taxid) WHERE name LIKE ? ESCAPE '\\' ORDER BY total_count DESC LIMIT 100", (pattern,)).fetchall()
-        return [(f"{r['name']} · {r['total_count']:,} assemblies · taxid {r['taxid']}", str(r['taxid'])) for r in rows]
+                found = {r['taxid']: r for r in conn.execute(
+                    "SELECT * FROM taxa WHERE name LIKE ? ESCAPE '\\' ORDER BY total_count DESC LIMIT ?",
+                    (pattern, limit * 4)) if r['taxid'] in self.eukaryote_ids}
+                english = [t for t, name in self.english.items()
+                           if needle in name.casefold() and t not in found and t in self.eukaryote_ids]
+                for chunk in (english[i:i + 400] for i in range(0, len(english), 400)):
+                    marks = ",".join("?" * len(chunk))
+                    found.update({r['taxid']: r for r in conn.execute(
+                        f"SELECT * FROM taxa WHERE taxid IN ({marks})", chunk)})
+                rows = sorted(found.values(), key=lambda r: (self.closeness(r, needle), -r['total_count']))[:limit]
+        return [(self.label(r), str(r['taxid'])) for r in rows]
 
     def icon_for(self, conn, taxid):
         """Nearest icon at or above this taxon, following the lineage to Eukaryota.
@@ -116,6 +151,34 @@ class Taxonomy:
             rows.append(dict(conn.execute("SELECT * FROM taxa WHERE taxid=?", (rows[-1]['parent_id'],)).fetchone()))
         return rows[::-1]
 
+    def assemblies_for(self, path, limit=1):
+        """Annotated accessions under the taxon a route selects, largest group first.
+
+        The recursive walk starts at the selected taxon rather than at Eukaryota,
+        so it touches only that subtree.
+        """
+        try:
+            taxid = int(str(path).split("/")[-1].partition("~")[0])
+        except (ValueError, AttributeError):
+            return []
+        if taxid not in self.eukaryote_ids:
+            return []
+        with closing(self.connect()) as conn:
+            if not conn.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='assemblies'").fetchone():
+                return []
+            return [r[0] for r in conn.execute(
+                """WITH RECURSIVE sub(taxid) AS (
+                       SELECT ? UNION ALL
+                       SELECT t.taxid FROM taxa t JOIN sub ON t.parent_id=sub.taxid WHERE t.taxid!=t.parent_id
+                   ) SELECT accession FROM assemblies JOIN sub USING(taxid) ORDER BY accession LIMIT ?""",
+                (taxid, limit))]
+
+    def selected_name(self, path):
+        taxid = int(str(path).split("/")[-1].partition("~")[0])
+        with closing(self.connect()) as conn:
+            row = conn.execute("SELECT name FROM taxa WHERE taxid=?", (taxid,)).fetchone()
+        return row['name'] if row else str(taxid)
+
     def taxon_path(self, taxid):
         """Path that expands every ancestor of a taxon, for search results and shortcuts."""
         taxid = int(taxid)
@@ -351,8 +414,7 @@ class Taxonomy:
         leaf_note = '<p class="atlas-leaf-note">This is a terminal taxon in the assembly snapshot. Use the breadcrumb to explore its relatives.</p>' if not has_children else ''
         return f'''<section class="atlas" aria-label="Tree of eukaryotic life">
           <header class="atlas-header">
-            <div><div class="atlas-kicker">HUGGING FACE BIO <span> / </span> GENOME ATLAS</div>
-              <h1>The tree of eukaryotic life<span>.</span></h1>
+            <div><h1>The tree of eukaryotic life<span>.</span></h1>
               <p>Follow the branches. Discover where we’ve annotated.</p></div>
             <div class="atlas-summary-block">{summary}</div>
           </header>
@@ -389,10 +451,10 @@ def credit_lines(taxonomy):
 
 
 def build_taxonomy_tab():
-    """Render the tree and its controls inside the Genome atlas tab."""
+    """Render the tree and its controls, and hand back the jump into the Database tab."""
     if not DATABASE.exists():
         gr.Markdown("The eukaryotic tree will appear when the taxonomy snapshot is available.")
-        return
+        return None
     taxonomy = Taxonomy()
     if taxonomy.icons:
         # The chart references each silhouette by URL, so the browser caches it
@@ -402,35 +464,61 @@ def build_taxonomy_tab():
                    js_on_load=(ROOT / "atlas.js").read_text(), apply_default_css=False,
                    elem_id="eukaryotic-atlas")
 
+    route = gr.State(DEFAULT_PATH)
+
+    def jump_text(path):
+        name = taxonomy.selected_name(path)
+        return (f"Show database results for {name}" if taxonomy.assemblies_for(path)
+                else f"No annotated assemblies in {name}")
+
+    def jump_label(path):
+        return gr.Button(jump_text(path), interactive=bool(taxonomy.assemblies_for(path)))
+
+    # The jump into the Database tab needs a real accession, so the button says
+    # up front whether the current group has any annotated assembly behind it.
+    open_database = gr.Button(jump_text(DEFAULT_PATH), elem_classes="action-button",
+                              elem_id="atlas-open-database")
+
+    def show(path):
+        return taxonomy.view(path), path, jump_label(path)
+
     def explore_tree(evt: gr.EventData):
         try:
-            return taxonomy.view(evt.route)
+            return show(evt.route)
         except (ValueError, TypeError, AttributeError) as exc:
             raise gr.Error("Choose a eukaryotic group in this snapshot.") from exc
 
-    tree.click(explore_tree, outputs=tree, show_progress="minimal", concurrency_limit=1)
+    tree.click(explore_tree, outputs=[tree, route, open_database], show_progress="minimal", concurrency_limit=1)
     with gr.Accordion("Find a lineage", open=False, elem_classes="atlas-disclosure"):
-        with gr.Row():
-            query = gr.Textbox(label="Eukaryotic taxon", placeholder="Scientific name, taxon ID, or a group such as animals")
-            find = gr.Button("Search lineages", elem_classes="action-button")
-        matches = gr.Dropdown(choices=[], label="Matching lineages", interactive=True)
-        status = gr.Markdown()
+        query = gr.Textbox(label="Find a lineage", show_label=False, elem_classes="lineage-query",
+                           placeholder="Scientific name, English name such as sponges or jellyfish, or a taxon ID")
+        status = gr.Markdown("Start typing to see matching lineages.", elem_classes="quiet-note")
+        matches = gr.Radio(choices=[], label="Matching lineages", show_label=False,
+                           interactive=True, elem_classes="lineage-matches")
 
         def taxonomy_search(text):
-            choices = taxonomy.search(text) if str(text or '').strip() else []
-            return gr.Dropdown(choices=choices, value=None), f"{len(choices)} results (up to 100, largest first)." if choices else "No matching eukaryotic taxa in this snapshot."
+            choices = taxonomy.search(text)
+            if not choices:
+                typed = str(text or "").strip()
+                return gr.Radio(choices=[], value=None), (
+                    "No matching eukaryotic taxa in this snapshot." if len(typed) >= 2
+                    else "Start typing to see matching lineages.")
+            best = choices[0][0].split(" · ")[0]
+            return (gr.Radio(choices=choices, value=choices[0][1]),
+                    f"{len(choices)} matches, closest first. Press Enter for **{best}**, or pick another.")
 
         def taxonomy_view(taxid):
-            return taxonomy.view_taxon(taxid) if taxid else taxonomy.view()
+            return show(taxonomy.taxon_path(taxid) if taxid else DEFAULT_PATH)
 
-        matches.input(taxonomy_view, matches, tree)
-        find.click(taxonomy_search, query, [matches, status])
-        query.submit(taxonomy_search, query, [matches, status])
-    if taxonomy.icons:
-        with gr.Accordion("Silhouette credits", open=False, elem_classes="atlas-disclosure"):
-            gr.Markdown("\n".join(["Silhouettes from [PhyloPic](https://www.phylopic.org), used unmodified. "
-                                   "Public-domain images need no credit; the CC BY ones do, and every artist is listed here. "
-                                   "`data/icons.json` maps each taxon to its image.", ""] + credit_lines(taxonomy)))
+        def taxonomy_best(text):
+            choices = taxonomy.search(text)
+            return taxonomy_view(choices[0][1] if choices else None)
+
+        # No separate search button: the list follows what is typed, Enter takes
+        # the closest match, and picking any row opens it.
+        query.change(taxonomy_search, query, [matches, status], show_progress="hidden")
+        query.submit(taxonomy_best, query, [tree, route, open_database])
+        matches.input(taxonomy_view, matches, [tree, route, open_database])
     with gr.Accordion("About the tree and coverage", open=False, elem_classes="atlas-disclosure"):
         gr.Markdown("This tree follows **NCBI Taxonomy within Eukaryota**. Animals and fungi share the Opisthokonta branch; "
                     "green plants include green algae. ‘Other lineages’ combines the remaining siblings for display and can be expanded. "
@@ -460,3 +548,14 @@ def build_taxonomy_tab():
                  "inventory_method": coverage.get('method'),
                  "published_versions_outside_current_GenBank_snapshot": coverage.get('unmatched_assembly_versions'),
                  "sources": taxonomy.metadata['sources']}, label="Snapshot provenance")
+    if taxonomy.icons:
+        with gr.Accordion("Silhouette credits", open=False, elem_classes="atlas-disclosure"):
+            gr.Markdown("\n".join(["Silhouettes from [PhyloPic](https://www.phylopic.org), used unmodified. "
+                                   "Public-domain images need no credit; the CC BY ones do, and every artist is listed here. "
+                                   "`data/icons.json` maps each taxon to its image.", ""] + credit_lines(taxonomy)))
+
+    def first_accession(path):
+        found = taxonomy.assemblies_for(path)
+        return found[0] if found else ""
+
+    return {"route": route, "button": open_database, "accession_for": first_accession}

tests/test_taxonomy.py

@@ -177,6 +177,32 @@ class TaxonomyTests(unittest.TestCase):
             # A trunk ribbon is still an ordinary ribbon, hoverable like any other.
             self.assertNotIn('class="flow flow-annotated is-path" data-node="0-0"', chart)
 
+    def test_search_matches_english_names(self):
+        for text, expected in (("sponges", "Porifera"), ("jellyfish", "Scyphozoa"),
+                               ("birds", "Aves"), ("human", "Homo sapiens")):
+            found = self.taxonomy.search(text)
+            self.assertTrue(found, text)
+            # The closest match leads, so it can be preselected in the picker.
+            self.assertTrue(found[0][0].startswith(expected + " · "), f"{text} -> {found[0][0]}")
+        self.assertEqual(self.taxonomy.search("9606")[0][1], "9606")
+        self.assertEqual(self.taxonomy.search("x"), [])
+
+    def test_database_jump_offers_an_annotated_accession(self):
+        with sqlite3.connect(f"{DATABASE.resolve().as_uri()}?mode=ro", uri=True) as conn:
+            if not conn.execute("SELECT name FROM sqlite_master WHERE name='assemblies'").fetchone():
+                self.skipTest("assembly table unavailable")
+        annotated = set(json.loads((DATABASE.parent / "coverage.json").read_text())["accessions"])
+        for path in (DEFAULT_PATH, "2759/33154/33208", self.taxonomy.taxon_path(40674)):
+            found = self.taxonomy.assemblies_for(path, 3)
+            self.assertTrue(found, path)
+            # Every offer is a published annotation, never a dead end.
+            for accession in found:
+                self.assertIn(accession, annotated, path)
+        # Mammal accessions must sit inside the mammal subtree, not above it.
+        mammals = set(self.taxonomy.assemblies_for(self.taxonomy.taxon_path(40674), 50))
+        birds = set(self.taxonomy.assemblies_for(self.taxonomy.taxon_path(8782), 50))
+        self.assertFalse(mammals & birds)
+
     def test_rejects_paths_outside_the_tree(self):
         for path in ("1", "33208", "2759/33208", "2759/2759~3", "2759/9606", "abc"):
             with self.assertRaises(ValueError, msg=path):