Deploy df060e3

The construct is the noun; the tools are verbs on it

Source: https://github.com/WINTER4000/turingDNA/commit/df060e3d534f6dad3fd12bf6cc4e4820f3d0da68

dee/auth.py

@@ -3026,3 +3026,261 @@ def edit_memory(user_id: Optional[str], memory_id: str, fact: str) -> Dict[str,
 def forget_memory(user_id: Optional[str], memory_id: str) -> Dict[str, Any]:
     """Delete outright. Memory the user cannot remove isn't theirs."""
     return _memory_write(user_id or "", memory_id, "DELETE")
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Constructs — the thing every tool operates ON
+# ═══════════════════════════════════════════════════════════════════════════
+# Migration 0012 created this table for exactly this purpose and nothing ever
+# read or wrote it. Meanwhile /api/mission reconstructed "constructs" on every
+# request by grouping artifacts on a NORMALISED NAME STRING — which merges
+# every artifact left at its default name ("Plasmid", "Library", …) into one
+# card, and splits a construct in two the moment you rename something.
+#
+# The point of wiring it now is not storage. It is that once a construct is
+# the thing the user has selected, every tool call can carry its id, and the
+# question "what work belongs together?" stops being a guess reconstructed
+# afterwards and becomes something recorded at the moment it happened.
+#
+# NOTE on the *_ids arrays: they are a bag, not a graph — they say a construct
+# HAS these artifacts, never that one was derived from another. Real lineage
+# (which region of which plasmid produced which guide set) needs its own edge
+# table; this is the grouping layer beneath it, not a substitute for it.
+
+_CONSTRUCTS_LIST_LIMIT = 100
+_CONSTRUCT_SEQ_MAX = 400_000
+_CONSTRUCT_ARTIFACT_KINDS = {"plasmid": "plasmid_ids",
+                             "crispr":  "crispr_ids",
+                             "primer":  "primer_ids"}
+_CONSTRUCT_PHASES = ("Design", "Build", "Edit", "Learn")
+
+
+def _valid_uuid(value: str) -> bool:
+    import re as _re
+    return bool(_re.match(r"^[0-9a-fA-F-]{36}$", value or ""))
+
+
+def save_construct(
+    user_id: Optional[str], *,
+    name: str, sequence_hash: str, wt_identifier: str = "",
+    wt_protein: str = "", sequence_dna: str = "", phase: str = "Design",
+    meta: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    """Create a construct. Returns {ok, id} or {ok:False, error}.
+
+    Callers should prefer :func:`find_or_create_construct` — a user pasting the
+    same sequence twice means "the thing I am already working on", not a second
+    project, and silently creating duplicates is how a workspace becomes a mess
+    the user has to tidy.
+    """
+    if not user_id:
+        return {"ok": False, "error": "Sign in to keep projects."}
+    if not (SUPABASE_URL and SUPABASE_SERVICE_KEY):
+        return {"ok": False, "error": "Projects aren't configured on this server."}
+    if not sequence_hash:
+        return {"ok": False, "error": "A construct needs a sequence to group on."}
+    from datetime import datetime, timezone, timedelta
+    expires_at = (None if has_pro_plan(user_id) else
+                  (datetime.now(timezone.utc)
+                   + timedelta(days=FREE_LIBRARY_TTL_DAYS)).isoformat())
+    payload = {
+        "user_id":       user_id,
+        "name":          (name or "Untitled construct")[:120],
+        "sequence_hash": sequence_hash[:64],
+        "wt_identifier": (wt_identifier or "")[:200] or None,
+        "wt_protein":    (wt_protein or "")[:_CONSTRUCT_SEQ_MAX],
+        "sequence_dna":  (sequence_dna or "")[:_CONSTRUCT_SEQ_MAX],
+        "phase":         phase if phase in _CONSTRUCT_PHASES else "Design",
+        "meta":          meta or {},
+        "expires_at":    expires_at,
+    }
+    import urllib.request
+    import urllib.error
+    try:
+        req = urllib.request.Request(
+            f"{SUPABASE_URL}/rest/v1/constructs",
+            data=json.dumps(payload).encode("utf-8"),
+            method="POST",
+            headers=_user_pgrst_headers({"Content-Type": "application/json",
+                                         "Prefer": "return=representation"}),
+        )
+        with urllib.request.urlopen(req, timeout=8.0) as resp:
+            rows = json.loads(resp.read().decode("utf-8"))
+            row = rows[0] if isinstance(rows, list) and rows else {}
+            return {"ok": True, "id": row.get("id"), "construct": row}
+    except urllib.error.HTTPError as exc:
+        body = ""
+        try:
+            body = exc.read().decode("utf-8")[:200]
+        except Exception:  # noqa: BLE001
+            pass
+        logger.warning("constructs insert HTTP %s: %s", exc.code, body)
+        if exc.code in (404, 406) or "PGRST" in body:
+            return {"ok": False,
+                    "error": "Projects aren't enabled yet (database migration pending)."}
+        return {"ok": False, "error": "Couldn't create the project."}
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("constructs insert failed: %s", exc)
+        return {"ok": False, "error": "Couldn't create the project."}
+
+
+def list_constructs(user_id: Optional[str]) -> list:
+    """The user's constructs, newest-touched first. Metadata only — the DNA
+    and protein are deliberately excluded so the switcher stays small."""
+    if not user_id or not (SUPABASE_URL and SUPABASE_SERVICE_KEY):
+        return []
+    import urllib.request
+    try:
+        url = (f"{SUPABASE_URL}/rest/v1/constructs"
+               f"?user_id=eq.{user_id}"
+               f"&select=id,name,created_at,updated_at,phase,sequence_hash,"
+               f"wt_identifier,library_id,plasmid_ids,crispr_ids,primer_ids"
+               f"&order=updated_at.desc&limit={_CONSTRUCTS_LIST_LIMIT}")
+        req = urllib.request.Request(url, method="GET", headers=_user_pgrst_headers())
+        with urllib.request.urlopen(req, timeout=6.0) as resp:
+            return json.loads(resp.read().decode("utf-8")) or []
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("constructs list failed for %s: %s", user_id, exc)
+        return []
+
+
+def get_construct(user_id: Optional[str], construct_id: str) -> Optional[Dict[str, Any]]:
+    """One construct in full, ownership enforced."""
+    if not user_id or not (SUPABASE_URL and SUPABASE_SERVICE_KEY):
+        return None
+    if not _valid_uuid(construct_id):
+        return None
+    import urllib.request
+    try:
+        url = (f"{SUPABASE_URL}/rest/v1/constructs"
+               f"?id=eq.{construct_id}&user_id=eq.{user_id}&select=*&limit=1")
+        req = urllib.request.Request(url, method="GET", headers=_user_pgrst_headers())
+        with urllib.request.urlopen(req, timeout=6.0) as resp:
+            rows = json.loads(resp.read().decode("utf-8"))
+            return rows[0] if isinstance(rows, list) and rows else None
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("constructs get failed: %s", exc)
+        return None
+
+
+def find_construct_by_hash(user_id: Optional[str], sequence_hash: str
+                           ) -> Optional[Dict[str, Any]]:
+    """The construct already grouping this sequence, if any.
+
+    This is the whole reason `sequence_hash` is on the table: the same sequence
+    means the same piece of work, regardless of what the user called it. It is
+    the honest version of the name-string matching /api/mission does today.
+    """
+    if not user_id or not sequence_hash or not (SUPABASE_URL and SUPABASE_SERVICE_KEY):
+        return None
+    import urllib.request
+    import urllib.parse
+    try:
+        url = (f"{SUPABASE_URL}/rest/v1/constructs"
+               f"?user_id=eq.{user_id}"
+               f"&sequence_hash=eq.{urllib.parse.quote(sequence_hash[:64])}"
+               f"&select=*&order=updated_at.desc&limit=1")
+        req = urllib.request.Request(url, method="GET", headers=_user_pgrst_headers())
+        with urllib.request.urlopen(req, timeout=6.0) as resp:
+            rows = json.loads(resp.read().decode("utf-8"))
+            return rows[0] if isinstance(rows, list) and rows else None
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("constructs find-by-hash failed: %s", exc)
+        return None
+
+
+def update_construct(user_id: Optional[str], construct_id: str,
+                     **fields: Any) -> Dict[str, Any]:
+    """Patch a construct. Only a fixed set of fields is writable, so a stray
+    key from a request body can never reach the row."""
+    if not user_id or not (SUPABASE_URL and SUPABASE_SERVICE_KEY):
+        return {"ok": False, "error": "Not configured."}
+    if not _valid_uuid(construct_id):
+        return {"ok": False, "error": "Bad id."}
+    allowed = {"name", "phase", "library_id", "plasmid_ids", "crispr_ids",
+               "primer_ids", "meta", "wt_protein", "sequence_dna",
+               "wt_identifier"}
+    payload = {k: v for k, v in fields.items() if k in allowed and v is not None}
+    if "name" in payload:
+        payload["name"] = str(payload["name"])[:120] or "Untitled construct"
+    if "phase" in payload and payload["phase"] not in _CONSTRUCT_PHASES:
+        payload.pop("phase")
+    if not payload:
+        return {"ok": False, "error": "Nothing to update."}
+    from datetime import datetime, timezone
+    payload["updated_at"] = datetime.now(timezone.utc).isoformat()
+    import urllib.request
+    try:
+        url = (f"{SUPABASE_URL}/rest/v1/constructs"
+               f"?id=eq.{construct_id}&user_id=eq.{user_id}")
+        req = urllib.request.Request(
+            url, data=json.dumps(payload).encode("utf-8"), method="PATCH",
+            headers=_user_pgrst_headers({"Content-Type": "application/json",
+                                         "Prefer": "return=representation"}))
+        with urllib.request.urlopen(req, timeout=6.0) as resp:
+            rows = json.loads(resp.read().decode("utf-8"))
+            return {"ok": True,
+                    "construct": rows[0] if isinstance(rows, list) and rows else None}
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("constructs update failed: %s", exc)
+        return {"ok": False, "error": "Couldn't update the project."}
+
+
+def delete_construct(user_id: Optional[str], construct_id: str) -> Dict[str, Any]:
+    """Delete the grouping only. The artifacts it referenced are NOT touched:
+    deleting a project must never silently destroy a plasmid the user still
+    has open in another tab."""
+    if not user_id or not (SUPABASE_URL and SUPABASE_SERVICE_KEY):
+        return {"ok": False, "error": "Not configured."}
+    if not _valid_uuid(construct_id):
+        return {"ok": False, "error": "Bad id."}
+    import urllib.request
+    try:
+        url = (f"{SUPABASE_URL}/rest/v1/constructs"
+               f"?id=eq.{construct_id}&user_id=eq.{user_id}")
+        req = urllib.request.Request(
+            url, method="DELETE",
+            headers=_user_pgrst_headers({"Prefer": "return=minimal"}))
+        with urllib.request.urlopen(req, timeout=6.0):
+            return {"ok": True}
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("constructs delete failed: %s", exc)
+        return {"ok": False, "error": "Couldn't delete."}
+
+
+def attach_artifact(user_id: Optional[str], construct_id: str,
+                    kind: str, artifact_id: str) -> Dict[str, Any]:
+    """Record that an artifact belongs to a construct, and advance the phase.
+
+    Read-modify-write rather than an atomic array append, because PostgREST
+    has no append primitive. Two tool runs finishing in the same instant could
+    drop one id — acceptable for a single user's own work, and the loss is a
+    missing cross-reference rather than a lost artifact, which still exists in
+    its own table. Worth replacing when the lineage edge table lands, since
+    that wants insert-only rows anyway.
+
+    Never raises: attribution failing must not fail the tool run the user
+    actually asked for.
+    """
+    col = _CONSTRUCT_ARTIFACT_KINDS.get(kind)
+    if not user_id or not col or not _valid_uuid(construct_id) \
+            or not _valid_uuid(artifact_id):
+        return {"ok": False, "error": "Bad attach request."}
+    row = get_construct(user_id, construct_id)
+    if not row:
+        return {"ok": False, "error": "No such project."}
+    current = row.get(col) or []
+    if artifact_id in current:
+        return {"ok": True, "already": True}
+    updated = (current + [artifact_id])[-200:]
+    # Phase only ever moves forward. A user opening the CRISPR tool after
+    # logging results should not drag the project back from Learn to Edit.
+    phase_for = {"plasmid": "Build", "primer": "Build", "crispr": "Edit"}
+    want = phase_for.get(kind)
+    fields: Dict[str, Any] = {col: updated}
+    if want:
+        cur_i = _CONSTRUCT_PHASES.index(row.get("phase") or "Design") \
+            if (row.get("phase") in _CONSTRUCT_PHASES) else 0
+        if _CONSTRUCT_PHASES.index(want) > cur_i:
+            fields["phase"] = want
+    return update_construct(user_id, construct_id, **fields)

dee/server.py

@@ -826,6 +826,8 @@ _RL_RULES = [
     ("/api/dna/generate",              (6,   60)),   # autoregressive — priciest
     ("/api/compiler",                  (30,  60)),   # pure logic; probes DNA reach
     ("/api/dna",                       (12,  60)),
+    ("/api/constructs",                (90,  60)),   # cheap CRUD; the
+                                                     # switcher polls it
     ("/api/plasmid",                   (60,  60)),
     ("/api/ping",                      (60,  60)),   # dwell heartbeat — its own
                                                      # bucket so ~2/min never eats
@@ -2198,6 +2200,25 @@ def create_app() -> Flask:
             return jsonify({"error": "Alignment failed — check the two sequences."}), 500
         return jsonify({"ok": True, **result})
 
+    # ── Attribution ───────────────────────────────────────────────────────
+    # The whole point of the construct being the selected object: when a tool
+    # saves something and the client sent the id it was working under, the
+    # link is RECORDED at the moment it happened rather than reconstructed
+    # later by matching name strings.
+    #
+    # Deliberately best-effort and silent. Attribution failing must never fail
+    # the save the user actually asked for — the artifact still exists in its
+    # own table, it is only the cross-reference that is missing.
+    def _attribute(auth, body, kind, result):
+        try:
+            cid = str((body or {}).get("construct_id") or "").strip()
+            new_id = (result or {}).get("id")
+            if not cid or not new_id or auth.anonymous:
+                return
+            _auth.attach_artifact(auth.user_id, cid, kind, str(new_id))
+        except Exception:  # noqa: BLE001
+            app.logger.warning("attribution failed for %s", kind, exc_info=True)
+
     @app.post("/api/plasmid/save")
     def plasmid_save() -> Response:
         auth, denied = _plasmid_signin_guard()
@@ -2218,6 +2239,7 @@ def create_app() -> Flask:
             source=str(body.get("source", "") or "")[:16] or None,
             sequence=data["sequence"], features=data["features"],
         )
+        _attribute(auth, body, "plasmid", result)
         _auth.cleanup_expired_plasmids_async(auth.user_id)
         return jsonify(result), (200 if result.get("ok") else 502)
 
@@ -2761,6 +2783,7 @@ def create_app() -> Flask:
             input_length=input_length,
             guides=guides,
         )
+        _attribute(auth, body, "crispr", result)
         _auth.cleanup_expired_crispr_designs_async(auth.user_id)  # lazy sweep
         return jsonify(result), (200 if result.get("ok") else 502)
 
@@ -2815,6 +2838,7 @@ def create_app() -> Flask:
             n_primers=n_primers,
             result=result_obj,
         )
+        _attribute(auth, body, "primer", result)
         _auth.cleanup_expired_primer_analyses_async(auth.user_id)  # lazy sweep
         return jsonify(result), (200 if result.get("ok") else 502)
 
@@ -3646,6 +3670,123 @@ def create_app() -> Flask:
         data["ok"] = True
         return _public_cors(jsonify(data))
 
+    # ── Constructs: the object every tool operates on ────────────────────
+    # The inversion. Until now a tool was a destination you pasted a sequence
+    # into, and each of the eight tool views had its own empty input. Nothing
+    # carried across them, so "which project does this guide set belong to?"
+    # could only ever be reconstructed afterwards by matching name strings.
+    #
+    # A construct is the noun. The tools become verbs applied to it. Once the
+    # client holds a selected construct and sends its id with every tool call,
+    # attribution stops being a reconstruction and becomes a record.
+    #
+    # SIGNED OUT these endpoints all 401 by design, and the client keeps its
+    # selection purely in local storage. Public tool access was a deliberate
+    # decision and must not regress: nothing here may become a precondition
+    # for running a tool.
+    def _construct_out(row):
+        """Trim a row for the client. The full DNA/protein is only sent by the
+        single-construct GET — the switcher must not ship megabytes."""
+        if not row:
+            return None
+        return {
+            "id": row.get("id"), "name": row.get("name"),
+            "phase": row.get("phase") or "Design",
+            "sequence_hash": row.get("sequence_hash"),
+            "wt_identifier": row.get("wt_identifier"),
+            "created_at": row.get("created_at"),
+            "updated_at": row.get("updated_at"),
+            "n_plasmids": len(row.get("plasmid_ids") or []),
+            "n_crispr": len(row.get("crispr_ids") or []),
+            "n_primers": len(row.get("primer_ids") or []),
+            "library_id": row.get("library_id"),
+        }
+
+    @app.get("/api/constructs")
+    def constructs_list() -> Response:
+        auth = _auth.get_auth()
+        if auth.anonymous:
+            # Not an error. A signed-out visitor has no saved projects and the
+            # UI shows its local-only selection instead.
+            return jsonify({"ok": True, "gated": True, "constructs": []})
+        rows = _auth.list_constructs(auth.user_id)
+        return jsonify({"ok": True, "gated": False,
+                        "constructs": [_construct_out(r) for r in rows]})
+
+    @app.post("/api/constructs")
+    def constructs_create() -> Response:
+        """Create, or return the one already grouping this sequence.
+
+        Pasting the same sequence twice means "the thing I am already working
+        on", not a second project. Silently creating a duplicate is how a
+        workspace turns into a list the user has to tidy, so the hash decides.
+        """
+        auth = _auth.get_auth()
+        if auth.anonymous:
+            return jsonify({"error": "Sign in to keep projects.",
+                            "kind": "signin_required"}), 401
+        body = request.get_json(force=True, silent=True) or {}
+        dna = "".join(str(body.get("sequence_dna") or "").split()).upper()
+        protein = "".join(str(body.get("wt_protein") or "").split()).upper()
+        basis = dna or protein
+        if not basis:
+            return jsonify({"error": "A project needs a sequence."}), 400
+        seq_hash = _hash_sequence(basis)
+
+        existing = _auth.find_construct_by_hash(auth.user_id, seq_hash)
+        if existing:
+            return jsonify({"ok": True, "reused": True,
+                            "construct": _construct_out(existing)})
+
+        res = _auth.save_construct(
+            auth.user_id,
+            name=str(body.get("name") or "").strip() or "Untitled construct",
+            sequence_hash=seq_hash,
+            wt_identifier=str(body.get("wt_identifier") or ""),
+            wt_protein=protein, sequence_dna=dna,
+            phase=str(body.get("phase") or "Design"))
+        if not res.get("ok"):
+            return jsonify({"error": res.get("error") or "Couldn't create."}), 400
+        return jsonify({"ok": True, "reused": False,
+                        "construct": _construct_out(res.get("construct"))})
+
+    @app.get("/api/constructs/<construct_id>")
+    def constructs_get(construct_id: str) -> Response:
+        auth = _auth.get_auth()
+        if auth.anonymous:
+            return jsonify({"error": "Sign in.", "kind": "signin_required"}), 401
+        row = _auth.get_construct(auth.user_id, construct_id)
+        if not row:
+            return jsonify({"error": "Not found."}), 404
+        out = _construct_out(row)
+        # Only here, and only for the one the user actually selected.
+        out["sequence_dna"] = row.get("sequence_dna") or ""
+        out["wt_protein"] = row.get("wt_protein") or ""
+        return jsonify({"ok": True, "construct": out})
+
+    @app.patch("/api/constructs/<construct_id>")
+    def constructs_patch(construct_id: str) -> Response:
+        auth = _auth.get_auth()
+        if auth.anonymous:
+            return jsonify({"error": "Sign in.", "kind": "signin_required"}), 401
+        body = request.get_json(force=True, silent=True) or {}
+        res = _auth.update_construct(
+            auth.user_id, construct_id,
+            **{k: body[k] for k in ("name", "phase") if k in body})
+        if not res.get("ok"):
+            return jsonify({"error": res.get("error") or "Couldn't update."}), 400
+        return jsonify({"ok": True, "construct": _construct_out(res.get("construct"))})
+
+    @app.delete("/api/constructs/<construct_id>")
+    def constructs_delete(construct_id: str) -> Response:
+        auth = _auth.get_auth()
+        if auth.anonymous:
+            return jsonify({"error": "Sign in.", "kind": "signin_required"}), 401
+        res = _auth.delete_construct(auth.user_id, construct_id)
+        if not res.get("ok"):
+            return jsonify({"error": res.get("error") or "Couldn't delete."}), 400
+        return jsonify({"ok": True})
+
     @app.get("/api/mission")
     def mission() -> Response:
         """Command-center rollup for the Mission Control home — ONE call that

dee/static/app.css

@@ -10160,3 +10160,72 @@ body.de-agent-run .dna-edit-actions { display: none; }
     .tc-arch { flex-wrap: wrap; }
     .tc-arch-seg { flex-basis: 48%; }
 }
+
+/* ── The active construct: chip + switcher ──────────────────────────────
+   The topbar used to name the TOOL you were in. Now, when something is
+   selected, it names what you are working ON and the tool is demoted to the
+   subtitle. With nothing selected these rules are inert and the topbar is
+   exactly what it was — which is what a signed-out visitor still gets. */
+.ctx-chip {
+    display: inline-flex; align-items: center; gap: 8px;
+    background: none; border: 1px solid var(--line); border-radius: 999px;
+    padding: 4px 12px 4px 10px; cursor: pointer; max-width: 100%;
+    min-height: 32px; color: var(--ink-strong);
+    font-family: inherit; transition: border-color .15s, background .15s;
+}
+/* `hidden` must win. An explicit display: beats the UA's [hidden] rule, so
+   without this the chip renders even with nothing selected — which is exactly
+   the signed-out first-run screen. Caught by tests/test_hidden_attribute.py,
+   which exists because this has bitten the codebase before. */
+.ctx-chip[hidden] { display: none; }
+.ctx-chip:hover { border-color: var(--ink-faint); background: var(--bg-subtle); }
+.ctx-chip:focus-visible { outline: 2px solid var(--brand); outline-offset: 2px; }
+.ctx-dot { width: 6px; height: 6px; border-radius: 50%; flex-shrink: 0;
+           background: var(--ink-faint); }
+[data-theme="dark"] .ctx-dot { background: var(--glow); }
+.ctx-name { font-size: 14px; font-weight: 600; letter-spacing: -0.01em;
+            overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.ctx-meta { font-size: 11px; color: var(--ink-faint); white-space: nowrap; }
+.ctx-caret { font-size: 9px; color: var(--ink-faint); flex-shrink: 0; }
+
+/* The demotion. Selecting a construct makes the tool line secondary rather
+   than hiding it — you still need to know which tool you're holding. */
+body[data-ctx="on"] .topbar-title { display: none; }
+body[data-ctx="on"] .topbar-sub { font-size: 11.5px; color: var(--ink-faint); }
+
+.ctx-menu {
+    position: absolute; z-index: 60; top: 52px; left: 56px;
+    min-width: 290px; max-width: min(420px, calc(100vw - 32px));
+    max-height: min(60vh, 460px); overflow-y: auto;
+    background: var(--bg-card); border: 1px solid var(--line);
+    border-radius: 10px; box-shadow: var(--elev-4); padding: 6px;
+}
+.ctx-menu-hd { font-size: 10px; letter-spacing: .10em; text-transform: uppercase;
+               color: var(--ink-faint); padding: 8px 10px 6px; }
+.ctx-menu-empty { font-size: 12px; color: var(--ink-faint); padding: 4px 10px 10px;
+                  line-height: 1.5; }
+.ctx-menu-sep { height: 1px; background: var(--line); margin: 6px 0; }
+.ctx-item, .ctx-act {
+    display: flex; width: 100%; align-items: baseline; gap: 10px;
+    background: none; border: 0; border-radius: 7px; cursor: pointer;
+    padding: 9px 10px; text-align: left; color: var(--ink-strong);
+    font-family: inherit; font-size: 13px; min-height: 40px;
+}
+.ctx-item:hover, .ctx-act:hover { background: var(--bg-hover); }
+.ctx-item.is-on { background: var(--bg-subtle); }
+.ctx-item.is-on .ctx-item-nm::after { content: ' ·  current'; color: var(--ink-faint);
+                                      font-size: 11px; font-weight: 400; }
+.ctx-item-nm { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis;
+               white-space: nowrap; font-weight: 500; }
+.ctx-item-mt { font-size: 10.5px; color: var(--ink-faint); flex-shrink: 0; }
+.ctx-act { color: var(--ink-soft); font-size: 12.5px; }
+
+@media (max-width: 720px) {
+    .ctx-name { font-size: 13px; }
+    .ctx-meta { font-size: 12px; }
+    .ctx-caret { font-size: 12px; }
+    .ctx-menu { left: 12px; right: 12px; min-width: 0; top: 56px; }
+    .ctx-item, .ctx-act, .ctx-menu-hd, .ctx-menu-empty,
+    .ctx-item-mt { font-size: 12px; }
+    body[data-ctx="on"] .topbar-sub { font-size: 12px; }
+}

dee/static/app.js

@@ -473,26 +473,47 @@ function showRoute(name) {
         const href = (a.getAttribute('href') || '').replace('#', '').toLowerCase();
         a.classList.toggle('active', href === name);
     });
-    // Contextual topbar: show the current tool + a one-line description so
-    // the user always knows where they are and what the tool does (replaces
-    // the old static "Engine" title).
-    const TOPBAR = {
+    // Contextual topbar. The map moved to _applyTopbar — it now has two
+    // triggers (route change AND construct change) and two copies would drift.
+    _applyTopbar(name);
+    // Carry the sequence into whichever tool the user just opened. Only fills
+    // an input they left empty — see rule 3 in context.js.
+    if (window.TDContext) window.TDContext.prefill(name);
+    window.scrollTo({ top: 0, behavior: 'instant' });
+}
+
+// Topbar labelling. Extracted from showRoute because it has two triggers,
+// not one: the route changing AND the construct changing. Inline in showRoute
+// it only ran on navigation, so adopting a construct while already on a view
+// left the tool line un-demoted.
+let _lastRoute = 'mission';
+function _applyTopbar(name) {
+    _lastRoute = name || _lastRoute;
+    const TB = {
         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'],
+        dna:     ['DNA Design',         'Score & generate DNA with Evo 2'],
+        compiler: ['Therapeutic Compiler', 'Variant \u2192 editing strategy'],
+        crispr:  ['CRISPR',             'Guide RNA design \u2014 knockout & base editing'],
         primers: ['Primer Analysis',    'Score & rank your candidate PCR primers'],
         docs:    ['Documentation',      'How TuringDNA works'],
-        turing:  ['Turing',             'Talk to the engine — it runs your tools'],
+        turing:  ['Turing',             'Talk to the engine \u2014 it runs your tools'],
     };
-    const tb = TOPBAR[name] || ['Engine', ''];
+    const tb = TB[_lastRoute] || ['Engine', ''];
     const tTitle = document.getElementById('topbarTitle');
     const tSub = document.getElementById('topbarSub');
     if (tTitle) tTitle.textContent = tb[0];
-    if (tSub) tSub.textContent = tb[1];
-    window.scrollTo({ top: 0, behavior: 'instant' });
+    // With a construct selected the tool line is DEMOTED to a subtitle under
+    // the construct's name: the answer to "where am I?" is the thing you are
+    // working on, not the tool you happen to be holding. Nothing selected and
+    // this is byte-for-byte the old topbar.
+    const ctx = window.TDContext && window.TDContext.get();
+    if (tSub) tSub.textContent = ctx ? (tb[1] ? tb[0] + ' \u00b7 ' + tb[1] : tb[0])
+                                     : tb[1];
 }
+if (window.TDContext) window.TDContext.subscribe(() => _applyTopbar());
 
 window.addEventListener('hashchange', () => showRoute(currentRoute()));
 showRoute(currentRoute());
@@ -9630,6 +9651,7 @@ function runOracle(opts){
     function sendToCrispr(seq, label) {
         seq = (seq || '').toUpperCase().replace(/[^ACGTN]/g, '');
         if (seq.length < 23) { _toast('Need at least ~23 bp to design CRISPR guides.'); return; }
+        if (window.TDContext) window.TDContext.adopt(seq, label, { quiet: true });
         const ta = document.getElementById('crisprInput');
         if (!ta) return;
         ta.value = seq; ta.dispatchEvent(new Event('input', { bubbles: true }));
@@ -9641,6 +9663,7 @@ function runOracle(opts){
     function sendToPrimers(seq, label) {
         seq = (seq || '').toUpperCase().replace(/[^ACGTN]/g, '');
         if (!seq) { _toast('Nothing to send.'); return; }
+        if (window.TDContext) window.TDContext.adopt(seq, label, { quiet: true });
         const t = document.getElementById('primerTemplate');
         if (!t) return;
         t.value = seq; t.dispatchEvent(new Event('input', { bubbles: true }));
@@ -9655,6 +9678,7 @@ function runOracle(opts){
         // posture as the CRISPR / Primer hand-offs.
         seq = (seq || '').toUpperCase().replace(/[^ACGTN]/g, '');
         if (seq.length < 30) { _toast('Need ≥30 bp of coding sequence to evolve a protein.'); return; }
+        if (window.TDContext) window.TDContext.adopt(seq, label, { quiet: true });
         const ta = document.getElementById('pasteArea');
         if (!ta) return;
         ta.value = seq; ta.dispatchEvent(new Event('input', { bubbles: true }));

dee/static/context.js

@@ -0,0 +1,359 @@
+/* ═══════════════════════════════════════════════════════════════════════
+   TDContext — the active construct.
+
+   THE INVERSION THIS FILE EXISTS FOR
+   ----------------------------------
+   Until now a tool was a DESTINATION. Eight routes, eight views, each with
+   its own empty input box, each asking for the sequence again. The "hand-off"
+   between them was a string copied from one <textarea> into another, and the
+   backend never learned which project any run belonged to — so "what work
+   belongs together?" could only be reconstructed afterwards by matching name
+   strings, which merges every artifact left at its default name and splits a
+   project the moment you rename something.
+
+   Here the construct is the noun and the tools are verbs applied to it. One
+   selection, held in one place, carried across every view and attached to
+   every request. Attribution stops being a reconstruction and becomes a
+   record — which is also what makes a real lineage graph possible later,
+   without hand-instrumenting each hand-off path.
+
+   THREE RULES, and each one is a way this could become worse than what it
+   replaces:
+
+   1. SIGNED OUT IT MUST BEHAVE EXACTLY AS BEFORE. Public tool access was a
+      deliberate decision. A visitor with no account keeps a purely local
+      selection; nothing here may become a precondition for running a tool.
+   2. IT MUST NEVER BLOCK. Pasting a new sequence switches the context
+      silently. The moment this can say "no", it is modal, and modal is worse
+      than scattered.
+   3. IT MUST NEVER CLOBBER. Pre-filling only ever touches an input the user
+      has left EMPTY. Overwriting something they typed would be the single
+      fastest way to make people distrust the whole idea.
+   ═══════════════════════════════════════════════════════════════════════ */
+(function () {
+    'use strict';
+
+    var LS_KEY = 'td.construct.v1';
+    var listeners = [];
+    var active = null;      // {id?, name, dna, protein, identifier, phase}
+    var known = [];         // server-side list, for the switcher
+
+    /* ── state ──────────────────────────────────────────────────────── */
+    function load() {
+        try {
+            var raw = localStorage.getItem(LS_KEY);
+            active = raw ? JSON.parse(raw) : null;
+        } catch (e) { active = null; }
+    }
+    function persist() {
+        try {
+            if (active) localStorage.setItem(LS_KEY, JSON.stringify(active));
+            else localStorage.removeItem(LS_KEY);
+        } catch (e) { /* private mode — the session still works, just not across reloads */ }
+    }
+    function notify() {
+        listeners.forEach(function (fn) {
+            try { fn(active); } catch (e) { console.error(e); }
+        });
+    }
+
+    function get() { return active; }
+    function id() { return active && active.id ? active.id : null; }
+
+    function set(c, opts) {
+        active = c || null;
+        persist();
+        notify();
+        if (!(opts && opts.quiet) && active) {
+            toast('Working on ' + active.name);
+        }
+    }
+    function clear() { set(null); notify(); }
+    function subscribe(fn) { listeners.push(fn); try { fn(active); } catch (e) {} }
+
+    function toast(msg) {
+        if (typeof window.showToast === 'function') window.showToast(msg, 'info');
+    }
+
+    /* ── adopting a sequence ────────────────────────────────────────── */
+    // Called whenever a sequence enters the app by ANY route — pasted, fetched,
+    // imported, or handed over from another tool. Switches silently; creates
+    // server-side only when signed in. Rule 2: this never refuses.
+    function adopt(seq, label, opts) {
+        opts = opts || {};
+        var dna = String(seq || '').replace(/\s+/g, '').toUpperCase();
+        if (dna.length < 12) return Promise.resolve(active);
+
+        // Same sequence = same work. Do not spawn a second project for it.
+        if (active && active.dna === dna) return Promise.resolve(active);
+
+        var local = {
+            id: null,
+            name: label || defaultName(dna),
+            dna: dna,
+            protein: opts.protein || '',
+            identifier: opts.identifier || '',
+            phase: 'Design',
+        };
+        set(local, { quiet: !!opts.quiet });
+
+        // Signed out this is where it ends, and that is a complete experience:
+        // the selection still threads every view for this session.
+        return fetch('/api/constructs', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                sequence_dna: dna, wt_protein: local.protein,
+                name: local.name, wt_identifier: local.identifier,
+            }),
+        }).then(function (r) {
+            if (!r.ok) return null;          // 401 signed out — expected, not an error
+            return r.json();
+        }).then(function (d) {
+            if (!d || !d.ok || !d.construct) return active;
+            // Server wins on identity, the local copy wins on payload: the
+            // list endpoint deliberately does not ship the sequence back.
+            active = Object.assign({}, local, {
+                id: d.construct.id,
+                name: d.construct.name || local.name,
+                phase: d.construct.phase || 'Design',
+            });
+            persist(); notify(); refreshList();
+            return active;
+        }).catch(function () { return active; });
+    }
+
+    function defaultName(dna) {
+        // Never "Untitled". A name you cannot tell apart from four others is
+        // the failure mode the name-string grouping already suffers from.
+        return 'Construct ' + dna.slice(0, 6) + '…' + dna.slice(-4);
+    }
+
+    /* ── the server-side list, for the switcher ─────────────────────── */
+    function refreshList() {
+        return fetch('/api/constructs').then(function (r) {
+            return r.ok ? r.json() : null;
+        }).then(function (d) {
+            known = (d && d.constructs) || [];
+            notify();
+            return known;
+        }).catch(function () { return known; });
+    }
+    function list() { return known; }
+
+    function open(constructId) {
+        return fetch('/api/constructs/' + encodeURIComponent(constructId))
+            .then(function (r) { return r.ok ? r.json() : null; })
+            .then(function (d) {
+                if (!d || !d.construct) return null;
+                var c = d.construct;
+                set({
+                    id: c.id, name: c.name, dna: c.sequence_dna || '',
+                    protein: c.wt_protein || '', identifier: c.wt_identifier || '',
+                    phase: c.phase || 'Design',
+                });
+                return active;
+            }).catch(function () { return null; });
+    }
+
+    function rename(name) {
+        if (!active) return Promise.resolve(null);
+        active.name = String(name || '').slice(0, 120) || active.name;
+        persist(); notify();
+        if (!active.id) return Promise.resolve(active);
+        return fetch('/api/constructs/' + encodeURIComponent(active.id), {
+            method: 'PATCH',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ name: active.name }),
+        }).then(function () { refreshList(); return active; })
+          .catch(function () { return active; });
+    }
+
+    /* ── the interceptor ────────────────────────────────────────────── */
+    // ONE place, not twenty. Editing every tool's fetch call by hand would
+    // have meant instrumenting ~20 sites and still missing whichever one gets
+    // added next month — and a lineage with a silent hole in it is worse than
+    // no lineage, because you cannot tell which is which.
+    var TOOL_PREFIXES = ['/api/crispr', '/api/primers', '/api/plasmid',
+                         '/api/design', '/api/dna', '/api/compiler',
+                         '/api/de/', '/api/align', '/api/structure'];
+    var nativeFetch = window.fetch.bind(window);
+
+    function isToolCall(url) {
+        var u = String(url || '');
+        for (var i = 0; i < TOOL_PREFIXES.length; i++) {
+            if (u.indexOf(TOOL_PREFIXES[i]) === 0) return true;
+        }
+        return false;
+    }
+
+    window.fetch = function (input, init) {
+        try {
+            var url = (typeof input === 'string') ? input
+                    : (input && input.url) || '';
+            var cid = id();
+            if (cid && init && init.method &&
+                String(init.method).toUpperCase() === 'POST' &&
+                isToolCall(url) && typeof init.body === 'string') {
+                var body = JSON.parse(init.body);
+                if (body && typeof body === 'object' && !Array.isArray(body)
+                    && !body.construct_id) {
+                    body.construct_id = cid;
+                    init = Object.assign({}, init, { body: JSON.stringify(body) });
+                }
+            }
+        } catch (e) {
+            // A body that is not JSON, or is not ours to touch. Attribution is
+            // never worth breaking the request the user actually made.
+        }
+        return nativeFetch(input, init);
+    };
+
+    /* ── pre-filling a tool view ────────────────────────────────────── */
+    // Rule 3: only ever fills an input the user left EMPTY.
+    var TOOL_INPUTS = {
+        crispr:   'crisprInput',
+        primers:  'primerTemplate',
+        design:   'pasteArea',
+        compiler: 'tcWindow',
+        dna:      'dnaReference',
+        plasmid:  'plasmidInput',
+    };
+
+    function prefill(route) {
+        if (!active || !active.dna) return false;
+        var elId = TOOL_INPUTS[route];
+        if (!elId) return false;
+        var el = document.getElementById(elId);
+        if (!el || (el.value || '').trim()) return false;   // never clobber
+        el.value = active.dna;
+        el.dispatchEvent(new Event('input', { bubbles: true }));
+        return true;
+    }
+
+    load();
+    window.TDContext = {
+        get: get, id: id, set: set, clear: clear, subscribe: subscribe,
+        adopt: adopt, open: open, rename: rename, list: list,
+        refreshList: refreshList, prefill: prefill,
+        TOOL_INPUTS: TOOL_INPUTS,
+    };
+
+    // The list is only meaningful signed in; a 401 here is normal and silent.
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', function () { refreshList(); });
+    } else { refreshList(); }
+}());
+
+/* ═══════════════════════════════════════════════════════════════════════
+   The chip + switcher.
+
+   Rule 3 has a UI corollary: switching and clearing must be one click and
+   always visible. A context you cannot see or change is worse than no
+   context — you end up editing the wrong object and only find out later.
+   ═══════════════════════════════════════════════════════════════════════ */
+(function () {
+    'use strict';
+    var C = window.TDContext;
+    if (!C) return;
+
+    function esc(s) {
+        return String(s == null ? '' : s).replace(/[&<>"']/g, function (m) {
+            return ({ '&': '&amp;', '<': '&lt;', '>': '&gt;',
+                      '"': '&quot;', "'": '&#39;' })[m];
+        });
+    }
+    function bp(n) { return n ? n.toLocaleString() + ' bp' : ''; }
+
+    function init() {
+        var chip = document.getElementById('ctxChip');
+        var menu = document.getElementById('ctxMenu');
+        if (!chip || !menu) return;
+
+        C.subscribe(function (c) {
+            chip.hidden = !c;
+            document.body.setAttribute('data-ctx', c ? 'on' : 'off');
+            if (!c) return;
+            var nm = document.getElementById('ctxName');
+            var mt = document.getElementById('ctxMeta');
+            if (nm) nm.textContent = c.name || 'Construct';
+            if (mt) {
+                // The un-saved case is stated, not hidden. A signed-out user
+                // whose selection lives only in this browser should know that.
+                mt.textContent = [bp((c.dna || '').length),
+                                  c.phase || '',
+                                  c.id ? '' : 'this browser only']
+                                 .filter(Boolean).join('  ·  ');
+            }
+        });
+
+        function close() {
+            menu.hidden = true;
+            chip.setAttribute('aria-expanded', 'false');
+        }
+
+        function render() {
+            var cur = C.get();
+            var rows = C.list() || [];
+            var h = '<div class="ctx-menu-hd">Constructs</div>';
+            if (!rows.length) {
+                h += '<div class="ctx-menu-empty">No saved projects yet. '
+                   + 'Paste or fetch a sequence and it becomes one.</div>';
+            }
+            rows.forEach(function (r) {
+                var on = cur && cur.id === r.id;
+                h += '<button class="ctx-item' + (on ? ' is-on' : '') + '" role="menuitem"'
+                   + ' data-open="' + esc(r.id) + '">'
+                   + '<span class="ctx-item-nm">' + esc(r.name) + '</span>'
+                   + '<span class="ctx-item-mt mono">' + esc(r.phase || 'Design')
+                   + (r.n_plasmids ? ' · ' + r.n_plasmids + 'p' : '')
+                   + (r.n_crispr ? ' · ' + r.n_crispr + 'g' : '')
+                   + (r.n_primers ? ' · ' + r.n_primers + 'pr' : '')
+                   + '</span></button>';
+            });
+            h += '<div class="ctx-menu-sep"></div>';
+            if (cur) {
+                h += '<button class="ctx-act" role="menuitem" data-rename="1">Rename…</button>';
+                h += '<button class="ctx-act" role="menuitem" data-clear="1">'
+                   + 'Work without a construct</button>';
+            }
+            menu.innerHTML = h;
+        }
+
+        chip.addEventListener('click', function (e) {
+            e.stopPropagation();
+            if (!menu.hidden) { close(); return; }
+            render();
+            menu.hidden = false;
+            chip.setAttribute('aria-expanded', 'true');
+            C.refreshList().then(function () { if (!menu.hidden) render(); });
+        });
+
+        menu.addEventListener('click', function (e) {
+            var t = e.target.closest('[data-open],[data-clear],[data-rename]');
+            if (!t) return;
+            e.stopPropagation();
+            if (t.dataset.open) { C.open(t.dataset.open); close(); return; }
+            if (t.dataset.clear) {
+                // Deliberately NOT called "delete". Clearing the selection
+                // must never read as destroying the work.
+                C.clear(); close(); return;
+            }
+            if (t.dataset.rename) {
+                var cur = C.get();
+                var next = window.prompt('Rename this construct', cur && cur.name);
+                if (next) C.rename(next);
+                close();
+            }
+        });
+
+        document.addEventListener('click', function () { if (!menu.hidden) close(); });
+        document.addEventListener('keydown', function (e) {
+            if (e.key === 'Escape' && !menu.hidden) close();
+        });
+    }
+
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', init);
+    } else { init(); }
+}());

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=20260818-peg3" />
+    <link rel="stylesheet" href="/static/app.css?v=20260818-ctx2" />
     <!-- The work catalog + the draggable rail. Kept out of app.css so two new
          self-contained surfaces stay reviewable; every colour is an app.css
          token, so both themes work with nothing added. -->
@@ -496,10 +496,27 @@
                         <line x1="3" y1="18" x2="21" y2="18"/>
                     </svg>
                 </button>
+                <!-- The construct chip. THE inversion, in markup: when a
+                     construct is selected it becomes the primary line and the
+                     tool name is demoted to a subtitle — you are working on a
+                     thing, using a tool, not visiting a tool. With nothing
+                     selected the chip is hidden and the tool title takes the
+                     lead, which is exactly today's behaviour and therefore
+                     exactly what a signed-out visitor still gets. -->
                 <div class="topbar-titles">
+                    <button class="ctx-chip" id="ctxChip" type="button" hidden
+                            aria-haspopup="menu" aria-expanded="false"
+                            aria-controls="ctxMenu"
+                            title="Switch or clear the construct every tool is working on">
+                        <span class="ctx-dot" aria-hidden="true"></span>
+                        <span class="ctx-name" id="ctxName">&mdash;</span>
+                        <span class="ctx-meta mono" id="ctxMeta"></span>
+                        <span class="ctx-caret" aria-hidden="true">&#9662;</span>
+                    </button>
                     <h1 class="topbar-title" id="topbarTitle">Plasmid Editor</h1>
                     <span class="topbar-sub" id="topbarSub">Map, annotate &amp; clone your construct</span>
                 </div>
+                <div class="ctx-menu" id="ctxMenu" role="menu" hidden></div>
                 <!-- Theme toggle relocated to the sidebar footer, by the account chip
                      (see #themeToggle in the aside) — it now stays reachable in the bench
                      view, where this topbar is hidden. -->
@@ -2852,7 +2869,8 @@
     <!-- 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=20260818-peg3" defer></script>
+    <script src="/static/context.js?v=20260818-ctx2" defer></script>
+    <script src="/static/app.js?v=20260818-ctx2" defer></script>
     <!-- The decision trace, BEFORE cockpit.js: applyEvent calls TDTrace.push
          on the very first event, and both are `defer`, so document order is
          load order. Loading it after would drop the opening events of a

tests/test_construct_context.py

@@ -0,0 +1,259 @@
+"""The construct as the object every tool operates on.
+
+THE INVERSION UNDER TEST
+------------------------
+A tool used to be a destination: eight routes, eight empty inputs, and a
+"hand-off" that copied a string from one <textarea> into another. Nothing
+carried across them and the backend never learned which project a run belonged
+to, so /api/mission had to reconstruct "constructs" by grouping artifacts on a
+normalised NAME STRING — which merges everything left at a default name and
+splits a project the moment you rename something.
+
+These tests pin the three properties that decide whether the replacement is
+better than what it replaces, because each is a way it could be worse:
+
+  1. SIGNED OUT, NOTHING CHANGES. Public tool access was deliberate. If any of
+     this becomes a precondition for running a tool, the change is a
+     regression no matter how tidy the workspace looks.
+  2. THE SAME SEQUENCE IS THE SAME PROJECT. Pasting twice must not spawn a
+     duplicate — that is how a workspace becomes a list the user has to tidy.
+  3. ATTRIBUTION IS BEST-EFFORT AND NEVER FATAL. A failed cross-reference must
+     not fail the save the user actually asked for.
+"""
+import json
+
+import pytest
+
+from dee import auth as dee_auth
+from dee import server
+
+
+def _client():
+    app = server.create_app()
+    app.config.update(TESTING=True)
+    return app.test_client()
+
+
+class _Auth:
+    def __init__(self, user_id=None):
+        self.user_id = user_id
+        self.anonymous = user_id is None
+
+
+# --------------------------------------------------------------------------- #
+# 1. Signed out, nothing changes
+# --------------------------------------------------------------------------- #
+def test_listing_constructs_signed_out_is_an_empty_gate_not_an_error(monkeypatch):
+    """A 200 with gated:true, not a 401. The switcher has to render for a
+    signed-out visitor without treating them as a failure."""
+    monkeypatch.setattr(server._auth, "get_auth", lambda: _Auth(None))
+    body = _client().get("/api/constructs").get_json()
+    assert body == {"ok": True, "gated": True, "constructs": []}
+
+
+@pytest.mark.parametrize("method,path", [
+    ("post", "/api/constructs"),
+    ("get", "/api/constructs/11111111-1111-1111-1111-111111111111"),
+    ("patch", "/api/constructs/11111111-1111-1111-1111-111111111111"),
+    ("delete", "/api/constructs/11111111-1111-1111-1111-111111111111"),
+])
+def test_writing_constructs_signed_out_is_refused_with_a_signin_kind(
+        monkeypatch, method, path):
+    monkeypatch.setattr(server._auth, "get_auth", lambda: _Auth(None))
+    cl = _client()
+    res = getattr(cl, method)(path, json={"sequence_dna": "ACGT" * 20})
+    assert res.status_code == 401
+    assert res.get_json().get("kind") == "signin_required"
+
+
+def test_the_client_keeps_its_own_selection_when_signed_out():
+    """context.js must not depend on the server for the signed-out path — the
+    selection lives in localStorage and still threads every view."""
+    with open("dee/static/context.js", encoding="utf-8") as fh:
+        src = fh.read()
+    assert "localStorage" in src
+    # adopt() posts, but a non-ok response must be swallowed, not thrown.
+    assert "if (!r.ok) return null;" in src
+
+
+def test_context_never_blocks_a_tool_run():
+    """Rule 2. There must be no code path where a missing construct prevents
+    a request — the interceptor only ever ADDS a field."""
+    with open("dee/static/context.js", encoding="utf-8") as fh:
+        src = fh.read()
+    assert "return nativeFetch(input, init);" in src
+    # Exactly ONE call site, so no early bail-out can creep in later: every
+    # path through the wrapper ends at the same return.
+    assert src.count("nativeFetch(") == 1
+
+
+def test_prefill_never_clobbers_what_the_user_typed():
+    """Rule 3. Overwriting a filled input is the fastest way to make the whole
+    idea untrustworthy."""
+    with open("dee/static/context.js", encoding="utf-8") as fh:
+        src = fh.read()
+    assert "if (!el || (el.value || '').trim()) return false;   // never clobber" in src
+
+
+# --------------------------------------------------------------------------- #
+# 2. The same sequence is the same project
+# --------------------------------------------------------------------------- #
+def test_posting_the_same_sequence_twice_reuses_the_construct(monkeypatch):
+    monkeypatch.setattr(server._auth, "get_auth", lambda: _Auth("u1"))
+    existing = {"id": "abc", "name": "MC1R", "phase": "Build",
+                "sequence_hash": "deadbeef"}
+    monkeypatch.setattr(server._auth, "find_construct_by_hash",
+                        lambda uid, h: existing)
+    called = {"n": 0}
+
+    def _never(*a, **k):
+        called["n"] += 1
+        return {"ok": True, "id": "new"}
+    monkeypatch.setattr(server._auth, "save_construct", _never)
+
+    body = _client().post("/api/constructs",
+                          json={"sequence_dna": "ACGT" * 20}).get_json()
+    assert body["ok"] is True and body["reused"] is True
+    assert body["construct"]["id"] == "abc"
+    assert called["n"] == 0, "a duplicate project must not be created"
+
+
+def test_a_construct_needs_a_sequence(monkeypatch):
+    monkeypatch.setattr(server._auth, "get_auth", lambda: _Auth("u1"))
+    res = _client().post("/api/constructs", json={"name": "no sequence"})
+    assert res.status_code == 400
+
+
+def test_the_list_payload_does_not_ship_the_sequence(monkeypatch):
+    """The switcher renders every project. Shipping the DNA with each would
+    make a routine dropdown megabytes."""
+    monkeypatch.setattr(server._auth, "get_auth", lambda: _Auth("u1"))
+    monkeypatch.setattr(server._auth, "list_constructs", lambda uid: [{
+        "id": "a", "name": "N", "phase": "Design", "sequence_hash": "h",
+        "sequence_dna": "ACGT" * 5000, "wt_protein": "MKV" * 100,
+        "plasmid_ids": ["p1"], "crispr_ids": [], "primer_ids": [],
+    }])
+    row = _client().get("/api/constructs").get_json()["constructs"][0]
+    assert "sequence_dna" not in row and "wt_protein" not in row
+    assert row["n_plasmids"] == 1 and row["n_crispr"] == 0
+
+
+def test_the_single_get_does_ship_the_sequence(monkeypatch):
+    """...because that one is the construct the user actually selected, and
+    the tools need it to pre-fill."""
+    monkeypatch.setattr(server._auth, "get_auth", lambda: _Auth("u1"))
+    monkeypatch.setattr(server._auth, "get_construct", lambda uid, cid: {
+        "id": cid, "name": "N", "phase": "Design",
+        "sequence_dna": "ACGTACGT", "wt_protein": "MKV",
+    })
+    c = _client().get(
+        "/api/constructs/11111111-1111-1111-1111-111111111111"
+    ).get_json()["construct"]
+    assert c["sequence_dna"] == "ACGTACGT" and c["wt_protein"] == "MKV"
+
+
+# --------------------------------------------------------------------------- #
+# 3. Attribution is best-effort and never fatal
+# --------------------------------------------------------------------------- #
+def test_attach_rejects_a_bad_kind_or_id():
+    assert dee_auth.attach_artifact("u1", "not-a-uuid", "plasmid", "x")["ok"] is False
+    good = "11111111-1111-1111-1111-111111111111"
+    assert dee_auth.attach_artifact("u1", good, "nonsense", good)["ok"] is False
+
+
+def test_phase_only_ever_moves_forward(monkeypatch):
+    """Opening the CRISPR tool after logging results must not drag a project
+    back from Learn to Edit."""
+    good = "11111111-1111-1111-1111-111111111111"
+    monkeypatch.setattr(dee_auth, "get_construct", lambda uid, cid: {
+        "id": cid, "phase": "Learn", "crispr_ids": []})
+    seen = {}
+
+    def _upd(uid, cid, **fields):
+        seen.update(fields)
+        return {"ok": True, "construct": {}}
+    monkeypatch.setattr(dee_auth, "update_construct", _upd)
+
+    dee_auth.attach_artifact("u1", good, "crispr", good)
+    assert seen["crispr_ids"] == [good]
+    assert "phase" not in seen, "Learn must not regress to Edit"
+
+
+def test_phase_advances_when_it_should(monkeypatch):
+    good = "11111111-1111-1111-1111-111111111111"
+    monkeypatch.setattr(dee_auth, "get_construct", lambda uid, cid: {
+        "id": cid, "phase": "Design", "crispr_ids": []})
+    seen = {}
+    monkeypatch.setattr(dee_auth, "update_construct",
+                        lambda uid, cid, **f: (seen.update(f),
+                                               {"ok": True, "construct": {}})[1])
+    dee_auth.attach_artifact("u1", good, "crispr", good)
+    assert seen["phase"] == "Edit"
+
+
+def test_attaching_the_same_artifact_twice_is_a_no_op(monkeypatch):
+    good = "11111111-1111-1111-1111-111111111111"
+    monkeypatch.setattr(dee_auth, "get_construct", lambda uid, cid: {
+        "id": cid, "phase": "Build", "plasmid_ids": [good]})
+    monkeypatch.setattr(dee_auth, "update_construct",
+                        lambda *a, **k: pytest.fail("should not write"))
+    assert dee_auth.attach_artifact("u1", good, "plasmid", good)["already"] is True
+
+
+def test_a_failing_attribution_does_not_fail_the_save(monkeypatch):
+    """The artifact still exists in its own table; only the cross-reference is
+    missing. Losing the save instead would be strictly worse."""
+    monkeypatch.setattr(server._auth, "get_auth", lambda: _Auth("u1"))
+    monkeypatch.setattr(server._auth, "save_plasmid",
+                        lambda *a, **k: {"ok": True, "id": "p-1"})
+    monkeypatch.setattr(server._auth, "cleanup_expired_plasmids_async",
+                        lambda uid: None)
+
+    def _boom(*a, **k):
+        raise RuntimeError("supabase down")
+    monkeypatch.setattr(server._auth, "attach_artifact", _boom)
+
+    res = _client().post("/api/plasmid/save", json={
+        "name": "p", "topology": "circular", "sequence": "ACGT" * 30,
+        "features": [], "construct_id": "11111111-1111-1111-1111-111111111111",
+    })
+    assert res.status_code == 200 and res.get_json()["ok"] is True
+
+
+def test_user_id_cannot_be_passed_as_a_field_at_all():
+    """The strongest version of the check: `user_id` is a positional parameter
+    of update_construct, so a caller splatting a request body that contains it
+    gets a TypeError rather than a silent ownership change. Asserted because
+    it is a property of the signature that a future refactor to **kwargs would
+    quietly remove."""
+    good = "11111111-1111-1111-1111-111111111111"
+    with pytest.raises(TypeError):
+        dee_auth.update_construct("u1", good, **{"user_id": "attacker"})
+
+
+def test_update_ignores_fields_the_client_should_not_write(monkeypatch):
+    """Everything outside the allow-list is dropped before the row is touched
+    — a TTL or an id from a request body must never reach it."""
+    good = "11111111-1111-1111-1111-111111111111"
+    captured = {}
+    import urllib.request
+
+    class _Resp:
+        def __enter__(self): return self
+        def __exit__(self, *a): return False
+        def read(self): return b"[]"
+
+    def _fake(req, timeout=0):
+        captured["body"] = json.loads(req.data.decode())
+        return _Resp()
+    monkeypatch.setattr(dee_auth, "SUPABASE_URL", "https://x")
+    monkeypatch.setattr(dee_auth, "SUPABASE_SERVICE_KEY", "k")
+    monkeypatch.setattr(urllib.request, "urlopen", _fake)
+
+    dee_auth.update_construct("u1", good, name="ok", expires_at="never",
+                              id="other", sequence_hash="forged", phase="Build")
+    assert "expires_at" not in captured["body"]
+    assert "id" not in captured["body"]
+    assert "sequence_hash" not in captured["body"]
+    assert captured["body"]["name"] == "ok"
+    assert captured["body"]["phase"] == "Build"