Deploy fab7842

The consequence pass now calls Evo 2, instead of claiming it did

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

dee/core/compiler.py

@@ -354,12 +354,17 @@ def compile_correction(wt_allele: str, patient_allele: str, *,
 # intergenic space, so I did not clear this guide".
 #
 # Every pass reports one of:
-#   ok           ran, nothing blocking
-#   warn         ran, with a caveat the designer must read
+#   ok           ran, produced a result, nothing blocking
+#   warn         ran, produced a result, with a caveat the designer must read
 #   error        ran, and refused
+#   failed       was ATTEMPTED and produced no result
 #   unavailable  did NOT run, because this deployment cannot — with the reason
 #   skipped      did not run because an earlier pass already refused
 #
+# `failed` is separate from `warn` on purpose. Reporting a model call that
+# errored as "passed with caveat" is a soft version of the same lie as
+# reporting an unrun pass as ok: in both cases nothing was assessed.
+#
 # "unavailable" is deliberately distinct from "ok". Conflating them is how a
 # tool ends up implying it checked something it never looked at.
 
@@ -398,7 +403,10 @@ class CompileReport:
 
     @property
     def incomplete_because(self) -> List[str]:
-        return [p.title for p in self.passes if p.status == "unavailable"]
+        """Passes that produced no assessment — whether they were never run
+        or were attempted and failed. Both leave the same hole in the record."""
+        return [p.title for p in self.passes
+                if p.status in ("unavailable", "failed")]
 
 
 # What this deployment can and cannot do, stated once so the passes and the
@@ -435,16 +443,18 @@ def compile_report(wt_allele: str, patient_allele: str, *,
                    window: str = "", offset: int = -1,
                    germline: bool = False,
                    can_enumerate: bool = True,
-                   can_score_consequence: bool = False,
+                   consequence: Optional[Dict[str, object]] = None,
                    can_check_specificity: bool = False) -> CompileReport:
     """Run the passes and report every one, including those that could not run.
 
-    The three `can_*` flags are supplied by the caller from LIVE capability
-    checks (is the DNA model reachable, is an off-target index loaded), never
-    hardcoded — the same "availability must mean reachable" rule the rest of
-    this codebase learned the hard way. Defaulting the two model-backed passes
-    to False means a caller that forgets to check gets an honestly incomplete
-    record rather than a falsely complete one.
+    `consequence` is the ACTUAL RESULT of scoring the variant, or None. It is
+    deliberately not a capability flag: the first version of this function
+    took `can_score_consequence: bool` and reported the pass as "ok" whenever
+    the model was merely *reachable*, so the UI printed "Assess edit
+    consequence — passed" while nothing had been assessed. That is the same
+    "configured means done" lie that dee/core/modal_client.reachable exists to
+    prevent, rebuilt one layer up. A pass reports success only when it holds
+    the output of work that happened.
     """
     if germline:
         raise GermlineRefused(
@@ -509,8 +519,30 @@ def compile_report(wt_allele: str, patient_allele: str, *,
         add("enumerate", "unavailable", CAPABILITY_NOTES["enumerate"])
 
     # ── consequence ─────────────────────────────────────────────────────
-    add("consequence", "ok" if can_score_consequence else "unavailable",
-        CAPABILITY_NOTES["consequence"])
+    # Reports on the RESULT, never on the ability to have produced one.
+    if consequence is None:
+        add("consequence", "unavailable", CAPABILITY_NOTES["consequence"])
+    elif not consequence.get("ok"):
+        add("consequence", "failed",
+            "Scoring was attempted and did not return a result: "
+            f"{consequence.get('error') or 'no detail'}. Nothing is reported "
+            "for this pass rather than an assumed-benign default. "
+            + CAPABILITY_NOTES["consequence"])
+    else:
+        dl = consequence.get("delta_ll")
+        label = consequence.get("label") or "the variant"
+        # State the direction in words. A bare signed number invites the
+        # reader to supply their own convention, and half of them will
+        # supply the wrong one.
+        if isinstance(dl, (int, float)):
+            direction = ("less likely than wild-type" if dl < 0
+                         else "more likely than wild-type" if dl > 0
+                         else "indistinguishable from wild-type")
+            detail = (f"{label}: delta log-likelihood {dl:+.4f} — the model "
+                      f"finds the patient sequence {direction}. ")
+        else:
+            detail = f"{label}: scored, no delta returned. "
+        add("consequence", "ok", detail + CAPABILITY_NOTES["consequence"])
 
     # ── specificity ─────────────────────────────────────────────���───────
     # Always carries its caveat, even when it runs: a pass that reports "ok"

dee/server.py

@@ -3416,6 +3416,47 @@ def create_app() -> Flask:
     # Lowers a pathogenic variant to an editing strategy, or refuses with a
     # diagnostic. See dee/core/compiler.py for the scope this operates in —
     # somatic design and assessment only, never a clinical decision.
+    def _score_variant_consequence(wt: str, patient: str, window: str, offset: int):
+        """Ask Evo 2 what the PATIENT allele does, in its real sequence context.
+
+        The variant scored is the pathogenic one against the wild-type window
+        — `<wt><1-based pos><patient>` — so a negative delta log-likelihood
+        means the model finds the patient's sequence less likely than
+        wild-type. That is supporting evidence about the lesion, not proof:
+        zero-shot, no training on this locus, no validated relationship to
+        clinical consequence.
+
+        Returns None when there is nothing to score (no window, or a lesion
+        with no single-base correction). Never raises — a scoring failure must
+        degrade the record's completeness, not the compile.
+        """
+        if not window or offset < 0 or offset >= len(window):
+            return None
+        if len(wt) != 1 or len(patient) != 1:
+            return None          # indels are not point substitutions
+        if window[offset].upper() != wt.upper():
+            return None          # the verify pass will refuse this anyway
+
+        label = f"{wt.upper()}{offset + 1}{patient.upper()}"
+        try:
+            res = _dna_scoring.score_dna_variants(window, [label], tier="achilles")
+        except Exception as exc:  # noqa: BLE001
+            app.logger.warning("consequence scoring failed: %s", exc)
+            return {"ok": False, "label": label,
+                    "error": "the DNA model did not return a score"}
+
+        scores = (res or {}).get("scores") or []
+        hit = next((s for s in scores if s.get("label") == label), None)
+        if hit is None:
+            skipped = (res or {}).get("skipped") or []
+            return {"ok": False, "label": label,
+                    "error": (f"the model returned no score for {label}"
+                              + (f" (skipped: {skipped})" if skipped else ""))}
+        return {"ok": True, "label": label, "delta_ll": hit.get("delta_ll"),
+                "reference_ll": (res or {}).get("reference_ll"),
+                "checkpoint": (res or {}).get("checkpoint"),
+                "tier": (res or {}).get("tier")}
+
     @app.post("/api/compiler/compile")
     def compiler_compile() -> Response:
         gate = _dna_signin_gate("compiler")
@@ -3434,23 +3475,21 @@ def create_app() -> Flask:
         if not wt and not patient:
             return jsonify({"error": "missing 'wt_allele' and 'patient_allele'"}), 400
 
-        # Capability comes from a LIVE probe, never a constant. A pass that
-        # cannot run must report `unavailable`, and the only way to know is to
-        # ask. Specificity stays off in this version on purpose: the human
-        # off-target index is coding-sequence only, so this endpoint does not
-        # claim to have cleared a guide it never checked outside coding space.
-        try:
-            can_score = bool(_dna_scoring.runnable("achilles"))
-        except Exception:  # noqa: BLE001 — capability must never break a compile
-            app.logger.debug("DNA capability probe failed", exc_info=True)
-            can_score = False
+        # Consequence scoring is OPT-IN. The compile itself is pure logic and
+        # returns in milliseconds; an Evo 2 call is a rented 7B GPU and ~80s
+        # cold, so running it on every compile would make the fast, honest
+        # part of the tool feel broken. Off by default means the pass reports
+        # `unavailable` — which is true — rather than quietly costing money.
+        consequence = None
+        if body.get("score_consequence"):
+            consequence = _score_variant_consequence(wt, patient, window, offset)
 
         try:
             report = _compiler.compile_report(
                 wt, patient, window=window, offset=offset,
                 germline=bool(body.get("germline")),
                 can_enumerate=True,
-                can_score_consequence=can_score,
+                consequence=consequence,
                 can_check_specificity=False,
             )
         except _compiler.GermlineRefused as exc:

dee/static/app.js

@@ -12310,10 +12310,14 @@ if (document.readyState === 'loading') {
 
     const ICON = {
         ok: '✓', warn: '!', error: '✕',
-        unavailable: '—', skipped: '·',
+        failed: '✕', unavailable: '—', skipped: '·',
     };
+    // 'failed' is NOT 'passed with caveat'. A model call that errored
+    // assessed nothing, and saying otherwise is the soft version of
+    // reporting an unrun pass as ok.
     const LABEL = {
         ok: 'passed', warn: 'passed with caveat', error: 'refused',
+        failed: 'attempted, no result',
         unavailable: 'not run', skipped: 'skipped',
     };
 
@@ -12432,7 +12436,13 @@ if (document.readyState === 'loading') {
         const win = ($('tcWindow').value || '').replace(/\s+/g, '').toUpperCase();
         const offset = parseInt($('tcOffset').value, 10);
         const btn = $('tcRun');
+        const scoring = !!($('tcScore') || {}).checked;
+        const origLabel = btn.textContent;
         btn.disabled = true;
+        // Only claim a wait when there IS one. The compile alone returns in
+        // milliseconds; saying "scoring on the GPU" for a pure-logic pass
+        // would be theatre.
+        if (scoring) btn.textContent = 'Compiling + scoring on the GPU…';
         try {
             const res = await fetch('/api/compiler/compile', {
                 method: 'POST',
@@ -12440,6 +12450,7 @@ if (document.readyState === 'loading') {
                 body: JSON.stringify({
                     wt_allele: wt, patient_allele: patient,
                     window: win, offset: isNaN(offset) ? -1 : offset,
+                    score_consequence: !!($('tcScore') || {}).checked,
                 }),
             });
             const data = await res.json();
@@ -12459,6 +12470,7 @@ if (document.readyState === 'loading') {
             setError((err && err.message) || String(err));
         } finally {
             btn.disabled = false;
+            btn.textContent = origLabel;
         }
     }
 

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=20260812-tc" />
+    <link rel="stylesheet" href="/static/app.css?v=20260812-tc2" />
     <!-- 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. -->
@@ -1326,6 +1326,19 @@
                           <span class="field-opt">· 0-based</span></label>
                       <input id="tcOffset" class="tc-num mono" type="number" min="0" value="0" />
 
+                      <label class="primer-toggle">
+                          <input type="checkbox" id="tcScore" />
+                          <span class="primer-toggle-text">
+                              <strong>Score the variant with Evo 2</strong>
+                              <span class="field-hint">Asks the genome model what the
+                              <em>patient's</em> allele does in this exact sequence context. Off by
+                              default: the compile itself is instant logic, while this is a rented
+                              7B GPU (~25s warm, ~80s cold). Leaving it off makes the consequence
+                              pass report <strong>not run</strong> — which is the truth — rather
+                              than quietly spending money.</span>
+                          </span>
+                      </label>
+
                       <div class="tc-actions">
                           <button class="ghost" type="button" id="tcExampleOk"
                                   title="A transition — base-editable, compiles">Example that compiles</button>
@@ -2830,7 +2843,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=20260812-tc" defer></script>
+    <script src="/static/app.js?v=20260812-tc2" 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_compiler.py

@@ -225,12 +225,56 @@ def test_specificity_still_carries_its_caveat_when_it_runs():
     assert "GUIDE-seq" in spec.detail
 
 
-def test_consequence_pass_states_it_is_zero_shot_even_when_available():
+def test_consequence_reports_the_number_when_scoring_actually_ran():
     r = C.compile_report("G", "A", window=WINDOW, offset=0,
-                         can_score_consequence=True)
-    d = _by_name(r)["consequence"].detail
-    assert "zero-shot" in d
-    assert "no validated relationship to clinical outcome" in d
+                         consequence={"ok": True, "label": "G1A", "delta_ll": -4.2})
+    p = _by_name(r)["consequence"]
+    assert p.status == "ok"
+    assert "-4.2000" in p.detail
+    assert "less likely than wild-type" in p.detail, "direction stated in words"
+    assert "zero-shot" in p.detail
+    assert "no validated relationship to clinical outcome" in p.detail
+
+
+def test_a_positive_delta_is_described_in_the_other_direction():
+    r = C.compile_report("G", "A", window=WINDOW, offset=0,
+                         consequence={"ok": True, "label": "G1A", "delta_ll": 1.5})
+    assert "more likely than wild-type" in _by_name(r)["consequence"].detail
+
+
+def test_reachability_alone_never_makes_the_consequence_pass_succeed():
+    """The bug this replaced: the pass took a capability flag and reported
+    'passed' whenever the model was merely reachable, so the UI said the edit
+    had been assessed when nothing had been scored."""
+    r = C.compile_report("G", "A", window=WINDOW, offset=0)
+    assert _by_name(r)["consequence"].status == "unavailable"
+
+
+def test_a_failed_scoring_attempt_is_failed_not_passed_with_caveat():
+    """'passed with caveat' on a model call that errored is the soft version
+    of reporting an unrun pass as ok — in both cases nothing was assessed."""
+    r = C.compile_report("G", "A", window=WINDOW, offset=0,
+                         consequence={"ok": False, "label": "G1A",
+                                      "error": "backend refused"})
+    p = _by_name(r)["consequence"]
+    assert p.status == "failed"
+    assert p.status != "warn", "must not read as a pass"
+    assert "backend refused" in p.detail
+    assert "assumed-benign" in p.detail
+
+
+def test_a_failed_pass_leaves_the_record_incomplete():
+    """Never run and attempted-but-failed leave the same hole."""
+    r = C.compile_report("G", "A", window=WINDOW, offset=0,
+                         consequence={"ok": False, "error": "boom"})
+    assert "Assess edit consequence" in r.incomplete_because
+
+
+def test_a_failed_consequence_does_not_block_the_compile():
+    """The lesion still routes; only the record is incomplete."""
+    r = C.compile_report("G", "A", window=WINDOW, offset=0,
+                         consequence={"ok": False, "error": "boom"})
+    assert r.compiled
 
 
 def test_a_refused_lesion_skips_the_rest_rather_than_reporting_ok():