Auto-opening Structure tab: name a protein, see it fold

Say "I want to engineer MC1R" and its 3-D structure now appears on the Bench
while Turing keeps working — no click, no wait.

- New fold_structure agent tool (dee/core/agent_tools.py) resolving a named
protein to its PUBLIC AlphaFold-DB model via the existing
resolve.resolve_uniprot(). The system prompt tells Turing to call it
proactively the moment the user names their target.
- New Structure tab + view on the Bench, first in the tab order, mounting the
existing resilient Mol* loader (mountAlphaFoldViewer) — so it inherits the
EBI-outage retry ladder and version fallback already built there.
- assistant.js relays the tool result to the parent app by postMessage;
TDStructure receives it (origin-checked) and mounts.

PRIVACY — the reason this is split the way it is: fold_structure sends ONLY
the gene symbol + organism to UniProt and returns a public precomputed model,
so nothing of the user's leaves the engine and it's safe to fire automatically.
De-novo folding of a user's own VARIANT would POST their sequence to a third
party (ESMFold), so it is deliberately NOT reachable from this tool and stays
the existing explicit, separately-consented action. The tool takes no
'sequence' parameter at all, and a test asserts that.
TDStructure hard-allowlists alphafold.ebi.ac.uk before handing any URL to the
loader, since it's reachable via postMessage.

Also fixes a real deep-link bug found while verifying: booting straight onto
#turing (the landing's "Meet Turing" link) ran showRoute BEFORE the TDBench
IIFE defined window.TDBench, so the "open a conversation, not a cold chat"
intercept silently no-opped and rendered the standalone chat anyway. Corrected
on the next tick, after boot routing settles.

469 tests green (4 new), verified end-to-end in the browser with the real
MC1R model rendering, no console errors.

dee/core/agent.py

@@ -139,13 +139,19 @@ _SYSTEM_PROMPT_TEMPLATE = (
     "You are Turing, the conversational orchestrator for TuringDNA, a "
     "directed-evolution workbench (design variant libraries with ESM-2, "
     "build/map plasmids, edit with CRISPR, learn from bench results). "
-    "Current loop phase: {phase}. You have five tools available right now: "
-    "fetch_sequence, design_crispr_guides, design_primers, "
+    "Current loop phase: {phase}. You have six tools available right now: "
+    "fetch_sequence, fold_structure, design_crispr_guides, design_primers, "
     "design_variant_library, and recommend_promoter. If a request could be "
     "answered by calling one "
     "of these, call it — do not describe what you would do, and do not "
     "answer a design/analysis question from your own knowledge instead of "
-    "running the real tool. If the user names a gene, protein, or "
+    "running the real tool. As soon as the user names the protein they want "
+    "to work on (human or mouse), ALSO call fold_structure for it — it is a "
+    "fast public AlphaFold-DB lookup that puts the 3-D structure on their "
+    "Bench while you keep working, and it sends only the gene symbol, never "
+    "a sequence. Do this once per protein, alongside whatever else the "
+    "request needs; don't announce it as a separate step or ask permission. "
+    "If the user names a gene, protein, or "
     "accession instead of pasting a sequence (e.g. \"human GFP\", "
     "\"NM_001301717\"), call fetch_sequence first to resolve it, then feed "
     "the sequence it returns into whichever design tool the request "

dee/core/agent_tools.py

@@ -73,6 +73,46 @@ def _tool_fetch_sequence(args: Dict[str, Any]) -> Dict[str, Any]:
     }
 
 
+def _tool_fold_structure(args: Dict[str, Any]) -> Dict[str, Any]:
+    """Resolve a named protein to its AlphaFold-DB predicted structure so the
+    Bench can show it the moment the user says what they're engineering.
+
+    PRIVACY, deliberately: this only ever sends (gene_symbol, organism) to
+    UniProt — never a sequence. The returned AlphaFold URL is a PUBLIC,
+    precomputed model fetched straight by the browser, so nothing of the
+    user's leaves the Space to get a wild-type structure on screen. De-novo
+    folding of a user's own VARIANT is a different thing entirely: it means
+    POSTing their amino-acid sequence to a third party (ESMFold /
+    api.esmatlas.com), so that stays an explicit, separately-consented
+    client-side action and is intentionally NOT reachable from this tool.
+    """
+    from dee.core import resolve as _resolve
+
+    gene = str(args.get("gene_symbol") or "").strip()
+    organism = str(args.get("organism") or "").lower().strip()
+    if not gene:
+        return {"ok": False, "error": "missing 'gene_symbol'"}
+    if organism not in ("human", "mouse"):
+        return {"ok": False,
+                "error": "AlphaFold lookup needs 'organism' set to human or mouse."}
+    try:
+        result = _resolve.resolve_uniprot(organism, gene)
+    except Exception:  # noqa: BLE001
+        logger.exception("fold_structure uniprot resolve failed")
+        return {"ok": False, "error": "Structure lookup failed — try again shortly."}
+    if not result.get("ok"):
+        return {"ok": False, "error": result.get("error") or "No structure found."}
+    return {
+        "ok": True,
+        "gene_symbol": gene,
+        "organism": organism,
+        "uniprot": result.get("uniprot", ""),
+        "alphafold_url": result.get("alphafold_url", ""),
+        "alphafold_page": result.get("alphafold_page", ""),
+        "source": "AlphaFold DB",
+    }
+
+
 def _tool_design_crispr_guides(args: Dict[str, Any]) -> Dict[str, Any]:
     from dee.core.crispr import find_guides
 
@@ -404,6 +444,7 @@ def _tool_recommend_promoter(args: Dict[str, Any]) -> Dict[str, Any]:
 # anonymous-trial quota /api/agent/step itself is gated by.
 _TOOLS: Dict[str, Dict[str, Any]] = {
     "fetch_sequence": {"fn": _tool_fetch_sequence, "requires_signin": True},
+    "fold_structure": {"fn": _tool_fold_structure, "requires_signin": True},
     "design_crispr_guides": {"fn": _tool_design_crispr_guides, "requires_signin": True},
     "design_primers": {"fn": _tool_design_primers, "requires_signin": True},
     "design_variant_library": {"fn": _tool_design_variant_library, "requires_signin": True},
@@ -445,6 +486,41 @@ TOOL_SPECS: List[Dict[str, Any]] = [
             },
         },
     },
+    {
+        "type": "function",
+        "function": {
+            "name": "fold_structure",
+            "description": (
+                "Look up a named protein's experimentally-validated predicted "
+                "3-D structure in AlphaFold DB and show it on the user's Bench. "
+                "Call this proactively, as soon as the user names the protein "
+                "they want to engineer (e.g. 'I want to engineer MC1R') — it is "
+                "fast (a public precomputed model, no folding is run) and it "
+                "puts the structure on screen while you keep talking. It sends "
+                "ONLY the gene symbol and organism to UniProt, never a "
+                "sequence, so it is always safe to call. Human and mouse only. "
+                "NOTE: this does NOT fold a mutated variant — predicting a "
+                "user's own variant structure de novo would send their sequence "
+                "to a third party, so that stays a separate explicit action the "
+                "user takes themselves in the UI. Requires the user to be signed in."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "gene_symbol": {
+                        "type": "string",
+                        "description": "Gene/protein symbol, e.g. MC1R, TP53, BRCA1.",
+                    },
+                    "organism": {
+                        "type": "string",
+                        "enum": ["human", "mouse"],
+                        "description": "AlphaFold lookup is supported for human and mouse.",
+                    },
+                },
+                "required": ["gene_symbol", "organism"],
+            },
+        },
+    },
     {
         "type": "function",
         "function": {

dee/static/app.css

@@ -6809,6 +6809,28 @@ body[data-ui="bench"] #navTuring { display: none; }
     .mc-grid { grid-template-columns: 1fr; }
 }
 
+/* ═══════════════════════════════════════════════════════════════════════
+   STRUCTURE TAB (2026-07-18) — the Bench's 3-D view. Auto-filled from the
+   fold_structure tool with a public AlphaFold-DB model. Reuses the existing
+   .alphafold-loading overlay styling for the load/error states.
+   ═══════════════════════════════════════════════════════════════════════ */
+.view--structure { padding: 28px 32px 40px; overflow: auto; }
+.struct { max-width: 1080px; margin: 0 auto; }
+.struct-head { display: flex; align-items: flex-end; justify-content: space-between;
+    gap: 20px; margin-bottom: 18px; }
+.struct-head h2 { font-weight: 500; letter-spacing: -0.012em; margin: 2px 0 0; }
+.struct-viewer { position: relative; width: 100%; height: min(62vh, 560px);
+    border: 1px solid var(--line-strong); background: #0E141B; overflow: hidden; }
+.struct-empty { position: absolute; inset: 0; display: flex; align-items: center;
+    justify-content: center; text-align: center; padding: 28px; color: rgba(255,255,255,.62);
+    font-size: 13.5px; line-height: 1.6; max-width: 460px; margin: auto; }
+.struct-note { margin-top: 12px; font-size: 12px; color: var(--ink-faint); line-height: 1.6; }
+@media (max-width: 860px) {
+    .view--structure { padding: 20px 18px 32px; }
+    .struct-head { flex-direction: column; align-items: flex-start; }
+    .struct-viewer { height: 52vh; }
+}
+
 /* ═══════════════════════════════════════════════════════════════════════
    THE BENCH (construct workspace) — Phase 2, 2026-07-13. Active only when
    data-ui="bench" AND data-bench="open". Repositions the EXISTING Turing

dee/static/app.js

@@ -368,7 +368,7 @@ renderGutter();
 // existed): 'turing' leads the list and is the no-hash fallback. The other
 // four tools stay one click away for hands-on work — Turing just isn't a
 // nav-rail peer anymore, it's what a session starts with.
-const ROUTES = ['mission', 'turing', 'plasmid', 'design', 'crispr', 'primers', 'docs'];
+const ROUTES = ['mission', 'turing', 'structure', 'plasmid', 'design', 'crispr', 'primers', 'docs'];
 
 // ── UI mode flag (Mission-Control-+-Bench re-architecture, 2026-07-13) ──
 // 'bench' is now the default UI; ?ui=classic remains as a rollback escape
@@ -438,6 +438,7 @@ function showRoute(name) {
     // the old static "Engine" title).
     const TOPBAR = {
         mission: ['Mission control',    'Your constructs and the loop'],
+        structure: ['Structure',        'Predicted 3-D model of your target'],
         plasmid: ['Plasmid Editor',     'Map, annotate & clone your construct'],
         design:  ['Directed Evolution', 'ESM-2 variant libraries from a wild-type'],
         crispr:  ['CRISPR',             'Guide RNA design — knockout & base editing'],
@@ -9003,7 +9004,7 @@ function runOracle(opts){
 // keep working. Only ever active in the opt-in bench UI.
 // ═══════════════════════════════════════════════════════════════════════
 (function () {
-    const TAB_ROUTES = ['design', 'plasmid', 'crispr', 'primers'];
+    const TAB_ROUTES = ['structure', 'design', 'plasmid', 'crispr', 'primers'];
     let current = null;   // { name, sub, phaseIdx, route }
 
     function el(id) { return document.getElementById(id); }
@@ -9091,6 +9092,105 @@ function runOracle(opts){
 
     wire();
     window.TDBench = { openConstruct: openConstruct, openConversation: openConversation, close: close, onRoute: onRoute };
+
+    // The top-level showRoute(currentRoute()) runs during initial script
+    // execution — BEFORE this IIFE defines window.TDBench — so booting straight
+    // onto #turing (the landing's "Meet Turing" deep-link) missed showRoute's
+    // "open a conversation, not a cold chat" intercept and rendered the
+    // standalone full-screen chat anyway. Catch it on the next tick rather than
+    // inline: other boot code still routes after this IIFE evaluates, and doing
+    // it synchronously here got undone by whatever ran later. Deferring one
+    // turn lets all boot-time routing settle, then we correct it once.
+    setTimeout(function () {
+        try {
+            if (typeof currentRoute === 'function' && currentRoute() === 'turing'
+                && typeof uiMode === 'function' && uiMode() === 'bench'
+                && document.body.getAttribute('data-bench') !== 'open') {
+                openConversation();
+            }
+        } catch (e) {}
+    }, 0);
+})();
+
+// ═══════════════════════════════════════════════════════════════════════
+// STRUCTURE TAB (2026-07-18) — the Bench's 3-D view, filled automatically.
+// When Turing resolves a named protein it calls the fold_structure tool,
+// which returns a PUBLIC AlphaFold-DB model reference (only the gene symbol
+// was sent to look it up — never a sequence). The chat panel relays that to
+// this controller, which mounts the same resilient Mol* viewer the identify
+// embed uses, so the structure is on screen while Turing keeps working.
+//
+// De-novo folding of a user's own VARIANT is deliberately NOT here: that
+// POSTs their amino-acid sequence to a third party (ESMFold), so it stays an
+// explicit, separately-consented action via the existing fold modal.
+// ═══════════════════════════════════════════════════════════════════════
+(function () {
+    let mountedAcc = null;   // don't remount the structure already showing
+
+    function el(id) { return document.getElementById(id); }
+
+    // Hard allowlist: this controller is reachable via postMessage, so it must
+    // never hand an attacker-supplied URL to the structure loader.
+    function safeAfUrl(u) {
+        try {
+            const p = new URL(String(u), window.location.origin);
+            return (p.protocol === 'https:' && p.hostname === 'alphafold.ebi.ac.uk') ? p.href : '';
+        } catch (_) { return ''; }
+    }
+
+    function show(info) {
+        info = info || {};
+        const url = safeAfUrl(info.alphafold_url);
+        const host = el('structViewer');
+        if (!url || !host) return;
+
+        const acc = String(info.uniprot || '').replace(/[^A-Za-z0-9]/g, '').slice(0, 20);
+        const gene = String(info.gene_symbol || '').slice(0, 40);
+        const org = String(info.organism || '').slice(0, 20);
+
+        const title = el('structTitle'), sub = el('structSub');
+        const link = el('structEntryLink'), note = el('structNote');
+        if (title) title.textContent = gene || 'Predicted structure';
+        if (sub) {
+            sub.textContent = 'AlphaFold DB predicted model'
+                + (acc ? ' · UniProt ' + acc : '') + (org ? ' · ' + org : '');
+        }
+        const page = safeAfUrl(info.alphafold_page);
+        if (link) { if (page) { link.href = page; link.hidden = false; } else { link.hidden = true; } }
+        if (note) {
+            note.hidden = false;
+            note.textContent = 'Public precomputed model — only the gene symbol was sent to '
+                + 'look this up. Your sequences never left the engine.';
+        }
+
+        if (mountedAcc && mountedAcc === acc) return;   // already showing this one
+        mountedAcc = acc;
+        host.innerHTML = '<div class="alphafold-loading">Loading predicted structure…</div>';
+        host.dataset.pdbUrl = url;
+        try { mountAlphaFoldViewer({ alphafold_url: url }, host); } catch (_) {}
+    }
+
+    // Show it AND bring the Structure tab forward (only inside an open bench —
+    // we never yank a user out of whatever else they're doing).
+    function open(info) {
+        show(info);
+        if (document.body.getAttribute('data-bench') === 'open'
+            && location.hash !== '#structure') {
+            location.hash = '#structure';
+        }
+    }
+
+    // Relay from the Turing panel (assistant.js) after a fold_structure call.
+    // Origin-checked: the only legitimate sender is our own iframe.
+    window.addEventListener('message', function (e) {
+        if (e.origin !== window.location.origin) return;
+        const d = e.data;
+        if (!d || d.type !== 'td-structure') return;
+        open({ gene_symbol: d.gene_symbol, organism: d.organism, uniprot: d.uniprot,
+               alphafold_url: d.alphafold_url, alphafold_page: d.alphafold_page });
+    });
+
+    window.TDStructure = { show: show, open: open };
 })();
 
 // ═══════════════════════════════════════════════════════════════════════

dee/static/assistant.js

@@ -312,6 +312,12 @@
                     return [p.name || "?", p.tier || "?"];
                 }) };
         }
+        if (name === "fold_structure") {
+            return { name: label, status: "done", result: result,
+                rows: [["protein", String(result.gene_symbol || "?")],
+                       ["uniprot", String(result.uniprot || "?")],
+                       ["source", String(result.source || "AlphaFold DB")]] };
+        }
         if (name === "fetch_sequence") {
             // No `items` here on purpose — the resolved sequence itself
             // (which can be thousands of nt) goes back to the model to
@@ -601,6 +607,24 @@
                 if (j.phase) c.phase = j.phase;
                 if (j.context_tokens_limit) { c.contextTokensUsed = j.context_tokens_used || 0; c.contextTokensLimit = j.context_tokens_limit; }
                 if (j.tool_result) c.messages.push({ role: "tool", tool: shapeToolResult(j.tool_name, j.tool_result) });
+                // fold_structure resolved a PUBLIC AlphaFold-DB model for the
+                // protein the user named — hand it to the parent app so the
+                // Bench's Structure tab fills in while Turing keeps talking.
+                // Only the model reference crosses; no sequence is involved.
+                // Same-origin target, mirroring app.js's td-theme post.
+                if (j.tool_name === "fold_structure" && j.tool_result && j.tool_result.ok
+                    && window.parent && window.parent !== window) {
+                    try {
+                        window.parent.postMessage({
+                            type: "td-structure",
+                            gene_symbol: j.tool_result.gene_symbol || "",
+                            organism: j.tool_result.organism || "",
+                            uniprot: j.tool_result.uniprot || "",
+                            alphafold_url: j.tool_result.alphafold_url || "",
+                            alphafold_page: j.tool_result.alphafold_page || "",
+                        }, window.location.origin);
+                    } catch (err) {}
+                }
                 pendingReply = { chat: c, index: c.messages.length, text: j.assistant_message || "(no reply)" };
                 c.messages.push({ role: "assistant", text: "" });
             }

dee/static/index.html

@@ -112,7 +112,7 @@
     <!-- ?v= query bumps invalidate browser + iframe asset caches when app.css /
          app.js change. Bump these numbers whenever you ship a frontend update —
          without them, users keep getting the stale file for up to a week. -->
-    <link rel="stylesheet" href="/static/app.css?v=20260718-onehome" />
+    <link rel="stylesheet" href="/static/app.css?v=20260718-structure2" />
     <link rel="icon" type="image/svg+xml" href="/static/favicon.svg?v=2" />
     <link rel="apple-touch-icon" href="/static/favicon.svg?v=2" />
     <!-- Mol* (PDBe) 3-D viewer is ~4.9 MB. We do NOT eager-load it on every
@@ -444,6 +444,7 @@
 
             <div class="bench-canvashead" id="benchCanvasHead" hidden>
               <nav class="bench-tabs" id="benchTabs" aria-label="Construct artifacts">
+                <button class="bench-tab" data-route="structure" type="button">Structure</button>
                 <button class="bench-tab" data-route="design"  type="button">Library</button>
                 <button class="bench-tab" data-route="plasmid" type="button">Map</button>
                 <button class="bench-tab" data-route="crispr"  type="button">Guides</button>
@@ -507,6 +508,34 @@
                         title="Turing — conversational engine" loading="lazy"></iframe>
               </section>
 
+              <!-- =============================== STRUCTURE view
+                   The Bench's Structure tab. Populated automatically when
+                   Turing resolves a named protein (fold_structure → a PUBLIC
+                   AlphaFold-DB model; only the gene symbol ever leaves the
+                   Space, never a sequence). Mounts the same resilient Mol*
+                   viewer the identify/AlphaFold embeds use. De-novo folding of
+                   a user's own VARIANT stays an explicit, separately-consented
+                   action (it would POST their sequence to a third party). -->
+              <section class="view view--structure2" data-view="structure" hidden aria-label="Predicted structure">
+                <div class="struct">
+                  <header class="struct-head">
+                    <div>
+                      <p class="card-kicker" id="structKicker">&sect; Structure</p>
+                      <h2 id="structTitle">Predicted structure</h2>
+                      <p class="card-sub" id="structSub">Turing loads the wild-type model as soon as you name a protein.</p>
+                    </div>
+                    <a class="ghost" id="structEntryLink" target="_blank" rel="noopener" hidden>Open AlphaFold entry</a>
+                  </header>
+                  <div class="struct-viewer" id="structViewer">
+                    <div class="struct-empty" id="structEmpty">
+                      Name a protein in the conversation — “I want to engineer MC1R” — and its
+                      predicted structure appears here.
+                    </div>
+                  </div>
+                  <p class="struct-note" id="structNote" hidden></p>
+                </div>
+              </section>
+
               <!-- =============================== DESIGN view (default) -->
               <section class="view view--design" data-view="design">
                 <!--
@@ -2272,7 +2301,7 @@
     <!-- Cloning reference data must load before app.js so the Designer
          can read VECTORS / ENZYMES / CLONING_METHODS / TAGS / LINKERS. -->
     <script src="/static/cloning_db.js?v=20260530-ui-polish" defer></script>
-    <script src="/static/app.js?v=20260718-onehome" defer></script>
+    <script src="/static/app.js?v=20260718-structure2" defer></script>
     <!-- Dwell-time heartbeat. Loads after auth.js so its /api/ping calls go
          through the JWT-attaching fetch wrapper (signed-in attribution). -->
     <script src="/static/telemetry.js?v=20260622-analytics" defer></script>

tests/test_fold_structure_tool.py

@@ -0,0 +1,58 @@
+"""Tests for the fold_structure agent tool — the Bench's auto-opening 3-D view.
+
+The privacy contract is the point of this tool and is asserted here: it must
+resolve a NAMED protein to a PUBLIC AlphaFold-DB model by sending only the gene
+symbol + organism, and must never accept or forward a sequence (de-novo folding
+of a user's own variant goes to a third party, so it stays an explicit,
+separately-consented client-side action).
+"""
+import pytest
+
+from dee.core import agent_tools as t
+
+
+def test_fold_structure_is_registered_and_specced():
+    assert "fold_structure" in t._TOOLS
+    spec = next(s for s in t.TOOL_SPECS if s["function"]["name"] == "fold_structure")
+    params = spec["function"]["parameters"]
+    assert set(params["required"]) == {"gene_symbol", "organism"}
+    # It must NOT take a sequence — that's the whole privacy boundary.
+    assert "sequence" not in params["properties"]
+    assert params["properties"]["organism"]["enum"] == ["human", "mouse"]
+
+
+def test_fold_structure_requires_gene_and_supported_organism():
+    assert t._tool_fold_structure({"organism": "human"})["ok"] is False
+    bad = t._tool_fold_structure({"gene_symbol": "MC1R", "organism": "zebrafish"})
+    assert bad["ok"] is False
+    assert "human or mouse" in bad["error"]
+
+
+def test_fold_structure_returns_public_model_reference(monkeypatch):
+    seen = {}
+
+    def fake_resolve_uniprot(organism, gene_symbol):
+        seen["args"] = (organism, gene_symbol)
+        return {"ok": True, "uniprot": "Q01726",
+                "alphafold_url": "https://alphafold.ebi.ac.uk/files/AF-Q01726-F1-model_v6.pdb",
+                "alphafold_page": "https://alphafold.ebi.ac.uk/entry/Q01726"}
+
+    from dee.core import resolve as _resolve
+    monkeypatch.setattr(_resolve, "resolve_uniprot", fake_resolve_uniprot)
+
+    out = t._tool_fold_structure({"gene_symbol": "MC1R", "organism": "human"})
+    assert out["ok"] is True
+    assert out["uniprot"] == "Q01726"
+    assert out["alphafold_url"].startswith("https://alphafold.ebi.ac.uk/")
+    assert out["source"] == "AlphaFold DB"
+    # ONLY (organism, gene) was sent onward — no sequence anywhere in the call.
+    assert seen["args"] == ("human", "MC1R")
+
+
+def test_fold_structure_surfaces_lookup_failure_honestly(monkeypatch):
+    from dee.core import resolve as _resolve
+    monkeypatch.setattr(_resolve, "resolve_uniprot",
+                        lambda o, g: {"ok": False, "error": "No reviewed UniProt entry found for ZZZ (human)."})
+    out = t._tool_fold_structure({"gene_symbol": "ZZZ", "organism": "human"})
+    assert out["ok"] is False
+    assert "ZZZ" in out["error"]